text
stringlengths 20
1.01M
| url
stringlengths 14
1.25k
| dump
stringlengths 9
15
⌀ | lang
stringclasses 4
values | source
stringclasses 4
values |
|---|---|---|---|---|
# Работа с семантикой, ссылками и парсинг веб-страниц: 16 полезных формул Google Sheets для SEO-специалистов
SEO — это рутина. Иногда приходится делать совсем тоскливые операции вроде удаления «плюсиков» в ключевых словах. Иногда — что-то более продвинутое вроде парсинга мета-тегов или консолидации данных из разных таблиц. В любом случае все это съедает тонны времени.
Но мы не любим рутину. Предлагаем 16 полезных функций Google Sheets, которые упростят работу с данными и помогут вам высвободить несколько рабочих часов или даже дней. (Уверены, о существовании некоторых функций вы не догадывались).
**Содержание статьи**[1. IF — базовая логическая функция](#id1)
[2. IFERROR — присваиваем свое значение в случае ошибки](#id2)
[3. ARRAYFORMULA — протягиваем формулу вниз в один клик](#id3)
[4. LEN — считаем количество символов в ячейке](#id4)
[5. TRIM — удаляем пробелы в начале и конце фразы](#id5)
[6. SUBSTITUTE — меняем/удаляем пробелы и спецсимволы](#id6)
[7. LOWER — переводим буквы из верхнего регистра в нижний](#id7)
[8. UNIQUE — выводим данные без дублирующихся ячеек](#id8)
[9. SEARCH — находим данные в строке](#id9)
[10. SPLIT — разбиваем фразы на отдельные слова](#id10)
[11. CONCATENATE — объединяем данные в ячейках](#id11)
[12. VLOOKUP — ищем значения в другом диапазоне данных](#id12)
[13. IMPORTRANGE — импортируем данные из других таблиц](#id13)
[14. IMPORTXML — парсим данные с веб-страниц](#id14)
[15. GOOGLETRANSLATE — переводим ключевики и другие данные](#id15)
[16. REGEXEXTRACT — извлекаем нужный текст из ячеек](#id16)
1. IF — базовая логическая функция
----------------------------------
Это одна из базовых функций, знакомых вам по Excel. Она помогает при решении разных SEO-задач. Формула IF выводит одно значение, если логическое выражение истинное, и другое — если оно ложное.
Синтаксис:
```
=IF(логическое_выражение;"значение_истина";"значение_ложь")
```
**Пример.** Есть список ключей с частотностями. Наша цель — занять ТОП-3. При этом мы хотим выбрать только такие ключи, каждый из которых приведет нам минимум 300 посетителей в месяц.
Определяем, какая доля трафика приходится на третью позицию в органике. Для этого идем в [этот сервис](https://www.advancedwebranking.com/ctrstudy/) и видим, что третья позиция приводит около 10% трафика из органики (конечно, эта цифра неточная, но это лучше, чем ничего).
Составляем выражение IF, которое будет возвращать значение 1 для ключей, который приведут минимум 300 посетителей, и 0 — для остальных ключей:
```
=IF(B2*0.1>=300;"1";"0")
```
Обратите внимание, в строке 7 формула выдала ошибку, поскольку значение частотности задано в неверном формате. Для подобных ситуаций есть продвинутая версия функции IF — IFERROR.
Обратите внимание: использование в формуле запятой или точки для десятичных дробей определено в настройках ваших таблиц.
2. IFERROR — присваиваем свое значение в случае ошибки
------------------------------------------------------
Функция позволяет вывести заданное значение в ячейку, если выдается ошибка.
Синтаксис:
```
=IFERROR(ваша формула;"значение в случае ошибки")
```
Используем эту функцию в примере, описанном выше. Зададим значение в случае ошибки «нет данных».
Как видите, значение #VALUE! изменило вид на понятное нам «нет данных».
3. ARRAYFORMULA — протягиваем формулу вниз в один клик
------------------------------------------------------
В работе с данными практически каждый раз приходится прописывать формулу для всех ячеек в столбце. «Тянуть» ее, зажав левую кнопку мыши, или копипастить — это прошлый век.
Достаточно заключить исходную функцию в функцию ARRAYFORMULA, и формула применится ко всем ячейкам ниже. Причем при удалении добавлении строк формула все равно будет работать — без пробелов в расчетах.
Синтаксис:
```
=ARRAYFORMULA(исходная формула)
```
Пример. Сделаем автоматическое применение формулы, описанной выше, для всех ячеек диапазона. Для этого заключаем исходную формулу в ARRAYFORMULA:
```
=ARRAYFORMULA(IFERROR(IF(B2:B*0,1>=300;"1";"0");"нет данных"))
```
Обратите внимание, что мы вместо ячейки B2 указали диапазон, для которого применяем формулу (B2:B — это весь столбец B, начиная со второй строки). Если указать одну ячейку, формула не сработает.
**Лайфхак.** Нажмите сочетание клавиш CTRL+SHIFT+ENTER после ввода основной формулы, и функция ARRAYFORMULA применится автоматически.
ARRAYFORMULA работает не со всеми функциями. Например, она не совместима с GOOGLETRANSLATE и IMPORTXML, о которых мы расскажем ниже.
4. LEN — считаем количество символов в ячейке
---------------------------------------------
Эта функция особенно полезна при составлении объявлений контекстной рекламы — когда важно не заступать за отведенное количество символов для заголовков, описаний, отображаемых URL, быстрых ссылок и уточнений.
В SEO функция LEN применяется, например, при составлении мета-тегов title и description. Символы функция считает с пробелами.
Синтаксис:
```
=LEN(ячейка с текстом)
```
**Пример.** Нам нужно составить тайтлы для всех страниц сайта. Мы знаем, что в результатах поиска отображается около 55 символов. Наша задача — составить тайтлы так, чтобы самая важная информация была в первых 55 символах. Прописываем формулу LEN для заполняемых ячеек. Теперь мы точно знаем, когда приближаемся к отображаемым 55 символам.
5. TRIM — удаляем пробелы в начале и конце фразы
------------------------------------------------
Когда парсишь семантику из разных источников, часто она содержит «мусорные» элементы — пробелы, плюсики, спецсимволы. Рассмотрим функции, которые помогают быстро почистить ядро. Одна из них — TRIM.
Эта функция удаляет пробелы в начале и конце фразы, указанной в ячейке.
Синтаксис:
```
=TRIM(ячейка, в которой нужно удалить пробелы до и после фразы)
```
Функция удаляет все пробелы до и после фразы — сколько бы их там ни было.
6. SUBSTITUTE — меняем/удаляем пробелы и спецсимволы
----------------------------------------------------
Универсальная функция замены/удаления символов в ячейках.
Синтаксис:
```
=SUBSTITUTE(где искать;"что искать";"на что менять";номер соответствия)
```
*Номер соответствия — порядковый номер встреченного значения на замену, например, первое встреченное заменить, остальные оставить. Опциональный параметр.*
**Пример.** У нас есть выгрузка ключевых фраз из Яндекс.Вордстат. Многие ключи содержат плюсики. Нам нужно их удалить.
Формула будет иметь вид:
```
=SUBSTITUTE(B12;"+";"";)
```
Что мы сделали:
* где искать — указали ячейку с данными;
* «что искать» — указали плюсик, который нужно удалить;
* «на что менять» — поскольку символ нужно удалить, мы указали кавычки без символов внутри; если бы нам нужна была замена, здесь бы мы прописали текст, на который нужно заменить плюсик;
* номер соответствия — здесь мы ничего не указали, и функция удалит все плюсы в фразе; если бы мы указали 1, то функция удаляла бы только первый плюсик, если 2 — второй и т. д.
7. LOWER — переводим буквы из верхнего регистра в нижний
--------------------------------------------------------
При составлении ключей и парсинге из разных источников (например, из мета-тегов конкурентов) может так получиться, что они будут иметь буквы в верхнем регистре. Для приведения ключей в унифицированный вид нужно перевести все буквы в нижний регистр. Для этого используется функция LOWER.
Синтаксис:
```
=LOWER(ячейка, текст в которой нужно перевести в нижний регистр)
```
8. UNIQUE — выводим данные без дублирующихся ячеек
--------------------------------------------------
Функция анализирует выделенный диапазон на предмет полных дублей и выводит только уникальные строки — в том же порядке, что и в исходном диапазоне.
Синтаксис:
```
=UNIQUE(диапазон данных)
```
**Пример.** Мы собрали ключи из Яндекс.Вордстат, поисковых подсказок, парсили слова конкурентов. Естественно, в этом массиве ключей у нас будут дубли. Нам они не нужны. Убираем их с помощью UNIQUE.
> Если вы хотите «одним махом» очистить ядро от мусора, используйте бесплатный [нормализатор слов](https://promopult.ru/ref/b6caacfac388cfa0/aHR0cHM6Ly9wcm9tb3B1bHQucnUvdG9vbHMvd29yZF9ub3JtYWxpemVyLmh0bWw=?utm_medium=paid_article&utm_source=habr&utm_campaign=blog&utm_term=b6caacfac388cfa0&utm_content=word_normalizer). Он убирает дублирующиеся фразы (с учетом перестановок), меняет регистры, удаляет пробелы и спецсимволы. По сути, он делает то же самое, что и функции TRIM, SUBSTITUTE, LOWER и UNIQUE вместе взятые — только в один клик.
9. SEARCH — находим данные в строке
-----------------------------------
С помощью этой функции вы быстро найдете необходимые вам строки с большом массиве данных.
Синтаксис:
```
=SEARCH(«что искать»;где искать)
```
Функция используется в разных ситуациях:
* выделить ключевые фразы с необходимым интентом (например, брендированные или связанные с определенной тематикой, товаром или услугой);
* найти определенные символы в URL (например, UTM-параметры или знак вопроса);
* найти URL для целей линкбилдинга — например, содержащие слова «guest-post»).
**Пример.** У нас есть список ключей для интернет-магазина дверей. Мы хотим найти все брендированные запросы и отметить их в таблице. Для этого используем формулу:
```
=SEARCH("porta";A1)
```
Но в таком виде формула при отсутствии слова «porta» в ключе выведет нам #VALUE!.. Кроме того, при наличии этого слова в искомой ячейке функция будет проставлять номер символа, с которого начинается это слово. Выглядит результат так:
Для получения результата поиска в удобной для нас форме используем дополнительно функции IF и IFERROR:
```
=IFERROR(IF(SEARCH("porta";A1)>0;"бренд";"0"))
```
10. SPLIT — разбиваем фразы на отдельные слова
----------------------------------------------
Функция делит строки на фрагменты, используя заданный разделитель.
Синтаксис:
```
=SPLIT(ячейка;"разделитель")
```
*Стоит иметь в виду, что вторая половина разделенного текста займет следующую колонку. Так что если у вас плотная таблица, перед применением формулы нужно добавить пустую колонку.*
**Пример.** У нас есть список доменов. Нам нужно разделить их на названия доменов и расширения. В функции SPLIT в качестве разделителя указываем точку и получаем результат:
11. CONCATENATE — объединяем данные в ячейках
---------------------------------------------
Эта функция, в отличие от предыдущей, объединяет данные из нескольких ячеек.
Синтаксис:
```
=CONCATENATE(ячейка 1;ячейка 2;...)
```
*Важно: в формулу можно вставлять не только значения ячеек, но и символы (в прямых кавычках).*
**Пример.** В примере с функцией SPLIT мы разделили домены. Сделаем обратную операцию с помощью CONCATENATE (указываем объединяемые ячейки и между ними указываем разделитель — точку):
12. VLOOKUP — ищем значения в другом диапазоне данных
-----------------------------------------------------
Функция выполняет поиск ключа в первом столбце диапазона и возвращает значение указанной ячейки в найденной строке.
Синтаксис:
```
=VLOOKUP(запрос;диапазон;номер_столбца;[сортировка])
```
**Пример 1.** Есть два массива ключевых фраз, полученных из разных источников. Нужно найти ключи в первом массиве, которые не встречаются во втором массиве. Для этого используем формулу:
```
=VLOOKUP(A2:A;B2:B;1;false)
```
Что мы сделали:
* задали диапазон A2:A, из которого берем ключи для сравнения;
* задали диапазон B2:B, с которым сравниваем ключи из столбца А;
* задали номер столбца (1), из которого подтягиваем ключи при совпадениях;
* false — указали, что сортировка нам не нужна.
Функция VLOOKUP часто используется при поиске данных на разных листах или в разных документах.
**Пример 2.** Мы выгрузили данные из Яндекс.Вебмастера и Google Search Console об индексации страниц сайта. Наша задача — сопоставить данные и определить, какие страницы индексируются в одном поисковике, но не индексируются в другом.
Заносим результаты выгрузок в файл Google Sheets. На одном листе — URL из Google, на втором — из Яндекса.
В ячейке C2 прописываем функцию VLOOKUP. Сразу заключаем в функцию в ARRAYFORMULA для автоматического протягивания вниз:
```
=ARRAYFORMULA(VLOOKUP(A2:A;Yandex!A2:A;1;false))
```
Теперь мы сразу видим, какие страницы проиндексированы в Google, но не проиндексированы в Яндексе.
Что мы сделали:
* задали диапазон A2:A текущего листа, из которого берем значение для сравнения;
* задали диапазон Yandex!A2:A листа с выгрузкой из Яндекса, с которым будем сравнивать значения URL из Google;
* указали номер столбца листа с выгрузкой из Яндекса, значения из которого подтягиваем при совпадении значений из сравниваемых диапазонов;
* false — указали, что сортировка нам не нужна.
> Если же вам нужно проверить одновременно индексацию конкретных страниц в Яндексе и Google, воспользуйтесь [инструментом](https://promopult.ru/ref/b6caacfac388cfa0/aHR0cHM6Ly9wcm9tb3B1bHQucnUvdG9vbHMvaW5kZXhpbmdfYW5hbHlzaXMuaHRtbA==?utm_medium=paid_article&utm_source=habr&utm_campaign=blog&utm_term=b6caacfac388cfa0&utm_content=indexing_analysis) от PromoPult. Загрузите список URL и запустите проверку. Если страница проиндексирована в поисковике, в столбце будет цифра 1, если нет — 0.
*Каким пользоваться этим инструментом и в каких ситуациях он полезен, читайте в [этом гайде](https://blog.promopult.ru/seo/bystryj-sposob-proverit-indeksaciyu-stranic-v-yandekse-i-google.html).*
13. IMPORTRANGE — импортируем данные из других таблиц
-----------------------------------------------------
Функция позволяет вставить в текущий файл данные из других таблиц.
Синтаксис:
```
=IMPORTRANGE("ссылка на документ";"ссылка на диапазон данных")
```
*Пример:*
```
=IMPORTRANGE("https://docs.google.com/spreadsheets/d/ХХХХХХХХ/","имя листа!A2:A25")
```
**Пример.** Вы продвигаете сайт клиента. Над проектом работает три специалиста: линкбилдер, SEO-специалист и копирайтер. Каждый ведет свой отчет. Клиент заинтересован отслеживать процесс в режиме онлайн. Вы формируете для него один отчет с вкладками: «Ссылки», «Позиции», «Тексты». На эти вкладки с помощью функции IMPORTRANGE подтягиваются данные по каждому направлению.
Преимущество функции в том, что вы открываете доступ только к конкретным листам. При этом внутренние части отчетов специалистов остаются недоступны для клиентов.
14. IMPORTXML — парсим данные с веб-страниц
-------------------------------------------
«Развесистая» функция для парсинга данных с веб-страниц с помощью XPath.
Синтаксис:
```
=IMPORTXML("url";"xpath-запрос")
```
Вот лишь несколько вариантов использования этой функции:
* извлечение метаданных из списка URL (title, description), а также заголовков h1-h6;
* сбор e-mail со страниц;
* парсинг адресов страниц в соцсетях.
**Пример.** Нам нужно собрать содержимое тегов title для списка URL. Запрос XPath, который мы используем для получения этого заголовка, выглядит так: «//title».
Формула будет такой:
```
=IMPORTXML(A2;"//title")
```
IMPORTXML не работает с ARRAYFORMULA, так что вручную копируем формулу во все ячейки.
Вот другие запросы XPath, которые вам будут полезны:
* выгрузить заголовки H1 (и по аналогии — h2-h6): //h1
* спарсить мета-теги description: //meta[@name='description']/@content
* спарсить мета-теги keywords: //meta[@name='keywords']/@content
* извлечь e-mail адреса: //a[contains([href](https://habr.com/ru/users/href/), 'mailTo:') or contains([href](https://habr.com/ru/users/href/), 'mailto:')]/@href
* извлечь ссылки на профили в соцсетях: //a[contains([href](https://habr.com/ru/users/href/), 'vk.com/') or contains([href](https://habr.com/ru/users/href/), 'twitter.com/') or contains([href](https://habr.com/ru/users/href/), 'facebook.com/') or contains([href](https://habr.com/ru/users/href/), 'instagram.com/') or contains([href](https://habr.com/ru/users/href/), 'youtube.com/')]/@href
Если вам нужно узнать XPath-запрос для других элементов страницы, откройте ее в Google Chrome, перейдите в режим просмотра кода, найдите элемент, кликните по нему правой кнопкой и нажмите Copy / Copy XPath.
15. GOOGLETRANSLATE — переводим ключевики и другие данные
---------------------------------------------------------
В мультиязычных проектах часто приходится переводить ключевые фразы. Удобнее всего это сделать с помощью функции GOOGLETRANSLATE прямо в таблице.
Синтаксис:
```
=GOOGLETRANSLATE(«текст»; [язык_оригинала]; [язык_перевода])
```
Например, если нам нужно перевести ключи с русского на английский, формула будет такой:
```
=GOOGLETRANSLATE(A1;"ru";"en")
```
Если бы мы переводили с английского на русский, то нужно было бы изменить порядок языков:
```
=GOOGLETRANSLATE(A1;"en";"ru")
```
GOOGLETRANSLATE не работает с ARRAYFORMULA, так что, как и в случае с IMPORTXML, протягиваем формулу вручную.
16. REGEXEXTRACT — извлекаем нужный текст из ячеек
--------------------------------------------------
Эта функция позволяет извлечь из строки с данными текст, описанный с помощью регулярных выражений RE2, [поддерживаемых](https://github.com/google/re2/blob/master/doc/syntax.txt) Google. Синтаксис регулярных выражений достаточно сложный, больше примеров вы найдете в [справке Google](https://support.google.com/a/answer/1371417?hl=ru).
Синтаксис:
```
=REGEXEXTRACT(где искать;”регулярное выражение”)
```
**Пример 1.** У нас есть список URL. Нужно извлечь домены. Здесь нам поможет регулярное выражение:
```
^(?:https?:\/\/)?(?:[^@\n]+@)?(?:www\.)?([^:\/\n]+)
```
**Пример 2.** В списке ключевых фраз нужно найти брендированные ключи со словами «porta» и «порта». Для поиска фраз с вхождением любого из этих слов используем регулярное выражение:
```
(?i)(\W|^)(porta|порта)(\W|$)
```
Как видите, в таблицах можно кроить и резать данные так, как вам будет нужно, достаточно разобраться в формулах. | https://habr.com/ru/post/468435/ | null | ru | null |
# Суперскалярный стековый процессор: оптимизация
Продолжение серии статей, разбирающих идею [суперскалярного](http://www.ixbt.com/cpu/cpu-pedia.shtml#superscal) процессора с
[OoO](http://www.ixbt.com/cpu/cpu-pedia.shtml#OoO) и [фронтендом](http://www.ixbt.com/cpu/cpu-pedia.shtml#front-end) стековой машины. Тема данной статьи — оптимизация обращений к памяти.
Предыдущие статьи:
[1](https://habrahabr.ru/post/278575/) — описание работы на линейном куске
[2](https://habrahabr.ru/post/279123/) — вызов функций, сохраняем регистры
[3](https://habrahabr.ru/post/280087/) — вызов функций, взгляд изнутри
До сих пор мы не обращали внимания на слабое место всех стековых машин — избыточные обращения к памяти.
В самом деле, когда наивный кодо-генератор стековой машины хочет получить значение переменной ‘a’, он пишет инструкцию ‘push a’. Возможностей сослаться на уже вычисленное выражение или его кусок стековый процессор не предоставляет.
Для регистровых процессоров компилятор решает эту проблему введением временных переменных с возможным размещением их в регистрах. Стоит придумать подобный механизм и для нашей внешне без-регистровой архитектуры.
Впрочем, придумывать то почти ничего и не надо, “всё уже украдено до нас”(С).
* введем аппарат закладок (bookmarks)
* закладка — регистр, к которому компилятор может обращаться по номеру, номера регистра и закладки совпадать не обязаны, хотя, это упростило бы жизнь
* компилятор для каждой функции определяет число закладок, которыми он собирается располагать
* при старте функции под закладки выделяется необходимое число регистров, освободить их нельзя вплоть до завершения функции
* закладки попадают внутрь регистрового окна и на них действует механизм FILL/SPILL
* если компилятор считает вычисленное значение ценным, то устанавливает закладку, например, инструкцией ‘bmk 1’, что означает: значение на вершине стека отныне считается закладкой с номером 1. Происходит ли при этом копирование значения в регистр закладки N1 или подменяется регистр, отвечающий за эту закладку, не важно, детали реализации
* когда в дальнейшем компилятору потребуется значение из этой закладки, он может его использовать, например, так: ‘add\_bmk 1’, т.е. значение с вершины стека будет просуммировано со значением закладки 1 и замещено этим значением
* с точки зрения бэкенда процессора, будет порожден старый добрый моп суммирования двух регистров в третий
* возникает необходимость второй линейки арифметических и логических инструкций (add->add\_bmk, mul->mull\_bmk, cmp->cmp\_bmk), но оно того стоит
* или более общий вариант — любой из аргументов или результат трех(двух)-адресной инструкции может быть закладкой
* можно себе представить и динамическое выделение закладок, без выделения максимального их количества в целях оптимизации количества использованных регистров, но это (на первый взгляд) выглядит слишком жестоким по отношению к железу
В результате у компилятора есть два условно новых ресурса для оптимизации.
Первый — выявление и размещение закладок, число которых может быть достаточно большим, оно не ограничено числом располагаемых регистров за отсутствием таковых. По большому счету это эквивалент локальных переменных, размещенных в “быстром” стеке.
Второй — эквивалентное преобразование выражений к виду, в котором максимально проявляется внутренний параллелизм. Компилятор старается уменьшить высоту деревьев выражений за счет роста вширь.
Ну и не забудем про традиционные техники оптимизации, которые не ориентированы на регистры и их распределение.
Для того, чтобы разобраться, как это может быть реализовано, взглянем на те
возможности, которые предоставляет нам [ассемблер LLVM](http://llvm.org/docs/CommandGuide/llvm-as.html). Не собираемся же мы в самом деле игнорировать весь накопленный в этой области “культурный слой”.
### LLVM
```
int a(int m, int n)
{
if (m == 0)
return n + 1;
if (n == 0)
return a(m - 1, 1);
return a(m - 1, a(m, n - 1));
}
```
**полученный LLVM asm**
```
; Function Attrs: nounwind readnone
define i32 @a(i32 %m, i32 %n) #0 {
%1 = icmp eq i32 %m, 0
br i1 %1, label %tailrecurse._crit_edge, label %.lr.ph
tailrecurse._crit_edge: ; preds = %tailrecurse.backedge, %0
%n.tr.lcssa = phi i32 [ %n, %0 ], [ %n.tr.be, %tailrecurse.backedge ]
%2 = add nsw i32 %n.tr.lcssa, 1
ret i32 %2
.lr.ph: ; preds = %0, %tailrecurse.backedge
%n.tr2 = phi i32 [ %n.tr.be, %tailrecurse.backedge ], [ %n, %0 ]
%m.tr1 = phi i32 [ %4, %tailrecurse.backedge ], [ %m, %0 ]
%3 = icmp eq i32 %n.tr2, 0
%4 = add nsw i32 %m.tr1, -1
br i1 %3, label %tailrecurse.backedge, label %5
; :5 ; preds = %.lr.ph
%6 = add nsw i32 %n.tr2, -1
%7 = tail call i32 @a(i32 %m.tr1, i32 %6)
br label %tailrecurse.backedge
tailrecurse.backedge: ; preds = %5, %.lr.ph
%n.tr.be = phi i32 [ %7, %5 ], [ 1, %.lr.ph ]
%8 = icmp eq i32 %4, 0
br i1 %8, label %tailrecurse.\_crit\_edge, label %.lr.ph
}
```
Здесь мы видим одни лишь инструкции потока управления, мест, где могла бы проявиться специфика стековой машины нет (если не считать за таковую вычисление +-1).
А как насчет [“бабочки” FFT,](https://ru.wikipedia.org/wiki/%D0%91%D0%B0%D0%B1%D0%BE%D1%87%D0%BA%D0%B0_(%D0%91%D0%9F%D0%A4)) (это уже скорее из области data flow)?
**фрагмент FFT**…
for (n = 1; n <= LogN; n++)
{
rw = Rcoef[LogN — n];
iw = Icoef[LogN — n];
if (Ft\_Flag == FT\_INVERSE) iw = -iw;
in = ie >> 1;
ru = 1.0;
iu = 0.0;
for (j = 0; j
{
for (i = j; i
{
io = i + in;
rtp = Rdat[i] + Rdat[io];
itp = Idat[i] + Idat[io];
rtq = Rdat[i] — Rdat[io];
itq = Idat[i] — Idat[io];
Rdat[io] = rtq \* ru — itq \* iu;
Idat[io] = itq \* ru + rtq \* iu;
Rdat[i] = rtp;
Idat[i] = itp;
}
sr = ru;
ru = ru \* rw — iu \* iw;
iu = iu \* rw + sr \* iw;
}
ie >>= 1;
}
…
Тело самого вложенного циклов ассемблере LLVM
( clang -c b.c -O3 --target=xcore -emit-llvm -S -o b\_o3.ll ) выглядит так:
**полученный ассемблер LLVM**.lr.ph21:; preds = %.preheader19, %.lr.ph21
%i.020 = phi i32 [ %76, %.lr.ph21 ], [ %j.025, %.preheader19 ]
%57 = add nsw i32 %i.020, %54
%58 = getelementptr inbounds double\* %Rdat, i32 %i.020
%59 = load double\* %58, align 4, !tbaa !1
%60 = getelementptr inbounds double\* %Rdat, i32 %57
%61 = load double\* %60, align 4, !tbaa !1
%62 = fadd double %59, %61
%63 = getelementptr inbounds double\* %Idat, i32 %i.020
%64 = load double\* %63, align 4, !tbaa !1
%65 = getelementptr inbounds double\* %Idat, i32 %57
%66 = load double\* %65, align 4, !tbaa !1
%67 = fadd double %64, %66
%68 = fsub double %59, %61
%69 = fsub double %64, %66
%70 = fmul double %ru.023, %68
%71 = fmul double %iu.024, %69
%72 = fsub double %70, %71
store double %72, double\* %60, align 4, !tbaa !1
%73 = fmul double %ru.023, %69
%74 = fmul double %iu.024, %68
%75 = fadd double %74, %73
store double %75, double\* %65, align 4, !tbaa !1
store double %62, double\* %58, align 4, !tbaa !1
store double %67, double\* %63, align 4, !tbaa !1
%76 = add nsw i32 %i.020, %ie.028
%77 = icmp slt i32 %76, %N
br i1 %77, label %.lr.ph21, label %.\_crit\_edge22
…
В виде графа зависимостей между инструкциями это выглядит так:
Навскидку, каждая вершина дерева из которой выходит более одного ребра является кандидатом на звание закладки. По крайней мере в том, что касается вычислений с плавающей точкой.
Во всяком случае, реализация описанной архитектуры в LLVM не выглядит безнадёжным мероприятием.
Дот-файл, вдруг пригодится:
**fft.dot**digraph graphname {
L000 [label="%54"];
L001 [label="%Rdat"];
L002 [label="%Idat"];
L003 [label="%ru.023"];
L004 [label="%iu.024"];
L005 [label="%i.020"];
L02 [label="%57 = add nsw i32 %i.020, %54"];
L03 [label="%58 = getelementptr double\* %Rdat, i32 %i.020"];
L04 [label="%59 = load double\* %58"];
L05 [label="%60 = getelementptr double\* %Rdat, i32 %57"];
L06 [label="%61 = load double\* %60"];
L07 [label="%62 = fadd double %59, %61"];
L08 [label="%63 = getelementptr double\* %Idat, i32 %i.020"];
L09 [label="%64 = load double\* %63"];
L10 [label="%65 = getelementptr double\* %Idat, i32 %57"];
L11 [label="%66 = load double\* %65"];
L12 [label="%67 = fadd double %64, %66"];
L13 [label="%68 = fsub double %59, %61"];
L14 [label="%69 = fsub double %64, %66"];
L15 [label="%70 = fmul double %ru.023, %68"];
L16 [label="%71 = fmul double %iu.024, %69"];
L17 [label="%72 = fsub double %70, %71"];
L18 [label=«store double %72, double\* %60»];
L19 [label="%73 = fmul double %ru.023, %69"];
L20 [label="%74 = fmul double %iu.024, %68"];
L21 [label="%75 = fadd double %74, %73"];
L22 [label=«store double %75, double\* %65»];
L23 [label=«store double %62, double\* %58»];
L24 [label=«store double %67, double\* %63»];
L005->L02; L000->L02; L005->L03; L001->L03;
L03->L04; L001->L05; L02->L05; L05->L06; L04->L07;
L06->L07; L002->L08; L005->L08; L08->L09; L002->L10;
L02->L10; L10->L11; L09->L12; L11->L12; L04->L13;
L06->L13; L09->L14; L11->L14; L003->L15; L13->L15;
L004->L16; L14->L16; L15->L17; L16->L17; L17->L18;
L003->L19; L14->L19; L004->L20; L13->L20; L19->L21;
L20->L21; L10->L22; L21->L22; L07->L23; L03->L23;
L08->L24; L12->L24; L05->L18;
}
### Эпилог
Вот мы и подошли к предварительному финишу.
Разобрались почему нужно новая архитектура, предложили вариант решения.
Изначально стоял вопрос, а отвечает ли эта архитектура поставленным требованиям.
И теперь можем ответить, да, по крайней мере в той небольшой части С, которую удалось проверить, мы получили
* ожидаемое упрощение аппаратной части
* внешне незаметную масштабируемость по числу регистров
* а также и по числу функциональных устройств
* потенциальное упрощение компиляторов
На первый (дилетантский) взгляд, не видны принципиальные проблемы, препятствующие реализации такой архитектуры в “железе”.
Мы намеренно не рассматривали такие вещи, как:
* вычисления с плавающей точкой, нужен ли для них отдельный стек, ...
* сохранение состояния процессора при переключении контекста
* прерывания
* ...
Всё это вопросы важные, но менее принципиальные.
А на данный момент автор считает свою задачу выполненной. | https://habr.com/ru/post/281352/ | null | ru | null |
# Просто о Qt. Библиотека контейнеров
Привет, хабр!
Сегодня я хотел бы рассказать о интересной и полезной фиче. Имя ее — Библиотека контейнеров. Это не одна, а целая группа полезных фич. А их назначение — организация и обработка групп элементов. Звучит интересно, да? Сейчас рассмотрим поближе — добро пожаловать под кат.
#### Вступление
###### Хочу сказать одну вещь — статья ориентирована на начинающих программистов. Продолжаем.
Одна из самых распространенных задач в программировании это организация обработки групп элементов. Программисты с ней очень много парятся. Ведь нужно все разложить по полочкам… Но в Qt есть замечательный помощник — Библиотека контейнеров. Этот помощник находится в модуле QtCore — значит нам не надо никаких дополнительных инклюдов. И так, поехали!
#### Вектор QVector
**Вектор** — структура данных очень похожая на обычный массив. Однако использование класса вектора предоставляет некоторые преимущества по сравнению с простым массивом. Например можно узнать количество элементов внутри вектора (его размер), или динамически расширять его. Еще этот контейнер экономнее чем другие виды контейнеров. Для добавления элементов в конец последовательного контейнера можно воспользоватся методом *push\_back()*. К элементам вектора можно обратится как посредством оператора индексации [], так и при помощи итератора. Например:
```
QVector vec;
vec.push\_back(10); // добавляем в конец вектора элемент
vec.push\_back(20);
vec.push\_back(30);
qDebug() << vec;
```
Будет выведено — *QVector(10,20,30)*.
#### Массив байтов QByteArray
Этот контейнер очень похож на QVector, но разница заключается в том, что это **не** шаблонный класс, и в нем допускается хранение только элементов, имеющих размер один байт. Объекты типа QByteArray можно использовать везде, где требуется промежуточное хранение данных. Количество элементов массива можно задать в конструкторе, а доступ к ним получать при помощи оператора [].
```
QByteArray arr(3);
arr[0] = arr[1] = 0xFF;
arr[2] = 0x0;
```
К данным объектов класса QByteArray можно также применить операцию сжатия и обратное преобразование. Это достигается при помощи двух глобальных функций *qCompress()* и *qUncompress()*. Просто сожмем и разожмем данные:
```
QByteArray a = "Some text...";
QByteArray aCompressed = qCompress(a);
qDebug << qUncompress(aCompressed);
```
Будет выведено *Some text...*.
#### Массив битов QBitArray
Этот класс управляет битовым (или **булевым**) массивом. Каждое из сохраняемых значений занимает только один бит, не расходуя лишней памяти. Этот тип используется для хранения большого количества переменных типа *bool*.
```
QBitArray arr(3);
arr[0] = arr[1] = true;
arr[2] = false;
```
#### Списки QList и QLinkedList
**Список** — это структура данных, представляющая собой упорядоченный набор связанных друг с другом элементов. Преимущество списков перед векторами и очередями состоит в том, что вставка и удаление элементов в любой позиции происходит эффективнее, так как для выполнения этих операций изменяется только минимальное количество указателей, исключение составляет только вставка элемента в центр списка. Но есть и недостаток — списки плохо приспособлены для поиска определенного элемента списка по индексу, и для этой цели лучше всего использовать вектор.
Списки реализует шаблонный класс QList. В общем виде данный класс представляет собой массив указателей на элементы.
Специфические операции для работы со списками:
* *move()* — Перемещает элемент с одной позиции на другую.
* *removeFirst()* — Выполняет удаление первого элемента списка.
* *removeLast()* — Выполняет удаление последнего элемента списка.
* *swap()* — Меняет местами два элемента списка на указанных позициях.
* *takeAt()* — Возвращает элемент на указанной позиции и удаляет его из списка.
* *takeFirst()* — Возвращает первый элемент и удаляет его из списка.
* *takeLast()* — Возвращает последний элемент и удаляет его из списка.
* *toSet()* — Возвращает контейнер *QSet* с данными содержащимися в списке.
* *toStdList()* — Возвращает стандартный список STL *std::List с элементами из списка.*
* *toVector()* — Возвращает вектор *QVector* с данными содержащимися в списке.
Если вы не собираетесь менять значения элементов, то, из соображения эффективности, не рекомендуется использовать оператор []. Вместо него юзайте метод *at()*, так как он возвращает константную ссылку на элемент.
Одна из самых распространенных операций — обход списка для последовательного получения значений каждого элемента списка. Например:
```
QList list;
list << 10 << 20 << 30;
QValueList::iterator it = list.begin(); // создаем итератор и переводим его в начало списка
while (it != list.end()) {
qDebug() << "Element:" << \*it;
++it;
}
```
В консоли будет отображено:
*Element:10
Element:20
Element:30*
Если вы работаете с большими списками и/или вам часто надо вставлять элементы, то эффективнее будет использовать двусвязные списки *QLinkedList*. Хотя этот контейнер прожорливие чем *QList*, зато операции вставки и удаления сводятся к переопределению четырех указателей, независимо от позиции удаляемого или вставляемого элемента.
#### Стек QStack
**Стек** реализует структуру данных, работающую по принципу Last In First Out — последним пришел, первым ушел. То есть из стека первым удаляется элемент, который был вставлен позже всех остальных.
Класс *QStack* представляет собой реализацию стековой структуры. Этот класс унаследован от *QVector*. Процесс помещения элементов в стек обычно называется **проталкиванием** (pushing), а извлечение из него верхнего элемента — **выталкиванием** (poping). Каждая операция проталкивания увеличивает размер стека на 1, а каждая операция выталкивания — уменьшает на 1. Для этих операций в классе *QStack* определены функции *push()* и *pop()*. Метод *top()* возвращает ссылку на верхний элемент. Пример использования стека:
```
QStack stk;
stk.push("Era"); // наполняем стек добавляя в него новые элементы
stk.push("Corvus Corax");
stk.push("Gathering");
while (!stk.empty()) {
qDebug() << "Element:" << stk.pop();
}
```
В консоли будет:
*Element:«Gathering»
Element:«Corvus Corax»
Element:«Era»*
#### Очередь QQueue
**Очередь** реализует структуру данных, работающую по принципу — первым пришел, первым ушел. Реализована очередь в классе *QQueue*, который унаследованный от *QList*.
Следующий пример демонстрирует пример использования очереди:
```
QQueue que;
que.enqueue("Era");
que.enqueue("Corvus Corax");
que.enqueue("Gathering");
while (!que.empty()) {
qDebug() << "Element:" << que.dequeue();
}
```
В консоли будет:
*Element:«Era»
Element:«Corvus Corax»
Element:«Gathering»*
#### Словари QMap, QMultiMap
Словари, в принципе, похожи на обычные, используемые в повседневной жизни. Они хранят элементы одного и того же типа, индексируемые ключевыми значениями. Достоинство словаря в том, что он позволяет быстро получать значение, ассоциированное с заданным ключом. Ключи должны быть уникальными, за исключением мультисловаря, который допускает дубликаты.
В контейнеры этого типа заносятся элементы вместе с ключами, по которым их можно найти, которыми могут выступать значения любого типа. В случае со словарем *QMap* необходимо следить за тем, чтобы не было занесено двух разных элементов с одинаковым ключом, ведь тогда не удастся извлечь один из этих элементов. Каждый ключ должен быть уникален.
При создании объекта *QMap* нужно передать его размер в конструктор. Этот размер не является, как это принято в других контейнерных классах, размером ограничивающим максимальное количество элементов, а представляет собой количество позиций. Количество позиций должно быть больше чем количество элементов, ожидаемых для хранения, иначе поиск элементов в словаря будет проводится недостаточно эффективно. Желательно чтобы это значение относилось к разряду простых чисел, так как в этом случае размещение элементов будет более удобным.
Некоторые методы:
* *iowerBound()* — Возвращает на первый элемент с заданным ключом.
* *toStdMap()* — Возвращает словарь STL с элементами нашего словаря.
* *upperBound()* — Возвращает на последний элемент с заданным ключом.
Одним из самых частых способов обращения к элементам словаря является использование ключа в операторе []. Но можно обойтись и без него, так как ключ и значение можно получить через метод итератора *key()* и *value()*, например:
```
QMap mapPhonebook;
mapPhonebook["Piggy"] = "+380 93 785 11 11";
mapPhonebook["Kermit"] = "+7 85 123 65 56";
mapPhonebook["Gonzo"] = "+49 73 631 32 21";
QMap::iterator it = mapPhonebook.begin();
for(;it != mapPhonebook.end(); ++it)
{
qDebug() << "Name:" << it.key() << "Phone:" << it.value();
}
```
В консоли будет:
*Name:Gonzo Phone: +49 73 631 32 21
Name:Kermit Phone: +7 85 123 65 562 21
Name:Piggy Phone: +380 93 785 11 11*
#### Хэши QHash и QMultiHash
Функциональность хэшей очень похожа на *QMap*, с той лишь разницей, что вместо сортировки по ключу, этот класс использует хэш-таблицу. Это позволяет ему осуществлять поиск ключевых значений гораздо быстрее, чем это делает *QMap*.
Так же как и в случае с QMap, следует обязательно соблюдать осторожность при использовании оператора индексации [], так как задание ключа, для которого элемент не существует, приведет к тому, что элемент будет создан. Поэтому важно всегда проверять наличие элемента, привязанного к ключу при помощи метода *containts()* контейнера.
Если вы намереваетесь разместить в *QHash* объекты собственных классов, то вам необходимо будет реализовать оператор сравнения == и специализированную функцию *qHash()* для вашего класса. Вот пример реализации оператора сравнения:
```
inline bool operator==(const MyClass& mc1, const MyClass& mc2)
{
return (mc1.firstName() == mc2.firstName()
&& mc1.secondName() == mc2.secondName()
);
}
```
Функция *qHash()* должна возвращать число, которое должно быть уникальным для каждого находящегося в хэше элемента. Например:
```
inline uint qHash(const MyClass& mc)
{
return qHash(mc.firstName()) ^ qHash(mc.secondName());
}
```
Класс *QMultiHash* унаследован от *QHash*. Он позволяет размещать значения с одинаковыми ключами и, в целом, похож на *QMultiMap*, но учитывает специфику своего родительского класса.
#### Множество QSet
Как заметил немецкий математик Георг Кантор, «Множество — это есть многое, мысленно подразумеваемое нами как единое». Это единое, в контексте Tulip, есть не что иное, как контейнер *QSet*, который записывает элементы в некотором порядке и предоставляет возможность очень быстрого просмотра значений и выполнения с ними операций, характерных для множеств, таких как объединение, пересечение и разность. Необходимым условием есть то, что ключи должны быть разными. Контейнер *QSet* можно использовать в качестве неупорядоченного списка для быстрого поиска данных.
Операции которые можно проводить с множествами: объединение, пересечение, разность.
Создадим два множества и запишем в них элементы:
```
QSet set1;
QSet set2;
set1 << "Lorem" << "Ipsum" << "Dolor";
set2 << "Sit" << "Amet" << "Lorem";
```
Произведем операцию объединения этих двух множеств, а для того чтобы элементы множеств остались неизменными, введем промежуточное множество *setResult*:
```
QSet setResult = set1;
setResult.unite(set2);
qDebug() << "Объединение = " << setResult.toList();
```
На экране появится следующее:
*Объединение = («Lorem»,«Ipsum»,«Dolor»,«Sit»,«Amet»)*
Таким же образом выполняются операции пересечения — *intersect()* и разности — *subtract()*.
#### Итоги
Сегодня читатель должен был научится работать с разного рода контейнерами Qt. Сегодня я рассказал лишь малую долю всей картины. Впереди еще Алгоритмы, Регулярные Выражения, QVariant, и многое другое. Может я и про них напишу).
##### Литература
1. 1. Макc Шлее. Qt 4.5 — Профессиональное программирование на С++
2. 2. Qt Reference Documentation
P.S. Данная статья ориентирована на обучение начинающих программистов. | https://habr.com/ru/post/127870/ | null | ru | null |
# Выдергивание информации из URL, в стиле Slack и Twitter
Многие пользуются Slack, Twitter и видели такие штуки:
| | |
| --- | --- |
| | |
Как это работает и как такое сделать самим?
Для тех, кому нужно срочно и сразу: я написал [готовый сервер](https://github.com/dyatlov/proclink-api) для возврата oembed-like информации об URL. Работающий вариант можно посмотреть [здесь](http://proc.link/).
А теперь по пунктам, откуда можно выдрать интересную инфу:
### 1. Oembed
Про и известно всем, на этом останавливаться не будем.
Есть такой формат как [Oembed](http://oembed.com/). Многие крупные порталы имеют в своем распоряжении oembed endpoint. Например:
* Youtube: [www.youtube.com/oembed?format=json&url=http%3A%2F%2Fwww.youtube.com%2Fwatch%3Fv%3DB8BNdhuABIY](http://www.youtube.com/oembed?format=json&url=http%3A%2F%2Fwww.youtube.com%2Fwatch%3Fv%3DB8BNdhuABIY)
* Twitter: [api.twitter.com/1/statuses/oembed.json?id=655102676024369154](https://api.twitter.com/1/statuses/oembed.json?id=655102676024369154)
* SoundCloud: [soundcloud.com/oembed?url=https%3A%2F%2Fsoundcloud.com%2Fharlem\_fetty%2Fjugg-feat-monty&format=json](https://soundcloud.com/oembed?url=https%3A%2F%2Fsoundcloud.com%2Fharlem_fetty%2Fjugg-feat-monty&format=json)
Из oembed информации можно получить гораздо более полную выжимку страницы чем пытаясь распарсить html, поэтому приоритетной задачей при парсинге URL является поиск oembed ссылок.
Это описано в п.4 на сайте [oembed.com](http://oembed.com):
В head страницы нужно добавить по крайней мере одну ссылку такого вида:
```
```
Как можно понять, здесь задается тип endpoint'а: xml или json. Соответственно, при парсинге html, если мы находим ссылку на oembed, то можно выдохнуть и взять нужную информацию из oembed ednpoint. Парсинг oembed для Golang реализован в [моей библиотеке](https://github.com/dyatlov/go-oembed).
### 2. Open Graph
Это дополнительная metadata на странице, которую используют Google+, Facebook и другие для встраивания содержимого страниц в свои ленты. Подробнее можно прочитать [здесь](http://ogp.me/). Эта разметка используется на огромном количестве сайтов, даже на Хабре. Например, посмотрите исходный текст этого поста и поищите по 'og:'.
Парсинг OpenGraph для Golang реализован в [моей библиотеке](https://github.com/dyatlov/go-opengraph) (наиболее полный функционал по сравнению с аналогами).
### 3. Собираем информацию по крупицам из того что есть
Если ни oembed ни opengraph на странице нету, то довольствуемся имеющимися данными:
* — для заголовка
* — для описания
* — для картинки
* \* если картинки нету, то выдираем первую картинку из основного текста
* \* если описания нету, то выдираем часть текста из основного контента как описание
Для выдирания контента я использую [github.com/dyatlov/go-readability](https://github.com/dyatlov/go-readability) — это [форк оригинального go-readability](https://github.com/mauidude/go-readability/pull/4) c добавлением whitelabeled attributes (это необходимо для корректного вытаскивания картинок).
Это реализовано в [github.com/dyatlov/go-htmlinfo](https://github.com/dyatlov/go-htmlinfo).
### 4. Генерация oembed для ресурсов не являющихся html
Ссылки могут быть не только на страницы, но и на картинки или видео, на архивы и т.д. Для таких ссылок никакой информации получить естественно не получится. Поэтому придется генерировать ее самим.
В Golang есть такая штука как [http#DetectContentType](https://golang.org/pkg/net/http/#DetectContentType). Основываясь на этой информации, можно получить тип контента, находящегося по указанному адресу, основываясь на первых нескольких сотнях байтов. Затем, базируясь на типе контента, можно предпринимать следующие шаги. В случае изображений я использую декодирование хедеров изображения и таким образом получаю их размеры, которые затем возвращаю в ответе. Все это реализовано в [соответствующей библиотеке](https://github.com/dyatlov/go-url2oembed).
### Защищаемся
Задачи (кроме очевидных):
1. Разворачивать redirect'ы и при этом не уходить в бесконечный цикл. Например, [bit.ly/1cWYIdC](http://bit.ly/1cWYIdC) должно стать Хабром. [Решение](https://github.com/dyatlov/go-url2oembed/blob/master/url2oembed/parser.go#L78)
2. Защита от атаки на локальные ресурсы (см. [атака на pocket](https://www.gnu.gl/blog/Posts/multiple-vulnerabilities-in-pocket/)). [Решение](https://github.com/dyatlov/go-url2oembed/blob/master/url2oembed/parser.go#L140)
3. Грузить только ограниченное количество информации (если пришла ссылка на ISO образ Linux, то незачем скачивать его весь). [Решение](https://github.com/dyatlov/go-url2oembed/blob/master/url2oembed/parser.go#L343)
### Заключение
Прошу прощения за большое количество отсылок к своим репозиториям и сумбурное описание. Старался сделать код понятным и при этом разбить его на логические модули, которые могут быть потом повторно использованы независимо. Надеюсь что кому-то это пригодится.
Исходный код готового сервера [здесь](https://github.com/dyatlov/proclink-api). А он сам [здесь](http://proc.link).
Для чего можно использовать: автоматическая подгрузка url preview для url'ов из комментариев, попап с preview в постах с url'ами и другие связанные с показом содержимого вещи. | https://habr.com/ru/post/269055/ | null | ru | null |
# Подводные камни идентификации Android-устройства
Некоторым разработчикам может понадобится идентифицировать Android-устройства своих пользователей. Чаще всего это делается не для того чтобы распознать именно девайс, а для определения конкретной установки приложения. Также я встречала несколько кейсов, когда это было необходимо, если у разработчика появлялось несколько приложений и он хотел понимать, что они работают в одной среде.
[Гугл говорит](https://developer.android.com/training/articles/user-data-ids), что идентифицировать устройство очень просто. Но мы же говорим об Android:)
*Данная статья ориентирована на приложения или библиотеки, которые не хотят привязываться к гугловым сервисам.*
Итак, давайте погрузимся в это чудесное приключение по получению уникального идентификатора устройства.
#### Тут мы видим несколько путей:
* Advertising ID
* IMEI
* MAC-address
* Serial Number
* Android ID
Выглядит пока что не плохо, не так ли? Целых пять способов получить уникальный идентификатор для Android-устройства. Я уверена, что если вы еще пошуршите по сети, то, наверняка, найдете еще парочку других способов, но тут я вынесла самые популярные. Итак, давайте пойдем по порядку.
### Advertising ID
Это уникальный для пользователя рекламный идентификатор, предоставляемый службами Google Play. Он необходим для работы рекламы, чтобы Google понимал, какую рекламу можно показывать конкретному пользователю и какая реклама уже была показана с помощью встроенных в приложения рекламных баннеров. А так же это значит, что вы лишитесь этого идентификатора, если ваше приложение будет скачано, к примеру, с Amazon, а помимо этого вам придется втащить в ваше приложение [гугловые библиотеки](http://www.androiddocs.com/google/play-services/setup.html).
```
dependencies {
compile 'com.android.support:appcompat-v7:21.0.3'
compile 'com.google.android.gms:play-services:6.5.87'
}
```
Вывод: мы не идентифицируем устройство во всех случаях.
Но мы же хотим наверняка, верно? Тогда идем дальше.
### IMEI
Это международный идентификатор мобильного оборудования, используемый на телефонах стандарта GSM. Номер IMEI используется сетями для идентификации смартфонов и блокировки доступа в сеть украденных или занесенных в черный список девайсов. Но к сожалению с IMEI может возникнуть ряд проблем:
* Возникает ошибка «Invalid IMEI»
* [IMEI можно изменить](https://drfone.wondershare.com/sim-unlock/change-imei-android.html)
* Для получения IMEI необходим permission:
```
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
String imei = telephonyMgr.getImei();
} else {
String imei = telephonyMgr.getDeviceId();
}
```
Вывод: мы не идентифицируем устройство во всех случаях и нас еще и могут обмануть:C
### MAC-address
Не надежно 100%. [Гугл сам об этом говорит](https://android-developers.googleblog.com/2011/03/identifying-app-installations.html), но, к сожалению, я действительно встречала пару приложений, которые полагались на MAC-address устройства. Не делайте так.
> It may be possible to retrieve a Mac address from a device’s WiFi or Bluetooth hardware. We do not recommend using this as a unique identifier. To start with, not all devices have WiFi. Also, if the WiFi is not turned on, the hardware may not report the Mac address.
### Serial Number
Считается уникальным серийным номером устройства, который остается с ним до “самого конца”. Получить его можно таким способом:
```
//Until Android 7.1 (SDK 25)
Build.SERIAL
//Android 8 (SDK 26) ++
Build.getSerial()
```
А теперь про проблемы. Во-первых, для получения серийного номера потребуется запросить у пользователя разрешение [*READ\_PHONE\_STATE*](https://developer.android.com/reference/android/os/Build#getSerial()), а пользователь может отказать. Во-вторых, серийный номер [можно изменить](https://techviral.net/change-serial-number-android/).
Вывод: мы не идентифицируем устройство во всех случаях, мы должны запросить permission у пользователя, которые их подбешивают и нас все еще могут обмануть.
### Android ID
— Вот оно! — должны завопить мы. — Решение всех наших бед!
Android ID — это тоже уникальный идентификатор устройства. Представляет из себя 64-разрядную величину, которая генерируется и сохраняется при первой загрузке устройства.
Получить его можно вот так:
```
Secure.getString(getContentResolver(), Secure.ANDROID_ID);
```
Казалось бы, такая короткая строчка избавляет нас от головной боли по идентификации устройства. Даже ребята из гугл использую Android\_ID для [LVL](https://developer.android.com/google/play/licensing/adding-licensing) в примере.
И тут наши надежды рушатся и ничто уже не будет прежним. После обновления на Android 8 [Android\_ID](https://developer.android.com/reference/android/provider/Settings.Secure.html#ANDROID_ID) теперь стал уникальным для каждого установленного приложения. Но, помимо этого, гугл ведь заботится о нас, так что приложения, которые были установлены до обновления останутся с прежними одинаковыми идентификаторами, которые гугл сохраняет с помощью специально написанного для этого [сервиса](https://developer.android.com/guide/topics/data/keyvaluebackup). Но если приложение будет удалено, а затем заново установлено — Android\_ID будет разным. Для того чтобы это не произошло, нужно использовать KeyValueBackup.
Но этот backup сервис нужно зарегистрировать, еще и package name указать. Более того, в документации написано, что это может не сработать по *любой* причине. И кто в этом виноват? Да никто, просто вот так.
#### Общий вывод
Если у вас хороший бекенд, то просто собирайте слепок устройства (установленные приложения, сервисы, любые данные об устройстве, которые можете достать) и сравнивайте параметры уже там, какой-то процент изменений считайте приемлемым.
P.S. Все подборки я публикую как всегда в телеграм канале [@paradisecurity](https://t-do.ru/paradisecurity), а ссылку можно найти в моем профиле, либо найти в поиске телеграм по названию.
С наступающим:) | https://habr.com/ru/post/434726/ | null | ru | null |
# Отчет по Exchange окружению с помощью Powershell (теперь и по Exchange 2013)
19 января вышла новая версия [скрипта](http://gallery.technet.microsoft.com/exchange/Generate-Exchange-2388e7c9), который позволяет получить наглядную информацию о состоянии инфраструктуры Exchange. Стив Гудман (Steve Goodman) добавил в версии 1.5.6 поддержку Exchange 2013. Если Вы еще не встречались с этим полезным инструментом, то рекомендуем сделать это уже сегодня.
Скрипт собирает много полезной информации по Exchange инфраструктуре и выводит ее в html-файл. Также можно автоматизировать получение отчетов на почту.
Список того, что включено в отчет, достаточно большой — вы можете найти его под катом.
Сам скрипт можно скачать [здесь](http://gallery.technet.microsoft.com/exchange/Generate-Exchange-2388e7c9).
Под катом приведен небольшой перевод [поста](http://www.stevieg.org/2011/06/exchange-environment-report/) автора о работе скрипта.
Администраторам Exchange довольно часто необходим такой документ, который бы давал обзор текущей Exchange инфраструктуры. Word и Visio не особо подходят, так как не позволяют постоянно держать информацию в актуальном состоянии или просто отслеживать изменения.
Предлагаемый скрипт позволяет автоматически создавать отчет для серверов и DAG (database availability groups) в Exchange 2003, 2007, 2010 и 2013, а именно:
• Общее количество серверов на версию и SP Exchange
• Общее количество почтовых ящиков на версию и SP Exchange
• Общее количество Exchange ролей в Вашей ИТ-инфраструктуре
• Разбивка по сайтам для следующих параметров:
o Почтовые ящики на сайте
o Exchange серверы, версия, пакет обновления и его версия, уровень службы, установленные роли, версия ОС и service
• Разбивка по каждой Database Availability Group, включая:
o Наименование каждой DAG, число членов и их список
o Информация о базе данных:
— Имя
— Количество почтовых ящиков на базу данных и их средний размер
— Количество архивных почтовых ящиков на базу данных и их средний размер – показывается только если БД включена в архивные почтовые ящики
— Размер БД и свободное место
— % свободного места в БД и логическом диске
— Время и дата последнего бекапа (новое) – показывается, если хотя бы одна база данных DAG имеет полный бекап
— Состояние циклического ведения журнала (Circular Logging) (новое) — показывается, если хотя бы для одной базы данных DAG включено циклическое ведение журнала
— Сервер, на котором находится активная копия
— Список серверов, на которых находятся активные копии и количество копий
• Разбивка по не-DAG базам данных, включая БД Exchange 2007 и 2003 с информацией о базе данных и имени группы хранения Storage Group (где это применимо).
На выходе получается [такой отчет](http://www.stevieg.org/downloads/ExchangeEnvironmentReport.html) (привожу здесь его небольшую часть).
Стоит отметить, что скрипт не позволяет получать детальную информацию о кластерах Exchange 2007/2003 CCR/SCC, но они показаны как ClusMBX в итоговом отчете. Также в настоящий момент, скрипт не показывает информацию о Публичных папках, но если кому-то это интересно, то автор обещает добавить пару функций; и, конечно, вы сами можете вносить любые изменения в код.
Чтобы выполнить скрипт, Вам необходим Exchange Management Shell (последняя версия для вашей среды с Powershell 2.0) и возможность получать информацию о сайтах AD, серверах Exchange, почтовых ящиках, DAG и БД. Она использует WMI для извлечения информации об ОС и определения кластеров Exchange 2007 и вычисления размера базы данных Exchange 2007 и Remote Registy calls для получения информации о пакетах обновлений. Любой администратор Exchange сможет осуществить эти задачи.
Выполнить скрипт просто – вам только необходимо уточнить, куда записывать файл HTML file:
```
.\Get-ExchangeEnvironmentReport -HTMLReport c:\report.html
```
Если Вы хотите получать отчеты на почту, то доступны следующие параметры прямо в скрипте для отправки отчета:
```
.\Get-ExchangeEnvironmentReport -HTMLReport c:\report.html -SendMail:$true -MailFrom:you@example.com -MailTo:you@example.com -MailServer:smtp.example.com
```
Наконец, чтобы задать график отправки отчета, ежедневно, добавим парамер –ScheduleAs, например:
```
.\Get-ExchangeEnvironmentReport -HTMLReport c:\report.html -SendMail:$true -MailFrom:you@example.com -MailTo:you@example.com -MailServer:smtp.example.com -ScheduleAs:DOMAIN\user
```
После создания отчета, он попытается создать задачу и попросит ввести пароль того пользователя, для которого вы выбрали отправку отчетов (через schtasks.exe).
Скачать [Get-ExchangeEnvironmentReport.ps1](http://gallery.technet.microsoft.com/exchange/Generate-Exchange-2388e7c9)
Upd: Так как большинство проголосовало за добавление скрипта в сам пост, привожу его полностью.
**Скрипт**
```
<#
.SYNOPSIS
Creates a HTML Report describing the Exchange environment
Steve Goodman
(Includes updates by Neil Johnson to support Exchange Server 2013)
THIS CODE IS MADE AVAILABLE AS IS, WITHOUT WARRANTY OF ANY KIND. THE ENTIRE
RISK OF THE USE OR THE RESULTS FROM THE USE OF THIS CODE REMAINS WITH THE USER.
Version 1.5.6, 16th Jan 2013
.DESCRIPTION
This script creates a HTML report showing the following information about an Exchange
2013, 2010 and to a lesser extent, 2007 and 2003, environment.
The following is shown:
* Report Generation Time
* Total Servers per Exchange Version (2003 > 2010 or 2007 > 2013)
* Total Mailboxes per Exchange Version and Organisation
* Total Roles in the environment
Then, per site:
* Total Mailboxes per site
* Exchange Servers with:
o Exchange Server Version
o Service Pack
o Update Rollup and rollup version
o Roles installed on server and mailbox counts
o OS Version and Service Pack
Then, per Database availability group (Exchange 2010/2013):
* Total members per DAG
* Member list
* Databases, detailing:
o Mailbox Count and Average Size
o Archive Mailbox Count and Average Size (Only shown if DAG includes Archive Mailboxes)
o Database Size and whitespace
o Database and log disk free
o Last Full Backup (Only shown if one or more DAG database has been backed up)
o Circular Logging Enabled (Only shown if one or more DAG database has Circular Logging enabled)
o Mailbox server hosting active copy
o List of mailbox servers hosting copies and number of copies
Finally, per Database (Non DAG DBs/Exchange 2007/Exchange 2003)
* Databases, detailing:
o Storage Group (if applicable) and DB name
o Server hosting database
o Mailbox Count and Average Size
o Archive Mailbox Count and Average Size (Only shown if DAG includes Archive Mailboxes)
o Database Size and whitespace
o Database and log disk free
o Last Full Backup (Only shown if one or more DAG database has been backed up)
o Circular Logging Enabled (Only shown if one or more DAG database has Circular Logging enabled)
This does not detail public folder infrastructure, or examine Exchange 2007/2003 CCR/SCC clusters
(although it attempts to detect Clustered Exchange 2007/2003 servers, signified by ClusMBX).
IMPORTANT NOTE: The script requires WMI and Remote Registry access to Exchange servers from the server
it is run from to determine OS version, Update Rollup, Exchange 2007/2003 cluster and DB size information.
.PARAMETER HTMLReport
Filename to write HTML Report to
.PARAMETER SendMail
Send Mail after completion. Set to $True to enable. If enabled, -MailFrom, -MailTo, -MailServer are mandatory
.PARAMETER MailFrom
Email address to send from. Passed directly to Send-MailMessage as -From
.PARAMETER MailTo
Email address to send to. Passed directly to Send-MailMessage as -To
.PARAMETER MailServer
SMTP Mail server to attempt to send through. Passed directly to Send-MailMessage as -SmtpServer
.PARAMETER ScheduleAs
Attempt to schedule the command just executed for 10PM nightly. Specify the username here, schtasks (under the hood) will ask for a password later.
.PARAMETER ViewEntireForest
By default, true. Set the option in Exchange 2007 or 2010 to view all Exchange servers and recipients in the forest.
.PARAMETER ServerFilter
Use a text based string to filter Exchange Servers by, e.g. NL-* - Note the use of the wildcard (*) character to allow for multiple matches.
.EXAMPLE
Generate the HTML report
.\Get-ExchangeEnvironmentReport.ps1 -HTMLReport .\report.html
#>
param(
[parameter(Position=0,Mandatory=$true,ValueFromPipeline=$false,HelpMessage='Filename to write HTML report to')][string]$HTMLReport,
[parameter(Position=1,Mandatory=$false,ValueFromPipeline=$false,HelpMessage='Send Mail ($True/$False)')][bool]$SendMail=$false,
[parameter(Position=2,Mandatory=$false,ValueFromPipeline=$false,HelpMessage='Mail From')][string]$MailFrom,
[parameter(Position=3,Mandatory=$false,ValueFromPipeline=$false,HelpMessage='Mail To')]$MailTo,
[parameter(Position=4,Mandatory=$false,ValueFromPipeline=$false,HelpMessage='Mail Server')][string]$MailServer,
[parameter(Position=4,Mandatory=$false,ValueFromPipeline=$false,HelpMessage='Schedule as user')][string]$ScheduleAs,
[parameter(Position=5,Mandatory=$false,ValueFromPipeline=$false,HelpMessage='Change view to entire forest')][bool]$ViewEntireForest=$true,
[parameter(Position=5,Mandatory=$false,ValueFromPipeline=$false,HelpMessage='Server Name Filter (eg NL-*)')][string]$ServerFilter="*"
)
# Sub-Function to Get Database Information. Shorter than expected..
function _GetDAG
{
param($DAG)
@{Name = $DAG.Name.ToUpper()
MemberCount = $DAG.Servers.Count
Members = [array]($DAG.Servers | % { $_.Name })
Databases = @()
}
}
# Sub-Function to Get Database Information
function _GetDB
{
param($Database,$ExchangeEnvironment,$Mailboxes,$ArchiveMailboxes,$E2010)
# Circular Logging, Last Full Backup
if ($Database.CircularLoggingEnabled) { $CircularLoggingEnabled="Yes" } else { $CircularLoggingEnabled = "No" }
if ($Database.LastFullBackup) { $LastFullBackup=$Database.LastFullBackup.ToString() } else { $LastFullBackup = "Not Available" }
# Mailbox Average Sizes
$MailboxStatistics = [array]($ExchangeEnvironment.Servers[$Database.Server.Name].MailboxStatistics | Where {$_.Database -eq $Database.Identity})
if ($MailboxStatistics)
{
[long]$MailboxItemSizeB = 0
$MailboxStatistics | %{ $MailboxItemSizeB+=$_.TotalItemSizeB }
[long]$MailboxAverageSize = $MailboxItemSizeB / $MailboxStatistics.Count
} else {
$MailboxAverageSize = 0
}
# Free Disk Space Percentage
if ($ExchangeEnvironment.Servers[$Database.Server.Name].Disks)
{
foreach ($Disk in $ExchangeEnvironment.Servers[$Database.Server.Name].Disks)
{
if ($Database.EdbFilePath.PathName -like "$($Disk.Name)*")
{
$FreeDatabaseDiskSpace = $Disk.FreeSpace / $Disk.Capacity * 100
}
if ($Database.ExchangeVersion.ExchangeBuild.Major -ge 14)
{
if ($Database.LogFolderPath.PathName -like "$($Disk.Name)*")
{
$FreeLogDiskSpace = $Disk.FreeSpace / $Disk.Capacity * 100
}
} else {
$StorageGroupDN = $Database.DistinguishedName.Replace("CN=$($Database.Name),","")
$Adsi=[adsi]"LDAP://$($Database.OriginatingServer)/$($StorageGroupDN)"
if ($Adsi.msExchESEParamLogFilePath -like "$($Disk.Name)*")
{
$FreeLogDiskSpace = $Disk.FreeSpace / $Disk.Capacity * 100
}
}
}
} else {
$FreeLogDiskSpace=$null
$FreeDatabaseDiskSpace=$null
}
if ($Database.ExchangeVersion.ExchangeBuild.Major -ge 14 -and $E2010)
{
# Exchange 2010 Database Only
$CopyCount = [int]$Database.Servers.Count
if ($Database.MasterServerOrAvailabilityGroup.Name -ne $Database.Server.Name)
{
$Copies = [array]($Database.Servers | % { $_.Name })
} else {
$Copies = @()
}
# Archive Info
$ArchiveMailboxCount = [int]([array]($ArchiveMailboxes | Where {$_.ArchiveDatabase -eq $Database.Name})).Count
$ArchiveStatistics = [array]($ArchiveMailboxes | Where {$_.ArchiveDatabase -eq $Database.Name} | Get-MailboxStatistics -Archive )
if ($ArchiveStatistics)
{
[long]$ArchiveItemSizeB = 0
$ArchiveStatistics | %{ $ArchiveItemSizeB+=$_.TotalItemSize.Value.ToBytes() }
[long]$ArchiveAverageSize = $ArchiveItemSizeB / $ArchiveStatistics.Count
} else {
$ArchiveAverageSize = 0
}
# DB Size / Whitespace Info
[long]$Size = $Database.DatabaseSize.ToBytes()
[long]$Whitespace = $Database.AvailableNewMailboxSpace.ToBytes()
$StorageGroup = $null
} else {
$ArchiveMailboxCount = 0
$CopyCount = 0
$Copies = @()
# 2003 & 2007, Use WMI (Based on code by Gary Siepser, http://bit.ly/kWWMb3)
$Size = [long](get-wmiobject cim_datafile -computername $Database.Server.Name -filter ('name=''' + $Database.edbfilepath.pathname.replace("\","\\") + '''')).filesize
if (!$Size)
{
Write-Warning "Cannot detect database size via WMI for $($Database.Server.Name)"
[long]$Size = 0
[long]$Whitespace = 0
} else {
[long]$MailboxDeletedItemSizeB = 0
if ($MailboxStatistics)
{
$MailboxStatistics | %{ $MailboxDeletedItemSizeB+=$_.TotalDeletedItemSizeB }
}
$Whitespace = $Size - $MailboxItemSizeB - $MailboxDeletedItemSizeB
if ($Whitespace -lt 0) { $Whitespace = 0 }
}
$StorageGroup =$Database.DistinguishedName.Split(",")[1].Replace("CN=","")
}
@{Name = $Database.Name
StorageGroup = $StorageGroup
ActiveOwner = $Database.Server.Name.ToUpper()
MailboxCount = [long]([array]($Mailboxes | Where {$_.Database -eq $Database.Identity})).Count
MailboxAverageSize = $MailboxAverageSize
ArchiveMailboxCount = $ArchiveMailboxCount
ArchiveAverageSize = $ArchiveAverageSize
CircularLoggingEnabled = $CircularLoggingEnabled
LastFullBackup = $LastFullBackup
Size = $Size
Whitespace = $Whitespace
Copies = $Copies
CopyCount = $CopyCount
FreeLogDiskSpace = $FreeLogDiskSpace
FreeDatabaseDiskSpace = $FreeDatabaseDiskSpace
}
}
# Sub-Function to get mailbox count per server.
# New in 1.5.2
function _GetExSvrMailboxCount
{
param($Mailboxes,$ExchangeServer,$Databases)
# The following *should* work, but it doesn't. Apparently, ServerName is not always returned correctly which may be the cause of
# reports of counts being incorrect
#([array]($Mailboxes | Where {$_.ServerName -eq $ExchangeServer.Name})).Count
# ..So as a workaround, I'm going to check what databases are assigned to each server and then get the mailbox counts on a per-
# database basis and return the resulting total. As we already have this information resident in memory it should be cheap, just
# not as quick.
$MailboxCount = 0
foreach ($Database in [array]($Databases | Where {$_.Server -eq $ExchangeServer.Name}))
{
$MailboxCount+=([array]($Mailboxes | Where {$_.Database -eq $Database.Identity})).Count
}
$MailboxCount
}
# Sub-Function to Get Exchange Server information
function _GetExSvr
{
param($E2010,$ExchangeServer,$Mailboxes,$Databases)
# Set Basic Variables
$MailboxCount = 0
$RollupLevel = 0
$RollupVersion = ""
# Get WMI Information
$tWMI = Get-WmiObject Win32_OperatingSystem -ComputerName $ExchangeServer.Name -ErrorAction SilentlyContinue
if ($tWMI)
{
$OSVersion = $tWMI.Caption.Replace("(R)","").Replace("Microsoft ","").Replace("Enterprise","Ent").Replace("Standard","Std").Replace(" Edition","")
$OSServicePack = $tWMI.CSDVersion
$RealName = $tWMI.CSName.ToUpper()
} else {
Write-Warning "Cannot detect OS information via WMI for $($ExchangeServer.Name)"
$OSVersion = "N/A"
$OSServicePack = "N/A"
$RealName = $ExchangeServer.Name.ToUpper()
}
$tWMI=Get-WmiObject -query "Select * from Win32_Volume" -ComputerName $ExchangeServer.Name -ErrorAction SilentlyContinue
if ($tWMI)
{
$Disks=$tWMI | Select Name,Capacity,FreeSpace | Sort-Object -Property Name
} else {
Write-Warning "Cannot detect OS information via WMI for $($ExchangeServer.Name)"
$Disks=$null
}
# Get Exchange Version
if ($ExchangeServer.AdminDisplayVersion.Major -eq 6)
{
$ExchangeMajorVersion = "$($ExchangeServer.AdminDisplayVersion.Major).$($ExchangeServer.AdminDisplayVersion.Minor)"
$ExchangeSPLevel = $ExchangeServer.AdminDisplayVersion.FilePatchLevelDescription.Replace("Service Pack ","")
} else {
$ExchangeMajorVersion = $ExchangeServer.AdminDisplayVersion.Major
$ExchangeSPLevel = $ExchangeServer.AdminDisplayVersion.Minor
}
# Exchange 2007+
if ($ExchangeMajorVersion -ge 8)
{
# Get Roles
$MailboxStatistics=$null
[array]$Roles = $ExchangeServer.ServerRole.ToString().Replace(" ","").Split(",");
if ($Roles -contains "Mailbox")
{
$MailboxCount = _GetExSvrMailboxCount -Mailboxes $Mailboxes -ExchangeServer $ExchangeServer -Databases $Databases
if ($ExchangeServer.Name.ToUpper() -ne $RealName)
{
$Roles = [array]($Roles | Where {$_ -ne "Mailbox"})
$Roles += "ClusteredMailbox"
}
# Get Mailbox Statistics the normal way, return in a consitent format
$MailboxStatistics = Get-MailboxStatistics -Server $ExchangeServer | Select DisplayName,@{Name="TotalItemSizeB";Expression={$_.TotalItemSize.Value.ToBytes()}},@{Name="TotalDeletedItemSizeB";Expression={$_.TotalDeletedItemSize.Value.ToBytes()}},Database
}
# Rollup Level / Versions (Thanks to Bhargav Shukla http://bit.ly/msxGIJ)
if ($ExchangeMajorVersion -ge 14)
{
$RegKey="SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\Installer\\UserData\\S-1-5-18\\Products\\AE1D439464EB1B8488741FFA028E291C\\Patches"
} else {
$RegKey="SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\Installer\\UserData\\S-1-5-18\\Products\\461C2B4266EDEF444B864AD6D9E5B613\\Patches"
}
$RemoteRegistry = [Microsoft.Win32.RegistryKey]::OpenRemoteBaseKey('LocalMachine', $ExchangeServer.Name);
if ($RemoteRegistry)
{
$RUKeys = $RemoteRegistry.OpenSubKey($RegKey).GetSubKeyNames() | ForEach {"$RegKey\\$_"}
if ($RUKeys)
{
[array]($RUKeys | %{$RemoteRegistry.OpenSubKey($_).getvalue("DisplayName")}) | %{
if ($_ -like "Update Rollup *")
{
$tRU = $_.Split(" ")[2]
if ($tRU -like "*-*") { $tRUV=$tRU.Split("-")[1]; $tRU=$tRU.Split("-")[0] } else { $tRUV="" }
if ($tRU -ge $RollupLevel) { $RollupLevel=$tRU; $RollupVersion=$tRUV }
}
}
}
} else {
Write-Warning "Cannot detect Rollup Version via Remote Registry for $($ExchangeServer.Name)"
}
}
# Exchange 2003
if ($ExchangeMajorVersion -eq 6.5)
{
# Mailbox Count
$MailboxCount = _GetExSvrMailboxCount -Mailboxes $Mailboxes -ExchangeServer $ExchangeServer -Databases $Databases
# Get Role via WMI
$tWMI = Get-WMIObject Exchange_Server -Namespace "root\microsoftexchangev2" -Computername $ExchangeServer.Name -Filter "Name='$($ExchangeServer.Name)'"
if ($tWMI)
{
if ($tWMI.IsFrontEndServer) { $Roles=@("FE") } else { $Roles=@("BE") }
} else {
Write-Warning "Cannot detect Front End/Back End Server information via WMI for $($ExchangeServer.Name)"
$Roles+="Unknown"
}
# Get Mailbox Statistics using WMI, return in a consistent format
$tWMI = Get-WMIObject -class Exchange_Mailbox -Namespace ROOT\MicrosoftExchangev2 -ComputerName $ExchangeServer.Name -Filter ("ServerName='$($ExchangeServer.Name)'")
if ($tWMI)
{
$MailboxStatistics = $tWMI | Select @{Name="DisplayName";Expression={$_.MailboxDisplayName}},@{Name="TotalItemSizeB";Expression={$_.Size}},@{Name="TotalDeletedItemSizeB";Expression={$_.DeletedMessageSizeExtended }},@{Name="Database";Expression={((get-mailboxdatabase -Identity "$($_.ServerName)\$($_.StorageGroupName)\$($_.StoreName)").identity)}}
} else {
Write-Warning "Cannot retrieve Mailbox Statistics via WMI for $($ExchangeServer.Name)"
$MailboxStatistics = $null
}
}
# Exchange 2000
if ($ExchangeMajorVersion -eq "6.0")
{
# Mailbox Count
$MailboxCount = _GetExSvrMailboxCount -Mailboxes $Mailboxes -ExchangeServer $ExchangeServer -Databases $Databases
# Get Role via ADSI
$tADSI=[ADSI]"LDAP://$($ExchangeServer.OriginatingServer)/$($ExchangeServer.DistinguishedName)"
if ($tADSI)
{
if ($tADSI.ServerRole -eq 1) { $Roles=@("FE") } else { $Roles=@("BE") }
} else {
Write-Warning "Cannot detect Front End/Back End Server information via ADSI for $($ExchangeServer.Name)"
$Roles+="Unknown"
}
$MailboxStatistics = $null
}
# Return Hashtable
@{Name = $ExchangeServer.Name.ToUpper()
RealName = $RealName
ExchangeMajorVersion = $ExchangeMajorVersion
ExchangeSPLevel = $ExchangeSPLevel
Edition = $ExchangeServer.Edition
Mailboxes = $MailboxCount
OSVersion = $OSVersion;
OSServicePack = $OSServicePack
Roles = $Roles
RollupLevel = $RollupLevel
RollupVersion = $RollupVersion
Site = $ExchangeServer.Site.Name
MailboxStatistics = $MailboxStatistics
Disks = $Disks
}
}
# Sub Function to Get Totals by Version
function _TotalsByVersion
{
param($ExchangeEnvironment)
$TotalMailboxesByVersion=@{}
if ($ExchangeEnvironment.Sites)
{
foreach ($Site in $ExchangeEnvironment.Sites.GetEnumerator())
{
foreach ($Server in $Site.Value)
{
if (!$TotalMailboxesByVersion["$($Server.ExchangeMajorVersion).$($Server.ExchangeSPLevel)"])
{
$TotalMailboxesByVersion.Add("$($Server.ExchangeMajorVersion).$($Server.ExchangeSPLevel)",@{ServerCount=1;MailboxCount=$Server.Mailboxes})
} else {
$TotalMailboxesByVersion["$($Server.ExchangeMajorVersion).$($Server.ExchangeSPLevel)"].ServerCount++
$TotalMailboxesByVersion["$($Server.ExchangeMajorVersion).$($Server.ExchangeSPLevel)"].MailboxCount+=$Server.Mailboxes
}
}
}
}
if ($ExchangeEnvironment.Pre2007)
{
foreach ($FakeSite in $ExchangeEnvironment.Pre2007.GetEnumerator())
{
foreach ($Server in $FakeSite.Value)
{
if (!$TotalMailboxesByVersion["$($Server.ExchangeMajorVersion).$($Server.ExchangeSPLevel)"])
{
$TotalMailboxesByVersion.Add("$($Server.ExchangeMajorVersion).$($Server.ExchangeSPLevel)",@{ServerCount=1;MailboxCount=$Server.Mailboxes})
} else {
$TotalMailboxesByVersion["$($Server.ExchangeMajorVersion).$($Server.ExchangeSPLevel)"].ServerCount++
$TotalMailboxesByVersion["$($Server.ExchangeMajorVersion).$($Server.ExchangeSPLevel)"].MailboxCount+=$Server.Mailboxes
}
}
}
}
$TotalMailboxesByVersion
}
# Sub Function to Get Totals by Role
function _TotalsByRole
{
param($ExchangeEnvironment)
# Add Roles We Always Show
$TotalServersByRole=@{"ClientAccess" = 0
"HubTransport" = 0
"UnifiedMessaging" = 0
"Mailbox" = 0
"Edge" = 0
}
if ($ExchangeEnvironment.Sites)
{
foreach ($Site in $ExchangeEnvironment.Sites.GetEnumerator())
{
foreach ($Server in $Site.Value)
{
foreach ($Role in $Server.Roles)
{
if ($TotalServersByRole[$Role] -eq $null)
{
$TotalServersByRole.Add($Role,1)
} else {
$TotalServersByRole[$Role]++
}
}
}
}
}
if ($ExchangeEnvironment.Pre2007["Pre 2007 Servers"])
{
foreach ($Server in $ExchangeEnvironment.Pre2007["Pre 2007 Servers"])
{
foreach ($Role in $Server.Roles)
{
if ($TotalServersByRole[$Role] -eq $null)
{
$TotalServersByRole.Add($Role,1)
} else {
$TotalServersByRole[$Role]++
}
}
}
}
$TotalServersByRole
}
# Sub Function to return HTML Table for Sites/Pre 2007
function _GetOverview
{
param($Servers,$ExchangeEnvironment,$ExRoleStrings,$Pre2007=$False)
if ($Pre2007)
{
$BGColHeader="#880099"
$BGColSubHeader="#8800CC"
$Prefix=""
} else {
$BGColHeader="#000099"
$BGColSubHeader="#0000FF"
$Prefix="Site:"
}
$Output="
";
#$Output+="";
$ExchangeEnvironment.TotalServersByRole.GetEnumerator()|Sort Name| %{$Output+=""}
$Output+="| $($Prefix) $($Servers.Key) | Exchange Version | Roles Installed | OS Version | OS Service Pack |
"
$TotalMailboxes=0
$Servers.Value | %{$TotalMailboxes += $\_.Mailboxes}
$Output+="| Mailboxes: $($TotalMailboxes) | |"
$ExchangeEnvironment.TotalServersByRole.GetEnumerator()|Sort Name| %{$Output+=" $($ExRoleStrings[$\_.Key].Short) |"}
$Output+=" | |
"
$AlternateRow=0
foreach ($Server in $Servers.Value)
{
$Output+="|| Server |"
if ($ShowStorageGroups)
{
$Output+=" Storage Group |"
}
$Output+=" Database Name | Mailboxes | Av. Mailbox Size |"
if ($ShowArchiveDBs)
{
$Output+=" Archive MBs | Av. Archive Size |"
}
$Output+=" DB Size | DB Whitespace |"
if ($ShowFreeDatabaseSpace)
{
$Output+=" Database Disk Free |"
}
if ($ShowFreeLogDiskSpace)
{
$Output+=" Log Disk Free |"
}
if ($ShowLastFullBackup)
{
$Output+=" Last Full Backup |"
}
if ($ShowCircularLogging)
{
$Output+=" Circular Logging |"
}
if ($ShowCopies)
{
$Output+=" Copies (n) |"
}
$Output+="
| --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- |
"
$AlternateRow=0;
foreach ($Database in $Databases)
{
$Output+="$($Database.MailboxCount)
$("{0:N2}" -f ($Database.MailboxAverageSize/1MB)) MB |"
if ($ShowArchiveDBs)
{
$Output+=" $($Database.ArchiveMailboxCount) |
$("{0:N2}" -f ($Database.ArchiveAverageSize/1MB)) MB |";
}
$Output+=" $("{0:N2}" -f ($Database.Size/1GB)) GB |
$("{0:N2}" -f ($Database.Whitespace/1GB)) GB |";
if ($ShowFreeDatabaseSpace)
{
$Output+=" $("{0:N1}" -f $Database.FreeDatabaseDiskSpace)% |"
}
if ($ShowFreeLogDiskSpace)
{
$Output+=" $("{0:N1}" -f $Database.FreeLogDiskSpace)% |"
}
if ($ShowLastFullBackup)
{
$Output+=" $($Database.LastFullBackup) |";
}
if ($ShowCircularLogging)
{
$Output+=" $($Database.CircularLoggingEnabled) |";
}
if ($ShowCopies)
{
$Output+=" $($Database.Copies|%{$\_}) ($($Database.CopyCount)) |"
}
$Output+="
";
}
$Output+="
"
$Output
}
# Sub Function to neatly update progress
function _UpProg1
{
param($PercentComplete,$Status,$Stage)
$TotalStages=5
Write-Progress -id 1 -activity "Get-ExchangeEnvironmentReport" -status $Status -percentComplete (($PercentComplete/$TotalStages)+(1/$TotalStages*$Stage*100))
}
# 1. Initial Startup
# 1.0 Check Powershell Version
if ((Get-Host).Version.Major -eq 1)
{
throw "Powershell Version 1 not supported";
}
# 1.1 Check Exchange Management Shell, attempt to load
if (!(Get-Command Get-ExchangeServer -ErrorAction SilentlyContinue))
{
if (Test-Path "C:\Program Files\Microsoft\Exchange Server\V14\bin\RemoteExchange.ps1")
{
. 'C:\Program Files\Microsoft\Exchange Server\V14\bin\RemoteExchange.ps1'
Connect-ExchangeServer -auto
} elseif (Test-Path "C:\Program Files\Microsoft\Exchange Server\bin\Exchange.ps1") {
Add-PSSnapIn Microsoft.Exchange.Management.PowerShell.Admin
.'C:\Program Files\Microsoft\Exchange Server\bin\Exchange.ps1'
} else {
throw "Exchange Management Shell cannot be loaded"
}
}
# 1.2 Check if -SendMail parameter set and if so check -MailFrom, -MailTo and -MailServer are set
if ($SendMail)
{
if (!$MailFrom -or !$MailTo -or !$MailServer)
{
throw "If -SendMail specified, you must also specify -MailFrom, -MailTo and -MailServer"
}
}
# 1.3 Check Exchange Management Shell Version
if ((Get-PSSnapin -Name Microsoft.Exchange.Management.PowerShell.Admin -ErrorAction SilentlyContinue))
{
$E2010 = $false;
if (Get-ExchangeServer | Where {$_.AdminDisplayVersion.Major -gt 14})
{
Write-Warning "Exchange 2010 or higher detected. You'll get better results if you run this script from an Exchange 2010 management shell"
}
}else{
$E2010 = $true
$localserver = get-exchangeserver $Env:computername
$localversion = $localserver.admindisplayversion.major
if ($localversion -eq 15) { $E2013 = $true }
}
# 1.4 Check view entire forest if set (by default, true)
if ($E2010)
{
Set-ADServerSettings -ViewEntireForest:$ViewEntireForest
} else {
$global:AdminSessionADSettings.ViewEntireForest = $ViewEntireForest
}
# 1.5 Initial Variables
# 1.5.1 Hashtable to update with environment data
$ExchangeEnvironment = @{Sites = @{}
Pre2007 = @{}
Servers = @{}
DAGs = @()
NonDAGDatabases = @()
}
# 1.5.7 Exchange Major Version String Mapping
$ExMajorVersionStrings = @{"6.0" = @{Long="Exchange 2000";Short="E2000"}
"6.5" = @{Long="Exchange 2003";Short="E2003"}
"8" = @{Long="Exchange 2007";Short="E2007"}
"14" = @{Long="Exchange 2010";Short="E2010"}
"15" = @{Long="Exchange 2013";Short="E2013"}}
# 1.5.8 Exchange Service Pack String Mapping
$ExSPLevelStrings = @{"0" = "RTM"
"1" = "SP1"
"2" = "SP2"
"3" = "SP3"
"4" = "SP4"}
# 1.5.9 Populate Full Mapping using above info
$ExVersionStrings = @{}
foreach ($Major in $ExMajorVersionStrings.GetEnumerator())
{
foreach ($Minor in $ExSPLevelStrings.GetEnumerator())
{
$ExVersionStrings.Add("$($Major.Key).$($Minor.Key)",@{Long="$($Major.Value.Long) $($Minor.Value)";Short="$($Major.Value.Short)$($Minor.Value)"})
}
}
# 1.5.10 Exchange Role String Mapping
$ExRoleStrings = @{"ClusteredMailbox" = @{Short="ClusMBX";Long="CCR/SCC Clustered Mailbox"}
"Mailbox" = @{Short="MBX";Long="Mailbox"}
"ClientAccess" = @{Short="CAS";Long="Client Access"}
"HubTransport" = @{Short="HUB";Long="Hub Transport"}
"UnifiedMessaging" = @{Short="UM";Long="Unified Messaging"}
"Edge" = @{Short="EDGE";Long="Edge Transport"}
"FE" = @{Short="FE";Long="Front End"}
"BE" = @{Short="BE";Long="Back End"}
"Unknown" = @{Short="Unknown";Long="Unknown"}}
# 2 Get Relevant Exchange Information Up-Front
# 2.1 Get Server, Exchange and Mailbox Information
_UpProg1 1 "Getting Exchange Server List" 1
$ExchangeServers = [array](Get-ExchangeServer $ServerFilter)
if (!$ExchangeServers)
{
throw "No Exchange Servers matched by -ServerFilter ""$($ServerFilter)"""
}
_UpProg1 10 "Getting Mailboxes" 1
$Mailboxes = [array](Get-Mailbox -ResultSize Unlimited) | Where {$_.Server -like $ServerFilter}
if ($E2010)
{
_UpProg1 60 "Getting Archive Mailboxes" 1
$ArchiveMailboxes = [array](Get-Mailbox -Archive -ResultSize Unlimited) | Where {$_.Server -like $ServerFilter}
_UpProg1 90 "Getting Databases" 1
if ($E2013)
{
$Databases = [array](Get-MailboxDatabase -IncludePreExchange2013 -Status) | Where {$_.Server -like $ServerFilter}
}
elseif ($E2010)
{
$Databases = [array](Get-MailboxDatabase -IncludePreExchange2010 -Status) | Where {$_.Server -like $ServerFilter}
}
$DAGs = [array](Get-DatabaseAvailabilityGroup) | Where {$_.Servers -like $ServerFilter}
} else {
$ArchiveMailboxes = $null
$ArchiveMailboxStats = $null
$DAGs = $null
_UpProg1 90 "Getting Databases" 1
$Databases = [array](Get-MailboxDatabase -IncludePreExchange2007 -Status) | Where {$_.Server -like $ServerFilter}
}
# 2.3 Populate Information we know
$ExchangeEnvironment.Add("TotalMailboxes",$Mailboxes.Count);
# 3 Process High-Level Exchange Information
# 3.1 Collect Exchange Server Information
for ($i=0; $i -lt $ExchangeServers.Count; $i++)
{
_UpProg1 ($i/$ExchangeServers.Count*100) "Getting Exchange Server Information" 2
# Get Exchange Info
$ExSvr = _GetExSvr -E2010 $E2010 -ExchangeServer $ExchangeServers[$i] -Mailboxes $Mailboxes -Databases $Databases
# Add to site or pre-Exchange 2007 list
if ($ExSvr.Site)
{
# Exchange 2007 or higher
if (!$ExchangeEnvironment.Sites[$ExSvr.Site])
{
$ExchangeEnvironment.Sites.Add($ExSvr.Site,@($ExSvr))
} else {
$ExchangeEnvironment.Sites[$ExSvr.Site]+=$ExSvr
}
} else {
# Exchange 2003 or lower
if (!$ExchangeEnvironment.Pre2007["Pre 2007 Servers"])
{
$ExchangeEnvironment.Pre2007.Add("Pre 2007 Servers",@($ExSvr))
} else {
$ExchangeEnvironment.Pre2007["Pre 2007 Servers"]+=$ExSvr
}
}
# Add to Servers List
$ExchangeEnvironment.Servers.Add($ExSvr.Name,$ExSvr)
}
# 3.2 Calculate Environment Totals for Version/Role using collected data
_UpProg1 1 "Getting Totals" 3
$ExchangeEnvironment.Add("TotalMailboxesByVersion",(_TotalsByVersion -ExchangeEnvironment $ExchangeEnvironment))
$ExchangeEnvironment.Add("TotalServersByRole",(_TotalsByRole -ExchangeEnvironment $ExchangeEnvironment))
# 3.4 Populate Environment DAGs
_UpProg1 5 "Getting DAG Info" 3
if ($DAGs)
{
foreach($DAG in $DAGs)
{
$ExchangeEnvironment.DAGs+=(_GetDAG -DAG $DAG)
}
}
# 3.5 Get Database information
_UpProg1 60 "Getting Database Info" 3
for ($i=0; $i -lt $Databases.Count; $i++)
{
$Database = _GetDB -Database $Databases[$i] -ExchangeEnvironment $ExchangeEnvironment -Mailboxes $Mailboxes -ArchiveMailboxes $ArchiveMailboxes -E2010 $E2010
$DAGDB = $false
for ($j=0; $j -lt $ExchangeEnvironment.DAGs.Count; $j++)
{
if ($ExchangeEnvironment.DAGs[$j].Members -contains $Database.ActiveOwner)
{
$DAGDB=$true
$ExchangeEnvironment.DAGs[$j].Databases += $Database
}
}
if (!$DAGDB)
{
$ExchangeEnvironment.NonDAGDatabases += $Database
}
}
# 4 Write Information
_UpProg1 5 "Writing HTML Report Header" 4
# Header
$Output="
### Exchange Environment Report
##### Generated $((Get-Date).ToString())
| Total Servers: | Total Mailboxes: | Total Roles: |
| --- | --- | --- |
|"
# Show Column Headings based on the Exchange versions we have
$ExchangeEnvironment.TotalMailboxesByVersion.GetEnumerator()|Sort Name| %{$Output+=" $($ExVersionStrings[$\_.Key].Short) |"}
$ExchangeEnvironment.TotalMailboxesByVersion.GetEnumerator()|Sort Name| %{$Output+=" $($ExVersionStrings[$\_.Key].Short) |"}
$Output+=" Org |"
$ExchangeEnvironment.TotalServersByRole.GetEnumerator()|Sort Name| %{$Output+=" $($ExRoleStrings[$\_.Key].Short) |"}
$Output+="|"
$Output+="|"
$ExchangeEnvironment.TotalMailboxesByVersion.GetEnumerator()|Sort Name| %{$Output+=" $($\_.Value.ServerCount) |" }
$ExchangeEnvironment.TotalMailboxesByVersion.GetEnumerator()|Sort Name| %{$Output+=" $($\_.Value.MailboxCount) |" }
$Output+=" $($ExchangeEnvironment.TotalMailboxes) |"
$ExchangeEnvironment.TotalServersByRole.GetEnumerator()|Sort Name| %{$Output+=" $($\_.Value) |"}
$Output+="
||
| |
"
# Sites and Servers
\_UpProg1 20 "Writing HTML Site Information" 4
foreach ($Site in $ExchangeEnvironment.Sites.GetEnumerator())
{
$Output+=\_GetOverview -Servers $Site -ExchangeEnvironment $ExchangeEnvironment -ExRoleStrings $ExRoleStrings
}
\_UpProg1 40 "Writing HTML Pre-2007 Information" 4
foreach ($FakeSite in $ExchangeEnvironment.Pre2007.GetEnumerator())
{
$Output+=\_GetOverview -Servers $FakeSite -ExchangeEnvironment $ExchangeEnvironment -ExRoleStrings $ExRoleStrings -Pre2007:$true
}
\_UpProg1 60 "Writing HTML DAG Information" 4
foreach ($DAG in $ExchangeEnvironment.DAGs)
{
if ($DAG.MemberCount -gt 0)
{
# Database Availability Group Header
$Output+="
| Database Availability Group Name | Member Count | Database Availability Group Members |
| $($DAG.Name) |
$($DAG.MemberCount) | "
$DAG.Members | % { $Output+="$($\_) " }
$Output+=" |
"
# Get Table HTML
$Output+=\_GetDBTable -Databases $DAG.Databases
}
}
if ($ExchangeEnvironment.NonDAGDatabases.Count)
{
\_UpProg1 80 "Writing HTML Non-DAG Database Information" 4
$Output+="
| Mailbox Databases (Non-DAG) |
| --- |
"
$Output+=\_GetDBTable -Databases $ExchangeEnvironment.NonDAGDatabases
}
# End
\_UpProg1 90 "Finishing off.." 4
$Output+="";
$Output | Out-File $HTMLReport
if ($SendMail)
{
_UpProg1 95 "Sending mail message.." 4
Send-MailMessage -Attachments $HTMLReport -To $MailTo -From $MailFrom -Subject "Exchange Environment Report" -BodyAsHtml $Output -SmtpServer $MailServer
}
if ($ScheduleAs)
{
_UpProg1 99 "Attempting to Schedule Task.." 4
$dir=(split-path -parent $myinvocation.mycommand.definition)
$params="-HTMLReport $HTMLReport"
if ($SendMail)
{
$params+=' -SendMail:$true'
$params+=" -MailFrom:$MailFrom -MailTo:$MailTo -MailServer:$MailServer"
}
$task = "powershell -c \""pushd $dir; $($myinvocation.mycommand.definition) $params\"""
Write-Output "Attempting to schedule task as $($ScheduleAs)..."
Write-Output "Task to schedule: $($task)"
schtasks /Create /RU $ScheduleAs /RP /SC DAILY /ST 22:00 /TN EER /TR $task
``` | https://habr.com/ru/post/170251/ | null | ru | null |
# Не нужно бояться Core Data
Давно подметил, что среди многих своих коллег по цеху присутствует некоторая подозрительность и даже в некотором роде неприязнь к Core Data, причем некоторые к фреймворку даже и не притрагивались. Чего уж там, и я в начале своего пути освоения новой платформы относился к нему предвзято, пойдя на поводу у подобных комментариев. Но не стоит поддаваться предрассудкам и мифам, не потрогав продукт самостоятельно. Тем из нас, кто пошел «против системы», но еще не постиг инструмент полностью, я и посвящаю эту статью. На основе небольшого примера, основанного на реальной задаче разработки мобильного клиента нашей социальной сети Мой Мир, я хочу рассказать о некоторых «подводных» камнях и заострить внимание начинающего разработчика на важных моментах оптимизации использования Core Data. Предполагается, что читающий уже имеет представление, для чего нужны основные элементы Core Data (`NSManagedObjectContext`, `NSPersistentStoreCoordinator` и т.д.) и хотя бы поверхностно ознакомлен с API.
Наш кейс: необходимо разработать приложение, позволяющее хранить и структурировать большой объем фотографий с различной метаинформацией о них. Для этого нам потребуется Core Data… и все.
[](http://habrahabr.ru/company/mailru/blog/235941/)
Core Data Stack
===============
Итак, первое, что мы должны сделать — приготовить правильный Core Data стэк. К счастью для нас, есть универсальное решение, я думаю известный всем Best Practice от WWDC 2013:
[Стэк](https://github.com/Wisors/CDTTest/blob/master/CoreData%20Tests/CoreData/CDTCoreDataStack.m) разделяется на два контекста, Main Context используется на главном потоке для чтения данных; Background Context — для редактирования, вставки и удаления больших объемов данных. То есть, рекомендуется изначально строить архитектуру своего приложения так, что все изменения происходят в бэкграунд контексте, а на главном контексте вы выполняете лишь read-only операции.
Хочется отметить, что по архитектуре стэков написано немало статей, описывающих всевозможные ветвления контекстов. На мой взгляд, они лишь задирают порог вхождения использования Core Data и только отпугивают начинающих разработчиков от применения фреймворка. На деле для 90% приложений будет достаточно вышеприведенной модели, еще 9% будет достаточно вообще одного Main Context и только оставшимся ~~изваращ~~ хардкорщикам нужно что-то более сложное.
Тонкие моменты
==============
* Начиная с iOS 7 sqlite хранилище в отличие от предыдущих версий работает в режиме [WAL(Write Ahead Log) журналирования](http://www.sqlite.org/wal.html), который позволяет совершать одну операцию записи и множественные операции чтения параллельно. Если вдруг вы поддерживаете iOS 6, то возможно включить этот режим при создании координатора стэка в версиях iOS 4+ с помощью `NSSQLitePragmasOption`, однако это может быть чревато неприятностями. Также в iOS 6 в стэке с двумя координаторами при синхронизации контекстов через нотификацию [могут не обновляться объекты в них](http://stackoverflow.com/questions/19562119/coredata-threading-ios-6-vs-7). Поэтому для iOS 6 лучше использовать стек с двумя контекстами, имеющими общий координатор и не заморачиваться с режимом журналирования, процент активных устройств крайне низок.
* WAL также хранит в себе мину замедленного действия в виде поломанной ручной миграции и возможных ошибок бэкапирования. Так как хранилище на диске организовано в виде трех файлов: dbname.sqlite, dbname.sqlite-wal и dbname.sqlite-shm, то при организации ручного бэкапа нужно не забывать сохранять их всех, иначе потом вас будет ждать очень «приятный» сюрприз. Инженеры Apple видимо сами забыли о наличии WAL файла, поэтому при использовании Migration Manager мы также можем разломать базу. Сам я не сталкивался с подобной проблемой, почитать подробнее можно [здесь](http://pablin.org/2013/05/24/problems-with-core-data-migration-manager-and-journal-mode-wal/).
* Типичные мануалы по Core Data и шаблон проекта в Xcode предлагают размещать стэк прямо в классе `AppDelegate` и инициализировать всё необходимое во время запуска приложения. Однако если в вашем приложении работа с базой имеет эпизодический или опциональный характер (например, она нужна только после регистрации пользователя в приложении и не нужна при гостевом доступе), имеет смысл вынести стек «в бок». Для этого подойдет отдельный `Singleton` класс, который будет инициализироваться непосредственно в тот момент, когда это действительно нужно. Это позволит сохранить существенный объем памяти и сократить время запуска приложения.
Проектирование модели
=====================
Продумывание схемы данных — самый важный момент при работе с Core Data. Исправление ошибки, допущенной на этапе проектирования архитектуры, может стоить разработчику кучу времени и нервов. Идеальный вариант, если после выхода в бой модель не изменяется. В реальности, если вам не придется прибегать к ручной миграции через Migration Manager и все изменения проглатываются [Lightweight Migration](https://developer.apple.com/library/ios/documentation/cocoa/conceptual/CoreDataVersioning/Articles/vmLightweightMigration.html) — вы молодец. Уделяйте этому этапу как можно больше времени и старайтесь экспериментировать с разными вариантами моделей.
Вернемся к нашему приложению, в нем мы хотим добиться следующих целей:
— ~~синхронизировать фотографии с сервером без аффекта на UI~~ (done! используем для этого Background Context в стэке);
— на главном экране показывать все фото, отсортированные по дате;
— на вторичном экране группировать фото, где критерии группировки — число лайков, фото внутри группы дополнительно сортируются по дате.
Подойдем для начала к решению задачи в лоб, создадим модель, в которой будет всего одна Entity — наша фотография со всей метаинформацией:
Получилось очень просто, и, будь мы ленивыми разработчиками, на этом работа была бы закончена (и статью писал бы кто-то другой :)).
Для тестирования мы будем предполагать, что на главном экране мы нам потребуется простой `NSFetchRequest`, результаты которого мы затем покажем в `UICollectionView`:
А на дополнительном экране мы воспользуемся всей мощью `NSFetchedResultsController` для формирования секций и сортировки в них:
Определившись с нашей моделью, сделаем контрольный замер производительности на iPhone 5 для 10000 фото. Здесь и далее мы будем производить тестирование нашей модели на типичные операции, связанные с нашей моделью:
* Вставка 10000 объектов с последующим сохранением контекста
* Реквест всех 10000 объектов, отсортированных по одному полю (в нашем случае дата)
* Использование `NSFetchedResultsController` c сортировкой по 2 полям и формированием секций (сортировка по количеству лайков и дате, формирование секций по количеству лайков)
* Все тот же контроллер с использованием `fetchBatchSize` равным 30 (предполагаемое количество фотографий на экране галереи на телефоне), для оценки эффективности блочной выборки данных
Все данные в таблицах приведены в секундах, соответственно вставка 10000 наших фотографий на iPhone 5 займет чуть меньше двух секунд.
| | |
| --- | --- |
| Операции\Тип модели | Модель V1 |
| Insets (10000 objects) | 1.952 |
| NSFetchRequest (1 sort) | 0.500 |
| NSFetchedResultsController (2 sorts) | 0.717 |
| NSFetchedResultsController (2 sorts + batchSize) | 0.302 |
Индексы
=======
Хотя время исполнения может показаться несущественным, не стоит пренебрегать возможностью оптимизации. Более того, на старых устройствах операции выполняются в разы медленнее, и забывать об этом точно не стоит. Первая оптимизация самая легкая и известна каждому — попробуем добавить индекс для полей, которые участвуют в формируемых нами запросах, а именно *date* и *likes*:
| | | | |
| --- | --- | --- | --- |
| Операции\Тип модели | Модель V1 | V1+индекс | Diff |
| Insert (10000 objects) | 1.952 | 2.193 | +12% |
| NSFetchRequest (1 sort) | 0.500 | 0.168 | -66% |
| NSFetchedResultsController (2 sorts) | 0.717 | 0.657 | -8% |
| NSFetchedResultsController (2 sorts + batchSize) | 0.302 | 0.256 | -15% |
Довольно неплохой прирост производительности при минимальных затратах. Заметьте, что время добавления записей выросло, это обусловлено необходимостью построения индекса. Именно поэтому важно применять индекс только там, где это действительно нужно. Проставляя флажок `Indexed` на все возможные поля, думая что это ускорит ваше приложение, вы делаете себе медвежью услугу.
Все ли соки мы выжали из индекса? Можно заметить, что `NSFetchedResultsController` «ускорился» значительно в меньшей степени, чем простой `NSFetchRequest`. В чем же дело?
Составные индексы
=================
Давайте заглянем под капот CoreData. В первую очередь для этого нам нужно включить лог для Core Data запросов, добавив в Run схему нашего проекта параметр " -com.apple.CoreData.SQLDebug 1" как на рисунке:
Далее нам необходим файл sqlite хранилища в его наполненном состоянии. Если вы работаете с симулятором, то Хcode 6 хранит файловую систему симуляторов в директории "~/Library/Developer/CoreSimulator/Devices/". Название директории симулятора соответствует значению Identifier, который можно посмотреть в списке устройств (открывается по Shitft+CMD+2). Далее ищем директорию своего приложения и узнаем полный путь до .sqlite файла, который обычно размещают в директории Documents приложения. Если же вы хотите получить доступ к хранилищу на устройстве, то самый простой способ воспользоваться приложением iExplorer, используя его как файл-менеджер для просмотра директорий приложений на вашем девайсе. Оттуда вы можете скопировать файлы хранилища (не забывайте про .sqlite-wal и .sqlite-shm файлы) в любую удобную вам директорию. Все, что осталось сделать — это подключиться к нашему хранилищу из консоли, выполнив команду:
```
sqlite3 PATH/TO/SQLITE/FILE
```
Теперь, запустив наш проект и скормив SQL директиве "**EXPLAIN QUERY PLAN**" запрос из логов Core Data, мы можем узнать некоторые подробности происходящих в sqlite процессов. Посмотрим, что же происходит на самом деле при выполнение `NSFetchRequest`:
```
sqlite> EXPLAIN QUERY PLAN SELECT 0, t0.Z_PK, t0.Z_OPT, t0.ZASSETURL, t0.ZCOUNTRY, t0.ZDATE, t0.ZHEIGHT, t0.ZLATITUDE, t0.ZLIKES, t0.ZLOCATIONDESC, t0.ZLONGITUDE, t0.ZSIZE, t0.ZWIDTH FROM ZCDTMOPHOTOV1INDEX t0 ORDER BY t0.ZDATE;
0|0|0|SCAN TABLE ZCDTMOPHOTOV1INDEX AS t0 USING INDEX ZCDTMOPHOTOV1INDEX_ZDATE_INDEX
```
Как и ожидалось SQL-запрос использует индекс, что и привело к существенному ускорению. А что же происходит в `NSFetchedResultsController`:
```
sqlite> EXPLAIN QUERY PLAN SELECT 0, t0.Z_PK, t0.Z_OPT, t0.ZASSETURL, t0.ZCOUNTRY, t0.ZDATE, t0.ZHEIGHT, t0.ZLATITUDE, t0.ZLIKES, t0.ZLOCATIONDESC, t0.ZLONGITUDE, t0.ZSIZE, t0.ZWIDTH FROM ZCDTMOPHOTOV1INDEX t0 ORDER BY t0.ZLIKES DESC, t0.ZDATE DESC;
0|0|0|SCAN TABLE ZCDTMOPHOTOV1INDEX AS t0 USING INDEX ZCDTMOPHOTOV1INDEX_ZLIKES_INDEX
0|0|0|USE TEMP B-TREE FOR RIGHT PART OF ORDER BY
```
Тут дела обстоят несколько хуже, индекс сработал только для *likes*, а для сортировки по дате создается временное бинарное дерево. Оптимизировать такое поведение легко, создав составной индекс (compound index) для обоих полей участвующих в запросе (CAUTION: если в вашем запросе появится дополнительное условие, например WHERE, с каким-то третьим полем, то его также необходимо добавить к составному индексу, иначе он не будет использоваться при запросе). Делается это очень легко в Data Model Inspector, указав через запятую все поля, включаемые в составной индекс, в списке Indexes нашей фото Entity:
Посмотрим, как теперь будет обрабатываться SQL-запрос:
```
sqlite> EXPLAIN QUERY PLAN SELECT 0, t0.Z_PK, t0.Z_OPT, t0.ZASSETURL, t0.ZCOUNTRY, t0.ZDATE, t0.ZHEIGHT, t0.ZLATITUDE, t0.ZLIKES, t0.ZLOCATIONDESC, t0.ZLONGITUDE, t0.ZSIZE, t0.ZWIDTH FROM ZCDTMOPHOTOV1COMPOUNDINDEX t0 ORDER BY t0.ZLIKES DESC, t0.ZDATE DESC;
0|0|0|SCAN TABLE ZCDTMOPHOTOV1COMPOUNDINDEX AS t0 USING INDEX ZCDTMOPHOTOV1COMPOUNDINDEX_ZLIKES_ZDATE
```
Можно убедиться, что вместо бинарного дерева используется составной индекс, и это не может не сказаться на производительности:
| | | | | |
| --- | --- | --- | --- | --- |
| Операции\Тип модели | Модель V1 | V1+индекс | V1+составной индекс | Diff(V1) |
| Insert (10000 objects) | 1.952 | 2.193 | 2.079 | +7% |
| NSFetchRequest (1 sort) | 0.500 | 0.168 | 0.169 | -66% |
| NSFetchedResultsController (2 sorts) | 0.717 | 0.657 | 0.331 | -54% |
| NSFetchedResultsController (2 sorts + batchSize) | 0.302 | 0.256 | 0.182 | -40% |
Разбиение сущностей
===================
Еще одна возможность для оптимизации — создание сущностей, которые содержат только нужную нам в конкретном запросе информацию. Мы видим, что наша структура содержит множество второстепенных полей, никак не участвующих в формировании выдачи первоначального результата в наших контроллерах. Более того, Core Data при работе с объектом полностью вытягивает их в память, то есть чем больше структура, тем больше потребляемой памяти (прим. в iOS 8 появилось API, позволяющее изменять объекты прямо в хранилище; API довольно ограничено в использовании, так как накладывает дополнительные требования на синхронизацию контекстов). В нашем приложении само собой напрашивается разделение нашей записи на две: сама фотография и метаданные для нее:
Проведем очередной тест и посмотрим на работу индексов для такой модели.
| | | | |
| --- | --- | --- | --- |
| Операции\Тип модели | Модель V2 | V2+индекс | Diff(V1+индекс) |
| Insert (10000 objects) | 3.218 | 3.524 | +61% |
| NSFetchRequest (1 sort) | 0.219 | 0.215 | +28% |
| NSFetchedResultsController (2 sorts) | 0.551 | 0.542 | -18% |
| NSFetchedResultsController (2 sorts + batchSize) | 0.387 | 0.390 | +52% |
Результаты этого теста довольно интересны. Обратите внимание, что скорость данной модели с использованием индекса идентична с учетом погрешности модели без него. Воспользовавшись уже известным нам способом заглянуть вглубь, мы можем обнаружить, что в обоих случаях индекс не задействуется, поскольку первым происходит JOIN метаданных, и только потом производятся сортировки в объединенной таблице:
```
sqlite> EXPLAIN QUERY PLAN SELECT 0, t0.Z_PK, t0.Z_OPT, t0.ZASSETURL, t0.ZMETA FROM ZCDTMOPHOTOV2INDEX t0 LEFT OUTER JOIN ZCDTMOPHOTOMETAINDEX t1 ON t0.ZMETA = t1.Z_PK ORDER BY t1.ZLIKES DESC, t1.ZDATE DESC;
0|0|0|SCAN TABLE ZCDTMOPHOTOV2INDEX AS t0
0|1|1|SEARCH TABLE ZCDTMOPHOTOMETAINDEX AS t1 USING INTEGER PRIMARY KEY (rowid=?)
0|0|0|USE TEMP B-TREE FOR ORDER BY
```
Итог: эта модель нам не подходит.
Нормализация
============
Продолжаем наши эксперименты. Мы убедились, что строгая нормализация данных не всегда есть хорошо для Core Data. Результаты прошлой модели оказались далеки от ожидаемых. Попробуем это исправить. Для этого достаточно продублировать наши поля *date* и *likes* в сущности фотографии (не забыв добавить составной индекс и отдельный для date), тем самым избежать необходимости LEFT OUTER JOIN в наших запросах. Решение оставлять или удалять эти поля в сущности метаданных нужно принять в зависимости от ситуации. Например, если дополтительно вы захотите сделать запрос с рейтингом стран по сумме лайков фотографий, сделанных в них, то при удалении этих полей мы опять столкнемся с необходимость делать JOIN, но уже в другую сторону связи. В нашем тесте свойства сущностей дублируются, и это совершенно нормальное являение для Core Data:
Посмотрим на результаты тестирования:
| | | | |
| --- | --- | --- | --- |
| Операции\Тип модели | Модель V3 | Diff(V1+составной индекс) | Diff(V1) |
| Insert (10000 objects) | 3.861 | +86% | +98% |
| NSFetchRequest (1 sort) | 0.115 | -32% | -77% |
| NSFetchedResultsController (2 sorts) | 0.283 | -15% | -61% |
| NSFetchedResultsController (2 sorts + batchSize) | 0.181 | -1% | -40% |
Эксперимент удался, мы добились ускорения операций чтения, которые являются основными в приложении до 40% в сравнении с самой быстрой плоской моделью и до 80% с первоначальным вариантом без индексов.
Итоги и тонкие моменты
======================
* Применяйте индексы и используйте их только для актуальных в ваших запросах полей. Не забывайте о существование составных индексов
* Экспериментируйте с разными схемами, тестируйте их производительность. Это очень просто, ведь в Xcode 6 появилась встроенная поддержка perfomance тестов.
* Не забывайте проверять как CoreData фреймворк генерирует SQL-запросы, используя логи. С помощью "*EXPLAIN QUERY PLAN*" изучайте как sqlite переваривает ваш SQL запрос.
* При обращении к результатам `NSFetchedResultsController` используйте только метод доступа, предоставляемый самим контроллером:
```
NSManagedObject *object = [controller objectAtIndexPath:indexPath];
```
Не стоит обращаться к массиву `fetchedObjects` или по протоколу *NSFetchedResultsSectionInfo* к массиву объектов секции:
```
NSManagedObject *object = [[controller fetchedObjects] objectAtIndex:index];
// или
NSArray *objects = [[[controller sections] objectAtIndex:sectionIndex] objects];
NSManagedObject *object = [objects objectAtIndex:index];
```
Почему, спросите вы? Если вы используете `fetchBatchSize` размером N, то после выполнения запроса контроллером в память будет загружено только первые N объектов (либо первая секция, если размер блока больше размера секции!). Как только вы запросите первый fault-объект за пределами загруженного блока или объект из другой секции, то контроллер произведет полный проход по результатам вашего запроса, то есть выполнит *N=количествоОбъектов / fetchBatchSize* запросов к хранилищу. Это операция приблизительно в 3-4 раза медленнее, чем простой запрос на все элементы. При использовании доступа через `objectAtIndexPath` такое поведение не наблюдается. Буду очень рад, если среди читающих найдется кто-то, кто может пролить свет на такое странное поведение, не описанное в документации.
* Нормализация — не всегда лучшее решение для Core Data
* Если со сцены в Купертино вам говорят о том, что новый iPhone в 2 раза быстрее предыдущего… нужно этому верить, на Core Data операциях эти утверждения подтверждаются практически полностью. Я подготовил сводный файл с результатами, где вы также найдете тесты iPhone 5S. Практически по всем результатам он быстрее своего предшественника в 2 раза. Соответвенно, на еще актуальном iPhone 4S эти результаты будут примерно в 2 раза медленнее, не говоря уже о еще более старых устройствах. [Здесь](https://cloud.mail.ru/public/6f25710d0d0c%2FCDT.xlsx) вы найдете сводную таблицу результатов, в которой также есть результаты нового iPhone 6.
Как вы можете заменить, Core Data является не только простым средством работы с данными, но и мощным инструментом в умелых руках. Исследуйте и экспериментируйте, а я надеюсь, что статья открыла для вас что-то новое и подтолкнула навстречу к более эффективному применению Core Data в своих проектах. Удачи! | https://habr.com/ru/post/235941/ | null | ru | null |
# PHP-Дайджест № 99 – итоги 2016 года и подборка интересных ссылок (11 – 25 декабря 2016)
[](https://habrahabr.ru/company/zfort/blog/318410/)
По традиции, подведем итоги уходящего года и вспомним самые значимые события в мире PHP, которых, к счастью, было немало. И конечно же, подборка со ссылками на свежие материалы за последние две недели.
С наступающим Новым годом! Приятного чтения.
 Уходящий год можно по праву назвать годом PHP 7. Несмотря на то что седьмая версия интерпретатора вышла в 2015, именно в этом году крупные компании перешли на PHP 7: [Badoo](https://habrahabr.ru/company/badoo/blog/279047/), [Tumblr](https://engineering.tumblr.com/post/152998126990/php-7-at-tumblr), [Dailymotion](http://engineering.dailymotion.com/php-7-deployment-at-dailymotion/), [WordPress.com](https://twitter.com/WordCampUS/status/805164029371158528), [Etsy](https://speakerdeck.com/wcgallego/hitting-the-turbo-button-upgrading-to-php-7-at-etsy-1) (сменили HHVM на PHP 7). Некоторые даже называли графики падения нагрузки на серверах после обновления не иначе как «php7 porn». В следующем году для фреймворков [Laravel 5.5](https://twitter.com/taylorotwell/status/809767371774816256) и [Symfony 4](https://twitter.com/fabpot/status/809743412715016192) минимальной версией станет PHP 7.
Конец года ознаменовался выпуском новой мажорной версии интерпретатора — [PHP 7.1](http://php.net/archive/2016.php#id2016-12-01-3) с [массой улучшений](https://wiki.php.net/rfc#php_71).
Параллельно шла работа и над следующей версией 7.2 и уже принят [ряд RFC](https://wiki.php.net/rfc#php_next_72). Кроме того Дмитрий Стогов с командой [ведут работу над реализацией JIT](http://news.php.net/php.internals/95531).
В этом году ветка PHP 5.5 получила свой последний релиз [5.5.38](http://php.net/archive/2016.php#id2016-07-21-2) и больше не поддерживается. А ветка 5.6 в следующие два года будет получать [только обновления безопасности](http://php.net/supported-versions.php).
Альтернативные реализации PHP также остаются популярными. Известная HHVM получила [LTS релиз](http://hhvm.com/blog/11711/hhvm-3-15). Кроме того появились [Peachpie](http://www.peachpie.io/) — компилятор PHP для .NET, и [Tagua VM](https://github.com/tagua-vm/tagua-vm) — виртуальная машина на Rust.
Группа PHP-FIG, хоть и переживала некоторый [кризис](https://groups.google.com/forum/#!topic/php-fig/e9qZue8nZXM), была реформирована по плану [PHP-FIG 3.0](https://medium.com/@michaelcullumuk/fig-3-0-91dbfd21c93b#.rmshx47vc). А также выпустила в свет ряд новых стандартов:
* [PSR-13: Link definition interfaces — принят](http://www.php-fig.org/psr/psr-13/)
* [PSR-11 Container Interface — в ревью](https://github.com/container-interop/fig-standards/blob/master/proposed/container.md)
* [PSR-14 Event Manager — черновик](https://github.com/php-fig/fig-standards/blob/master/proposed/event-manager.md)
* [PSR-15 HTTP Middlewares — черновик](https://github.com/php-fig/fig-standards/blob/master/proposed/http-middleware/middleware.md)
* [PSR-16: Simple Cache — черновик](https://github.com/php-fig/fig-standards/blob/master/proposed/simplecache.md)
* [PSR-17 HTTP Factories — черновик](https://github.com/php-fig/fig-standards/blob/master/proposed/http-factory/http-factory.md)
А также в рамках Interoperability инициатив развиваются стандарты по более узким направлениям:
* [Asynchronous Interoperability](https://github.com/async-interop)
* [Container Interoperability](https://github.com/container-interop)
* [Configuration Interoperability](https://github.com/config-interop)
* [Framework Interoperability](https://github.com/framework-interop)
* [Event Bus Interoperability](https://github.com/php-eventbus-interop)
Популярный фреймворк в этом году обозначился последним релизом включающим улучшения в ветке 1.1 — [Yii 1.1.17](https://habrahabr.ru/post/275065/). И целым рядом обновлений актуальной второй версии фреймворка: [2.0.7](https://habrahabr.ru/post/277201/), [2.0.8](https://habrahabr.ru/post/282724/), [2.0.9](https://habrahabr.ru/post/305432/), [2.0.10](https://habrahabr.ru/post/313180/). Активно [планируется версия 2.1](https://github.com/yiisoft/yii2/wiki/Plan-for-next-major-versions), и начата работа в соответствующей ветке.
К core-команде [присоединился @dynasource](http://rmcreative.ru/blog/post/dynasource-prisoedinilsja-k-yii). Запущен новый [yiiframework.ru](https://yiiframework.ru). Yii получил [награду Tagline](http://yiiframework.ru/news/122/yii-polucil-nagradu-tagline-kak-lucsij-backend-frejmvork) как лучший backend-фреймворк. Была опубликована книга с рецептами по Yii 2 — [Yii 2 Application Development Cookbook](https://www.packtpub.com/web-development/yii2-application-development-cookbook-third-edition). А также в этом году прошли [конференция в Киеве](http://rmcreative.ru/blog/post/yii-2-conference-2016--otchjot-i-materialy) и [первый Хакатон по Yii](https://habrahabr.ru/post/304092/).
В этом году фреймворку [Symfony 2 исполнилось 5 лет](http://symfony.com/blog/symfony-2-0). А тем временем свет увидело целых 2 релиза: фреймворка [Symfony 3.1.0](http://symfony.com/blog/symfony-3-1-0-released) и [Symfony 3.2.0](http://symfony.com/blog/symfony-3-2-0-released). Пакеты Symfony были загружены уже [более 500 миллионов раз](http://symfony.com/blog/symfony-reaches-500-million-downloads).
Фреймворку [исполнилось 5 лет](https://laravel-news.com/laravel-turns-five). В середине года вышел релиз [Laravel 5.3](https://habrahabr.ru/post/308380/). А также доступен [план выхода ближайших версий](https://laravel-news.com/laravel-release-process), согласно которому 5.4 выйдет уже в начале следующего года, a 5.5 станет LTS версией и ожидается в июле 2017.
В этом году активно развивались платные продукты из экосистемы Laravel: [Forge](https://forge.laravel.com/), [Spark](https://spark.laravel.com/), [Envoyer](https://envoyer.io/).
Уходящий год ознаменовался долгожданным релизом [Zend Framework 3](https://framework.zend.com/blog/2016-06-28-zend-framework-3.html), работа над которым длилась почти 4 года. Репозиторий фреймворка [был переименован](https://framework.zend.com/blog/2016-05-03-zf-repo-rename.html) из zf2 в zendframework. По фреймворку доступна [книга](https://olegkrivtsov.github.io/using-zend-framework-3-book/html/), в том числе на русском. В это же время было объявлено о завершении поддержки [Zend Framework 1](https://framework.zend.com/blog/2016-06-28-zf1-eol.html). А также свет увидел [Zend Expressive](https://framework.zend.com/blog/2016-01-28-expressive-1.0-stable.html) — микрофреймворк для создания веб-приложения на основе PSR-7 middleware.
Среди других событий уходящего года следует выделить:
* [Composer 1.0.0](https://seld.be/notes/composer-goes-gold) — Первый стабильный релиз Composer
* [Phalcon 3.0.0](https://blog.phalconphp.com/post/phalcon-3-0-0-released) — LTS релиз популярного PECL-фреймворка
* [Go! AOP Framework 1.0.0](https://github.com/goaop/framework/releases/tag/1.0.0), [2.0.0](https://github.com/goaop/framework/releases/tag/2.0.0)
* [Энди Гутманс покинул Zend](https://andigutmans.com/2016/02/24/starting-a-new-journey/)
* [15 лет проекту Drupal](https://www.drupal.org/news/drupal-15-years-old-and-still-gaining-momentum)
А что бы вы выделили еще? Пишите в комментариях к посту!
### Новости и релизы
* [Приватный Packagist](https://medium.com/packagist/introducing-private-packagist-492553d10660#.l26apu3br) — Представлен [packagist.com](https://packagist.com/) — корпоративное SaaS решение для использования приватных зависимостей взамен [Satis](https://github.com/composer/satis) и [Toran Proxy](https://toranproxy.com/).
* [Phalcon 3.0.3](https://blog.phalconphp.com/post/phalcon-3-0-3-released-and-merry-christmas)
### PHP
* [RFC: Class-like Primitive Types](https://wiki.php.net/rfc/class-like_primitive_types) — Черновик предложения по реализации квазиобъектного поведения для примитивных типов. При этом их внутреннее представление не изменится и расширять их невозможно, но будет доступно использование `instanceof`, а в будущем — реализация общих предков, например, `\Number` для `float` и `int`.
* [RFC: Server-Side Request and Response Objects](https://wiki.php.net/rfc/request_response) — Предлагается включить в ядро анонсированное совсем недавно расширение [request](https://pecl.php.net/package/request), которое добавляет объекты Request и Response взамен суперглобальным массивам.
* [RFC: Debugging PDO Prepared Statement Emulation v2](https://wiki.php.net/rfc/debugging_pdo_prepared_statement_emulation_v2) — Принято предложение по эмуляции подготовленных выражений непосредственно в PHP для удобства отладки.
### Инструменты
* [pbudzon/dhcp-php](https://github.com/pbudzon/dhcp-php) — Реализация DHCP-сервера на PHP. [Пост](https://mysteriouscode.io/blog/dhcp-implementation-in-php/) и [видео демо](https://vimeo.com/195208678) в поддержку от автора.
* [clue/php-commander](https://github.com/clue/php-commander) — Инструмент для создания простых консольных приложений с лаконичным интерфейсом.
* [PHP API Clients](https://blog.wyrihaximus.net/2016/12/announcing-php-api-clients/) — Организация в рамках которой реализовываются асинхронные клиенты для различных сервисов.
* [naneau/php-obfuscator](https://github.com/naneau/php-obfuscator) — Обфускатор для PHP, который парсит код и подменяет имена переменных и т.п.
* [frickelbruder/kickoff](https://github.com/frickelbruder/kickoff) — Инструмент проверяет некоторые SEO-параметры сайта и предназначен для использования в CI.
* [mgp25/Instagram-API](https://github.com/mgp25/Instagram-API) — Библиотека реализует скрытые в официальном API возможности Instagram.
### Материалы для обучения
* ##### Symfony
+ [Symfony: миф о раздутом фреймворке](http://matmati.net/symfony-myth-bloated-framework/)
+ [Неделя Symfony #520 (12-18 декабря 2016)](http://symfony.com/blog/a-week-of-symfony-520-12-18-december-2016)
+ [Неделя Symfony #521 (19-25 декабря 2016)](http://symfony.com/blog/a-week-of-symfony-521-19-25-december-2016)
+  [Symfony — комбинируем GridFS файлы с ORM сущностями](https://habrahabr.ru/post/314966/)
* ##### Yii
+ [Разработка на Yii 2: Роутинг и создание URL](https://code.tutsplus.com/tutorials/programming-with-yii2-routing-and-url-creation--cms-26869)
+ [tuyakhov/yii2-json-api](https://github.com/tuyakhov/yii2-json-api) — Реализация спецификации JSON API для Yii 2.
+  [Yii2 RESTful API-интерфейс для AngularJS](https://habrahabr.ru/post/318242/)
+  [Yii2-advanced: Делаем интернационализацию с источником в Redis](https://habrahabr.ru/post/318102/)
+  [Виджет мультиязычности в YII2 без использования базы данных](https://habrahabr.ru/post/317828/)
+  [Пример создания практичной Debug панели в Yii](https://habrahabr.ru/post/317562/)
* ##### Laravel
+ [Масштабируем Laravel с помощью AWS Elastic Beanstalk](https://deliciousbrains.com/scaling-laravel-using-aws-elastic-beanstalk-part-2-setting-up-vpc-rds-elasticache/)
+  [Создание веб-приложения на PHP с иcпользованием Firebird и Laravel](https://habrahabr.ru/post/317458/)
+ [Полиморфные связи в Eloquent](https://www.sitepoint.com/what-are-polymorphic-relations-and-how-do-we-use-them-with-eloquent/)
+ [Пример реализации логин-ссылки без пароля на Laravel](https://www.sitepoint.com/lets-kill-the-password-magic-login-links-to-the-rescue/)
* [Оптимизация производительности PHP благодаря использованию полного обозначения функций](http://veewee.github.io/blog/optimizing-php-performance-by-fq-function-calls/) — Исследование о том, почему вызов глобальных функций `\foo()` быстрее чем `foo()`. Также доступен инструмент [roave/functionfqnreplacer](https://github.com/roave/functionfqnreplacer), который просканирует исходники и добавит слэш где необходимо.
* [pds/skeleton](https://github.com/php-pds/skeleton) — Рекомендация по структуре PHP пакета.
* [Предотвратить запуск PHP-скрипта несколько раз одновременно](https://www.exakat.io/prevent-multiple-php-scripts-at-the-same-time/) — О реализации блокировки.
* [Наследование vs композиция и принцип открытости/закрытости SOLID](http://patrick.louys.ch/2016/12/11/open-closed-principle/)
* [Улучшаем тесты: ожидание vs реализация](http://codeception.com/12-21-2016/writing-better-tests-expectation-vs-implementation.html)
* [Семантическая подсветка переменных в PhpStorm 2016.3](https://blog.jetbrains.com/phpstorm/2016/12/semantic-variable-colours-new-in-phpstorm-2016-3/)
* [Оптимизация рекурсивных алгоритмов с помощью trampoline](http://brylkowski.com/php-cant-jump-thing-about-recursion/)
* [Все, что вы знаете о шифровании с открытым ключом в PHP — неверно](https://paragonie.com/blog/2016/12/everything-you-know-about-public-key-encryption-in-php-is-wrong)
* [Об уязвимостях (в том числе PHP) в мультимедиа модулях самолетов](http://blog.ioactive.com/2016/12/in-flight-hacking-system.html)
*  [PHP модуль на C++](http://blog.knock-it.ru/post/cpp-php-extension/)
*  [Как не нужно использовать паттерн Repository](https://habrahabr.ru/post/316836/)
*  [Alameda, Bower и NPM интеграция в CleverStyle Framework](https://habrahabr.ru/post/317894/)
*  [Масштабирование ClickHouse, управление миграциями и отправка запросов из PHP в кластер](https://habrahabr.ru/company/smi2/blog/317682/)
*  [Как мы уже 4 года выживаем в условиях двух релизов в день](https://habrahabr.ru/company/badoo/blog/317700/)
*  [Улучшение производительности PHP 7](https://habrahabr.ru/company/mailru/blog/318008/)
### Аудио и видеоматериалы
*  [PHP подкаст #13](http://podcast.ostretsov.ru/2016/12/19/php-podcast-13/)
*  [Видеообзор PHP 7.1](https://nomadphp.com/php-7-1-10-minutes/)
*  [PHP Roundtable Podcast #057: Все о компании Zend](https://www.phproundtable.com/episode/all-things-zend-framework-apigility-certification)
*  [Abusing PHP 7’s OPcache to Spawn Webshells](https://www.youtube.com/watch?v=yLpsIWh7rvU)
### Занимательное
* [Спроси backend-разработчиков Badoo. Часть 1. Платформа](https://habrahabr.ru/company/badoo/blog/317442/)
Спасибо за внимание и еще раз с наступающим Новым годом! Пусть он будет для вас лучше чем два предыдущих в сумме!
Если вы заметили ошибку или неточность — сообщите, пожалуйста, в [личку](https://habrahabr.ru/conversations/pronskiy/). Вопросы и предложения пишите на [почту](mailto:roman@pronskiy.com) или в [твиттер](https://twitter.com/pronskiy).
» [Прислать ссылку](https://bit.ly/php-digest-add-link)
» [Быстрый поиск по всем дайджестам](https://pronskiy.com/php-digest/)
← [Предыдущий выпуск: PHP-Дайджест № 98](https://habrahabr.ru/company/zfort/blog/317366/) | https://habr.com/ru/post/318410/ | null | ru | null |
# От умного дома к умным корпорациям
###### *«… Если бы в этот момент мистер Рипли вывел нас во двор и, оборотясь к дому, сказал: «Стань, домик, к Нью-Йорку задом, а ко мне передом», и домик, подобно избушке на курьих ножках, выполнил бы эту просьбу при помощи электричества, мы бы не слишком удивились.»*
###### *Ильф и Петров. Одноэтажная Америка. 1935г.*
### Часть первая
#### Введение
Мы компания, которая в этом году отпраздновала 5 лет, SAP-партнер с АСУТП-прошлым. В настоящий момент внедряем системы управления имуществом для крупных компаний, собственников недвижимости. Для справки: зачастую количество объектов составляет нескольких десятков тысяч (редко – сотни тысяч), а площадь превышает миллионы квадратных метров. Для таких компаний, с их географией и требованиями по надежности и безопасности, SAP является наиболее предпочтительным решением, но в этой статье речь пойдет не об этом (об этом, если есть интерес, можем рассказать отдельно).
В этой статье речь пойдет не об этом, а о том, что нам выпал случай заняться строительством высокотехнологичного и интеллектуального загородного частного коттеджа… и мы с удовольствием за это взялись. И предлагаем вам историю того пути, который мы проделали с начала года от умного коттеджа до умной корпорации.
На всех этапах строительства и инженерных решениях останавливаться не будем, хочется отметить лишь отличительные характеристики в части автономности и энергоэффективности:
1. Стены выполнены из керамического камня, утеплены пятнадцатисантиметровым слоем минерального утеплителя, и завершает этот пирог облицовочный кирпич. С учетом чистовой отделки толщина стены составляет порядка 70 сантиметров, что должно обеспечивать хорошую сохранность тепла в условиях подмосковной зимы.
2. Окна. Использовались шестикамерные рамы с энергоэффективными стеклами (основной источник теплопотерь – ИК-спектр на 98% отражается обратно). Поверх окон установлены электрические ролл-ставни, защищающие от вандализма, они создают дополнительный воздушный слой, и летом затеняют солнечную сторону.
3. Энергетика. Во главе угла стоит система Xantrex производства Schneider Electric, а так же входным стабилизатором, блоком аккумуляторов, солнечными панелями на 3,6 кВт, блок автоматического запуска генератора и управление через веб-интерфейс.
4. Отопление. Бойлер с несколькими контурами, газовый котел, гелиоустановка и тепловой насос. Тёплые полы и радиаторы в комнатах имеют индивидуальные линии с электрическими клапанами (климат-контроль в каждой комнате).
5. Вентиляция. Приточно-вытяжная установка с рекуператором и гидроузлом (зимой греем, летом охлаждаем). В каждую комнату/зону индивидуальный вентиляционный клапан. Установка имеет дифференциальный датчик давления и автоматическую регулировку производительности.
6. Освещение. Преимущественно светодиодное. Второй свет с использованием SolarTube.
Вот такой вот объект для автоматизации мы имеем. Перед нами стояла задача по увязке всех инженерных систем дома в единую, простую и понятную систему управления, которая бы обеспечивала комфортное, безопасное и энергоэффективное проживание. Все помнят Алису (<http://habrahabr.ru/post/160067/>), и мы, находясь под впечатлением этого и ещё некоторых проектов, решили повторить нечто подобное. Мы также хотели, чтобы система была действительно интеллектуальной. С минимальными органами управления.
Например:
* Свет включается автоматически в зависимости от времени суток, внешнего освещения, выбранного сценария и присутствия человека в комнате (именно за обнаружение присутствия, а не движения (!!!), у нас отвечает специальный датчик производства Leviton).
* Уровень вентиляции в отдельно взятой комнате автоматически управляется по присутствию в ней человека и содержанию в воздухе CO2 (<http://habrahabr.ru/post/187210/>). В отличие от существующих норм с троекратным обменом воздуха в помещении.
* За поддержание температуры в комнате отвечают радиаторные батареи, теплые полы, система вентиляции.
Ну и, естественно, в каждой комнате хотелось отдавать свои голосовые команды (не Google); переключать сценарии (кино, сон, дискотека); управлять мультимедиа, ролл-ставнями, розетками; ставить/снимать с охраны; иметь возможность удаленного управления с телефона/планшета, включая подключение к IP-камерам. В какой-то момент мы подошли к проектированию архитектуры, и встали перед выбором: либо делать всё на KNX, либо придумать что-то своё. Как вы уже, наверное, догадались, мы выбрали второй вариант. За KNX говорило большое количество готовых устройств/интерфейсов, красивых рамок и выключателей, но единственное что было не в пользу KNX – это два знания: знание того, сколько стоят электронные компоненты и знание того как это всё сделать самостоятельно. Так мы подошли к созданию своего контроллера. Когда мы раздумывали, каким он должен быть, мы подумали, что было бы здорово сделать такую платформу, которую бы мы могли использовать, как и у себя дома, так и в большинстве наших коммерческих проектов.
У нас родилась идея создания максимально простого и компактного продукта, который бы можно было установить в любую квартиру за небольшие деньги. Кроме того, система должна быть модульной и гибко подстраиваться под различные задачи. В то же время её можно использовать и в сфере ЖКХ (госсектор) и в корпоративном сегменте.
Сначала мы постарались сформулировать критерии, которыми должен отвечать контроллер «УМНОГО ДОМА»:
1. Контроллер должен основываться на принципах «Открытого программного и аппаратного обеспечения» (Open-source software, Open-source hardware). Среда программирования должна быть простой и понятной. Любой человек обладающий техническими знаниями смог бы самостоятельно создать/модернизировать и запрограммировать такое устройство.
2. Контроллер должен быть универсален и использоваться во всех аспектах управления «УМНОГО ДОМА» от теплого пола до мультимедиа. Совместим с различными типами датчиков, исполнительными устройствами, готовыми решениями по вентиляции, отоплению и безопасности.
3. Контролер должен быть самодостаточным и «автономным» для применения его в одной отдельно-взятой комнате, но при этом несколько контроллеров должны объединяться в сеть и в этом случае область применения расширяется до квартиры, коттеджа или большого здания под управлением центрального сервера.
4. Контроллер должен поддерживать передачу данных по Ethernet либо Wi-Fi (опционально).
5. Контроллер должен обладать компактными размерами, чтобы поместиться в стандартный подрозетник, и при этом оставить достаточно места для сопутствующих монтажных проводов.
6. Контроллер должен обладать низкой стоимостью и высокой надежностью.
#### Разработка системы
В качестве основы для всей системы наш выбор упал на контроллер-платформу «Ардуино»
В интернете масса информации по проектам, юзкейсам, реализованным на данной платформе, поэтому отдельно останавливаться на ней не будем, отметим только, что она полностью соответствует приведенным выше критериям.
В качестве прототипа было решено объединить самые компактные версии контроллера и сетевого модуля, сделав многослойную плату. Плата контроллера — Femtoduino с ATMEGA328p-MU на борту, сетевой модуль на базе ENC26J60, пара стабилизаторов, резисторы, клеммники.
Всё это мы разместили на небольшой печатной «материнской плате». При этом плата контроллера целиком помещается в стандартный подрозетник, а самым большим конструктивным элементом получился разъем RJ45 для сетевого кабеля.
###### На фото: WiFi-камера, Датчик присутствия Leviton, Лампочка-свеча 220V, твердотельное реле, датчик CO2 K-30, Arduino Mega2560 + Ethernet Shield, наш контроллер v1 и v2, модуль распознавания голоса, AC-DC 5В (600ma), femtoduino usb, DC-DC преобразователь, ENC26J60
Изначально для прототипа планировалось изготовить необходимые печатные платы методом ЛУТ, однако шаг между контактами для подключения контроллера оказался слишком маленьким, что повысило требования к качеству платы. После пары неудачных попыток, от ЛУТ пришлось отказаться и заказать плату в специализированной организации.
#### Femtoduino
Существует две версии этого контроллера: с miniUSB разъемом для программирования и без.
Первые версии контроллера, которые к нам пришли, были без разъема и программировались через другой Arduino-совместимый контроллер с помощью AVRIsp. Для удобства программирования на материнской плате был предусмотрен штыревой разъем под шлейф, соединяющийся с платой программатором. Тем не менее, этот способ программирования далеко не самый удобный. Кроме того, в процессе работы несколько контроллеров этого типа успели выйти из строя из-за ошибок во время перезаписи. В новой версии этой проблемы уже не было.
#### Femtoduino USB
Вторая версия контроллера значительно упростила работу с ним, так как для программирования теперь предусмотрен специальный USB разъем. Он программируется также как и любая другая плата Arduino. Однако из-за FTDI чипа, который нужен для его работы, возникла проблема со связью контроллера с модулем распознавания голоса. Rx/Tx выводы напрочь отказывались работать с чем-то ещё, кроме USB. Проблему устранить так и не удалось (разработчик платы признал, что FTDI действительно мешает работе нужных выводов), поэтому пришлось использовать обходное решение – библиотеку SoftwareSerial. Она позволяет эмулировать последовательный порт на любых выводах, вместо аппаратных, которые работать отказались.
#### ENC26J60
Это очень компактный сетевой модуль, фактически состоящий из одного только разъема RJ45 на миниатюрной плате почти таких же размеров. К сожалению, для этого ENC26J60 не годится библиотека стандартного ардуиновского Ethernet-модуля, вместо неё использовалась библиотека EtherCard. Эта библиотека достаточно сильно отличается от встроенной в среду разработки, что не очень удобно при разработке скетчей под неё.
Таким образом, все необходимые устройства были протестированы и собраны на материнской плате. Получился следующий контроллер:
В процессе перехода на Femtoduino USB, контроллер удалось уменьшить в размерах:
В итоге, у нас получился компактный контроллер, соединяющийся с сервером по Ethernet кабелю и способный решать широкие задачи по автоматизации дома (питание от 220V в качестве опции на фото).
#### ТТХ:
* Размеры: 45x43x25 мм
* Micro-B USB порт для программирования
* RJ45 для сетевого подключения
* Питание DC
* 5-10V (100-240VAC — опция)
* Микроконтроллер: ATMEGA328p-MU
* Размер программной памяти: 32 KB
* Размер ОЗУ данных: 1 KB
* Доступно: 8 аналоговых портов,11 цифровых портов
* I2C: порты A4 (SDA) и A5 (SCL)
* ШИМ: порты A3, D5, D6 и D9
#### Область применения решения «Умный дом»
##### Комфорт
* контроль качества воздуха
* климат-контроль (интеграция с вентиляцией/кондиционированием/отоплением)
* управление ролл-ставнями/жалюзи/гаражными воротами
* управление теплыми полами (водяные/электрические)
* управление светом (для диммирования требуется доп. компоненты)
* голосовое управление
* автоматические сценарии
* управление поливом
##### Безопасность
* Контроль доступа на объект (постановка/снятие на охрану)
* Обнаружение движения/присутствия
* Пожарная безопасность
* Контроль открытия/закрытия окон/дверей
* Обнаружение утечки воды
* Интеграция с системой видеонаблюдения
* Уведомление по различным каналам SMS/Email
##### Эффективность
Автоматический мониторинг приборов учета
* вода
* газ
* электричество
#### Разработка серверной части
Для серверной части системы наш выбор пал на проект MajorDoMo. MajorDoMo — это открытая и доступная платформа для автоматизации и управления системой умного дома. Подробно о проекте можно узнать на сайте разработчика smartliving.ru. Этот программный продукт полностью удовлетворяет требованиям, предъявленным к нашей системе. Это открытая, простая в настройке система, которую можно адаптировать для самых различных задач по автоматизации. В то же время, система управляется через веб-интерфейс, что позволяет использовать её с любых устройств.
В MajorDoMo используется язык PHP для программирования всех сценариев работы системы, при этом в нем реализован удобный графический интерфейс, который позволяет разобраться в настройке системы даже людям, мало знакомым с программированием.
В нашем проекте мы планировали использовать пакет MajorDoMo, установленный на Raspberry Pi, который можно использовать как веб-сервер. В ходе тестов стало ясно, что MajorDoMo слишком требовательна к железу, и такой слабый сервер с трудом справляется с задачей. После попыток оптимизации серверной части и разгона самой железки, было решено отказаться от неё, так как задержка между отправкой и выполнением команд была слишком большой. В дальнейшем в качестве сервера для MajorDoMo мы использовали выделенный сервер (Digital Ocean), к которому подключались через 3G модем. Несмотря на то, что сервер находится в Амстердаме, отклик на выполнение команд стал практически мгновенный.
На основе последнего прототипа было решено сделать демонстрационный стенд, который бы позволил наглядно показать весь функционал полученного контроллера системы умного дома.
На место Raspberry Pi пришел TP-Link 3020 с кастомной прошивкой, который соединялся с выделенным сервером, и вся система была доступна по внешнему IP.
В лицевую фальшпанель, закрывающую подрозетник, решено было поместить отдельную плату с датчиками. На этой плате размещены два датчика света: цифровой, умеющий пересчитывать результат в люксы, и обычный фоторезистор, а также цифровой датчик температуры (DS18B20, куда же без него), панель модуля распознавания голоса и микрофон к ней. Для соединения платы с датчиком сделан отдельный шлейф, который подключается напрямую к плате контроллера в отведенный для него разъем. Плата датчиков получилась настолько компактной, что практически не занимает места внутри самого подрозетника. Вся начинка уместилась в пространстве между рамкой подрозетника и крышкой.
Итоговая архитектура макета:
Сам стенд в конечном виде представляет собой четыре подрозетника, скрепленных вместе. Два из них это управляемая розетка (розетка + твердотельное реле) и кнопочный выключатель, соединенный с контроллером. С помощью реле можно управлять нагрузкой, подключенной к этой розетке, например, электрической лампочкой. В третьем подрозетнике расположился блок питания для всей системы, а в четвертом сам контроллер.
Помимо панели с датчиками, устанавливаемой на контроллер (в которую входит датчик температуры, два датчика света и микрофон), к контроллеру подключаются два дополнительных датчика температуры (1-Wire), геркон, датчик движения и светодиоды. Также на макете сделан разъем для подключения WiFi-камеры с сервоприводом.
Как можно увидеть, у нас получилась довольно объёмная обвязка для такого миниатюрного контроллера. Кроме того, многие из используемых датчиков цифровые, а значит, требуют использования библиотек для работы с ними. Именно из-за этого при написании скетча для макета возникла проблема. В контроллере этого типа не так много памяти, что ставит ограничение на размер кода программы. Проблему удалось решить существенной оптимизацией кода.
Полный код можно посмотреть тут **(подробнее)**
```
#include
#include
#include
#include
#include
SoftwareSerial mySerial(1, 0); //Software serial initialization
#define ONE\_WIRE\_BUS 4 //Dallas initialisation
OneWire oneWire(ONE\_WIRE\_BUS);
DallasTemperature sensors(&oneWire);
DeviceAddress Ter1;
DeviceAddress Ter2;
DeviceAddress Ter3;
int tempC1 = 1;
int tempC2 = 1;
int tempC3 = 1;
static byte mymac[] = { 0x74,0x69,0x69,0x2D,0x30,0x31 };
static byte myip[] = { 192,168,0,150 };
static byte gwip[] = { 192,168,0,1 };
static byte hisip[] = { 192,168,2,1 };
//char website[] PROGMEM = "192.168.2.1";
#define REQUEST\_RATE 3000
Servo servo1;
int xAxis = 90;
int BH1750address = 0x23;
byte buff[2];
int dLight = 0;
#define relay1Pin 9 //Основной свет
//#define relay2Pin 2 //ФОновая подсветка
#define buttonPin 3 //Кнопка
int buttonState = HIGH;
int lastButtonState = LOW;
long lastDebounceTime = 0;
long debounceDelay = 100;
int lightState = 0;
#define reedPin 8
int reedState = 0;
#define PIRPin 7
int pirState = 0;
#define photo1Pin = 2;
int photo1Value = 0;
int sensor = 0; //Текущий датчик
#define LED1Pin 2
#define LED2Pin 5
#define LED3Pin A0
#define LED4Pin A1
int background = 0;
const char http\_OK[] PROGMEM =
"HTTP/1.0 200 OK\r\n"
"Content-Type: text/html\r\n"
"Pragma: no-cache\r\n\r\n";
const char link[] PROGMEM = "GET /objects/?object=";
const char linkLight[] PROGMEM = "GET /objects/?object=lightgroup1&op=m&m=updateState&state=";
const char website[] PROGMEM = " HTTP/1.1" "\r\n" "Host: 192.168.2.1" "\r\n" "\r\n";
byte Ethernet::buffer[600];
BufferFiller bfill;
Stash stash;
static long timer;
///////////////////////////////////////// SETUP /////////////////////////////////////////
void setup () {
mySerial.begin(9600);
sensors.begin();
sensors.getAddress(Ter1, 0);
sensors.setResolution(Ter1, 12);
sensors.getAddress(Ter2, 1);
sensors.setResolution(Ter2, 12);
sensors.getAddress(Ter3, 2);
sensors.setResolution(Ter3, 12);
ether.begin(sizeof Ethernet::buffer, mymac, 10);
ether.staticSetup(myip, gwip);
ether.copyIp(ether.hisip, hisip);
timer = - REQUEST\_RATE; //Запуск таймера
servo1.attach(6);
pinMode(relay1Pin, OUTPUT);
pinMode(buttonPin, INPUT);
pinMode(reedPin, INPUT);
pinMode(PIRPin, INPUT);
pinMode(LED1Pin, OUTPUT);
pinMode(LED2Pin, OUTPUT);
pinMode(LED3Pin, OUTPUT);
pinMode(LED4Pin, OUTPUT);
delay (100); //Инициализация голосового модуля
mySerial.write(0xAA);
mySerial.write(0x37);
delay(100);
mySerial.write(0xAA);
mySerial.write(0x21);
delay(100);
}
///////////////////////////////////////// LOOP /////////////////////////////////////////
void loop () {
word len = ether.packetReceive();
word pos = ether.packetLoop(len);
netSend();
if (pos)
netReply(pos);
checkButton();
checkReed();
checkPIR();
checkSerial();
}
//////////////////////////////////////// NETWORK ////////////////////////////////////////
void netSend() { //Передача показаний датчиков
if (millis() > timer + REQUEST\_RATE) {
timer = millis();
switch (sensor) {
case 0: //Фоторезистор
sensor = 1;
photo1Value = analogRead(2);
Stash::prepare(PSTR("$Fphoto1&op=m&m=updateValue&value=$D$F"), link, photo1Value, website);
ether.tcpSend();
break;
case 1: //ЦиФровой датчик света
sensor = 2;
//dLight = getLx();
//Stash::prepare(PSTR("$Fdlight1&op=m&m=updateValue&value=$D$F"), link, dLight, website);
//ether.tcpSend();
break;
case 2: //Датчик температуры
sensor = 0;
sensors.requestTemperatures();
tempC1 = (int)(sensors.getTempC(Ter1)\*100);
tempC2 = (int)(sensors.getTempC(Ter2)\*100);
tempC3 = (int)(sensors.getTempC(Ter3)\*100);
Stash::prepare(PSTR("$Fds1&op=m&m=updateTemp&temp=$D&temp2=$D&temp3=$D$F"), link, tempC1, tempC2, tempC3, website);
ether.tcpSend();
break;
}
}
}
void netReply(word pos) { //Обработка входящих команд и ответ сервера
bfill = ether.tcpOffset();
char \*data = (char \*) Ethernet::buffer + pos;
char sub[4];
char \*var;
var = strstr(data, "srv1=");
if (var != NULL) {
var += 5;
for (int i=0; i<=2; i++) sub[i] = var[i];
xAxis = atoi(sub);
servo1.write(xAxis);
}
var = strstr(data, "lgr1=");
if (var != NULL) {
Serial.print("Command recieved!");
digitalWrite(52, 1);
}
//LED Control
var = strstr(data, "led1=");
if (var != NULL) {
var += 5;
for (int i=0; i<=1; i++) sub[i] = var[i];
digitalWrite(LED1Pin, (atoi(sub)));
}
var = strstr(data, "led2=");
if (var != NULL) {
var += 5;
for (int i=0; i<=1; i++) sub[i] = var[i];
digitalWrite(LED2Pin, (atoi(sub)));
}
var = strstr(data, "led3=");
if (var != NULL) {
var += 5;
for (int i=0; i<=1; i++) sub[i] = var[i];
digitalWrite(LED3Pin, (atoi(sub)));
}
var = strstr(data, "led4=");
if (var != NULL) {
var += 5;
for (int i=0; i<=1; i++) sub[i] = var[i];
digitalWrite(LED4Pin, (atoi(sub)));
}
bfill.emit\_p(PSTR("$FArduino Web Server
==================
"), http\_OK);
ether.httpServerReply(bfill.position());
/\*bfill.emit\_p(PSTR(
"$F"
"Arduino Web Server
==================
"
"ds1=$Dds2=$Dds3=$Dphoto1=$DdLight=$Dpir=$Dreed=$Dlight=$Dsrv1=$D"
), http\_OK, tempC1, tempC2, tempC3, photo1Value, dLight, pirState, reedState, lightState, xAxis);
ether.httpServerReply(bfill.position());\*/
}
/////////////////////////////////////// FUNCTIONS ///////////////////////////////////////
/\*unsigned short getLx() {
unsigned short val = 0;
BH1750\_Init(BH1750address);
delay(1000);
if(2==BH1750\_Read(BH1750address))
{
val=((buff[0]<<8)|buff[1])/1.2;
}
return val;
}
int BH1750\_Read(int address) {\
int i=0;
Wire.beginTransmission(address);
Wire.requestFrom(address, 2);
while(Wire.available())
{
buff[i] = Wire.read(); // receive one byte
i++;
}
Wire.endTransmission();
return i;
}
void BH1750\_Init(int address) {
Wire.beginTransmission(address);
Wire.write(0x10);//1lx reolution 120ms
Wire.endTransmission();
}\*/
void checkButton() { // Button
int reading = digitalRead(buttonPin);
if (reading != lastButtonState) {
lastDebounceTime = millis();
}
if ((millis() - lastDebounceTime) > debounceDelay) {
if (reading != buttonState) {
buttonState = reading;
if (buttonState == HIGH) {
switchLight();
}
}
}
lastButtonState = reading;
}
void switchLight() {
//if (lightState > 1) lightState = 1;
lightState = !lightState;
digitalWrite(relay1Pin, lightState);
Stash::prepare(PSTR("$F$D$F"), linkLight, lightState, website);
ether.tcpSend();
}
void checkReed() {
int a = digitalRead(reedPin);
if (a != reedState) {
reedState = a;
Stash::prepare(PSTR("$Freed1&op=m&m=updateState&state=$D$F"), link, reedState, website);
ether.tcpSend();
}
}
void checkPIR() {
int a = digitalRead(PIRPin);
if (a != pirState) {
pirState = a;
Stash::prepare(PSTR("$Fpir1&op=m&m=updateState&state=$D$F"), link, pirState, website);
ether.tcpSend();
}
}
void checkSerial() { // VR Module
if (mySerial.available()) {
byte com = mySerial.read();
switch(com) {
case 0x11: //Включить реле 1
lightState = 1;
digitalWrite(relay1Pin, lightState);
Stash::prepare(PSTR("$F$D$F"), linkLight, lightState, website);
ether.tcpSend();
break;
case 0x12: //Выключить реле 1
lightState = 0;
digitalWrite(relay1Pin, lightState);
Stash::prepare(PSTR("$F$D$F"), linkLight, lightState, website);
ether.tcpSend();
break;
case 0x13: //Камера влево
xAxis -= 30;
if (xAxis < 10) xAxis = 10;
servo1.write(xAxis);
break;
case 0x14: //Камера вправо
xAxis += 30;
if (xAxis > 170) xAxis = 180;
servo1.write(xAxis);
break;
case 0x15: //Фоновая подсветка
background = !background;
digitalWrite(LED1Pin, background);
digitalWrite(LED2Pin, background);
digitalWrite(LED3Pin, background);
digitalWrite(LED4Pin, background);
break;
}
}
}
```
Вот что у нас получилось в итоге:
Все показания датчиков выведены на главную страничку MajorDoMo, а на модели комнаты сделаны кнопки для управления светодиодами, встроенными в подрозетники. Так же пользователь может получить изображение с WiFi-камеры и повращать ей.
Посмотреть как это работает можно тут: <http://smarthouse.isystemsautomation.ru>
На голосовой модуль записаны несколько голосовых команд, которые позволяют, например, включить лампочку – управляемую нагрузку в розетке, или повернуть камеру влево-вправо.
---
### Часть вторая
Дальше события развивались стремительным для нас образом. Мы показали макет одним людям, затем другим… сработал «социальный лифт», и нам было предложено поучаствовать в форуме «Открытые Инновации» в разделе Smart City за 3 недели до открытия. Мы не могли упустить возможность продемонстрировать свои наработки. Мы начали креативить, и родилась идея с макетом здания, фонтаном и элементами инженерной инфраструктуры города. Достаточно быстро мы прошли путь от эскиза и 3D-модели до воплощения в “железе и бетоне”.
Вот так воплощались наши мысли:
Для управления различными группами света использовался блок из 18 реле.
Из датчиков мы вывели на макете фоторезистор и датчик температуры. Ещё один датчик температуры остался под стендом, чтобы можно было сравнивать разницу температур.
Также на макете присутствует управляемый фонтан. Рядом с фонтаном расположился водосчётчик, который «символично» учитывает расход воды. На счетчике можно остановиться подробнее. Выбран он не случайно, а для того, чтобы продемонстрировать самое типичное бытовое применение для нашей системы умного дома. Он представляет собой обычный водосчётчик с импульсным выводом. Принцип его работы очень простой: раз в 10 литров счетчик замыкает контакт внутри себя, контроллер легко может считать этот импульс и приплюсовать его к сохраненному значению. Осталось только заставить его вращаться. Конечно, можно было бы подсоединить его напрямую к компрессору, который качает воду в фонтане, но тогда конструкция бы получилось сложной и ненадежной. Поэтому требовалось альтернативное решение. После вскрытия счетчика выяснилось, что он состоит из двух механически несвязанных частей: самого счетчика в герметичном корпусе и маленькой крыльчатки, установленной в трубе. Вращался счетчик с помощью магнита, установленного на оси этой крыльчатки. Решение напрашивалось само собой – чтобы смоделировать работу счетчика вовсе не нужно возиться с водой, достаточно разобрать его, убрав кусок трубы с крыльчаткой и с помощью миниатюрного моторчика создавать вращающееся магнитное поле. В качестве такого электродвигателя под рукой оказался маленький скоростной мотор от авиационной модели. На его лопастях были заклеены два неодимовых магнита из детской игрушки, а сам мотор вмонтирован в пластиковый кожух, который как раз пристыковывался на заднюю стенку счетчика. В итоге, мы получили управляемый с контроллера (а скорость его можно регулировать с помощью ШИМ) счетчик, который позволяет наглядно показать, как считываются и передаются показания на сервер
#### Графический интерфейс
Для доступа к поэтажным планам макета, помимо веб-интерфейса предоставляемого MajorDoMo, мы использовали собственную разработку – модуль визуализации поэтажных планов (МВПП), немного «допилив» ее под соответствующие задачи. Нужно отметить, что изначально МВПП разрабатывался и входил в состав Автоматизированной системы управления недвижимостью для корпоративного сегмента и предназначался для широкого круга задач, в том числе:
* Управление площадями;
* Управление размещением сотрудников/организаций;
* Управление инженерными сетями и оборудованием;
* Отображение геометрии поэтажного плана;
* Редактирование геометрии поэтажного плана;
* Визуализация и редактирование рабочих мест;
* Отображение атрибутивной информации (по зданиям, этажам, помещениям, рабочим и технологическим местам), хранящейся в модулях SAP;
* Редактирование атрибутивной информации и сохранение ее в SAP;
* Построение различных аналитических отчетов.
Архитектура программного комплекса выглядит следующим образом:
Веб-приложение МВПП написано с использованием Java/JavaScript и опубликовано на Apache Tomcat, серверная часть модуля использует ArcGIS for Server компании ESRI, СУБД – Oracle с расширением для работы с пространственными данными. Двухсторонняя связь МВПП с SAP реализована посредством веб-сервисов, авторизация пользователей в SAP сквозная, с использованием SAP SSO2 cookie. Вот как это примерно выглядит.
Ниже представлен функционал размещения рабочих мест. Все изменения, проводимые на поэтажном плане в МВПП (изменение геометрии, атрибутов, рабочих мест и прочее) передаются и сохраняются в SAP.
Если Хабрасообществу будет интересно – распишем реализацию более подробно. А пока желающие могут сами [поиграться с приложением](http://demo.isystemsautomation.ru/isplan/?b=IB99000000000100000003&f=IM99000000000100001023).
Итак, вернемся к нашему макету.
Основной функционал, который мы хотели получить от МВПП при его использовании совместно с макетом заключался в следующем:
* Визуализация поэтажных планов здания и прилегающей территории;
* Управление освещением и фонтаном;
* Мониторинг состояния набора датчиков, находящихся на макете (с возможностью построения графиков);
* Просмотр видео с камеры наблюдения, установленной на макете (и управление поворотом камер);
* Запуск сервисов передачи в модуль ТОРО SAP информации по отслеживаемым датчикам (при выходе значения какого-либо показателя за границы предельно допустимых значений).
Для использования МВПП в качестве интерфейса управления умным домом, мы несколько доработали его, расширили модель пространственных данных в БД (добавили слой датчиков, уличных фонарей, мебели, прилегающей территории и прочее) и в ArcMAP отрисовали четыре этажа с прилегающей территорией, связав все объекты по идентификаторам с объектами в SAP. То же самое проделали со всеми датчиками.
Фонари объединили в три группы – по периметру, вокруг дома и вдоль дороги. Соответственно, при нажатии на любой фонарь внутри группы, изменение состояния происходит на всех фонарях группы (на скриншоте горят фонари группы «по периметру»). При срабатывании датчика на парковке предполагалось, что на соответствующем парковочном месте в интерфейсе визуализации появляется символ автомобиля. При включении фонтана на макете, его символ на интерфейсе визуализации так же должен «оживать».
Написали сервисы получения информации от контроллера умного дома с ее сохранением информацией в базе данных (для простоты использовали MS SQL) и сервисы, передающие на контроллер управляющие воздействие (включить/выключить). Хранение получаемой информации с датчиков необходимо для возможности строить графики за прошлые периоды, что так же было реализовано. Рассмотрим подробнее контроль температуры и расхода воды.
Для каждого датчика реализовали индивидуальную настройку граничных значений.
Сами датчики на плане так же подсвечиваем цветом в соответствии со статусом нахождения в том или ином коридоре (выше нормы, норма и ниже нормы).
При выходе значения датчика из коридора допустимых значений (< 20 и > 30 градусов Цельсия), запускается сервис создания в ТОРО (SAP) соответствующего инцидента.
В интерфейсе визуализации для каждого датчика можно задавать граничные условия и указывать действия, которые должны происходить при нарушении этих условий.
Также, для показательных целей, настроена передача в ТОРО с определенным интервалом значений с датчика расхода воды, установленного на фонтане.
Также имеется возможность выбрать другой этаж.
В дальнейших планах – полностью отказаться от использования MajorDoMo с реализацией у себя (в МВПП) необходимого функционала, поработать над интерфейсом.
В результате, с помощью веб-приложения, которое может быть запущено в браузере на компьютере или мобильном устройстве (в частности, на iPad), мы получаем возможность удаленного мониторинга следующих параметров: состояния освещения, показателей с датчиков (расход воды, освещенность, температура, парковка), камер наружного наблюдения. Также веб-приложение позволяет управлять освещением (как наружных групп, так и ламп внутри здания), поворотом камеры и работой фонтана.
Мы отработали на форуме 3 дня, и за это время наш макет вызывал большой интерес, как у специалистов, так и случайных прохожих. Те, кто погружались в технические особенности, не могли поверить, что весь цикл управления (от датчиков до SAPа) работал на боевых серверах.
Кадры с крутящимся фонтаном, на удивление, начинали большинство новостных выпусков на ТВ, посвященных работе форума. Про нас даже сняли небольшой сюжет:
Рабочие моменты:
### Заключение
В предложенном материале мы постарались поделиться тем опытом, который получили в результате выполнения проекта по строительству энергоэффективного и интеллектуального коттеджа. Данный проект подходит к концу, завершается отделка и пуско-наладка. И в заключении хочется поделиться нашими планами по развитию.
Развитие мы видим по следующим направлениям:
1. Сделать серийный контроллер для умного дома максимально дешевым и открытым (OpenSource Hard/OpenSource Soft). Сейчас ведем переговоры с китайскими производителями, прорабатываются несколько версий (Ethernet/Wifi + AC/DC). Согласно нашему плану, стоимость для конечного потребителя не должна превышать 500р за версию c Ethernet.
2. Мы ведем разработку сенсорной панели с экраном, датчиками и микрофоном, которая будет заменять лицевую фальшпанель, закрывающую подрозетник стандартного типоразмера.
3. Планируем выпускать на базе данного контроллера уже готовые решения для конкретных задач. Например, контроллер теплого пола будет содержать в себе реле, 3 датчика температуры, питание от 220В и Ethernet модуль (опция). Потребитель получит уже готовое решение для своей задачи. Аналогично, для диммирования света и обнаружения протечек.
4. Планируем под «одной крышей» собрать единомышленников и партнеров, где предлагаем совместно поучаствовать в обмене идеями по развитию систем управления жилой и промышленной инфраструктурой, направленной на безопасность, повышение эффективности и удобства использования. Рабочее название проекта – iCity.
Мы открыты для идей и предложений по всем направлениям, а также принимаем опытных специалистов в свою немногочисленную команду.
Для анализа спроса, просим оставить свой голос в форме для голосования. | https://habr.com/ru/post/206694/ | null | ru | null |
# Многопоточный линейный список: проблема существования элемента, повышение производительности и соотношение с STL
Здравствуйте, уважаемые посетители Хабра!
В этой статье речь пойдёт о связном списке, многопоточности и С++. Сразу отмечу, что были все шансы положить эту работу «на полочку» и использовать в небольшом количестве личных проектов. Вместо этого я всё-таки решил выложить её на суд общественности – вдруг это действительно покажется кому-нибудь полезным или интересным. Более того, если окажется, что кто-нибудь когда-нибудь уже успел сделать что-нибудь подобное, укажите мне эти материалы, пожалуйста. Однако сколько я ни пытался гуглить на эту тему, все попытки были безуспешны.
Также отмечу, что речь пойдёт не о классическом связном списке, а о моём творческом переосмыслении использования этой структуры данных в многопоточном окружении. Я рассматривал сценарий неупорядоченного интенсивного многопоточного обращения к списку. Это означает, что любой поток в любой момент независимо от других может получить доступ к списку и произвести требуемые операции. Если он только добавляет или изменяет элементы, это ещё полбеды. Если же он ещё и удаляет элементы, могут возникнуть различные интересные особенности.
Этот проект, которым я занимался на правах хобби и саморазвития, по ряду причин растянулся на весьма длительный срок. Кроме того, по мере работы над ним я интенсивно учился: проект начинался без знания и понимания STL и проектировался соответственно, используя только внутренние средства собственно языка С++. Однако потом я весьма серьёзно его модифицировал с учётом STL и даже под STL. Что у меня из этого получилось, судить вам, уважаемые читатели.
Для наиболее полного понимания описываемого здесь материала вам потребуется познакомиться со следующими книгами:
* Александреску А. – «Современное проектирование на С++».
* Рихтер Д., Назар К. – «Windows via C/C++, Программирование на языке Visual C++».
* Джосаттис Н. – «Стандартная библиотека С++. Справочное руководство. Второе издание» или аналогичная книга по STL.
Линейный список
---------------
Линейный список – известная структура данных, применяемая ещё со времён языка С и ранее. Его элемент представляет собой некоторый объект в памяти, имеющий связи с одним или двумя соседними аналогичными элементами – здесь приведён пример для двусвязного списка:
```
struct ListItem
{
<… некоторые данные …>
List *pNext;
List *pPrev;
};
```
Соответственно, сам список – это некоторая (под)программа, которая выполняет манипуляции с этими элементами. Как правило, известен указатель на начало и, опционально, на конец списка: этого достаточно, чтобы, начиная с первого элемента, пройти по всем его элементам вплоть до конца.
По сути, я описываю уже хорошо изученную и известную всем информацию: это был ликбез для тех, кто совсем не в курсе. За подробностями, например, можно обратиться сюда:
[Линейный список (Википедия)](https://ru.wikipedia.org/wiki/%D0%A1%D0%B2%D1%8F%D0%B7%D0%BD%D1%8B%D0%B9_%D1%81%D0%BF%D0%B8%D1%81%D0%BE%D0%BA)
В библиотеке STL есть такой замечательный контейнер std::list (двусвязный список), а также его близнец – std::forward\_list (односвязный список). То есть если вам не интересно, как список устроен и функционирует внутри, а вы хотите им просто пользоваться для своих задач, предложенные контейнеры – ваш вариант.
Но есть одно но…
Проблемы многопоточности
------------------------
Повторюсь, что когда я начинал разбирать эту тему, я собирался всё сделать, полагаясь только на внутренние средства С++ без какой-либо поддержки STL. Ценность того, что получилось бы, была бы ниже, если бы я всё-таки решил рассказать об этом здесь. Но с другой стороны, я был совершенно свободен от каких-либо концепций или ограничений библиотеки, а потому был не связан ничем и искал подходы непредвзято и независимо.
Раньше, в далёкие-далёкие времена, подавляющее большинство компьютеров были одноядерными и однопроцессорными. Линейный список был относительно простой и прозрачной структурой данных, и работа с ним не вызывала особых затруднений. Сейчас же даже смартфоны стали многоядерными. В условиях многопоточности даже такая простейшая структура, как связный список, серьёзно усложняется. Обеспечение корректной работы в многопоточном режиме вообще серьёзно усложняет любую программу, это известный факт.
Возьмём некий абстрактный сценарий интенсивной работы со списком различными потоками: каждый из них в совершенно произвольный момент времени может добавлять, удалять, изменять элементы, и т.д. С одной стороны, работа со списком в этом случае должна быть прежде всего безопасной: если произойдут какие-либо нарушения данных и неопределённое поведение программы, это будет совершенно неподходящее решение. С другой стороны, очень хотелось бы, чтобы работа с ним была как можно более быстродействующей.
Для решения первой проблемы список, очевидно, придётся как-то блокировать, а также синхронизировать доступ к нему. Вторую проблему – производительность – пока отложим.
В этой статье рассматривается только блокировка всего списка потоком для осуществления монопольного доступа потока к нему. Другие варианты казались сомнительными, например, по следующим соображениям. Предположим, у нас двухсвязный список, и мы решили удалить элемент из него. Для этого надо заблокировать сам узел, а также предыдущий и последующий.
В это самое время перед началом операции другой поток удаляет как раз, например, предшествующий узел. Мы блокируем удаляемый и останавливаемся в ожидании освобождения предыдущего узла, заблокированного другим потоком. А он блокируется на ожидании последующего для него, т.е. нашего удаляемого узла. Всё, вот и взаимная блокировка. Так что этот способ не является надёжным.
Если ваши потоки не хранят какие-либо указатели (или итераторы) на конкретные узлы, то задача предельно упрощается. Фактически, можно обойтись только средствами STL. Поток блокирует список, обращается к какому-либо элементу в нём (например, с начала, с конца или посредством поиска в нём по каким-либо критериям), обрабатывает или удаляет этот элемент, добавляет какие-либо новые, не сохраняя ссылки на них, а затем завершает работу со списком. Всё это – монопольно заблокировав доступ к списку в одном потоке, единолично владея им на время требуемых операций. В этом случае совершенно логично использовать std::list и средства блокировки библиотеки. При всём при этом следует учесть, что пока ваш поток выполняет всю требуемую работу, другие потоки остановятся в ожидании, т.е. работа со списком будет осуществляться в однопоточном режиме.
Я же рассматривал другой, более сложный сценарий, когда поток хранит указатель или итератор на нужный ему элемент. Например, ваша программа работает над какими-то сложными вычислениями, взяв исходные данные из элемента списка, а затем, после обработки, обновляет его значение, добавив туда результаты вычислений. При этом другие потоки также имеют доступ к этому же списку. Я не делал каких-либо предположений о характере приложения: другой поток может легко удалить по каким-то причинам именно этот элемент. Или перенести его в другое место. Таким образом, работа со списком становится проблематичной не только по обычным соображениям многопоточности и синхронизации.
Проблема существования элемента
-------------------------------
В чём фундаментальное отличие списка от, скажем, массива? В **распределённом** расположении элементов списка. Все элементы массива расположены в единой области памяти. Даже если вы храните указатель на какой-либо его элемент, вы точно уверены, что обращение по его адресу будет корректным (разумеется, если массив не был перемещён в памяти в другое место с расширением его размера, например). Если нужный вам элемент удалили или переместили в другом потоке, вы просто обратитесь по прежнему адресу, поймёте по каким-либо признакам, что нужного вам элемента здесь нет, затем попробуете поискать его и т.д. Разумеется, программа должна заранее поддерживать такую возможность. Но, в любом случае, её работа останется корректной, пока вы находитесь в корректных пределах памяти.
Совсем другая ситуация – в случае списка (а также в случае дерева, графа – любой структуры данных с распределёнными элементами). Если элемент по вашему указателю удалили в другом потоке, вы об этом даже не узнаете, и при попытке обращения по его адресу получите нарушение доступа (в лучшем случае). Даже если он не будет фактически удалён из памяти (например, в случае использования интеллектуальных указателей), он будет удалён из списка, т.е. не будет являться его частью. Вы об этом также не узнаете. Корректная работа со списком нарушается.
При этом интенсивная многопоточная работа со списком создаёт совершенно фантастические сценарии. Вы можете даже быть уверены, что с вашим элементом и указателем на него всё нормально – вплоть до обращения к какой-либо функции списка для работы с ним.
Пример. Пусть есть часть списка, и в некоторую функцию-метод списка передаётся указатель на узел, который обозначим как (#), в то время как узлы, связанные с ним, будем обозначать относительными по отношению к нему номерами. На момент вызова функции известно, что этот элемент существует и указатель на него корректен, то есть состояние списка в этой области такое:
Пусть теперь узел (#) передаётся как параметр в некоторую функцию списка. Эта функция, как водится, блокируется в ожидании доступа к нему. Пока она ждала, до неё поработали три потока, удалившие узел (#) вместе с прилежащими к нему так, что получилось:
Затем ещё 5 потоков вставили ещё 5 элементов в список, начиная с (-2). Обозначим новые элементы как (nN), где N — относительный среди этих пяти номер, начиная с нуля:
Тут наконец получает время наш поток, который вызывали с (#). Вопрос такой: что ему делать в этом случае, ведь (#) уже давно нет?
Ответ: всё сильно зависит от операции, а также от сценария использования списка. Однако, поскольку мы рассматриваем самый общий случай без каких-либо ограничений, можно сделать некоторые общие предположения.
Если это операция удаления, то достаточно просто проверить, присутствует ли заданный элемент в списке. Если нет, то его уже удалили, и больше ничего делать не нужно. Если да, то удалить. Аналогично — для операции чтения/изменения содержимого узла: если узел удалён, то читать/изменять уже нечего. А вот самые большие проблемы возникают при операциях вставки нового узла, а также при перемещении к следующему/предыдущему. С одной стороны, указанного узла уже нет, и можно вернуть неудачу. С другой — узел должен быть вставлен, и такая ситуация может возникнуть в любой момент.
Поскольку приоритетом (для общего случая) всё же безопасность и надёжность, а только потом быстродействие, то, очевидно, когда поток наконец получил время работы внутри функции, то придётся устанавливать факт присутствия элемента в списке: а он вообще есть там ещё или уже нет? Это решает одну проблему: по крайней мере, мы не нарушим работу всего списка в случае отсутствия запрошенного узла там и избежим ошибок доступа к памяти в связи с этим. Но не решает проблему вставки и переходов: непонятно, куда теперь вставлять новый узел и переходить от уже удалённого.
Решение проблемы существования элемента будет подробно рассматриваться далее. Вопрос же, что делать, когда мы обнаружили, что элемента уже нет, а он очень нужен, выходит за рамки этой статьи, поскольку это целиком зависит от алгоритма работы использующей список программы. Разумеется, она должна предусматривать такие сценарии и соответствующие реакции на них: например, если элемента нет, то перейти к началу списка или выполнить какую-нибудь другую операцию. Главное, что нужно обеспечить в этой ситуации – это корректную и безопасную работу списка, а также уведомление о подобных ситуациях.
### Прямой поиск элемента
Самый простой и прямолинейный подход – это проверка присутствия элемента в списке посредством последовательного прохода по нему в поиске заданного элемента. Т.е. просто ищется данный элемент. Если он в списке есть, мы работаем с ним. Если же нет, то, в зависимости от функции, выходим с успехом или неудачей, и пусть вызывающая программа принимает решение, что делать в этой ситуации. Главное, что работа со списком в любом случае будет корректной.
Этот способ безопасен и вполне работоспособен, но, особенно для списков большого размера, приводит к катастрофическому падению производительности. Фактически, работа со списком оказывается однопоточной: список блокируется на время поиска заданного элемента в нём, и другие потоки не могут получить к нему доступ. Во-вторых, резко повышаются накладные расходы – в **каждой** операции со списком приходится проверять, есть ли нужный на момент операции элемент, и огромная доля времени уходит не на полезную работу, а на проверку наличия элемента. Тем не менее, этот простой незамысловатый подход вполне годится для списков малого объёма и не слишком интенсивных операций с ним, а также в качестве первого приближения к решению проблемы существования элемента.
Но что делать, если у нас список с большим количеством элементов, а работа с ним весьма интенсивная: множество потоков постоянно добавляют, изменяют и удаляют элементы из него? Есть ли способ как-нибудь ускорить его работу?
### Память или быстродействие
Есть известный факт, что увеличение используемой программой памяти может увеличить скорость работы программы. Например, программа интенсивно использует результаты каких-то вычислений. Вместо того, чтобы каждый раз выполнять их заново, можно всё вычислить заранее и сохранить их результаты в какой-нибудь таблице или массиве. Затем программа просто обращается в нужную ячейку таблицы и сразу получает нужное значение, что существенно ускоряет её работу.
Именно этот подход я и использовал в случае списка. Создадим битовый массив. Добавим в служебную информацию каждого его элемента, помимо обязательного указателя на следующий и, опционально, предыдущий элементы ещё два новых поля: первый – это его уникальный номер в пределах этого списка, а второй – это указатель на сам список. Теперь, когда элемент создаётся, ему присваивается уникальный номер, и в битовом массиве по соответствующему индексу устанавливает единица. Когда элемент удаляется, этот бит обнуляется. Номер создаваемого элемента постоянно увеличивается при каждом создании нового элемента – уже использованные обнулённые биты не используются повторно.
Теперь, когда требуется проверить наличие заданного элемента, вместо линейного поиска его во всём списке просто происходит обращение к битовому массиву по индексу этого элемента в нём, и факт его наличия сразу устанавливается, причём за константное время, не зависящее от размера списка.
Этот способ позволяет достичь максимального быстродействия, однако он имеет свои серьёзные недостатки. Первый – придётся выделить память под весь массив сразу, часть бит которого может вообще не понадобиться за время работы программы, но эту память можно было бы использовать на другие нужды. Эту проблему и способ сгладить перерасход памяти рассмотрим чуть ниже.
Второй недостаток серьёзнее и интереснее – каждый новый элемент списка создаётся по монотонно возрастающему номеру. Это означает, что рано или поздно свободные биты массива будут исчерпаны.
В этот момент, к сожалению, придётся остановиться, заблокировать список и начать его обслуживать. Т.е. сжать биты этого массива, удалив все нулевые биты от промежуточных ранее удалённых элементов списка, оставив только биты для реально существующих в данный момент элементов, сместив все эти биты к началу массива. Придётся опять пройти по всему списку, причём в однопоточном режиме, переписав все индексы для каждого элемента. Очевидная выгода этого по сравнению с предыдущим подходом в том, что в данном случае это будет выполняться всего **один** раз за длительный период времени. Далее список может продолжать работу как прежде в предельно быстродействующем режиме.
Разумеется, я не имею ввиду, что в список узлы только добавлялись, т.к. в этом случае все биты массива будут единичными. Я рассматриваю сценарий, когда элементы интенсивно и произвольно удаляются и добавляются. Т.е. общее количество элементов списка с начала его работы может измениться незначительно. Естественно, вопрос выбора объёма массива зависит от характера работы программы. Также всегда можно создать новый массив большего объёма, если размера текущего не хватает.
### Использование нулевых бит от уже удалённых прежде элементов
Можно поступить и по-другому: при создании элемента искать первый нулевой бит с начала битового массива. Это оптимизирует расход памяти, но приведёт к падению производительности: теперь опять каждый раз при создании нового элемента придётся выполнять дополнительную работу – просматривать массив в поисках свободного бита. Но по сравнению с проверкой наличия элемента прямым просмотром списка выигрыш налицо: мы будем просматривать **массив** рядом расположенных элементов, причём каждый элемент такого массива содержит множество бит, т.е. мы обрабатываем множество узлов списка за раз (64 бита для современных систем или даже 128/256/512 в случае использования SSE/AVX). Ищем первое слово, не равное слову со всеми единичными битам, далее ищем первый нулевой бит в этом слове. Фактически, этот метод – промежуточный по быстродействию между предыдущим и методом прямого просмотра.
### Оптимизация расхода памяти для незанятых бит массива
Допустим, мы предполагаем длительную и интенсивную работу со списком, выделив для него огромный массив бит. Но так получилось, что фактически программа работала иначе: обращалась к списку редко, выполняла другие операции, которым тоже требуется память. В результате получаем почти неиспользованный массив бит огромного объёма и проблемы с памятью в других частях программы. Сплошные неудобства!
Linux, насколько я могу судить, автоматически решает эту проблему (хотя опытные разработчики-линуксоиды пусть меня поправят, если что). Вы выделяете память под массив, но фактически система эту память массиву **не передаёт** до тех пор, пока она реально не понадобится. Происходит оптимизация использования памяти. Windows такого делать не позволяет. Вернее, позволяет, но это придётся делать своими руками.
Для тех, кто совсем не в курсе, поясню: вашему приложению (точнее, соответствующему ему процессу), система выделяет **виртуальное адресное пространство** большого объема – вплоть до 8 Тб для 64-разрядной Windows. Физической памяти в системе может быть намного меньше – 8 или 16 Гб на данный момент для массовых компьютеров. Операционная система **отображает** адреса вашего виртуального пространства процесса на адреса физической памяти, делая это прозрачным образом без вашего прямого участия. Естественно, большая часть свободной виртуальной памяти процесса оказывается обычно незанятой. Так вот, когда вы просите Windows выделить память обычными средствами, она эту память одновременно выделяет как в вашем виртуальном пространстве, так в физической памяти. Если вы выделите битовый массив большого объёма, вы рискуете сразу занять всю доступную память на вашей машине без гарантии, что эта память вообще может понадобиться.
Однако можно поступить и по-другому: разметить огромный участок памяти в виртуальном пространстве процесса, но передавать ему физическую только тогда, когда она реально нужна. Сделать это можно посредством структурной обработки исключений в Windows, за подробностями прошу обратиться в книге Рихтер Д., Назар К. – «Windows via C/C++, Программирование на языке Visual C++».
Реализация
----------
Это было бы только идеей и теорией, если бы я не реализовал все эти идеи на практике, причём не в виде простенькой экспериментальной программы: я делал её максимально тщательно как для production, намереваясь использовать в своих реальных проектах, поэтому именно в таком виде вам её и представляю. Подумал, что было бы несправедливо и слишком эгоистично применять сделанное в своём ограниченном количестве проектов, если это может оказаться полезным или хотя бы просто интересным широкому кругу разработчиков. С другой стороны, создатели библиотеки Boost и других более специализированных библиотек предлагают свои работы всем желающим абсолютно бесплатно. Почему я не могу поступить таким же образом?
### Абстракция – список без данных
Я разделил список на два логических уровня. Первый уровень – это список, каждый элемент которого не содержит никаких полезных данных, а содержит только служебную информацию: указатели на соседние элементы, а также, опционально, те два дополнительных поля для ускорения проверки наличия элемента в списке. Однако уже на этом уровне возможно выполнять все базовые операции над списком: добавление и удаление элементов, разбиение и объединение списков и т.д. Фактически, я сконцентрировался прежде всего на этом уровне.
Второй уровень – это добавление фактических данных к элементу списка, а также добавление новых операций в список для работы с этими данными. Всё это обеспечивается в С++ путём наследования. Но о деталях пойдёт речь ниже.
Такое разбиение реализации на два уровня имело свой смысл: зачем учитывать наличие конкретных данных, если целый ряд операций никак не зависит от этих данных? Для любых данных элементов списка всё равно придётся удалять их и добавлять новые в список, а также выполнять другие типичные операции.
Начинал я с предельно простой и незамысловатой концепции, взятой ещё из приведённой в начале статьи конструкции из языка С. Как внутри, так и вне списка применяются внутренние указатели C/С++. Разница была лишь в том, что добавление данных, как было указано выше, отложено на более поздний срок.
Пусть есть элемент списка без данных, содержащий лишь указатель (или указатели) на соседний/-ие элемент(ы). Тогда соответствующий код для него схематично можно представить так:
```
template class List\_OneLinked; //односвязный список
//узлы списка
struct ListElement\_OneLinked //узел односвязного списка (без данных)
{
ListElement\_OneLinked \*pNext; //указатель на следующий элемент списка
};
//классы списков
template class List\_OneLinked //односвязный список
{
//свойства
//указатели на узлы списка
ListElement \*pFirst = nullptr; //указатель на первый узел
ListElement \*pLast = nullptr; //указатель на последний узел
SRWLOCK csSRW = { 0 }; //структура для критической секции блокировки
<…m-функции (методы) класса>
};
```
Элемент для односвязного списка содержит внутри себя указатель на следующий элемент, и только. Класс списка параметризуется типом этого элемента, подразумевая, что этот тип будет изменён на стадии добавления данных. Он содержит внутри себя указатели на первый и последний элементы. Поскольку я исходно нацеливал этот проект только для Windows, то также включена критическая секция типа SRWLock для блокировки списка. Далее определяются конструкторы, деструктор, а также все необходимые функции для работы со списком.
Данная реализация содержит сразу две проблемы.
Первая – открытый доступ к содержимому служебной информации элемента. Это означает, что, получив доступ к какому-либо узлу, т.е. имея указатель на этот узел, мы можем непосредственно обратиться к последующему или предыдущему элементу.
*Однако при многопоточной работе со списком это **недопустимо**.*
Это недопустимо главным образом потому, что этот переход осуществляется в обход блокировки и, следовательно, защиты списка. В самом деле, предположим, имея указатель на некоторый элемент pCurr, мы сохранили значение на следующий относительно него элемент в указателе pNext следующим образом: pNext = pCurr->pNext. После этого выполняем некоторую длительную операцию над данным узлом pCurr. В это же время другие потоки удалили следующие относительно pCurr элементы списка. Закончив работу с pCurr, текущий поток переходит к следующему элементу, используя старое значение, сохранённое в локальной pNext, и получает ошибку доступа либо неопределённое поведение, поскольку элемента по адресу локального pNext уже не существует, и нужно обращаться к обновлённому значению pCurr->pNext, если текущий элемент по адресу pCurr, в свою очередь, тоже вообще ещё существует.
Из этого примера можно сделать два вывода для предотвращения этой ситуации:
* извне списка осуществлять переход к следующему/предыдущему узлу и вообще осуществлять любую работу с элементами списка только через функции (методы) класса списка, производящие блокировку списка и делающими доступ к списку безопасным;
* получать доступ к элементам по возможности непосредственно перед обращением к ним (например, получать указатель на следующий элемент pNext = list.GetNext(pCurr) не заранее, а непосредственно перед тем, как появится необходимость в переходе к следующему узлу).
Именно поэтому для реализации вывода из первого пункта следует запретить доступ к указателям на смежные элементы извне:
```
class ListElement_OneLinked //узел односвязного списка (без данных)
{
ListElement_OneLinked *pNext; //указатель на следующий элемент списка
friend List_OneLinked; //объявляем класс односвязного списка привилегированным для обеспечения доступа из него
};
```
Вторая проблема несколько деликатнее. Чтобы понять её, следует структуру классов описать более подробно. Класс списка определён как шаблонный и работает не с элементами типа ListElement\_OneLinked, а с типом ListElement, передаваемым в качестве параметра шаблона. Это сделано для того, чтобы иметь возможность создавать внутри класса новые узлы с данными. Для того, чтобы делать это, нужно знать точный тип создаваемого узла. Точный тип узла списка пока ещё не известен: он будет определён позже вместе с данными. Функция создания элемента выделяет память для него, инициализирует указатели, а затем возвращает указатель на созданный элемент в вызывающую функцию. Так в вызывающей функции производного класса можно будет провести инициализацию других, специфичных для этого класса и доопределённых позже свойств элемента. Иными словами, точное определение типа узла списка оставлено на будущее, и для того, чтобы список корректно функционировал, важно лишь, чтобы его элементы содержали указатель pNext, остальное пока не имеет значения.
Таким образом, на базе ListElement\_OneLinked впоследствии путём наследования будет создан новый класс для элемента с конкретными данными и передан классу List\_OneLinked через параметр шаблона. Одновременно на базе List\_OneLinked будет создан новый производный класс, доопределяющий операции с этими новыми данными.
Однако даже такой вариант не является совсем корректным. В ранних версиях класса списка несколько раз применялась операция явного преобразования типа reinterpret\_cast(...). Дело в том, что шаблонный класс работает с типом-параметром шаблона ListElement, который является производным от ListElement\_OneLinked/ListElement\_TwoLinked. А в функциях класса создаются переменные в выражениях типа:
ListElement \*pNext = pCurr->pNext;
Причём pCurr->pNext здесь — это указатель на ListElement\_OneLinked/ListElement\_TwoLinked, как члены базовых классов.
Выход: либо объявлять переменную, указывая явный базовый тип ListElement\_OneLinked/ListElement\_TwoLinked, либо приводить её к производному типу явно.
На самом деле даже явное определение базового типа не является корректным, например, в функции удаления (очистки) списка:
```
//удаляем все элементы списка
ListElement *pCurr = pFirst;
ListElement *pNext = nullptr;
while (pCurr != nullptr)
{
pNext = reinterpret_cast(pCurr->pNext);
delete pCurr;
pCurr = pNext;
}
```
Если изменить тип указателей:
```
ListElement_OneLinked *pCurr = pFirst;
ListElement_OneLinked *pNext = nullptr;
```
то это будет означать, что будут удалены операцией
```
delete pCurr;
```
только базовые части каждого узла списка, что неправильно. Либо, как вариант, придётся уже указатель pCurr приводить к его производному типу:
```
delete reinterpret_cast(pCurr);
```
Таким образом, в любом случае от явного преобразования reinterpret\_cast при такой структуре классов не избавиться, что не является лучшим решением (точнее, что совсем нехорошо на самом деле).
По этой причине, чтобы избавиться от таких вот явных преобразований, было решено изменить базовый класс для элемента (для двусвязного списка – аналогично):
```
template class ListElement\_OneLinked //узел односвязного списка (без данных)
{
ListElement \*pNext; //указатель на следующий элемент списка
friend List\_OneLinked; //объявляем класс односвязного списка привилегированным для обеспечения доступа из него
};
```
Кратко это можно охарактеризовать так: базовый элемент списка содержит указатель на другой элемент, но тип этого указателя ещё пока не известен, потому как передаётся параметром шаблона (точное определение этого типа оставлено на будущее). Иными словами: на данном этапе тип узла списка (т.е. каким он будет в итоге) ещё не определён, он будет определён позже. Но сейчас мы сохраняем указатель на элемент будущего, пока ещё не известного, типа. Итоговый тип узла списка передаётся сюда как параметр шаблона.
Теперь не потребуется никаких преобразований, поскольку везде – и в классе списка, и в классе для узлов – используются указатели одного типа ListElement. ListElement здесь и в классе списка – это итоговый класс для элемента с конкретными данными.
Это означает, что теперь класс списка стал максимально абстрагированным от конкретного его содержимого: известно лишь, что его узлы содержат указатели на другие такие узлы, и, пользуясь этой информацией, в классе списка выполняются все базовые операции над ними с соответствующей многопоточной блокировкой.
### Решение проблемы существования элемента – простой поиск (версия 01.03.2018)
Первая версия была предельно простой и незамысловатой и не выходила за описанные выше рамки. Использовались внутренние указатели С++, память для элементов выделялась посредством операции new и удалялась с помощью delete, список блокировался на содержащейся в нём критической секции. О средствах библиотеки STL я не знал и не подозревал, а также о том, на какой уровень они выводят программирование на С++.
Уже на этом этапе я на практике столкнулся с описанной ранее проблемой существования элемента и понял, что простой блокировки списка недостаточно. Я перемещался по списку с помощью соответствующих функций со всеми мерами предосторожности, список корректно блокировался, но программа всё равно успешно падала с разной периодичностью. Именно тогда я выяснил, что наличие элемента придётся проверять, что привело к изменению логики ключевых функций.
Приведу в пример функцию добавления элемента после заданного:
```
ListElement* AddAfter(ListElement* const pElem, bool bProtected = false) throw (FailElemCreation, Nullptr, NotPartOfList)
{
if (!pElem)
throw Nullptr(); //генерация исключения об ошибочном параметре (нулевой указатель)
//блокируем список на время операции
if (!bProtected)
LockListExclusive();
//проверяем, является ли переданный элемент частью списка
if (!FindElement(pElem, true))
{
if (!bProtected)
UnlockListExclusive();
throw NotPartOfList(); //генерация исключения - переданный элемент не является частью списка
}
ListElement *pCurr = new ListElement;
if (!pCurr)
{
if (!bProtected)
UnlockListExclusive();
throw FailElemCreation(); //генерация исключения о неудаче выделения памяти для узла списка
}
//проверяем, является ли это первым элементом списка
if (pFirst == nullptr)
{
pFirst = pLast = pCurr;
pCurr->pNext = nullptr;
}
else
{
//устанавливаем указатель в текущем элементе списка на только что созданный
ListElement *pNext = pElem->pNext;
pElem->pNext = pCurr;
pCurr->pNext = pNext;
//проверяем, является ли текущий элемент последним
if (pElem == pLast)
pLast = pCurr;
}
//разблокируем список
if (!bProtected)
UnlockListExclusive();
return pCurr;
}
```
Видно, что прежде чем создать новый элемент, она проверяет, присутствует ли в списке заданный элемент, вызывая функцию FindElement(…):
```
bool FindElement(ListElement* const pElem, bool bProtected = false) const throw (Nullptr)
{
if (!pElem)
throw Nullptr(); //генерация исключения об ошибочном параметре (нулевой указатель)
if (!bProtected)
LockListShared(); //блокируем список на время операции
ListElement *pCurr = pFirst;
bool bResult = false;
while (pCurr != nullptr)
{
if (pCurr == pElem)
{
bResult = true;
break;
}
pCurr = pCurr->pNext;
}
if (!bProtected)
UnlockListShared(); //разблокируем список
return bResult;
}
```
### Дальнейшее усложнение классов многопоточного списка – классы стратегий (версии 18.02.2019, 27.11.2019)
Изначально проект нацеливался строго на Windows. Но в какой-то момент я подумал, почему бы не добавить ему гибкости? Почему только Windows? Ведь список реализовывался по сути на чистом С++, от Windows у него было только одно: критическая секция SRWLock. К тому моменту я уже познакомился с концепцией классов стратегий. Об этом вы можете подробно почитать в книге Александреску А. – «Современное проектирование на С++». В ней описаны многие необычные и потрясающие вещи, которые могут быть полезны даже сейчас несмотря на то, что книге уже 12 лет.
Одна из них – это классы стратегий. Классы стратегий, по сути, – это и есть изменений поведения класса посредством шаблонов, о чём упоминал Б. Страуструп в своей известной книге. Только в книге Александреску эта тема широко раскрывается.
Предположим, ваш класс выполняет одно какое-то строго определённое действие. Вы можете вынести определение этого действия за пределы класса, создать на основе этого действия отдельный класс и передать его в ваш исходный класс в качестве параметра шаблона. Это усложняет код, его чтение и понимание, но зато существенно добавляет вашему классу гибкости: чтобы заменить данное конкретное действие каким-то другим, аналогичным, вам достаточно просто будет написать другую подобную стратегию и передать её вашему классу в качестве параметра шаблона. Всю остальную работу сделает за вас компилятор.
#### Стратегия блокировки
Применяя это к описываемому списку, я вынес блокировку через SRWLock в отдельную стратегию, а затем написал несколько других стратегий: через обычную критическую секцию Windows, через мьютексы С++ STL и т.д. Потом можно будет добавить чисто специфичные для Linux методы. Таким образом, класс стал подходящим не только для Windows, но я всегда могу очень быстро перенастроить его обратно для Windows оптимальным образом, просто указав нужную стратегию.
```
//блокировка посредством критической секции SRWLock
//так как критическую секцию типа SRWLock как-либо удалять не нужно, то деструктор классу не требуется (конструктор также не требуется из инициализации члена
//класса прямо в классе: С++11)
class ThreadLockingWin_SRWLock //блокировка посредством критической секции SRWLock
{
mutable SRWLOCK csSRW = { 0 }; //структура для критической секции типа SRWLock
public:
ThreadLockingWin_SRWLock(bool bInitialize = true)
{
//конструктор; bInitialize - флаг того, что требуется инициализация критической секции
if(bInitialize)
InitializeSRWLock(&csSRW); //инициализируем критическую секцию SRWLock
}
//функции управления блокировкой
void LockExclusive(void) const noexcept //выполняет блокировку ресурса для изменения
{
AcquireSRWLockExclusive(&csSRW);
}
void UnlockExclusive(void) const noexcept //выполняет разблокировку ресурса после изменения
{
ReleaseSRWLockExclusive(&csSRW);
}
void LockShared(void) const noexcept //выполняет блокировку ресурса для чтения
{
AcquireSRWLockShared(&csSRW);
}
void UnlockShared(void) const noexcept //выполняет разблокировку ресурса после чтения
{
ReleaseSRWLockShared(&csSRW);
}
void Lock(void) const noexcept //выполняет блокировку ресурса
{
AcquireSRWLockExclusive(&csSRW);
}
void Unlock(void) const noexcept //выполняет разблокировку ресурса
{
ReleaseSRWLockExclusive(&csSRW);
}
};
```
#### Стратегия работы с памятью
Примерно к этому моменту я также серьёзно взялся изучать STL и в числе первых средств этой библиотеки познакомился с интеллектуальными указателями. А затем подумал: почему я не могу добавить поддержку интеллектуальных указателей в свой список? Тогда я вынес тип указателя, а также создание и удаление данных элемента списка в отдельную стратегию:
```
//стратегия работы с памятью при помощи встроенных указателей C/С++
//выделитель памяти по умолчанию
template class DefaultAllocator\_InternalPointer
{
public:
template static Type\* Create(ArgTypes... Args) noexcept //выполняет выделение памяти для объекта
{
return new Type(Args...);
}
};
template class DefaultAllocator\_InternalPointer //частичная специализация для массивов
{
public:
static Type\* Create(size\_t size) noexcept //выполняет выделение памяти для массива
{
if (size != 0)
return new Type[size];
else
return nullptr;
}
};
//удалитель по умолчанию
template class DefaultDeleter\_InternalPointer
{
public:
void operator()(Type\* ptr) noexcept //для того, чтобы можно было использовать в удалителях классов типа unique\_ptr
{
Delete(ptr);
}
static void Delete(Type \*ptr) noexcept //выполняет удаление объекта из памяти
{
if(ptr)
delete ptr;
}
};
template class DefaultDeleter\_InternalPointer //частичная специализация для массивов
{
public:
void operator()(Type\* ptr) noexcept //для того, чтобы можно было использовать в удалителях классов типа unique\_ptr
{
Delete(ptr);
}
static void Delete(Type \*ptr) noexcept //выполняет удаление массива из памяти
{
if(ptr)
delete[] ptr;
}
};
//тип объекта, для которого создаётся указатель, передаётся в параметре Type шаблона
//Deleter и Allocator - это удалители и выделители памяти для объектов типа Type
template, class \_Allocator = DefaultAllocator\_InternalPointer> class InternalPointer
{
public:
//объявления типов
using ptrType = Type \* ; //тип указателя на тип объекта
using Allocator = \_Allocator; //выделитель памяти
using Deleter = \_Deleter; //удалитель
using shared\_ptrType = ptrType; //для поддержки интеллектуальных указателей
using weak\_ptrType = ptrType; //для поддержки интеллектуальных указателей
//функции
template static ptrType Create(ArgTypes... Args) noexcept
{
//функция создаёт объект и возвращает указатель на него
//на вход: Args - аргументы-параметры для конструктора объекта типа Type
//на выход: указатель на созданный объект типа Type
return Allocator::Create(Args...); //создаём объект с помощью переданного выделителя памяти
}
static void Delete(ptrType& pObject) noexcept
{
//удаляет объект из памяти, устанавливая указатель на него в нулевое значение
//на вход: pObject - ссылка на указатель объекта для удаления, DeleterFunc - указатель на функцию-удалитель
if (pObject)
{
Deleter::Delete(pObject); //удаляем объект с помощью переданного удалителя
pObject = nullptr;
}
}
static ptrType MakePointer(Type& obj) noexcept
{
//возвращает указатель заданного типа на существующий объект
//на выход: указатель на объект типа Type
return &obj
}
};
```
Аналогичная стратегия для интеллектуальных указателей:
```
//стратегия работы с памятью при помощи интеллектуальных указателей shared_ptr/weak_ptr С++
//выделитель памяти по умолчанию
template class DefaultAllocator\_SmartSharedPointer
{
public:
template static std::shared\_ptr Create(ArgTypes... Args) noexcept //выполняет выделение памяти для объекта
{
return std::make\_shared(Args...);
}
};
template class DefaultAllocator\_SmartSharedPointer //частичная специализация для массивов
{
public:
static std::shared\_ptr Create(size\_t size) noexcept //выполняет выделение памяти для массива
{
if (size != 0)
return std::make\_shared(size);
else
return nullptr;
}
};
//удалитель по умолчанию
template class DefaultDeleter\_SmartSharedPointer
{
public:
void operator()(std::shared\_ptr\* ptr) noexcept //для того, чтобы можно было использовать в удалителях классов типа unique\_ptr
{
Delete(\*ptr);
}
static void Delete(std::shared\_ptr& ptr) noexcept //выполняет удаление объекта из памяти
{
ptr = nullptr; //сбрасываем указатель, что приводит к удалению объекта, если нет других объектов
}
};
template class DefaultDeleter\_SmartSharedPointer //частичная специализация для массивов
{
public:
void operator()(std::shared\_ptr\* ptr) noexcept //для того, чтобы можно было использовать в удалителях классов типа unique\_ptr
{
Delete(\*ptr);
}
static void Delete(std::shared\_ptr& ptr) noexcept //выполняет удаление массива из памяти
{
ptr = nullptr; //сбрасываем указатель, что приводит к удалению объекта, если нет других объектов
}
};
//тип объекта, для которого создаётся указатель, передаётся в параметре Type шаблона
//Deleter и Allocator - это удалители и выделители памяти для объектов типа Type
template, class \_Allocator = DefaultAllocator\_SmartSharedPointer> class SmartSharedPointer
{
public:
//объявления типов
using ptrType = std::shared\_ptr; //тип указателя на тип объекта
using Allocator = \_Allocator; //выделитель памяти
using Deleter = \_Deleter; //удалитель
using shared\_ptrType = ptrType; //указатель для совместного владения
using weak\_ptrType = std::weak\_ptr; //слабый указатель
//функции
template static ptrType Create(ArgTypes... Args) noexcept
{
//функция создаёт объект и возвращает указатель на него
return Allocator::Create(Args...); //создаём объект с помощью переданного выделителя памяти
}
static void Delete(ptrType& pObject) noexcept
{
//устанавливаем указатель на объект в нулевое значение; если это - последний указатель, которым владеет этот объект, то объект будет удалён
//из памяти
Deleter::Delete(pObject); //удаляем объект с помощью переданного удалителя
}
static ptrType MakePointer(Type& obj) noexcept
{
//возвращает указатель заданного типа на существующий объект
//на выход: указатель на объект типа Type
return std::shared\_ptr(&obj);
}
};
```
Стратегия памяти принимает три параметра: тип объекта Type, а также распределитель и удалитель памяти. На основании типа объекта стратегия создаёт тип указателя на этот тип – либо Type \*, либо std::shared\_ptr, в зависимости от стратегии, а также предлагает соответствующие функции создания и удаления объекта. Эти функции, если говорить о распределителях и удалителях по умолчанию, создают объект либо через операцию new Type, либо через функцию std::make\_shared(…). Всё это работает благодаря тому, что разыменование указателя происходит одинаково как для встроенного указателя С++, так и для интеллектуального std::shared\_ptr. Конечно, в случае двусвязного списка и интеллектуальных указателей, чтобы избежать неприятной особенности зацикливания указателей, для указателей на предыдущий элемент используется std::weak\_ptr, и во время компиляции для двусвязного списка в зависимости от выбранной стратегии памяти выбирается, как его разыменовывать (это – новая особенность С++17):
```
//если тип pPrev является weak_ptr, то обращаться к нему можно только после преобразования в shared_ptr с помощью функции lock()
if constexpr (std::is_same_v>) //C++17: if constexpr
pFirst->pPrev.lock() = nullptr;
else
pFirst->pPrev = nullptr;
```
Таким образом, теперь список не создаёт самостоятельно свои элементы: он перенаправляет вызов соответствующей стратегии.
#### Стратегия проверки наличия элемента
Разумеется, и решение проблемы существования элемента я вынес в отдельную стратегию: если списку требуется проверить наличие какого-то его элемента, он просто переадресует вызов соответствующей стратегии. Самый первый, незамысловатый и топорный подход стал стратегией прямого поиска DirectSearch. Далее я разработал ещё две стратегии на основе двух описанных ранее подходов с битовым массивом в порядке их описания: SearchByIndex\_BitArray и SearchByIndex\_BitArray2. Для Windows для возможности постепенного занимания памяти битовым массивом по мере его заполнения также добавил ещё две стратегии:
SearchByIndex\_BitArray\_MemoryOnRequestLocal и SearchByIndex\_BitArray2\_MemoryOnRequestLocal.
Как было отмечено ранее, для работы этих продвинутых стратегии требуется, чтобы элемент списка содержал в себе индекс в битовом массиве и указатель на базовый класс списка (об этом см. ниже), т.е. был определён следующим образом:
```
//элементы списка с информацией для быстрой проверки присутствия элемента в списке
template class \_MemoryPolicy> class ListElement\_OneLinked\_CP //узел односвязного списка (без данных)
{
public:
using MemoryPolicy = \_MemoryPolicy; //сохраняем используемую стратегию работы с памятью внутри класса элемента
private:
typename MemoryPolicy::ptrType pNext; //указатель на следующий элемент списка
unsigned long long ullElementIndex; //индекс элемента среди всех созданных в списке
ListBase \*pList; //указатель на список-владелец элемента
//объявляем шаблонный класс односвязного списка привилегированным для обеспечения доступа из него; класс объявляется привилегированным ВЕСЬ, независимо от конкретных
template class CheckingPresenceElementPolicy> friend class List\_OneLinked;
//объявляем шаблонную функцию операции "+" привилегированной
template class CheckingPresenceElementPolicy> friend List\_OneLinked operator+(List\_OneLinked&, List\_OneLinked&) noexcept; //объявляем операцию объединения списков привилегированной
//объявляем классы стратегий поиска и проверки элемента списка привилегированными
template friend class DirectSearch;
template friend class SearchByIndex\_BitArray;
template friend class SearchByIndex\_BitArray2;
};
```
#### Соотношение стратегии памяти со стратегиями проверки наличия элемента
При подробном рассмотрении оказалось, во взаимоотношениях стратегии памяти со стратегиями проверки наличия элемента присутствует подводный камень.
Предположим, вы используете интеллектуальные указатели в качестве стратегии памяти, а также стратегию с использованием битового массива для ускоренной проверки наличия элемента в списке. Вы удаляете элемент, стратегия памяти сбрасывает его указатель. При этом этот элемент фактически не удаляется из памяти, поскольку у вас в вашей вызывающей программе есть другой интеллектуальный указатель на него. В дальнейшем вы обращаетесь к списку с этим элементом, и он совершенно корректно делает проверку, обращаясь к его данным – индексу в битовом массиве и указателю на список. Элемент фактически удаляется из памяти только тогда, когда больше не осталось нигде никаких ссылок на него.
Совсем не то происходит в случае использования встроенных указателей С++. В этом случае стратегия памяти **действительно** удалит этот элемент из памяти с помощью операции delete. В дальнейшем вы, как и в предыдущем случае, обратитесь к списку с этим элементом, и он попытается **обратиться** к элементу по этому адресу в целях считать индекс битового массива и указатель на список. А этого делать нельзя: элемент ведь уже удалён из памяти! В лучшем случае вы получите нарушение доступа, в худшем – неопределённое поведение, когда библиотека С++, библиотека времени выполнения или просто операционная система запишет туда совершенно произвольное значение, которые считает список и попытается установить по ним факт присутствия элемента в списке.
Таким образом, получается, что внутренние указатели совместимы только со стратегией прямой проверки DirectSearch, а интеллектуальные указатели в данном случае предлагают не только присущую им безопасность, но и увеличение производительности: ведь только с их использованием можно применять битовые массивы, которые существенно увеличивают работу списка в многопоточном режиме!
Чтобы гарантировать соответствие и исключить несовместимые конфигурации стратегий, я включил в каждый класс списка следующую проверку:
```
//проверка, что внутренний указатель С++ (Type *) может использоваться только со стратегией проверки элемента прямого поиска (DirectSearch)
static_assert(!(std::is_same_v> == true && std::is\_same\_v, DirectSearch> == false), "Internal C++ pointer memory policy can be used only with DirectSearch policy.");
```
Она сравнивает переданные в список классы стратегий и, в случае их несовместимости, останавливает компиляцию с соответствующим выводом сообщения об ошибке.
### Исключения или возврат ошибок
Исходно обработка ошибок списка осуществлялась только посредством исключений. Но как-то на каком-то уже не помню форуме я вычитал, что исключения замедляют программу, и для максимальной производительности следует использовать традиционный возврат ошибок. Так и сделал, создав два новых класса на основе исходных, только переписав их под возврат ошибок.
### Базовый класс списка
Реализация описанных выше стратегий проверки наличия элементов выявила одну важную проблему. Элемент списка, как мы помним, содержит помимо уникального в данном списке номера ещё также указатель на этот список: ведь у нас может быть в программе два и более списков, каждый из которых содержит собственный битовый массив флагов наличия элемента. Как убедиться, что данный элемент принадлежит именно данному списку, а не другому? Только посредством хранения указателя на весь список внутри каждого элемента.
Проблема в том, что теперь за счёт добавления разнообразных стратегий в наш класс списка мы существенно усложнили его **тип**. Допустим, у нас есть два разных списка с одинаковым типом элемента и одинаковой стратегий памяти, но с разными стратегиями блокировки и проверки наличия элементов в них. Для компилятора это будут два разных **типа** списков. Указатель на какой тип хранить в элементе? Причём класс для элемента заранее не знает, какая именно стратегия будет применяться, он должен учесть их **все**.
Вспомним также, что и стратегия блокировки, и стратегия проверки наличия элемента, и даже связность (односвязный или двусвязный) списка относятся только к характеру поведения самого списка, но никак не относятся к хранимым им **данным**. А ведь нас как конечных пользователей этого класса интересуют именно данные! Так что, с одной стороны, использовав классы стратегий, мы добавили себе гибкости, а с другой – усложнили себе жизнь и добавили проблем.
Можно ли всё-таки как-нибудь сделать так, чтобы и волки были сыты, и овцы целы?
Можно. Можно вывести указатели на данные из класса (т.е из типа) списка. Помимо указанных прежде двух уровней организации списка появился ещё один – нулевой:
```
//базовый класс списка
template class ListBase
{
using ptrListElement = typename ListElement::MemoryPolicy::ptrType; //извлекаем тип указателя из класса элемента списка и переданной ему стратегии работы с памятью
protected:
//указатели на узлы списка
ptrListElement pFirst{ nullptr };
ptrListElement pLast{ nullptr };
};
```
Теперь, т.к. реальные классы списков наследуются от него, если мы хотим обратиться к данным списка вне зависимости от его реального типа, нам следует обратиться к его базовому классу ListBase. Получаем доступ к началу и концу списка, а затем работаем с его данными как хотим. Конкретный тип списка, а также комбинация используемых в нём стратегий значения не имеет.
### Итераторы
Уже вовсю плотно работая с STL в реальном проекте (не моём :) ), а также продолжая изучать его в книгах, я обратил внимание на цикл for по коллекции. Ведь этот цикл – не просто часть STL, он стал уже внутренней частью языка. Я подумал, что тоже могу добавить поддержку его в свой проект.
Для этого необходимо добавить поддержку итераторов, абстрагируясь от конкретного способа работы с указателями и переходу по списку.
Пример итератора:
```
class ListIterator //класс итератора для перебора элементов
{
ptrListElement pCurrElement{ nullptr }; //текущий элемент, на который указывает итератор
const List_OneLinked\* pList = nullptr; //указатель на список, которому принадлежит данный элемент
bool bProtected = true; //флаг того, что список блокирован извне итератора
public:
ListIterator() {}
ListIterator(ptrListElement pElem, const List\_OneLinked\* pList, bool bProtected = true)
noexcept : pCurrElement(pElem), pList(pList), bProtected(bProtected) {}
ListIterator(const ListIterator& li) noexcept : pCurrElement(li.pCurrElement), pList(li.pList) {}
ptrListElement& operator\*()
{
if (!bProtected)
{
pList->LockListShared(); //блокируем список на время операции
if (!pList->FindElement(pCurrElement, nullptr, true))
{
if (!bProtected)
pList->UnlockListShared();
throw ListErrors::NotPartOfList(); //генерация исключения - переданный элемент не является частью списка
}
}
ptrListElement& pli = pCurrElement;
if (!bProtected)
pList->UnlockListShared(); //разблокируем список после операции
return pli;
}
operator bool() noexcept { return pCurrElement != nullptr; }
operator ptrListElement() noexcept { return pCurrElement; }
void operator++() //префиксный инкремент: ++it
{
if (!bProtected)
{
pList->LockListShared(); //блокируем список на время операции
if (!pList->FindElement(pCurrElement, nullptr, true))
{
if (!bProtected)
pList->UnlockListShared();
throw ListErrors::NotPartOfList(); //генерация исключения - переданный элемент не является частью списка
}
}
pCurrElement = pCurrElement->pNext;
if (!bProtected)
pList->UnlockListShared(); //разблокируем список после операции
}
ListIterator operator++(int) noexcept //постфиксный инкремент: it++
{
ListIterator itPrev = \*this;
if (!bProtected)
{
pList->LockListShared(); //блокируем список на время операции
if (!pList->FindElement(pCurrElement, nullptr, true))
{
if (!bProtected)
pList->UnlockListShared();
throw ListErrors::NotPartOfList(); //генерация исключения - переданный элемент не является частью списка
}
}
pCurrElement = pCurrElement->pNext;
if (!bProtected)
pList->UnlockListShared(); //разблокируем список после операции
return itPrev;
}
bool operator==(const ListIterator li)
{
if (!bProtected)
pList->LockListShared(); //блокируем список на время операции
bool bResult = (pCurrElement == li.pCurrElement && pList == li.pList);
if (!bProtected)
pList->UnlockListShared(); //разблокируем список после операции
return bResult;
}
bool operator!=(const ListIterator li)
{
if (!bProtected)
pList->LockListShared(); //блокируем список на время операции
bool bResult = false;
if (pList == nullptr || li.pList == nullptr)
bResult = !(pCurrElement == li.pCurrElement);
else
bResult = !(pCurrElement == li.pCurrElement && pList == li.pList);
if (!bProtected)
pList->UnlockListShared(); //разблокируем список после операции
return bResult;
}
};
```
```
Для того, чтобы список был доступен в операторе for по коллекции, в него необходимо добавить также функции begin() и end():
ListIterator begin(bool bProtected = false) noexcept
{
if(!bProtected)
LockListShared(); //блокируем список на время операции
ListIterator lit(ListBase::pFirst, this);
if (!bProtected)
UnlockListShared(); //разблокируем список
return lit;
}
ListIterator end() noexcept
{
return ListIterator();
}
```
Теперь стало возможным написать следующим образом:
```
using List = ListData, true>;
List list;
try
{
for(auto& leValue : list)
\_tprintf\_s(TEXT("%I64u\n"), leValue->u64Value);
}
catch(…)
{
…
}
```
leValue имеет тип указателя на элемент списка.
Первоначально я внёс поддержку итераторов только в списки с поддержкой исключений.
Причина была проста: поскольку код внутри цикла недоступен, то корректно обработать ошибки не представляется возможным. Остаётся только обрабатывать исключения, обернув цикл в блок try. Вообще, ходить по списку таким образом, когда с ним интенсивно работают другие потоки, является не лучшей идеей: лучше заблокировать список самостоятельно, а затем спокойно пройти по нему в однопоточном режиме. Но всё-таки если зачем-то требуется сделать именно так, как в примере выше, то теперь и для этого есть возможность.
### Обобщение стратегии проверки наличия элемента на произвольный контейнер; итераторы для списков без исключений
На самом деле я изначально планировал (и до сих планирую) сделать не только многопоточный список, но также ещё и дерево. Для некоторых своих нужд. Граф тоже можно, но во-первых, он мне не был нужен, а во-вторых, граф – штука сложная и с весьма нетривиальными алгоритмами, а мне не хотелось погружаться в это без особой нужды.
В первоначальном варианте стратегия проверки наличия элемента была ориентирована только на список, и её функции принимали указатель на элемент и указатель на базовый класс списка (ListBase \*). Впоследствии я подумал: но ведь в случае дерева придётся делать ровно то же самое! Делать отдельную, но по сути точно такую же стратегию?
Решение было простое: абстрагироваться от списка. Это означало, что теперь на вход будут поступать не указатели на элементы, а итераторы. А функции станут шаблонными, чтобы принимать указатели на контейнер любого подходящего типа.
Так что теперь исходная функция, например, регистрации списка в битовом массиве
```
void RegisterList(const ListBase\* const pList, ptrListElement const pStart, ptrListElement const pEnd = nullptr) noexcept
{
//регистрирует элементы списка, присоединённые к данному
//на вход: pList - указатель на список, которым нужно обновить соответствующие данные в элементах, pStart - начальный обновляемый элемент,
//pEnd - конечный обновляемый элемент
if (pElementPresentFlags)
{
ptrListElement pCurr = pStart;
unsigned long long ullQWordIdx = 0; //индекс учетверённого слова внутри массива
unsigned long long ullBitIndex = 0; //индекс бита внутри учетверённого слова
while (pCurr != pEnd && pCurr != nullptr)
{
if (ullCurrentElementIndex == ullNumElementsMax)
UpdateFlagsArray(pList->pFirst);
pCurr->ullElementIndex = ullCurrentElementIndex;
pCurr->pList = const\_cast \*>(pList);
ullQWordIdx = ullCurrentElementIndex / ce\_ullNumBitsInWord; //индекс учетверённого слова внутри массива
ullBitIndex = ullCurrentElementIndex % ce\_ullNumBitsInWord; //индекс бита внутри учетверённого слова
pElementPresentFlags[ullQWordIdx] |= 1ULL << ullBitIndex; //устанавливаем бит
ullCurrentElementIndex++;
ullNumElements++;
pCurr = pCurr->pNext;
}
}
}
```
Превратилась в функцию регистрации контейнера:
```
template void RegisterContainer(Container\* const pContainer, Iterator itStart, Iterator itEnd = Iterator{})
{
//регистрирует элементы контейнера, присоединённые к данному
//на вход: pContainer - указатель на контейнер, которым нужно обновить соответствующие данные в элементах; itStart - начальный итератор обновляемого
//элемента, itEnd - конечный итератор обновляемого элемента
if (pElementPresentFlags)
{
unsigned long long ullQWordIdx = 0; //индекс учетверённого слова внутри массива
unsigned long long ullBitIndex = 0; //индекс бита внутри учетверённого слова
for (auto it = itStart; it != itEnd; ++it)
{
ptrElementType& pCurr = \*it;
if (ullCurrentElementIndex == ullNumElementsMax)
UpdateFlagsArray(pContainer);
pCurr->ullElementIndex = ullCurrentElementIndex;
pCurr->pContainer = pContainer;
ullQWordIdx = ullCurrentElementIndex / ce\_ullNumBitsInWord; //индекс учетверённого слова внутри массива
ullBitIndex = ullCurrentElementIndex % ce\_ullNumBitsInWord; //индекс бита внутри учетверённого слова
pElementPresentFlags[ullQWordIdx] |= 1ULL << ullBitIndex; //устанавливаем бит
ullCurrentElementIndex++;
ullNumElements++;
}
}
}
```
Переход по списку по указателям трансформировался в переход по абстрактному контейнеру посредством итераторов. Теперь для дерева достаточно будет реализовать свои итераторы, и его поддержка данными стратегиями будет уже обеспечена.
Это потребовало вернуть итераторы в списки без исключений, но сделать их недоступными извне и предназначенными только для внутреннего использования.
### Адаптер для данных
Достаточно интенсивно поработав с STL, а также набирая, запуская и изучая учебные программы из книг, я обратил внимание на простоту работы с контейнерами STL.
Например, обратите внимание на следующий код:
```
std::vector v = { 0, 1, 2, 3, 4, 5 };
for (auto& i : v)
i = 1;
```
Я создаю вектор, передав ему нужный мне тип int, и всё! Контейнер сразу готов к работе, если мне не нужно изменить какие-то дополнительные параметры, заданные по умолчанию, что чаще всего не происходит! У меня же, исходя из трёхуровневой организации списка, в каждом случае пришлось бы сначала создавать новый класс для элемента, а затем – писать класс для списка с данными, реализуя специфичные для итогового списка операции. Представляете, сколько работы! А если вам понадобится создать другой список для других данных, придётся проделывать всё заново или, на крайний случай, копировать предыдущий код, слегка его изменяя. Это уже напоминает ту самую возню с языком С и Windows API, где для каждого элементарного действия приходится заполнять все нужные данные для структуры, а затем вызывать нужную функцию. И либо постоянно держать всё это в голове, либо также постоянно читать MSDN, изучая аргументы каждой новой функции! Рутинно и страшно неудобно!
Я стал искать способы, как получить возможность создавать свой список по аналогии с контейнерами STL, чтобы не пришлось каждый раз заново выполнять одну и ту же рутинную работу: создавать отдельный класс для любого нового элемента, а затем – отдельный класс списка по работе с элементами этого типа. Так появился адаптер для списка с данными данных.
Адаптер для списка с данными – это класс, в параметрах шаблона которого вы передаете сразу нужный вам тип **данных**, а не элемента. Тип элемента, который я назвал составным типом элемента, на основе этих данных он создаёт **самостоятельно**:
```
template class \_MemoryPolicy> class ListElementCompound\_OneLinked\_CP
{
ElementData ed; //данные
public:
using ListElement = ListElementCompound\_OneLinked\_CP;
using MemoryPolicy = \_MemoryPolicy; //сохраняем используемую стратегию работы с памятью внутри класса элемента
template ListElementCompound\_OneLinked\_CP(Args... args) : ed(args...) {}
ListElementCompound\_OneLinked\_CP(const ElementData& ed) : ed(ed) {}
ElementData& operator\*()
{
return ed;
}
operator ElementData()
{
return ed;
}
private:
typename MemoryPolicy::ptrType pNext = nullptr; //указатель на следующий элемент списка
unsigned long long ullElementIndex = 0; //индекс элемента среди всех созданных в списке
ListBase\* pContainer = nullptr; //указатель на список-владелец элемента
...
};
```
Отдельным моментом стоит упомянуть доступ к данным элемента. Тип элемента содержит операцию «\*»:
```
ElementData& operator*()
{
return ed;
}
```
Это значит, что если есть указатель на элемент pElement, то чтобы получить доступ к хранящимся в нём данным, его необходимо разыменовывать дважды:
```
ElementData& li = **pCurrElement;
```
Один раз – чтобы получить доступ к объекту типа ListElementCompound\_OneLinked по его указателю: ListElementCompound\_OneLinked& le = \*pCurrElement, а второй раз – чтобы получить доступ к данным через операцию ‘\*’: ElementData& li = \*le.
Это выглядит весьма странно и нетипично, но предполагается, что вы будете работать не через указатели (для этого и так уже был готовый исходный вариант), а через итераторы.
Далее, создавая список на основе адаптера, вы указываете нужные вам стратегии, как это было ранее. Адаптер на основе всех ваших параметров автоматически создаёт нужные типы и передаёт их базовому внутреннему списку, от которого наследуется. Общее определение класса:
```
template class \_MemoryPolicy = SmartSharedPointer, class LockingPolicy = ThreadLocking\_STDMutex, template class CheckingPresenceElementPolicy = DirectSearch, bool bExceptions = true> class List\_OneLinked\_DataAdapter;
```
Специализация для списка с исключениями:
```
template class \_MemoryPolicy, class LockingPolicy, template class CheckingPresenceElementPolicy>
class List\_OneLinked\_DataAdapter :
public List\_OneLinked, true>, DirectSearch, true>>, ListElementCompound\_OneLinked, ListElementCompound\_OneLinked\_CP>, LockingPolicy, CheckingPresenceElementPolicy, true>
{
…
}
```
Выглядит весьма громоздко, многоэтажно и страшненько. Я знаю. Но зато это определение автоматически делает всё, что нужно, без непосредственного участия собирающегося использовать его программиста. С помощью std::conditional\_t и std::is\_same\_v производится сравнение переданной вами стратегии проверки наличия элемента со стратегий прямого поиска и, в зависимости от результата, выбирается соответствующий тип составного элемента списка: с наличием индекса в битовом массиве и указателя на список или же без. Это позволит сэкономить вам память за счёт ненужных дополнительных данных внутри каждого узла, если вы используете стратегию прямого поиска.
Внутри класса лишь реализованы специфичные для него итераторы, а также необходимые по аналогии с STL функции push\_back()/push\_front(), переадресующие вызовы в базовый многопоточный список. Можно добавить и другие функции позже, чтобы список стал совсем похожим на STL'овский. Но при этом он будет со всеми необходимыми защитами и опциями по увеличению производительности в многопоточной среде.
Работа с адаптером для данных стала выглядеть так. Создание объектов списка:
```
List_TwoLinked_DataAdapter list00;
List\_TwoLinked\_DataAdapter list00;
```
Если вас устраивают все стратегии и параметры по умолчанию, то создание списка становится совсем кратким:
```
List_TwoLinked_DataAdapter list1;
```
Как видите, внешне совершенно никакой разницы по сравнению с STL’вским за исключением того, что название класса списка другое.
Теперь работать с ним можно как по старинке, через функции базового класса:
```
list0.AddLast(nullptr, false, false, 0);
list0.AddLast(nullptr, false, false, 1);
list0.AddLast(nullptr, false, false, 2);
list0.AddLast(nullptr, false, false, 3);
```
Здесь последовательно в конец списка добавляются числа от 0 до 3. Чтобы дойти до аргумента, передаваемого в конструктор создаваемого типа при его создании, приходится явно проставлять значения первых трёх аргументов.
```
int x = *list0.GetLast(); //тип приходится указывать явно, иначе через auto будет выведен тип ListElementCompound_TwoLinked_CP<...>
cout << "x = " << x << endl << endl;
```
Да, здесь возникает определённое неудобство в явно указании типа, но это – следствие попытки опять обратиться в список через прежнюю функцию по работе с указателями. Если добавить в адаптер функцию back(), которая вернёт итератор, то при работе через него не будет такой проблемы:
```
auto x = *list0.back();
```
После подстройки итераторов под требования STL:
```
//определения типов для STL
using iterator_category = std::forward_iterator_tag;
using value_type = const ElementData;
using difference_type = std::ptrdiff_t;
using pointer = const typename List::ptrListElement;
using reference = const ElementData&;
```
становится возможным использовать список в алгоритмах библиотеки:
```
unsigned int i = 0;
for (auto& dElem : list1)
cout << i++ << ": " << dElem << endl;
transform(list1.begin(), list1.end(), list1.begin(), [](double& dElem1)
{
return dElem1 * dElem1;
});
vector v(list1.cbegin(), list1.cend());
…
copy(v.begin(), v.end(), list1.begin());
```
Разумеется, придётся организовывать перехват и обработку исключений: все примеры выше приведены для работы в одном потоке в целях тестирования совместимости с STL.
Применение алгоритмов STL делает возможным интересный момент: можно использовать сразу несколько алгоритмов одновременно, запуская их в нескольких потоках параллельно. Это невозможно сделать обычными средствами (например, используя std::list и средства блокировки), не имея доступ к внутреннему содержимому класса списка. Можно было только блокировать весь список целиком на время работы всего алгоритма. Конечно, это ускорит работу для выполняющего алгоритм потока, но сделает список недоступным для других потоков. Правда, если применять ту же «тонкую» блокировку SRWLock, можно выполнять над списком несколько алгоритмов одновременно, если они этот список не модифицируют. Но первый же поток на запись встанет в ожидании завершения операции чтения списка всеми же остальными потоками.
Предлагаемый же вариант списка позволяет организовать работу с ним более гибко. Например, вы можете организовать работу со списком так, чтобы выполнять немодифицирующие алгоритмы в первой половине списка несколькими потоками одновременно, в то время как ряд других потоков могут что-нибудь добавлять или изменять во второй половине списка. Тот факт, что список блокируется на время **одной** операции, а не всего алгоритма, позволит «просачиваться» операциям записи через последовательность операций чтения списка, что сделает работу с ним более гибкой, производительной и эффективной.
### Объединение двух вариантов классов списков с поддержкой исключений и без в один с булевым параметром
Первоначально списки были в варианте только с исключениями. Затем я добавил новые – без исключений с возвратом ошибок, а старые переименовал с добавлением буквы “E”в названии класса: List\_OneLinked\_E и List\_TwoLinked\_E. Это потребовало везде указывать по четыре объявления класса списка.
Затем я решил, что это неудобно по многим причинам. Зачем нам два совершенно разных класса, если это один и тот же список просто с поддержкой исключений или же без? Я объединил оба списка каждого типа в единый класс с дополнительным булевым параметром, а конкретная их реализация с исключениями и без – это две специализации единственного класса для указанного булева параметра.
### Шаблонная операция объединения списков
Шаблонная операция объединения списков ранее работала только со списками одного типа. Она объединяла либо только односвязные списки, либо только двусвязные.
Однако, если вдуматься, то ведь совершенно неважно, списки какого типа участвуют в операции: односвязные или двусвязные. Также неважны их стратегии блокировки, какая у них стратегия проверки существования элементов, а также то, поддерживают ли они обработку исключений или нет. Всё это относится только к организации списка, но не к данным, содержащимся в нём. Важно, чтобы совпадали только тип данных и стратегия памяти для элементов. Соответственно, теперь, после объединения списков с булевым параметром относительно исключений, операция на вход принимает списки любого типа со всеми вариантами их параметров:
```
template class CheckingPresenceElementPolicy1,
template class CheckingPresenceElementPolicy2, bool bExceptions1, bool bExceptions2,
template class, bool> class ListType1, template class, bool> class ListType2>
auto operator+(ListType1& list1, ListType2& list2) noexcept;
```
Теперь в качестве результирующего типа списка компилятором выбирается, в зависимости от установки внешнего параметра ce\_bGetMinLinksList, список либо с минимальной, либо с максимальной связностью и, в зависимости от этого решения, используются соответствующие его параметры:
```
constexpr unsigned int ce_uiMinLinksNumber = std::min(ListType1::GetLinksNumber(),
ListType2::GetLinksNumber());
constexpr unsigned int ce\_uiMaxLinksNumber = std::max(ListType1::GetLinksNumber(),
ListType2::GetLinksNumber());
using ListTypeResultMinLinks = std::conditional\_t::GetLinksNumber() == ce\_uiMinLinksNumber, ListType1, ListType2>;
using ListTypeResultMaxLinks = std::conditional\_t::GetLinksNumber() == ce\_uiMaxLinksNumber, ListType1, ListType2>;
using ListTypeResult = std::conditional\_t;
...
constexpr bool bExceptionsResultMinLinks = ListType1::GetLinksNumber() == ce\_uiMinLinksNumber ? bExceptions1 : bExceptions2;
constexpr bool bExceptionsResultMaxLinks = ListType1::GetLinksNumber() == ce\_uiMaxLinksNumber ? bExceptions1 : bExceptions2;
constexpr bool bExceptionsResult = ce\_bGetMinLinksList ? bExceptionsResultMinLinks : bExceptionsResultMaxLinks;
```
На основании выбранных параметров создаётся список результата:
```
ListTypeResult list(list1.GetNumElementsMax_SearchElementPolicy(true) + list2.GetNumElementsMax_SearchElementPolicy(true), false);
```
Затем у этого списка указатели настраиваются на начало первого и конец второго списка:
```
//устанавливаем указатели, объединяющие списки (один или оба из них могут оказаться пустыми, поэтому нужны проверки)
if (list1.GetFirst(true))
list.ListBase::pFirst = list1.GetFirst(true);
else
list.ListBase::pFirst = list2.GetFirst(true);
if (list1.GetLast(true))
list1.GetLast(true)->pNext = list2.GetFirst(true);
if (list2.GetLast(true))
list.ListBase::pLast = list2.GetLast(true);
else
list.ListBase::pLast = list1.GetLast(true);
//регистрируем элементы списка в соответствующей стратегии поиска элемента
list.CheckingPresenceElementPolicyResult::RegisterContainer(&list, typename ListTypeResult::iterator{ list.ListBase::pFirst, &list });
```
Далее прежние списки очищаются, и производится выход из функции.
Слабым местом этой функции является двойная блокировка списков с потенциальной взаимной блокировкой:
```
//блокируем списки: здесь - потенциальная взаимная блокировка; нужен способ заблокировать оба списка одновременно за единую атомарную операцию типа std::lock(mutex1, mutex2)
list1.LockListExclusive();
list2.LockListExclusive();
```
Можно ввести некоторую функцию для одновременной блокировки двух списков за единую атомарную операцию типа std::lock(mutex1, mutex2), однако не все стратегии блокировки поддерживают одновременную блокировку двух объектов синхронизации, как std::lock(…).
Кроме того, у двух списков могут быть разные стратегии блокировки. Решение этой проблемы (если оно вообще существует) оставлено на будущее.
### Компиляция под Linux
Компиляция проверялась через проект ListDataAdapterTest, изначально написанный на чистом C++ без специфичных для Windows особенностей, на Linux Ubuntu 16.04 LTS, компилятор g++ 8.2.0. Большинство незначительных нюансов было легко исправить, и проект успешно скомпилировался, а вывод программы совпал с аналогичным выводом под Windows. Однако это – в том случае, если закомментировать строку объединения списков через операцию «+»:
```
auto list3 = list00 + list1;
```
Если её оставить как есть, то возникнет ошибка компиляции в описанной выше операции «+» так, как если бы она не была объявлена привилегированной в классе составного элемента списка. Аналогичная ошибка в классе стратегии прямой проверки наличия элемента DirectSearch. В Visual C++ здесь всё нормально, однако эти же ошибки появляются, если в классе составного элемента и в классе списка закомментировать объявление операции объединения списков и DirectSearch как привилегированных. Такое впечатление, что g++ просто пропускает эти объявления и жалуется на закрытые/защищённые члены соответствующих классов.
(В g++ версии 9 (Ubuntu 20.04) те же ошибки.)
Почему пропускаются объявления привилегированности и как это исправить, так и не разобрался. Я не силён в особенностях компилятора GCC. Оставил этот момент также на будущее.
За исключением этого нюанса, других серьёзных ошибок компиляции нет.
### Описание структуры заголовочных файлов
Уважаемые читатели, полноценный проект под лицензией LGPL 3.0 я опубликовал на GitHub по адресу:
[github.com/SkyCloud555/ListMT](https://github.com/SkyCloud555/ListMT)
Это – одно решение, состоящее из нескольких тестовых проектов. Основной же код многопоточного списка, в силу его реализации через шаблоны, располагается в нескольких заголовочных файлах:
* List.h – базовый класс списка без данных, реализующий все базовые операции со списком, возможные без определения конкретных данных, а также подобные STL адаптеры для данных.
* ListE.h – версии списка с поддержкой исключений.
* ListElement.h – определение базовых классов для элемента списка.
* ListErrors.h – определение кодов и классов ошибок для исключений.
* Помимо перечисленных основных файлов также реализованы следующие:
* MemoryPolicy.h – стратегии работы с памятью;
* ThreadLocking.h – стратегии блокировки.
* SearchContainerElement.h – стратегии проверки наличия элемента в списке, абстрактно описанные для любого контейнера с итераторами.
Кроме финального проекта я также добавил три старые версии в папке «Old versions», чтобы можно было кратко оценить, как изменялся проект по мере развития.
Тестирование
------------
Основной проект с названием List представляет собой программу с интерфейсом под Windows, хардкорно реализованным через Windows API (я по-другому пока не умею). В этой программе вы выбираете тип списка (односвязный или двухсвязный), а также указываете начальное количество элементов и желаемое количество потоков. Элементы списка содержат единственное 64-битное значение. После создания списка программа в каждом потоке в цикле выполняет переход по списку вперёд или назад на случайное количество элементов, а затем добавление или удаление элемента. Никакой реальной полезной работы посредством этого списка не выполняется, и вся энергия уходит на обогрев атмосферы, но это и не нужно: нам необходимо лишь оценить работоспособность и производительность списка в интенсивном многопоточном окружении. Мерой производительности выступает количество итераций описанного выше цикла в секунду, выполненных всеми потоками.
Настройка списка производится посредством указания соответствующих стратегий в коде программы и последующей перекомпиляции. Все стратегии для главной программы указываются в основном модуле ListMain.cpp, стратегия памяти же выбирается в ListDataExample.h.
Вообще говоря, с экспериментами я несколько схалтурил. Честно признаюсь. Главным образом потому, что там в ряде случаев у списка существенно изменяется количество элементов. Для чистоты эксперимента для измерения производительности следовало бы поставить тест таким образом, чтобы количество элементов в среднем не менялось за исследуемый период либо менялось крайне несущественно. Только при таких условиях справедливо было бы оценивать значение производительности на основании среднего значения. Если кому-нибудь это интересно, предлагаю заняться организацией таких экспериментов самостоятельно.
Я не стал исправлять исходную организацию тестов из следующих соображений. ~~Прежде всего, мне было просто лень.~~ Во-первых, на мой взгляд, никому не интересны точные количественные значения производительности ~~с вычисленной погрешностью~~: важно оценить работу и производительность списка **качественно**. Во-вторых, это позволяет оценить изменение производительности списка с ростом его объёма, что тоже довольно важная и интересная информация. По этим причинам я не стал изменять исходные эксперименты. В-третьих, над всеми вариантами списка выполняет один и тот же код теста, что в этом смысле ставит их в одинаковые условия: тот факт, что они при этом ведут себя по-разному, и позволяет судить о качестве изменений.
Чтобы включить замер производительности, установить флаг ce\_bPerformanceMeasure в модуле ListMain.cpp на значение true. Программа создаст файл «PerformanceMeasure.txt» с парами «количество элементов – число циклов/сек», разделённых символом «:».
### Результаты измерений производительности
Разумеется, я не стал проводить тесты для всех возможных конфигураций списка, потому что их очень много. Я сосредоточился только на ключевых.
Тестирование проводилось на моей порядком уже устаревшей, но до сих пор весьма бодрой конфигурации Intel Core i7-3930K, DDR3-1333, 4-канальный контроллер памяти. Компиляция проводилась посредством Visual Studio 2019 для режима Release x64, операционная система Windows 7 x64. Я не стал играться с количеством потоков, так что во всех тестах всегда использовались максимально доступные в данной системе 12 потоков. Список всегда создавался с 10000 случайными по значению элементами, за исключением последнего теста.
#### Тестирование по стратегиям памяти
Использование встроенных указателей, как я упоминал ранее, позволяет применять только стратегию прямого поиска для проверки наличия элемента в списке. Соответственно, чтобы сравнение был корректным, и для интеллектуальных указателей будет применяться в этом тесте только эта стратегия.
В качестве стратегии блокировки выбрана критическая секция с «тонкой» блокировкой как наиболее производительная в Windows (см. ниже): ThreadLockingWin\_SRWLock. Обработка ошибок осуществляется путём возврата кода ошибок, т.е. вариант без исключений.
На этом графике показано количество циклов, произведённых суммарно всеми потоками за секунду, в зависимости от продолжительности теста (в секундах). Очевидно, что производительность непостоянна ввиду случайного характера обращений потоков к списку.
Второй график показывает, как изменяется количество элементов списка во время теста. Каких-либо глубокомысленных утверждений по поводу этого графика делать не буду, за исключением очевидного: ясно, что они работают несколько по-разному, и связность списка вместе со стратегией памяти оказывают своё влияние. Двусвязный список с внутренними указателями – единственный из всех, который неожиданным образом не изменяется в среднем в размерах за всё время теста.
Усреднённая производительность (циклы/с) за измеряемый период:
По крайней мере, можно утверждать, что вариант списка с интеллектуальными указателями работает медленнее варианта со встроенными указателями, чего и следовало ожидать. В обоих случаях каким-то образом получается, что односвязный работает быстрее двусвязного, что в очередной раз показывает, что в многопоточном режиме многие привычные вещи могут измениться.
#### Тестирование по стратегиям проверки наличия элемента
Самым интересным является тестирование по стратегиям проверки наличия элемента. В качестве стратегии памяти указаны, естественно, интеллектуальные указатели по описанным ранее причинам. Остальное всё то же самое: блокировка посредством ThreadLockingWin\_SRWLock и обработка ошибок путём возврата кода ошибки.
Можно сказать определённо, что все стратегии работают примерно одинаково. Это и понятно: в односвязном списке при удалении его элемента приходится каждый раз просматривать список до элемента, который указывает на удаляемый. Это сводит на нет все усилия по оптимизации доступа к списку и ускорению проверки наличия элемента в нём. Следовательно, односвязный список – не лучший выбор для интенсивной неупорядоченной многопоточной работы с ним.
График по количеству элементов приводить не буду: там нет ничего интересного. Отмечу лишь, что теперь увеличивается число элементов у всех списков.
Совершенно иная ситуация возникает для двусвязного списка. Чтобы графики выглядели красиво, я даже исключил стратегию прямого просмотра списка DirectSearch из него, поскольку по результатам она явно «выпадает» из числа остальных. Кроме того, я увеличил предельное количество элементов в 4 раза, достигнув которое, тест останавливается.
Прежде всего, производительность обращений к списку (равно как и загрузка процессора при этом, став 99-100%) очень резко и существенно возросла! Во-вторых, пара стратегий с последовательным заполнением бит массива имеют примерно одинаковую не меняющуюся в течение теста производительность. Скорость работы же второй пары стратегий нелинейно уменьшается. Почему это так, станет понятно из графика для количества узлов списка.
Списки с первой парой стратегий растут в количестве элементов, причём линейно. Вторая же пара даёт существенно нелинейный рост, причём большее число элементов имеет список, тем медленнее он увеличивается. Это понятно, т.к. с ростом числа элементов при создании нового приходится в среднем просматривать большее количество бит массива в поисках свободного. Первая же пара стратегий не занимается этим, она использует новый бит для каждого нового элемента. Таким образом, список с такой стратегией имеет максимальную производительность доступа и ближе всего к классическому списку: и создание, и удаление элементов производится за константное время, не зависящее от количества элементов. Однако при этом он предоставляет некоторые гарантии целостности и безопасности в многопоточном окружении, пусть и ценой определённых затрат памяти.
Список же со второй парой стратегий, конечно, заметно медленнее. Тем не менее, он всё равно существенно быстрее вариантов с прямой проверкой. Так что действительно можно рекомендовать его в качестве некоторого промежуточного по производительности, но более оптимального по расходам памяти.
На самом деле списки со стратегией прямого поиска также будут работать медленнее при увеличении количества элементов в них: большее количество элементов придётся просматривать каждый раз. Просто за время теста список не успевает увеличиться настолько, чтобы это стало заметно несмотря на хаотичные колебания производительности.
Усреднённые значения производительности показывают, что стратегии с битовым массивом при последовательном его заполнении позволили увеличить производительность обращений к списку примерно в 200 раз, т.е. на 2 порядка, по сравнению со стратегиями прямого поиска. Это – весьма радикальное изменение. Производительность же вариантов с оптимальным по памяти заполнением бит, как было отмечено выше, конечно, заметно медленнее, но всё равно гораздо быстрее вариантов с прямой проверкой.
Стоит отметить также, что использование механизма передачи памяти по запросу несколько замедляет обращения к списку. Не слишком чтобы критично, но эффект присутствует и заметен, особенно – в варианте с экономным использованием памяти (жёлтая линия на графиках).
#### Тестирование по стратегиям блокировки
Рассмотрим теперь, как будет изменяться производительность списка при выборе различных стратегий блокировки. Я использовал три типа блокировок: «тонкая» блокировка SRWLock, обычная критическая секция Windows и мьютекс STL. По остальным же настройкам использовалась самая быстрая версия списка: двухсвязный, интеллектуальные указатели, стратегия проверки наличия элемента – SearchByIndex\_BitArray, вариант без исключений.
Как и следовало ожидать, «тонкая» блокировка увеличивает производительность почти на 25%.
Скорость работы с критической секцией Windows и мьютексом STL примерно одинакова.
#### Исключения
Чтобы оценить влияние исключений на производительность, я провёл три теста. В первых двух использовался двусвязный список, интеллектуальные указатели, стратегия проверки наличия элемента – SearchByIndex\_BitArray, критическая секция SRWLock. Для последнего теста использовалось всё то же самое, только блокировка была заменена на обычную критическую секцию для сравнения.
Видно, что поддержка исключений способна действительно снизить скорость работы, особенно если использовать более «грубый» вариант блокировки. Однако следует помнить, что в этом случае будет недоступна поддержка STL и циклов for по коллекции.
Выводы
------
Это был для меня весьма масштабный эксперимент. Имею ввиду вовсе не тесты выше, а весь проект целиком. Не ожидал сам, что он настолько затянется. Тем не менее я выполнил его целиком от и до в той мере, в которой планировал. Разумеется, в конечном итоге это всё равно не итоговый вариант, а лишь некоторый рабочий прототип, реализация описанных в начале статьи идей.
По результатам тестов ясно, что под Windows самым быстрым оказался двусвязный список с интеллектуальными указателями, стратегией проверки наличия элемента SearchByIndex\_BitArray, критической секцией SRWLock и без исключений. В такой конфигурации список обеспечивает максимальную производительность при интенсивных хаотичных обращениях к нему из различных потоков и по поведению ближе всего к классическому списку с гарантиями безопасности в многопоточном режиме. Вариант с более экономным расходом памяти тоже весьма производителен (по сравнению с прямой проверкой DirectSearch), но всё же заметно медленнее, чем предыдущая, и его производительность падает с увеличением количества элементов.
Если вы думаете, что буду здесь агитировать за то, какую классную штуку я сделал и как здорово её использовать, то нет: на самом деле я начну с того, что буду вас отговаривать. В самом деле:
* Подумайте, не возможно ли использовать контейнер с другим расположением элементов: например, массив. Он не имеет таких проблем, как список.
* Если вы не храните никаких указателей или итераторов на конкретные элементы, то вполне допустимо использовать стандартный std::list и любые средства блокировки. Блокируйте список целиком и работайте с ним любым образом в одном потоке. Если список небольшого размера, а тем более если обращения к нему нечастые, то он не станет узким местом в производительности вашей программы. Используйте проверенные и стандартные средства там, где это возможно~~, а не поделки левых программистов~~. Вы же не хотите, ~~если у вас серьёзный бизнес,~~ чтобы программа упала в самый неожиданный момент~~, а заказчики остались недовольны~~.
* По возможности, упорядочивайте доступ к данным. Это справедливо и для предложенного здесь проекта: многопоточный список не знает, что делать, если окажется, что нужного элемента нет, так как он был удалён в другом потоке. Всё, что он сможет – это сообщить об этом в вызывающую программу, потому что только она может знать, как решить эту проблему.
* Любой предложенный здесь односвязный список либо даже двусвязный со стратегий прямой проверки наличия элемента ничем не лучше, чем стандартный с дополнительной внешней блокировкой. На самом деле, с точки зрения производительности он даже хуже, потому что ради гарантий безопасности выполняет колоссальную дополнительную работу по просмотру списка при каждой операции.
* Если вам важна производительность, обращение к списку частое, а он сам большого размера, вам следует использовать любую подходящую стратегию проверки наличия элемента через битовый массив. Размеры массива, а также прочие стратегии выбирайте исходя из условий и желаемых потребностей вашей программы. Однако при всём при этом это не гарантирует гладкую и безоблачную работу со списком. Например, список остановится с ошибкой, если один поток считывает значения из него, а другой – удаляет элементы вокруг считываемых значений. Таких сценариев следует избегать. Всё, что гарантируется – это целостность списка при максимальном уровне быстродействия доступа к нему. Вся ответственность за сценарий использования, а также что делать в случае ошибочных ситуаций, лежит целиком на вас. А также все возможные проблемы по расходу памяти на битовый массив, принудительную остановку на время его обслуживания и т.д. Однако, при выполнении всех мер предосторожности и наличии обработки ошибочных ситуаций, это позволяет организовать гибкую и производительную работу со списком из разных потоков, например, как в описанном выше случае, когда в его первой половине выполняется считывание или добавление данных, а во второй: изменение или удаление. Разбиение обращения на отдельные защищаемые операции вместо одной блокировки на время единственного длительного действия в одном потоке позволяет увеличить эффективность работы со списком.
* Стратегии с передачей памяти битовому массиву по требованию также хотя бы частично приближают многопоточный список к классическому: по крайней мере, до полного заполнения массива памяти будет занято ровно столько, сколько фактически требуется. Однако это влечёт за собой снижение производительности.
Недостатки проекта:
* Отмеченная ранее возможность взаимной блокировки в операции объединения списков.
* Все блокировки и разблокировки внутри классов делаются вручную, в стиле языка С. Знаю, что это некрасиво и нехорошо: лучше создавать объект, осуществляющий блокировку посредством механизма RAII: блокировка при создании объекта и автоматическая разблокировка при его уничтожении. Я взялся было переделывать на такой лад, но поскольку этих блокировок там уйма, я в какой-то момент остановился, махнул рукой и вернул всё как было. Если сделаю дерево, там сделаю сразу как надо. Ну, либо если пойму, что переделать это в списке всё-таки необходимо.
* Стратегии проверки наличия элемента не предусматривают создание нового битового массива, если старый полностью заполнен. Они лишь выбрасывают соответствующее исключение.
Надеюсь, это было интересно. Новичкам может быть полезно, т.к. всё рассматривается от простого к сложному. Профессионалов же попрошу сказать, насколько, на ваш взгляд, описанные здесь идеи применимы на практике в реальных проектах? Случался ли в вашей деятельности случай, когда по смыслу вам требовался список или дерево, а не другой контейнер, но он становился узким местом в вашей программе из-за описанных здесь проблем? Либо приходилось сильно изменять или усложнять программу. Если встречались с этим ранее, то как вы это решали?
Разумеется, по сути этот проект – лишь реализация моего собственного взгляда на решение этой проблемы. Вполне вероятно, что найдётся какой-нибудь вариант получше. Повторю мысль из начала, что я делал это изначально для себя и не планировал выкладывать на всеобщее обозрение. Но всё-таки я сделал это по описанным там же причинам, так что буду рад конструктивной критике.
**P.S.** При внимательном рассмотрении кода вы можете наткнуться на такую конструкцию:
```
//многократное наследование (допускает передачу последней структуры или класса в самый базовый)
class thisclass {}; //класс-пустышка, используемый для аргумента по умолчанию в классе, производном от ListElementData_OneLinked/ListElementData_TwoLinked
//элементы односвязного списка
template class ListElementData\_OneLinked1 : public ListElement\_OneLinked::value, ListElementData\_OneLinked1<>, DerivedListElement>, MemoryPolicy>
{
unsigned \_\_int64 u64Value = 0; //некое значение узла
template friend class ListData; //объявляем шаблонный класс списка с данными привилегированным для обеспечения доступа из него
public:
ListElementData\_OneLinked1(unsigned \_\_int64 u64Value = 0) : u64Value(u64Value) {} //конструктор
};
template class ListElementData\_OneLinked2 : public ListElementData\_OneLinked1::value, ListElementData\_OneLinked2<>, DerivedListElement>>
{
using ListElementBase = ListElementData\_OneLinked1::value, ListElementData\_OneLinked2<>, DerivedListElement>>;
unsigned char ucSomeData[1024 - sizeof(decltype(ListElementBase::u64Value))]; //имитируем некоторые данные для заполнения памяти
template friend class ListData; //объявляем шаблонный класс списка с данными привилегированным для обеспечения доступа из него
public:
ListElementData\_OneLinked2(unsigned \_\_int64 u64Value = 0) : ListElementBase(u64Value) {} //конструктор
};
```
Сия чёрная магия заслуживает отдельной статьи. Правда, это ещё менее практическая вещь, чем описываемый здесь многопоточный список, но она имеет свои любопытные особенности. Может быть, как-нибудь попозже я тоже об этом напишу. | https://habr.com/ru/post/506716/ | null | ru | null |
# Программная генерация звуков
Звук можно представить ввиде бесконечного количества волн различной частоты
и амплитуды. Волны, в свою очередь, могут иметь практически любую форму.
Из самых распространенных и чаще всего используемых можно назвать: синусоидальная (sine), квадратная (square), пилообразная(saw), треугольная (triangle), и шум (noise). Сначала попробуем разобраться с основными параметрами волны: период и амплитуда.
Частота (измеряется в герцах) — количество периодов в секунду. Например при частоте 44100Hz количество периодов равно 44100. Теперь когда основные термины изучены перейдем непосредственно к алгоритму генерации волн.
1) Sine волна
`float samplerate; // частота сэмпла
float wavefrequency; // частота волны
float wavevolume; // громкость волны
float period=samplerate/wavefrequency/2; //вычисляем период волны
float pi=3.14; //число pi
int n;
for(int a=0;a
{
n=wavevolume*sin(a*pi/period); //вычисление sine-волны
buffer[a]=n; //заносим вычисленное значение в буфер
}`
Например нам надо получить 16-килобайтный синусоидальный звук частотой 1000Hz и при этом качество сэмпла должно быть 44100Hz, тогда наши параметры будут иметь следующие значения: samplerate=44100, wavefrequency=1000, samplelenght=16384.
Особенного пояснения требует параметр wavevolume. Издавна известно, что качество звука пропорционально зависит от его битности (8-bit, 16-bit, 24-bit и т.д.). Для 8-bit — значение от 0..255, для 16-ти – 0...65536, для 24-х – 0...16777216. Какой выбрать? Смотря какая у вас задача, но меньше 16-ти я бы не посоветовал (хотя бывают и исключения – когда надо сократить объем сэмпла взамен качеству).
2) Пилообразная волна (saw)
`float sr_2m=samplerate/wavefrequency; //Вычисляем период
int c=0; //Специальная переменная для проверки
//на окончание периода
for(int a=0;a
{
if(c>=sr_2m) c=0; //если период закончился, то начать следующий
buffer[a]=wavevolume*(c/period)-wavevolume; //вычисление волны
c++;
}`
3) Треугольная (triangle)
`float period=samplerate/wavefrequency/2; //вычисляем период волны
int c=period*2;
int c2=-1;
float sr_2m=period;
float sr=samplerate/wavefrequency/4;
for(int a=0;a
{
if(c>sr_2m) c=sr_2m,c2=-1;
if(c<0) c=0,c2=1;
buffer[a]=wavevolume*(c/sr)-wavevolume;
c+=c2;
}`
4) Шум (noise)
`srand(wavevolume);
s1=mv.samplerate/wor,psc=s1+1,wov>>=7;
if(tabcnt==0)
{
for(ps=0;ps
{
if(psc>s1)
{
psc-=s1;
n=256*((rand()%(wov+1))-wov/2);
}
buffer[ps]=n;
psc++;
}
}`
Теперь усложним задачу — сложим две волны разной частоты и амплитуды.
…
`char buffer[16384];
float tone1=65,tone2=131;
float samplerate=44100/2; // Частота дискретизации
int a,b,amp1=128,amp2=64;
for(a=0;a<16384;a++)
{
b=amp1*sin(a*pi/samplerate/tone1)+amp2*sin(a*pi/samplerate/tone2);
if(b>128) b=128;
if(b<-128) b=-128;
buffer[a]=b;
}`
…
С таким сэмплом уже можно писать мелодии. В принципе, это основа wave
synthesis при помощи которой можно создать любой звук.
И напоследок пара советов:
1) Для получения более насыщенного звука складывайте волны с различными
формами: sine+square, triangle+saw, или вот такой вот монстр: saw+square+
triangle+saw.
2) Перкусия (hat) лучше всего получается путем сложения noise+sine. | https://habr.com/ru/post/126835/ | null | ru | null |
# R*-tree в Go, немного геймдева и поиска элементов в пространстве
Приветствую, уважаемые читатели Habr!
Сегодня я хотел бы рассказать об интересном подвиде одного алгоритма, о котором Вы могли возможно забыть!
Начну с предыстории...
----------------------
У меня довольно интересный опыт в разработке модификаций для мультиплееров (далее - **МП**) трехмерных игр на серверной и клиентской части для разных игровых проектов, как на языках JS, так и Lua, которые использовались на сервере и клиенте.
В один прекрасный день, я все же решил углубиться в настоящий Highload и изучать для себя язык Go. Пока я ходил по собеседованиям, я понял, что у меня действительно малозначительный опыт именно в разработке высоконагруженных систем.
И, пока всё это происходило, я понял, что знания все же необходимо подтягивать, а сами собеседования помогут направить меня в нужное русло. И, после одного из собеседований с вопросами об индексах, я решил углубиться в них (помимо бездумного расставления btree и hash через EXPLAIN ANALYZE).Так я наткнулся на интересный для себя индекс в PostgreSQL - **GiST**.
Что из себя представляет индекс **GiST**? Вспомним, что **GiST** - это подвид структуры **R-tree**, которая позволяет быстро обращаться к данным в пространстве.
Когда я это прочитал, мне стало невероятно интересно, как в игровых модификациях, с которыми я работал, обстоят дела с пространственным поиском?
Как с этим обстоят дела в той сфере, где я работаю:
---------------------------------------------------
Там, где я работаю, существует один из старейших МП, разработанный ещё в 2004 году. Исходников у меня не было, поэтому мне стало интересно, как решали эту проблему тогда и, возможно, сейчас.
Объяснение для тех, кто совсем не связан с играми.
В каждом МП, где большое количество игроков (а я работал с МП, где средний онлайн на одном сервере более 300-500, а порой и 1000 человек). Представляем себе большую карту и понимаем, что игрокам не обязательно видеть друг друга на большом расстоянии.
Поэтому у каждого игрока есть своя зона видимости - то есть, **зона стрима**.
Эта зона стрима обновляется не в реальном времени каждую возможную единицу времени, а раз в секунду, для того чтобы не создавать большой нагрузки на сервер МП. В итоге, я решил узнать, как конкретно игрок 1 должен узнавать, что игрок 2 должен находиться в зоне стрима.
Обратившись к своему хорошего другу, с кем я продолжаю работать в этой сфере, и скинув ему интересную [статью](https://habr.com/ru/post/224965/), он подсказал мне, как действительно устроен стриминг в этом МП. Он смог покопаться в закрытом исходном коде и найти конкретно то место, которое меня интересовало. Ответ меня поразил и смутил. Разработчик МП буквально перебирал каждого игрока для каждого игрока.
Я был в шоке, но в то же время понимал, почему разработчик этого старого МП ограничился всего 1000 игроков в пределах одного сервера. Если бы он поставил хотя бы ограничение в 1500 игроков, то сложность поиска игроков в зоне стрима увеличилась бы уже буквально в 2.25 раз. И, судя по метрикам, даже текущее решение съедало не мало так ресурсов.
Решение уже близко
------------------
Вооружившись современным инструментов в виде языка Go я решил провести искусственное нагрузочное тестирование с алгоритмами **R-tree** и квадратичным (каждый игрок для каждого игрока) линейным поиском.
Что я сделал в логике приложения на Go?
На сервере есть сущности с данными:
* Координаты X и Y
* Массив указателей на игроков, которые находятся в зоне видимости этой сущности
Данные области видимости и "поля" для поиска:
* Размер поля в X и Y (2000x2000 у. е.)
* Размер стороны области видимости
Область видимости, в данном случае - это квадрат с равными сторонами, которые указаны в данных выше. Сущность, к которой применяется поиск, находится в центре этого квадрата.
Синхронизация в логике Go обновляется раз в секунду.
У следующих сущностей будут случайно сгенерированная позиция в пределах поля.
Теперь к самим показателям, начнем с **квадратичного линейного поиска**:
| | | |
| --- | --- | --- |
| Количество сущностей, единиц | Область видимости, у. е. | Время обновления стриминга для всех игроков, мсек |
| 1000 | 200 | 72.5 |
| 2000 | 200 | 295 |
| 4000 | 100 | 1150 |
С учетом того, что синхронизация обновляется раз в секунду, мы можем понять, что при показателях в **4000** сущностей сервер просто перестанет нам отвечать, если все данные обрабатываются в одном потоке или если есть обращение к этой структуре...
Как это выглядит в коде:
```
for i := 0; i < len(players); i++ {
for k := 0; k < len(players); k++ {
p1 := players[i]
p2 := players[k]
if(dist(p1, p2) > visibleDistance) {
continue;
}
p1.playersInStream = append(p1.playersInStream, p2)
}
}
```
Сложность квадратичного линейного поиска здесь буквально **O(n^2)**, и мы можем её сократить. Например, если один игрок уже видит второго, то и второй игрок видит первого. Следовательно, нам не нужно перебирать весь список игроков внутри второго цикла. В итоге, можем представить новый код уже вот так:
```
for i := 0; i < len(players); i++ {
for k := i; k < len(players); k++ {
p1 := players[i]
p2 := players[k]
if(dist(p1, p2) > visibleDistance) {
continue;
}
p1.playersInStream = append(p1.playersInStream, p2)
p2.playersInStream = append(p2.playersInStream, p1)
}
}
```
Довольно банальное решение, и я был крайне удивлен, что разработчик мультиплеера к этому не пришел. Показатели **O(n^2)/2**:
| | | |
| --- | --- | --- |
| Количество сущностей, единиц | Область видимости, у. е. | Время обновления стриминга для всех игроков, мсек |
| 1000 | 200 | 35 |
| 2000 | 200 | 150 |
| 4000 | 100 | 580 |
Уже лучше, но даже с учетом затрат в виде 580 из 1000 мсек чисто на синхронизацию - это невероятно много, потому что в том же потоке работает ещё и основная логика сервера. В общем, это решение так же не подходит...
И, наконец, гвоздь программы - **R-tree**!
К моему счастью (огромное спасибо [dhconnelly](https://github.com/dhconnelly)) я буквально сразу нашел библиотеку [rtreego](https://github.com/dhconnelly/rtreego), которая реализовывала структуру **R-tree** в языке Go.
| | | |
| --- | --- | --- |
| Количество сущностей, единиц | Область видимости, у. е. | Время обновления стриминга для всех игроков, мсек |
| 1000 | 200 | 16 |
| 2000 | 200 | 55 |
| 4000 | 100 | 110 |
Я был невероятно удивлен, ведь показатели времени обновления зоны стрима оказались от 4 до 10 раз меньше, чем то, что используется сейчас!
*Что удивительно, в моей сфере есть более современный мультиплеер, у которого есть примерно аналогичная проблема, но утверждать я, к сожалению, ничего не могу, так как нет доступа к исходному коду от слова СОВСЕМ.*
*Однако есть только метрики со стороны логического ядра работы, на которые я могу полагаться. Показатели отображали, что сеть не была перегружена от слова совсем, как и логическое ядро, однако наблюдались невероятно большие проблемы с синхронизацией при более 1300 игроков на одном сервере.*
Причем здесь вообще R\*-tree?
-----------------------------
Я уже радовался победе, что сделал что-то полезное, как друг, которому я скидывал [эту же статью](https://habr.com/ru/post/224965/) обратил внимание, что там написано **R\*-tree**, а не R-tree в некоторых местах.
Как мы поняли, R\*-tree и R-tree - это две разных структуры данных, первая является подвидом второй. Параллельно я решил покопаться у себя в показателях, заведя свой код с отладкой, и понял, что 70-80% времени занимает вставка и удаление.
Я решил сравнить R-tree и R\*-tree хоть в каких-нибудь бенчмарках, чтобы убедиться, что, возможно, есть алгоритм ещё эффективнее.
Поискав бенчмарки R\*-tree в сравнении R-tree и наткнувшись на:
На что мне удалось наткнуться, пока я искал данные об R\*-tree* Delphi в [статье](https://habr.com/ru/post/224965/);
* R\*-tree в Boost (туда я пока не хочу);
* Статью про нейробиологию от 2020 года научного деятеля в Швеции;
* Имплементация на Java вместе с бенчмарками и показателями эффективности структуры.
Имплементация на Java с показателями оказалась ровно тем, что мне нужно, но...
Оказалось, что показатели вставки в R\*-tree гораздо медленнее, но поиск гораздо эффективнее. Мне стало резко интересно, а есть ли R\*-tree такое в Go? И такого не оказалось.
И тут мне невероятно сильно захотелось это воссоздать и сравнить на практике...
Так что же такое R-tree? И в чём разница R-tree и R\*-tree?
-----------------------------------------------------------
После таких историй пора приступить к делу и понять, в чём разница между **R\*-tree** и **R-tree** простыми словами
**R-tree** - это древовидная структура, которая разбивает пространство на области.
**R\*-tree** - это подвид структуры дерева R-tree, которое балансирует эти данные, чтобы поиск по этому дереву был эффективнее.
Заранее спешу сообщить, что указанная [статья](https://habr.com/ru/post/224965/) ответит на большую часть Ваших вопросов, но если Вам трудно перейти, то постараюсь объяснить своими словами, чтобы не углубляться, буквально на картинках.
Возьмем пример обычного **R-tree**:
Визуализация структуры R-Tree по ГуттмануСиними квадратами обозначаются поддеревья или ветки.
Красными квадратами обозначаются "листья" этих поддеревьев, в которых хранятся элементы.
Черные точки - те самые элементы в этом дереве.
Теперь же возьмем пример **R\*-tree**:
Топологическое дерево R\*-Tree Все данные остаются теми же самыми, но мы буквально можем заметить визуальные отличия:
1. Поддеревья и ветки располагаются так, чтобы не накладываться друг на друга. Уменьшается перекрытие веток.
2. Все ветки или поддеревья стараются быть минимальных размеров. Уменьшается площадь листьев и веток.
Как раз, в этом и есть главная задумка **R\*-tree**!
При абсолютно каждой вставке элемента происходит цикл, который перебирая все возможные элементы, старается уменьшить площадь веток и перекрытие веток, таким образом, упрощая в будущем поиск по этой структуре данных!
Как мы понимаем, за счет таких манипуляций, растёт и цена (то есть, время) вставки элемента. Причем, если дерево становится больше, то и элементов нужно перебирать больше.
Ну и зачем оно вообще нужно: что одно, что второе?
--------------------------------------------------
Буквально, на примере разработки игровых модификаций, я пришел к таким выводам:
Где можно использовать **R-tree**?
* Игровые мультиплееры с большим количеством элементов;
* Любая реал-тайм карта с множеством элементов, которые перемещаются (например, карта автомобилей с такси)
Где можно использовать **R\*-tree**?
* Статические карты хоть с миллионом миллионов элементов (например, это можно использовать в игровом стриминге статических объектов);
* Любые гео-данные, которые читаются в несколько раз чаще, чем заполняются (например, карта целого города или области)
Псевдо-бенчмарки
----------------
Я решил не использовать стандартное решение в виде бенчмарков Go и буквально на своих примерах показать время обработки запросов. Я решил взять приблизительные размеры карты той игры, в которой я работал, и актуальный размер зоны стрима.
* Область в условных единицах: 8000x8000
* Область видимости: 500x500, элемент находится в центре зоны видимости
* Позиции элементов: генерируются случайно
* Показатели: средние из 3-5 прогонов
| | | |
| --- | --- | --- |
| Тип поиска | **R-tree** | **R\*-tree** |
| Вставка 1000 элементов | 18.5 мсек | 330 мсек |
| Вставка 100 тысяч элементов | 2.91 сек | 37 сек |
| Вставка 1 млн элементов | 37.8 сек | 6 мин 30 сек |
| Поиск среди 1000 элементов (1 тыс. итераций) | 1.5 мсек | 0.2 мсек |
| Поиск среди 100 тысяч элементов (1 тыс. итераций) | 140.1 мсек | 8 мсек |
| Поиск среди 1 млн элементов (1 тыс. итераций) | 1.4 сек | 40 мсек |
*Интересная идея: невероятно эффективным (и простым в реализации, особенно в случае языка Go) решением является создание нескольких деревьев для поиска, чтобы искать элементы в разных горутинах в нескольких деревьях. Простыми словами - чтобы достичь максимальной эффективности - нужно найти для себя максимальное количество элементов в среднем на дерево и делить деревья на равные части. Буквально, как партицирование в БД :)*
Самое важное (ссылка на мою реализацию R\*-tree в Go):
------------------------------------------------------
GitHub - anayks/go-rstar-tree: an R\*-Tree library for Go[github.com](https://github.com/anayks/go-rstar-tree)Конец
-----
Невероятно огромное спасибо за внимание!
Если Вы знаете более эффективные решения для игр или гео-данных на вставку или чтение, я буду очень рад почитать в комментариях!
Дополнительно
-------------
Ссылка на реализацию rtreego (обычного R-tree), которую я взял за основу и [переделал её под R\*-tree](https://github.com/dhconnelly/rtreego). | https://habr.com/ru/post/666904/ | null | ru | null |
# Бесплатный сыр бесплатных VPN
Здравствуйте, уважаемые коллеги.
Часто доводилось наблюдать (на Хабре в том числе) обсуждения безопасности веб-серфинга через публичные незащищенные WiFi сети и рекомендации по защите.
Как минимум советуется к использованию HTTPS везде, где только это возможно. Многие вспоминают про TOR и/или VPN. Кто-то предпочитает VPN до своего собственного сервера (зато он гарантированно логи подключений не пишет!), кто-то VPN покупает. Бывает, вспоминают и о халяве. Полной или с ограничениями (xxx Мб в месяц для пробы и мы рады будем видеть вас среди наших клиентов, если вам понравится). В частности примелькались такие «лейблы», как Expat Shield и SecurityKISS. Условия у них разные, но это не суть. В том или ином виде, с ограничениями или без, но это халява. Поставили, пробуем.
SecurityKISS успешно подключился и отрапортовал, что External IP 217.147.94.149 (UK).
Пинг, произвольный сайт в браузере… вроде все работает. Проверяем telnet-ом коннект к 25 порту на некий интернет-сервер, в консоли которого сижу в момент эксперимента напрямую, без туннеля. Tcpdump, запущенный на внешнем интерфейсе сервера молчит о каких-либо попытках подключения, трафика на 25 порт нет. Но telnet уверяет, что коннект есть. Правда баннера почтовика нет… Набираю EHLO 123 и в ответ вываливается
421 Cannot connect to SMTP server xx.xx.xx.xx (xx.xx.xx.xx:25), connect timeout
где xx.xx.xx.xx — IP моего сервера.
Как вы понимаете, это отвечает не мой сервер xx.xx.xx.xx и не telnet с его «Подключение к xx.xx.xx.xx… Не удалось открыть подключение к этому узлу, на порт Y: Сбой подключения»
Пробую то же самое на 80-м порту. Коннект есть, tcpdump ничего не показывает. Набираю через некоторое (достаточно продолжительное) время GET / — пошли TCP-SYN пакеты (реально 80 порт не прослушивается, никакого сервиса на нем нет).
IP 217.147.94.149.8414 > xx.xx.xx.xx.80: S 832655572:832655572(0) win 16384
Вывод — прозрачно проксируют все, что могут.
Пробуем Expat Shield.
Коннект на 25 порт проходит похоже без фокусов, баннер и все остальное на месте. Пробуем 80 порт. Такой же эффект, как и в случае SecurityKISS. И тут автор заметки делает очепятку. Вместо GET пишет GER. Сеанс рвется с выводом вот этого
`400 Bad Request
400 Bad Request
===============
---
nginx/1.0.6`
На этот раз информативней, «светится» nginx/1.0.6.
Вот такая безопасность. Эти сервисы, конечно, защитят от прослушивания в случае гостевого WiFi, но в случае стационарного проводного подключения риск раскрыть данные аутентификации или получить модифицированный контент на порядок выше, чем если этими туннелями не пользоваться.
Если кто-то заинтересовался, есть еще небольшой любопытный и чем-то похожий материал на тему интернета через 3G. | https://habr.com/ru/post/148200/ | null | ru | null |
# Google maps с человеческим адресом.
Увидел статью про gmap и решил добавить немного своей инфы.
Буквально пару недель назад надо было интегрировать gmap непосредственно с сайтом. Было дано 35 зон и их надо было показывать на определенных страницах. Конечно, можно было создать 35 переменных и установить соответствие зона-координаты. Но это было бы как-то нудно ) Начал искать сначало непосредственно в google maps api. Подходящего не нашел. Разве что только поисковик по картам. Но это не подходило. Пошел дальше. И о чудо =) Правда сначало я этого не понял. [geotop](http://emad.fano.us/blog/?p=277) здесь можно выбрать нужный алгоритм. Теперь будем его прикручивать. Выбираем карту, которая нам по душе, но я советую мою. Дальше-
просто часть кода, по идее все должно быть понятно.
`script src="http://maps.google.com/maps?file=api&v=1&key=ваш ключ" type="text/javascript">`
div id=«map» style=«width: 650px; height: 500px»> \*\*\*карта
script type=«text/javascript»>
var map = new GMap(document.getElementById(«map»));
map.addControl(new GLargeMapControl());
map.addControl(new GMapTypeControl());
/script>
script type=«text/javascript» src=«[geo.localsearchmaps.com/?city=](http://geo.localsearchmaps.com/?city=)? echo $local ?&country=pt»>\*\*\*\*\*вот! А вот сюда я вписал путь непосредственно к скрипту
/script>
/div>
С картой все понятно, теперь посмотрим сюда | https://habr.com/ru/post/12939/ | null | ru | null |
# Выделение и CSS
Навык выделения текста и других объектов сформировался у пользователей компьютеров много лет назад. Мы выделяем содержимое веб-страниц по разным причинам. Возможно, нужно скопировать текст и где-то его процитировать, возможно — кому-то просто легче читать текст, выделяя его фрагменты. На мобильных устройствах, правда, выделять что-либо сложнее. Меня, например, это раздражает. Мне не нравится выделять содержимое веб-страниц на телефоне. Эта операция кажется какой-то «неправильной».
[](https://habr.com/ru/company/ruvds/blog/500290/)
В этом материале я расскажу обо всём, что нужно знать о стилизации выделений средствами CSS. В частности, речь пойдёт о псевдоэлементе `::selection` и о свойстве `user-select`. Эта статья направлена на то, чтобы показать всем желающим возможности CSS по работе с выделениями, и на то, чтобы рассказать о том, когда и как использовать разные методы работы с выделениями.
Основы
------
На [MDN](https://developer.mozilla.org/ru/docs/Web/CSS/::selection) можно узнать о том, что псевдоэлемент `::selection` позволяет применить стили к части документа, который был выделен пользователем (например, с помощью мыши).
Для использования `::selection` достаточно воспользоваться следующей конструкцией:
```
p::selection {
color: #fff;
background-color: #000;
}
```
*Выделенный текст*
[Вот](https://codepen.io/shadeed/pen/22f0f50259fd73630b79e1b7cb041445) пример, с которым можно поэкспериментировать.
Свойства, поддерживаемые ::selection
------------------------------------
Стоить отметить, что псевдоэлемент `::selection` поддерживает только свойства `color`, `background` и `text-shadow`.
Настройка собственных эффектов выделения
----------------------------------------
Что если нам нужно, чтобы выделение выглядело бы по-особенному? Например, чтобы выделение имело бы определённую высоту или некий интересный фон? Взгляните на следующий рисунок.
*Пример особой настройки выделения*
Это возможно, хотя и потребует приложения некоторых усилий. Вот как сделано выделение, показанное выше:
* Добавлен псевдоэлемент, с тем же текстом, который мы выделяем. Затем псевдоэлементу задано свойство `height: 50%` и белый фоновый цвет.
* Псевдоэлемент расположен над исходным текстом.
Если теперь выделить текст, то псевдоэлемент перекроет 50% текста по вертикали. Это позволяет сымитировать нужный нам эффект.
```
p {
position: relative;
color: #fff;
}
p:after {
content: attr(data-content);
position: absolute;
color: #000;
top: 0;
left: 0;
width: 100%;
height: 50%;
background-color: #fff;
}
p::selection {
background: rgba(76, 125, 225, 0.18);
}
```
Об этой методике я узнал [здесь](https://stackoverflow.com/questions/41260365/how-to-apply-a-background-color-to-only-half-of-the-text-on-selecting).
Ещё один вариант подобного выделения представлен ниже. Здесь я, вместо сплошного выделения, реализовал выделение в виде CSS-градиента. Смысл тут заключается в использовании белого градиента с высотой в 50% и в однократном заполнении элемента фоновым рисунком благодаря использованию значения `no-repeat` при настройке свойства `background`.
```
h1:after {
content: attr(data-content);
position: absolute;
color: #000;
top: 0;
left: 0;
width: 100%;
background: linear-gradient(#fff, #fff) top/100% 50% no-repeat;
}
```
На следующем рисунке показано разъяснение этой методики.
*Реализация градиентного выделения*
Надеюсь, я смог понятно объяснить эту идею. [Вот](https://codepen.io/shadeed/pen/5074964e902cd83d96e5ce7ba9ee1423?editors=1100) рабочий пример.
Анимирование выделения
----------------------
Работая над предыдущим примером, я задался следующим вопросом: «Реально ли анимировать выделение?». Например, в процессе выделения текста высота выделения составляет 50%. А когда указатель мыши уводят в сторону, высота выделения увеличивается до 80%. Как это сделать? А вот так:
```
p {
transition: background 0.3s ease-out;
}
p:hover:after {
background-size: 100% 80%;
}
```
*Текст в процессе выделения*
*Текст после завершения выделения*
[Вот](https://ishadeed.com/assets/selection-css/selection-animation.mp4) видео, в котором демонстрируется анимированное выделение.
Многострочный текст
-------------------
Представленная выше методика настройки выделения, к сожалению, не подходит для многострочного текста. Для того чтобы, всё же, реализовать нечто подобное и для такого текста, нужно прибегнуть к возможностям JavaScript и поместить каждое слово во встроенный (строчный) элемент, например — в . После того, как каждое слово окажется в собственном элементе , к каждому из таких элементов надо добавить псевдоэлемент. А уже после этого к многострочному тексту можно применить вышеописанный эффект.
Вот скрипт, позволяющий поместить каждое слово в -контейнер:
```
let paragraph = document.querySelector(".text");
const words = paragraph.textContent.split(" ");
paragraph.innerHTML = "";
words.forEach(function (word) {
let wordItem = document.createElement("span");
wordItem.setAttribute("data-word", word);
wordItem.innerHTML = word + " ";
paragraph.appendChild(wordItem);
});
```
После этого элементы надо стилизовать. Затем к каждому из них надо добавить псевдоэлемент:
```
span {
position: relative;
font-size: 1.25rem;
line-height: 1.4;
}
span::after {
content: attr(data-word);
position: absolute;
left: 0;
right: 0;
top: -0.28em;
height: 75%;
padding-top: 0.14em;
background: #fff;
pointer-events: none;
}
span::selection {
background: rgba(#4C7DE1, 0.18);
}
```
Если посмотреть на эту конструкцию в деле, то окажется, что она работает, но не совсем так, как можно ожидать. Ниже показан пример выделения многострочного текста. Можно заметить, что выделение выглядит неоднородным.
*Неоднородное выделение*
Я бы сказал, что подобное многострочное выделение получается не очень хорошим, и что его не стоит использовать в глобальном масштабе. Возможно, его стоит применять лишь, скажем, для организации выделения какого-то отдельного абзаца.
[Тут](https://ishadeed.com/article/selection-in-css/) с таким выделением можно поэкспериментировать.
Креативный подход к использованию ::selection и text-shadow
-----------------------------------------------------------
Так как одним из свойств, которые поддерживает псевдоэлемент `::selection`, является `text-shadow`, мы можем попытаться достичь каких-нибудь интересных эффектов, используя несколько теней текста. Исследуем возможности, которые открывает перед нами эта идея.
### ▍Выделение с длинными тенями
*Выделенный текст отбрасывает длинные тени*
Вот как реализовать этот эффект:
```
p::selection {
color: #444444;
background: #ffffff;
text-shadow: 1px 0px 1px #cccccc, 0px 1px 1px #eeeeee, 2px 1px 1px #cccccc, 1px 2px 1px #eeeeee, 3px 2px 1px #cccccc, 2px 3px 1px #eeeeee, 4px 3px 1px #cccccc, 3px 4px 1px #eeeeee, 5px 4px 1px #cccccc, 4px 5px 1px #eeeeee, 6px 5px 1px #cccccc, 5px 6px 1px #eeeeee, 7px 6px 1px #cccccc;
}
```
### ▍Эффект контурного текста
*Выделенный текст становится контурным*
Эту идею я нашёл в [данной](https://css-tricks.com/adding-stroke-to-web-text/) статье. Речь идёт о том, что с помощью свойства `text-shadow` можно сымитировать эффект контурного текста.
```
p::selection {
color: #fff;
text-shadow:
-1px -1px 0 #000,
1px -1px 0 #000,
-1px 1px 0 #000,
1px 1px 0 #000;
}
```
### ▍Эффект размытия
*Выделенный текст выглядит размытым*
Ещё один интересный эффект, который можно применить к выделенному тексту, заключается в размытии этого текста. Суть тут в том, чтобы использовать при настройке цвета текста свойство `color: transparent`. Тени, задаваемые с помощью `text-shadow`, при этом никуда не исчезнут, что и даст нужный эффект.
```
p::selection {
color: transparent;
text-shadow: 0 0 3px #fff;
}
```
Уверен, что вы сами сможете придумать ещё очень много примеров применения `text-shadow` для стилизации выделений. Это свойство даёт нам безграничные возможности.
### ▍Тени текстов и производительность
Не рекомендуется использовать слишком сложные стили при настройке `text-shadow`. Дело в том, что чрезмерное увлечение этим свойством приводит к проблемам с производительностью. [Вот](https://ishadeed.com/assets/selection-css/text-shadow-performance.mp4) видео, демонстрирующее один из примеров таких проблем.
*Использование очень сложных стилей при настройке выделения текста*
Представленный здесь неоновый эффект очень сложен. Обратите внимание на то, что при выделении этого текста заметна задержка между моментом выделения текста и моментом применения стилизации. Кроме того, обратите внимание на то, что сверху и слева появляется то, что появляться не должно. Поэтому прошу вас использовать `text-shadow` осмотрительно.
Выделяются ли элементы форм?
----------------------------
Краткий ответ на вопрос, вынесенный в заголовок этого раздела, будет звучать как «да». Мне кажется, что это неправильно: выделяешь страницу, а оказывается, что содержимое внутри полей ввода тоже выделяется. Вот как это выглядит.
*Содержимое внутри полей ввода выделяется*
Тут может быть выделен и текст внутри кнопки. В разделе, посвящённом `user-select`, мы поговорим о том, стоит или нет позволять пользователям выделять формы элементов.
[Вот](https://codepen.io/shadeed/pen/40ddda73c073f3cf9162023d6a314838) пример.
Исследование свойства user-select
---------------------------------
Свойство `user-select` даёт нам возможность задавать возможность выделения конкретного текста пользователем. Это свойство может оказаться полезным для отключения возможности выделения текста, что может пригодиться для ограничения возможностей пользователя по выделению материалов, расположенных рядом друг с другом. [Вот](https://drafts.csswg.org/css-ui-4/#propdef-user-select) стандарт, описывающий `user-select`.
Это свойство может принимать следующие значения: `none, auto, text, contain, all`.
Сценарии использования user-select
----------------------------------
### ▍Текст и иконка
Если в элементе есть текст и иконка — в виде символа или значка, взятого из какого-нибудь шрифта, то при выделении текста будет выделяться и эта иконка. Рассмотрим пример, представленный на следующем рисунке.
*Кнопка с текстом и иконкой*
Вот код этой кнопки:
```
Our Services▼
```
При выделении этого элемента он выглядит так, как показано ниже.
*Выделенная кнопка*
В подобном совершенно нет необходимости. Обратите внимание на то, что в разметке используется атрибут `aria-hidden`, скрывающий иконку от средств чтения с экрана. Для того чтобы решить проблему с выделение того, что выделять не нужно, мы можем воспользоваться следующим стилем:
```
button span[aria-hidden="true"] {
user-select: none;
}
```
Это позволяет запретить выделение иконки. И, в то же время, мы привязываем запрет выделения к атрибуту `aria-hidden`. В результате всё, что не должно выделяться, скорее всего, не должно быть видимым и для средств чтения с экрана.
### ▍Флажки
Меня раздражает такое поведение флажков, когда, устанавливая или снимая флажок, я случайно выделяю текст его описания. Вот как это выглядит.
*Текст описания флажка выделен случайно*
Решить эту проблему можно, стилизовав элемент следующим образом:
```
label {
user-select: none;
}
```
### ▍Выделение всего текста
Значение `all`, которое может принимать свойство `user-select`, позволяет добиваться интересного эффекта. Если это свойство с таким значением есть у родительского элемента, то весь текст, содержащийся в таком элементе, можно выделить одним щелчком мыши. Это может оказаться полезным для работы с текстовым содержимым, которое должно выделяться целиком. Например — для выделения фрагментов кода, имеющихся на странице:
```
.embed-code {
user-select: all;
}
```
Фрагмент текста, оформленный таким стилем, можно выделить одним щелчком мыши по нему.
Веб-приложения
--------------
Веб-приложение должно восприниматься пользователем как настоящее приложение. Можно ли выделять текст кнопок в обычных приложениях? Нет, нельзя. Важно, чтобы веб-приложения отражали привычные черты обычных приложений, делая это даже с учётом того, что они созданы с использованием HTML и CSS.
Рассмотрим несколько примеров из жизни.
### ▍Slack
В Slack можно выделять метки и поля ввода. Однако тексты кнопок не выделяются.
*Подписи кнопок не выделяются*
Вот ещё один пример.
*Подпись в заголовке модального окна выделяется*
А дату чата выделить нельзя.
*Дату выделить нельзя*
В целом — мне кажется странным то, что в приложении можно выделять некоторые тексты, которые, вроде бы, не должны поддерживать выделение. В интерфейсе Slack есть места, где используется `user-select: none`, но таких мест меньше, чем можно ожидать. Например мне, как пользователю, нет никакой выгоды от выделения заголовка модального окна.
### ▍Notion
Подход к выделению элементов, реализованный в Notion, мне нравится больше. Это веб-приложение больше похоже на реальное приложение, а не на веб-сайт, любую часть интерфейса которого можно выделить.
*То, что не должно выделяться, не выделяется*
Ни один фрагмент текста с этого рисунка не выделяется. Это — именно то, чего можно ожидать от приложения.
Не используйте глобальное отключение выделения
----------------------------------------------
Не рекомендуется отключать выделение глобально. Когда вы пользуетесь отключением выделения — постарайтесь, чтобы оно отключалось бы лишь у элементов, для которых оно не имеет смысла. Для этого можно создать вспомогательный класс. Например — такой:
```
.disable-selection {
-webkit-user-select:text;
-moz-user-select:text;
-ms-user-select:text;
user-select:text;
}
```
Нехороший паттерн
-----------------
Есть один UX-паттерн, который мне крайне не нравится. Он заключается в показе предупреждения при попытке выделения текста. Это раздражает и создаёт у пользователя такое ощущение, будто его взаимодействием с сайтом пытаются управлять. Пример этого паттерна показан ниже.
*Запрет выделения с показом уведомления*
Пожалуйста, не делайте так.
Выделение на мобильных устройствах
----------------------------------
Существует свойство `-webkit-touch-callout` для iOS Safari, которое должно отключать показ стандартной подсказки, выводимой при выделении текста. Я попытался воспользоваться этим свойством, но оно не работает.
```
p {
-webkit-touch-callout: none;
}
```
Стили `::selection` тоже не работают.
А свойство `user-select: none` работает так, как ожидается.
Я постарался найти реальный пример, иллюстрирующий эту проблему. Я скопировал фрагмент текста из Википедии. При этом был скопирован и совершенно ненужный мне текст `(listen)`. Это раздражает.
*Вместе с полезным текстом скопировано и (listen)*
Вместо того чтобы позволять пользователю копировать это вот «listen», лучше было бы добавить к этому элементу стиль `user-select: none`. В результате при копировании текста, содержащего этот элемент, он копироваться не будет.
Итоги
-----
Здесь мы рассмотрели методы настройки выделения элементов веб-страниц с использованием средств CSS. Возможно, вам интересно будет взглянуть и на [этот](https://css-tricks.com/force-selection-text-block/) материал.
**Уважаемые читатели!** Как вы настраиваете выделение текстов в своих проектах?
[](https://ruvds.com/ru-rub/?utm_source=habr&utm_medium=perevod&utm_campaign=VydelenieCSS#order) | https://habr.com/ru/post/500290/ | null | ru | null |
# collectd — собираем системную и пользовательскую статистику
#### Вопрос номер 0 — зачем?
В посте про [pnp4nagios](http://coolcold.habrahabr.ru/blog/79354/) я писал «Nagios/Pnp4Nagios не замена комплексу сбора статистики о состоянии системы». Почему я так думаю? Потому что 1) статистика состояния системы обширна и включает множество показателей 2) не всегда есть смысл их мониторить, точнее генерировать алерты. Например, знать сколько сколько операций ввода-вывода делает диск или происходит переключений контекста неплохо, но почти никогда не критично. Ну и кроме того, Nagios просто не предназначен для этого. В данной статье я не буду делать полное описание системы, ограничусь лишь особенно интересными, с моей точки зрения, моментами.
#### Вопрос номер 1 — почему collectd?
Основные моменты почему из Munin, Cacti и прочих я выбрал collectd:
1. Масштабируемость
2. Легковесность
3. Концепция — всё есть плагины
4. Сбор и запись данных разделены
5. Количество собираемых показателей
6. Расширяемость
Общая схема работы collectd:
[](http://collectd.org/images/architecture-schematic.png)
##### Масштабируемость
Для забора данных на центральную ноду(ы) используется push (в отличии от poll/pull в Cacti/Munin). Хранением данных может заниматься более чем одна нода и более того, можно разделить данные для хранения на разных нодах. Передачей данных занимается отдельный плагин — network.
##### Легковесность
Основной демон и плагины написаны на C и легко переживают 10ти секундный интервал сбора данных не нагружая систему.
##### Всё есть плагины
Сборщик данных о загрузке процессора — плагин. Информация о процессах — плагин. Запись и создание RRD/CSV — плагин.
##### Сбор и запись данных разделены
Данные можно как читать так и записывать. collectd разделяет плагины на «читателей» и «писателей». Те, что собирают информацию — читатели. После тогда как данные прочитаны, они отправляются к зарегистрированным писателям, которые в общем случае могут быть любыми. Наиболее «популярный» писатель это плагин network который отправляет данные на центральную ноду и RRDTool, под RRD как правило, и подразумевают статистику. Таким образом на ноде можно иметь как статистику в RRD, так и отправлять данные на дальнейшую обработку.
##### Количество собираемых показателей
На текущий момент существует более 90 базовых плагинов для сбора информации о системе и приложениях.
##### Расширяемость
Для добавления собственных источников данных существуют:
1. Плагин [exec](http://collectd.org/wiki/index.php/Plugin:Exec) в общем стандартный способ расширения — запускается программа, выводимые на stdout данные обрабатываются, но и здесь есть у collectd плюс — программа не обязана выходить после вывода значений, более того, рекомендуется запуститься и выводить данные в цикле, экономя ресурсы на запуске, что особенно актуально для скриптов.
2. Python/Perl/Java биндинги — являются как читателями так и писателями, более подробное описание ниже
#### Расширямость за счёт биндингов (bindings)
Привязки, это по сути плагины для доступа к внутренним механизмам collectd из других языков и написания плагинов на них. На текущий момент поддерживаются Java/Perl/Python. Например, для Python'a интерпретатор запускается при старте collectd, содержится в памяти экономя ресурсы на запуск каждые несколько секунд и даёт возможность скриптам иметь доступ к API.
Так скрипт может зарегистрироваться как поставщик данных (reader) и/или как писатель (writer), зарегистрированная процедура будет вызываться каждый заданный в конфигурации интервал времени. Если с читателем всё понятно, то на писателя стоит обратить отдельное внимание — ваш скрипт легко может быть встроен для обработки всех проходящих данных, т.е. можно, например, сделать свою базу хранимых значений. Простой [пример](http://collectd.org/documentation/manpages/collectd-python.5.shtml#examples) такого плагина на Python есть в документации проекта.
#### Интересные и полезные особенности плагинов
* Перво-наперво мне понравился плагин [disk](http://collectd.org/wiki/index.php/Plugin:Disk) — он из коробки умел мерять среднее время ответа диска:
[](http://web.coolcold.org/screens/2.6.28.8/list.html)
* Плагин [tail](http://collectd.org/wiki/index.php/Plugin:Tail) — позволяет читать файлы как tail(1) и при помощи регекспов выдергивать значения. Из отмачченых значений можно взять минимум/максимум/среднее, посчитать общее количество записей, просуммировать, например для nginx'a можно собрать статистику по времени ответа и реквестам для локейшна примерно так:
1. Добавляем в лог nginx'a запись о времени обслуживания запроса:
`log_format maintime '$remote_addr - - [$time_local] reqtime=$request_time "$request" $status $body_bytes_sent "$http_referer" "$http_user_agent" "$host" upstream: $upstream_addr gzip:"$gzip_ratio"';`
2. Создаем запись в конфиге collectd:
```
LoadPlugin tail
Instance "nginxproxy"
Regex " reqtime=([0-9]+\\.[0-9]+) "
DSType "GaugeMax"
Type "latency"
Instance "max responce time"
Regex " reqtime=([0-9]+\\.[0-9]+) "
DSType "GaugeAverage"
Type "latency"
Instance "avg responce time"
Regex ".\*"
DSType "CounterInc"
Type "derive"
Instance "requests"
```
Получаем графики общего количества запросов, максимального времени ответа и среднего времени ответа соответственно:
Схожими возможностями обладает плагин Curl
* Плагин processes — может собирать информацию о количестве запущенных процессов попадающих под фильтр, количестве их тредов, размере занимаемой памяти, вводе-выводе, например:
В данном случае данные не совсем верны — это не дисковые операции read/write а вообще все, т.е. запись в сокет токже посчитана. Авторам я сообщил, возможно исправят в следующей версии.
* плагин [UnixSock](http://collectd.org/wiki/index.php/Plugin:UnixSock) позволят обмениваться данными при помощи [простого текстового протокола](http://collectd.org/wiki/index.php/Plain_text_protocol), в частности можно получить или отправить значение счётчика. При помощи данного плагина возможна интеграция в Nagios.
#### Другие возможности
##### Фильтры и цепочки
Начиная с версии 4.6 появился механизм фильтров и цепочек, схожий с цепочками в iptables. При помощи данного механизма можно фильтровать данные, например отсекать значения у которых временная метка ( timestamp ) больше или меньше текущего времени на N, что может быть полезно если на каком-то сервере собьются часы. RRD попадет время из будущего и показания будут искажены.
##### Нотификация и threshholds
Базовая система [извещений](http://collectd.org/wiki/index.php/Notifications_and_thresholds#Notifications) и [пороговых значений](http://collectd.org/documentation/manpages/collectd.conf.5.shtml#threshold_configuration) появилась начиная с версии 4.3. Аналогично читателям и писателям, существуют «продюсеры» и «потребители» — первые производят извещения, вторые обрабатывают их. В частности плагин Exec может как реагировать на извещения, например запускать скрипт, так и передавать извещения из скриптов.
Сконфигурировав набор пороговых значений можно создавать извещения при отклонениях от нормы. Стоит, однако, понимать что данные базовые возможности не заменяют тот же Nagios. Для полноценной работы с Nagios можно использовать идущую в комплекте программу [collectd-nagios](http://collectd.org/documentation/manpages/collectd-nagios.1.shtml) которая позволяет опрашивать сокет созданный плагином UnixSock и возвращать результат в стандартном для Nagios'a формате
#### Недостатки
К недостаткам я могу причислить по большому счету только систему отображения графиков. Учитывая что с одного хоста может генерироваться около 200т счетчиков, визуализация становится не на последнем месте. Стандартный интерфейс collection3 неплох, но далек от совершенства. На текущий момент разрабатывается несколько независимых систем отображения графиков, но порекомендовать какой-либо пока не могу.
#### Прочее
Один из разработчиков Sebastian Harl (tokee) является мейнтейнером пакета в Debian посему в бэкпортах почти всегда есть последняя версия | https://habr.com/ru/post/93205/ | null | ru | null |
# Обзор Spring-компонентов. Часть 1 – Spring Boot и фреймворк интеграции
В обзоре собраны краткие описания каждого компонента экосистемы, чтобы дать понимание – как выглядит мир Spring, и ориентиры – что из этого стоит изучить глубже и применять в проекте.
Вторая часть обзора доступна по ссылке – «[Обзор Spring-компонентов. Часть 2 – Spring Cloud](https://habr.com/ru/post/674882/)».
### Вступление
Принцип «искать нужно там, где потерял, а не там, где светло» кажется очевидным. И все же приходилось видеть, как участники смежного проекта два года бились в аналитическом параличе, выбрав неподходящие инструменты. Со временем, вопрос «что такое Spring» стал источником опасений – не приведет ли незнание экосистемы к выбору ошибочного решения и бесполезной трате ресурсов на изучение или использование в проекте.
Перед структурированием компонентов, возник вопрос – на какой источник информации опираться. У Spring с этим творческий беспорядок – проекты в GitHub, реестр стартерных зависимостей, портал Spring Initializr, официальная документация – все источники противоречат друг другу. Решил опираться на документацию. В ней нет снятых с поддержки и экспериментальных проектов. Некоторые из 85 проектов включают несколько Spring-компонентов, поэтому их количество в обзоре – около сотни.
Методика анализа стандартная – выявляем границы системы, компоненты верхнеуровневой структуры и их назначение. Поскольку человек может одновременно оперировать примерно семью сущностями, вводим промежуточную структуру – разделяем компоненты на типы, представленные в КДПВ.
В обзоре собраны краткие описания каждого компонента экосистемы, чтобы дать общее понимание – как выглядит мир Spring, и ориентиры – что из этого стоит изучить глубже и, возможно, применить в проекте.
В разрезе проектов, структура получилась такая:
| |
| --- |
| **Компоненты Spring Boot приложений** |
| [**1.1 Уровень интеграции компонентов**](#%D0%A3%D1%80%D0%BE%D0%B2%D0%B5%D0%BD%D1%8C%D0%98%D0%BD%D1%82%D0%B5%D0%B3%D1%80%D0%B0%D1%86%D0%B8%D0%B8)Spring BootSpring Framework – Core[**1.2 Уровень бизнес-логики**](#%D0%A3%D1%80%D0%BE%D0%B2%D0%B5%D0%BD%D1%8C%D0%91%D0%B8%D0%B7%D0%BD%D0%B5%D1%81-%D0%BB%D0%BE%D0%B3%D0%B8%D0%BA%D0%B8)Spring Framework – TestingSpring Framework – LanguagesSpring ShellSpring StatemachineSpring Batch [**Spring Security**](#SpringSecurity)Spring SecuritySpring Security KerberosSpring Authorization Server[**2. Уровень обмена данными с хранилищами**](#%D0%A3%D1%80%D0%BE%D0%B2%D0%B5%D0%BD%D1%8C%D0%9E%D0%B1%D0%BC%D0%B5%D0%BD%D0%B0%D0%94%D0%B0%D0%BD%D0%BD%D1%8B%D0%BC%D0%B8%D0%A1%D0%A5%D1%80%D0%B0%D0%BD%D0%B8%D0%BB%D0%B8%D1%89%D0%B0%D0%BC%D0%B8)Spring Framework – Data AccessSpring LDAP[**Spring Data**](#SpringData)Spring Data Commons[**Поддержка SQL БД**](#%D0%9F%D0%BE%D0%B4%D0%B4%D0%B5%D1%80%D0%B6%D0%BA%D0%B0SQL%D0%91%D0%94)Spring Data JPASpring Data EnversSpring Data RESTSpring Data JDBCSpring Data R2DBCSpring Data for Apache Solr (устарел)Spring Data JDBC Extensions (устарел) | [**Поддержка NoSQL БД**](#%D0%9F%D0%BE%D0%B4%D0%B4%D0%B5%D1%80%D0%B6%D0%BA%D0%B0NoSQL%D0%91%D0%94)Spring Data MongoDBSpring Data ElasticsearchSpring Data RedisSpring Data Neo4jSpring Data for Apache CassandraSpring Data CouchbaseSpring Data LDAP[**Поддержка Grid-хранилищ**](#%D0%9F%D0%BE%D0%B4%D0%B4%D0%B5%D1%80%D0%B6%D0%BA%D0%B0Grid%D0%A5%D1%80%D0%B0%D0%BD%D0%B8%D0%BB%D0%B8%D1%89)Spring Data for Apache GeodeSpring Data for VMware Tanzu GemFire[**Интеграция с BigData**](#%D0%98%D0%BD%D1%82%D0%B5%D0%B3%D1%80%D0%B0%D1%86%D0%B8%D1%8F%D0%A1BigData)Spring for Apache Hadoop (устарел)[**3. Уровень сетевого обмена данными**](#%D0%A3%D1%80%D0%BE%D0%B2%D0%B5%D0%BD%D1%8C%D0%A1%D0%B5%D1%82%D0%B5%D0%B2%D0%BE%D0%B3%D0%BE%D0%9E%D0%B1%D0%BC%D0%B5%D0%BD%D0%B0%D0%94%D0%B0%D0%BD%D0%BD%D1%8B%D0%BC%D0%B8)Spring Framework – Web MVC (Web Servlet)Spring Framework – WebFlux (Web Reactive)Spring Framework – IntegrationSpring Web FlowSpring HATEOASSpring for GraphQLSpring Web ServicesSpring REST Docs[**MQ (Message Queue)**](#MQ)Spring AMQPSpring for Apache Kafka |
| [**4. Фреймворк корпоративной интеграции**](#%D0%A4%D1%80%D0%B5%D0%B9%D0%BC%D0%B2%D0%BE%D1%80%D0%BA%D0%9A%D0%BE%D1%80%D0%BF%D0%BE%D1%80%D0%B0%D1%82%D0%B8%D0%B2%D0%BD%D0%BE%D0%B9%D0%98%D0%BD%D1%82%D0%B5%D0%B3%D1%80%D0%B0%D1%86%D0%B8%D0%B8) |
| Spring Integration | |
Чтобы увидеть все проекты можно развернуть раздел «Компоненты Spring Cloud приложений», обзор на который будет во второй части.
Компоненты Spring Cloud приложений
| |
| --- |
| **Компоненты Spring Cloud приложений** |
| **5. Адаптация Spring Boot приложений к облачной среде**Spring CloudSpring Cloud CommonsSpring Cloud OpenFeignSpring Cloud Circuit BreakerSpring Cloud SecuritySpring Cloud Schema RegistrySpring Cloud SleuthSpring Cloud ContractSpring Cloud Cluster**Spring Session**Spring Session Core**Session-репозитории**Spring Session Data RedisSpring Session MongoDBSpring Session JDBCSpring Session HazelcastSpring Session for Apache Geode**6. Инфраструктурные сервисы, переносимые между облачными платформамиСервис с ролью Gateway**Spring Cloud Gateway**Сервисы с ролью Config Server**Spring Cloud ConfigSpring Cloud VaultSpring Cloud Bus**Сервисы с ролью Service Discovery**Spring Cloud Netflix (Eureka)Spring Cloud Zookeeper**Интеграция с Service Mesh**Spring Cloud Consul | **7. Инфраструктурные сервисы, интегрированные в облачные платформы (клиенты подключения)**Spring Cloud AlibabaSpring Cloud KubernetesSpring Cloud for Amazon Web ServicesSpring Cloud Azure (Microsoft)Spring Cloud GCP (Google)Spring Cloud for Cloud FoundrySpring CredHubSpring VaultSpring Cloud Connectors**Администрирование приложений в облачных платформах**Spring Cloud CLISpring Cloud SkipperSpring Cloud Pipelines (устарел)**Сервисы администрированияс ролью Open Service Broker**Spring Cloud App BrokerSpring Cloud Open Service BrokerSpring Cloud – Foundry Service Broker (устарел)**8. Микро-фреймворки для разработки микросервисов**Spring Cloud FunctionSpring Cloud StreamSpring Cloud Stream ApplicationsSpring Cloud TaskSpring Cloud Task App Starters**Оркестровка конвейеров из Stream и Task сервисов**Spring Cloud Data FlowSpring Flo |
---
Компоненты Spring Boot приложений
---------------------------------
Уровень интеграции компонентов приложения
-----------------------------------------
#### 1. Spring Boot
Проект содержит пять разнородных компонентов:
1.1 Классы автоконфигурации для всех компонентов Spring.
1.2 Механизм загрузки и переопределения свойств для классов автоконфигурации.
1.3 Родительский POM для maven (spring-boot-starter-parent).
1.4 Плагин для maven (spring-boot-maven-plugin).
1.5 Spring Boot Actuator.
**Назначение компонентов:**
**1.1. Классы автоконфигурации для всех компонентов Spring**
Это привычные классы конфигурации, содержащие условные аннотации. Если не выполняется прописанные в аннотациях условия, блокируется запуск bean-методов. Аннотации проверяют:
* Есть ли в проекте зависимость, требующая загрузки в контейнер Dependency Injection (DI) бинов этим классом автоконфигурации.
* Не отключен ли разработчиком запуск этого класса автоконфигурации, через аннотацию в классе конфигурации.
* Не переопределена ли разработчиком загрузка в DI отдельных бинов этого класса автоконфигурации, через ее реализацию в классе конфигурации.
* Не переопределены ли разработчиком свойства для настройки бинов, через любой из 12 источников свойств.
И далее, класс автоконфигурации загружает бины в DI-контейнер по принципу «не навреди», отдавая приоритет настройкам разработчика.
**1.2. Механизм загрузки и переопределения свойств для классов автоконфигурации**
Поддерживаются 12 источников загрузки свойств в порядке приоритета.
В том числе, этот компонент поддерживает третий принцип 12-факторных приложений – «Настройки, зависящие от развертывания, должны храниться вне сервиса». Spring Boot позволяет вынести, в виде properties файлов, до 2600 настроек на сервер конфигураций Spring Cloud Config.
**1.3. Родительский POM для maven (spring-boot-starter-parent)**
Хранит информацию о версиях транзитивных зависимостей. Снимает необходимость указывать версии зависимостей в POM файле, автоматически подгружая совместимую.
**1.4. Плагин для maven (spring-boot-maven-plugin)**
В дополнение к формированию стандартных WAR и JAR файлов, он позволяет:
* Создавать Fat JAR – включающие встроенный сервер.
* Создавать Thin JAR – без библиотек внешних зависимостей. Зависимости подгружаются на сервере, при первом запуске. Множество микросервисов могут переиспользовать зависимости из единого локального maven репозитория.
* Создавать Docker образы, в том числе многослойные. Многослойность теоретически позволяет ускорить сборку образа. Заявлено что, «медленно» собрав многослойный образ, далее, при минорных изменениях кода, можно будет быстро обновлять только один слой. Но тесты показывают, выигрыша нет. Второй «быстрый» этап выполняется в 6 раз медленнее, чем сборка полного образа штатными средствами Docker.
* Запускать код проекта на исполнение командой run непосредственно из maven, с формированием jar в фоне. Позволяет скачать из Git исходный код с вложенной maven-embedded и запустить в системе, не требуя ничего, кроме установленного JDK.
**1.5. Spring Boot Actuator**
Реализует функционал JMX через стандартный HTTP протокол. Включает коллекцию преднастроенных точек подключения.
О некорректной терминологии в Spring:Взглянув на этот список, начинают странно восприниматься многие утверждения. «мы ведем разработку на Spring Boot» звучит как «мы возим тонны кирпичей на ключах от грузовика». Произнесенное с большой значимостью «мы используем Spring без Spring Boot» вызывает вопрос – стоят ли сакрализации лишние полсотни строк в классе конфигурации?
Вопросы исчезают, когда выясняется что использование логически некорректных терминов стало частью маркетинговой стратегии. Они провоцируют поиск глубокого смысла, дают темы для конференций по «спринг-потрошению» и мотивируют создавать интернет-порталы по описанию Spring функциональности на человеческом английском.
Используемые в этой статье термины «Spring Boot/Cloud приложения» тоже формально некорректны, но выбраны как устоявшиеся и продвигаемые разработчиками Spring.
**О документации Spring Boot:**
Стоит учесть, что в документацию Spring Boot вынесены произвольные части описания каждого из компонентов Spring. Поэтому документацию по компонентам есть смысл читать в комплексе с одноименными разделами Spring Boot. Например, загрузка в БД начальных данных из файлов JSON описана в Spring Data, а из файлов в формате SQL – в Spring Boot.
Также, в документации Spring Boot есть раздел «How-to Guides» с рекомендуемыми шаблонами для использования различных компонентов Spring.
#### 2. Spring Framework – Core
**Корневой компонент:**
**2.1. IoC Container** – компонент для внедрения зависимостей (DI - Dependency Injection) и реализации концепции IoC (Inversion of Control, инверсия контроля). На Хабре более устоялся синоним «DI-контейнер».
В этот контейнер Spring Boot загружает преднастроенные бины Spring-компонентов, а разработчик – бины с бизнес-логикой и логикой их взаимной интеграции (внедрения зависимостей). DI-контейнер сам выполняет внедрение зависимостей, обеспечивая «инверсию контроля».
**Вспомогательный функционал:**
**2.2. Resources** – унифицированный интерфейс и его имплементации для абстрагирования доступа к низкоуровневым ресурсам через классы JDK – File, Files, Path, InputStream, ByteArrayInputStream и к ресурсам в ServletContext.
**2.3. Validation и Spring Type Conversion** – набор библиотек для валидации, преобразования типов и локализация форматов.
**2.4. SpEL** – язык выражений Spring.
**2.5. Spring AOP** – для организации проксирования методов, – выполнения дополнительной логики перед или после выполнения методов, обернутых прокси-объектами.
В сравнении с полнофункциональными AOP-библиотеками, спроектирован по принципу 10% функциональности, закрывающей 100% типовых потребностей разработчика. Для нетиповых случаев предусмотрено подключение AspectJ.
Использование Spring AOP включает два шага:
* Создать класс (прокси) с логикой, которая должна выполняться при вызове методов или возврате ответа из них.
* Создать класс сканирования, с условиями при которых методы должны оборачиваться прокси-объектами.
Логика прокси-объекта может преобразовывать передающиеся данные, блокировать их передачу в метод или не затрагивать их, например, засекая время для измерения производительности или логируя факт передачи.
Механизм сканирования позволяет массово применять дополнительную логику к произвольным методам приложения. Пример: авторизация доступа в Spring Security к методам классов бизнес-логики.
**2.6. Аннотации для проверки на Null в IDE.**
**2.7. Кодеки сериализации и буферы данных.**
---
Уровень бизнес-логики
---------------------
#### 3. Spring Framework – Testing
Функционал для юнит и интеграционного тестирования в Spring.
#### 4. Spring Framework – Languages
Поддержка языков Kotlin, Groovy и семейства Dynamic Language (JSR-223).
#### 5. Spring Shell
Компонент для разработки приложений с интерфейсом командной строки.
#### 6. Spring Statemachine
Компонент для реализации в приложении концепции конечного автомата.
#### 7. Spring Batch
Компонент для однотипной обработки больших массивов данных. Как правило, при запуске приложение считывает набор заданий из источника данных (БД, файлы XML, CSV и т.п.) и сохраняет результат обработки в то же или другое хранилище.
### Spring Security
#### 8. Spring Security
Компоненты для авторизации, аутентификации и защиты от эксплойтов.
**Авторизация** – разрешение или блокировка доступов на трех уровнях:
* уровень HTTP запросов,
* уровень методов в java классах,
* уровень отдельных записей БД.
**Аутентификация** – проверка, к какой учетной записи и роли относится пользователь.
Варианты реализации:
**8.1. Username/Password** – идентификация пользователя по логину и паролю.
* Form – с отправкой логина и пароля в теле запроса,
* Basic – с отправкой логина и пароля в заголовке запроса WWW-Authenticate,
* Digest – с отправкой одноразовой хэш-суммы на основе логина и пароля.
**8.2. Remember Me** – идентификация пользователя в разных сеансах.
* с хешированием токенов в cookie,
* с хранением токенов в БД или ином хранилище.
**8.3. Анонимная аутентификация** – позволяет явно задать ресурсы, доступные анонимам, и запретить неавторизованный доступ к оставшимся. Страхует от NullPointerException, когда перехватчик аудита запрашивает SecurityContextHolder чтобы определить, какой принципал отвечает за данную операцию.
**8.4. Pre-Authentication** – аутентификация внешними системами:
* по SSL-сертификату (X.509),
* по заголовку HTTP запроса (Siteminder),
* на уровне контейнера Java EE.
**8.5. JAAS** (Java Authentication and Authorization Service) - аутентификация средствами низкоуровневой структуры безопасности Java SE.
**8.6. CAS** (Central Authentication Service) – SSO-аутентификация (Single Sign-On – технология единого входа) на сервере CAS от компании Apereo.
**8.7. X509** – взаимная аутентификация – проверка подлинности узла связи и проверки личности клиента на основе SSL-сертификата.
**8.8. Run-As** – поддержка выполнения пользователем некоторой логики от имени другого пользователя.
**8.9. OAuth2** (компонент включает поддержку **OpenID**) – поддержка внешнего сервера аутентификации:
* OAuth 2.0 (например, GitHub),
* OpenID Connect 1.0 (например, Google).
Внешним сервером аутентификации может быть и ваше Spring-приложение ([пример](https://www.baeldung.com/spring-security-oauth-jwt)). Токены JWT лучше, чем логин/пароль подходят для защиты межсистемных запросов.
**8.10. SAML2** – протокол SSO-аутентификации на основе XML.
Кроме аутентификации, реализованы:
**8.11. Поддержка хранения учетных данных пользователей:**
* в оперативной памяти,
* в реляционной БД,
* в LDAP.
LDAP – тип специализированных БД со своим уникальным языком запросов. Они спроектированы для хранения информации о пользователях – логинов, хэшей паролей и пользовательских ролей. Также могут хранить ФИО, должности, адреса, телефоны и прочие данные пользователей.
**8.12. Logout** - функция для аннулирования аутентификации.
Как организовать двухфакторную аутентификацию, аутентификация по географическому местоположению и т.п. в официальной документации не описано, но есть статьи на Baeldung.com. Только по Spring Security там 180 статей.
#### 9. Spring Security Kerberos
Компонент для беспарольной аутентификации для Windows-пользователей, уже залогиненных под доменной учетной записью. Kerberos – протокол SSO-аутентификации, используемый в Windows Server (Active Directory).
#### 10. Spring Authorization Server
Компонент для создания поставщиков удостоверений OpenID Connect 1.0 и продуктов сервера авторизации OAuth2. Новый проект с версией 0.3.0.
---
Уровень обмена данными с хранилищами
------------------------------------
#### 11. Spring Framework – Data Access
В модуле реализованы:
**11.1. Transaction Management** – компонент управления транзакциями.
**11.2. DAO Support** – компонент для перехвата исключений уровня DAO. Активируется аннотацией @Repository.
**11.3. Spring JDBC** – компонент для работы с реляционными БД через JDBC и jdbcTemplate.
**11.4. Spring R2DBC** – реактивный аналог Spring JDBC.
**11.5. Spring ORM** – компонент для работы с реляционными БД через произвольные имплементации JPA, включая Hibernate EntityManager, а также через Hibernate Session.
**11.6. Spring OXM** (Object-XML Mapping) – компонент для сериализации и десоциализации XML. Также используется синоним – маршаллинг.
#### 12. Spring LDAP
Аналог Spring JDBC для LDAP, с реализацией LdapTemplate ([термин LDAP](#LDAP)).
### Spring Data
#### 13. Spring Data Commons
Общий функционал всех Spring Data компонентов. Предназначен для унифицированного взаимодействия с SQL, NoSQL, LDAP и Grid хранилищами. Позволяет мигрировать между разными типами БД, не затрагивая код, меняя только maven зависимости.
**Основной функционал:**
**13.1. Repositories** – включает:
* Коллекцию стандартных CRUD-запросов, в том числе с пагинацией.
* Единый язык запросов для разных типов БД (SQL, NoSQL, Grid).
* Механизм проброса запросов в ORM или БД на специфичном для них языке (JPQL, SQL и т.п.)
Запросы на языке Spring Data формируются путем составления из ключевых слов имен java методов. При этом java методы должны расширять интерфейс CrudRepository или его наследников. Пример:
```
List findByLastnameOrderByFirstnameAsc(String lastname);
```
* List findByLastname – найти все Person с заданным значением в поле Lastname,
* OrderByFirstname – отсортировать по полю Firstname,
* Asc – тип сортировки «по возрастанию».
Подробнее по ссылкам:
* [Реестр ключевых слов](https://docs.spring.io/spring-data/commons/docs/current/reference/html/#repository-query-keywords)
* [Правила формирования имен методов и порядок их парсинга](https://docs.spring.io/spring-data/commons/docs/current/reference/html/#repositories.query-methods.details)
**Дополнительный функционал:**
**13.2. Projections** – запросы отдельных атрибутов объектов. Запросы могут формироваться тремя способами:
* Interface-based Projections – на основе дополнительного интерфейса,
* Class-based Projections – на основе DTO,
* Dynamic Projections – динамические.
**13.3. Query by Example (QBE)** – динамические запросы объектов, аналог Criteria.
**13.4. Auditing** – сбор информации, кто и когда создавал или изменял данные в БД.
### Поддержка SQL БД в Spring Data
#### 14. Spring Data JPA
Компонент для работы с любыми реляционными БД.
#### 15. Spring Data Envers
Поддержка Hibernate Envers – аудит, кто и когда создавал или изменял данные в БД.
#### 16. Spring Data REST
Реализация CRUD-операций с реляционными БД через REST API. Достаточно добавить entity-классы, и REST API сформируется для них автоматически. Использует REST запросы в HAL-формате (HAL – один из вариантов реализации HATEOAS).
#### 17. Spring Data JDBC
Компонент для работы с реляционными БД, без поддержки JPA, EntityManager, Lazy и кэширования. Позиционируется как простое решение для простых задач. Поддерживает MyBatis и все еще поддерживает Spring Data Commons. Не путать со Spring JDBC в модуле «Spring Framework – Data Access».
#### 18. Spring Data R2DBC
Компонент для работы с реляционными БД через реактивные драйверы.
#### 19. Spring Data for Apache Solr (устарел)
Apache Solr – платформа полнотекстового поиска. Поддержка прекращена. Рекомендован переход на Elasticsearch. Примечание: устаревшие, но поддерживаемые компоненты отражаются в обзоре, чтобы читателю не требовалось тратить время на изучение заведомо ненужных компонентов.
#### 20. Spring Data JDBC Extensions (устарел)
Расширения для поддержки БД Oracle. Поддержка прекращена. Полезный функционал разнесен по другим компонентам Spring.
### Поддержка NoSQL БД в Spring Data
#### 21. Spring Data MongoDB
Поддержка MongoDB – классическая NoSQL БД с динамическими схемами. Может хранить записи с произвольным набором атрибутов, без предварительного конфигурирования.
#### 22. Spring Data Elasticsearch
Поддержка Elasticsearch – БД, ориентированная на полнотекстовый поиск.
#### 23. Spring Data Redis
Поддержка Redis – БД, обычно используемая для организации кэша или очередей сообщений (MQ).
#### 24. Spring Data Neo4j
Поддержка Neo4j – графовая БД, одна из самых зрелых и полнофункциональных.
#### 25. Spring Data for Apache Cassandra
Поддержка Cassandra – распределенная БД – масштабируемая и отказоустойчивая.
#### 26. Spring Data Couchbase
Поддержка Cassandra – конкурент MongoDB. MongoDB вышла раньше и занимает большую долю рынка. До 2020 года на Couchbase были жалобы на нестабильность. Какая БД лучше, в интернете много споров с взаимоисключающей информацией.
#### 27. Spring Data LDAP
Аналог Spring LDAP с поддержкой Spring Data Commons.
### Поддержка Grid-хранилищ
In-Memory Data Grid (IMDG) или просто Grid – хранит в оперативной памяти непосредственно java объекты, в потокобезопасной Map (HashTable или ConcurrentMap). Такой способ хранения освобождает от необходимости использовать ORM.
Функции Grid-сервера:
1. Управляет кластерами хранилищ, позволяя их реплицировать, партиционировать (разделять данные по хранилищам в кластере) и сохранять данные на диск.
2. Является точкой входа как для прямых запросов к Map, так и с помощью языка объектных запросов OQL (Object Query Language).
3. Обеспечивает распределенные вычисления на основе хранящихся данных. Аналогично хранимым процедурам, PL-SQL и Transact-SQL в реляционных БД.
#### 28. Spring Data for Apache Geode
Поддержка Apache Geode – полнофункциональной In-Memory Data Grid.
#### 29. Spring Data for VMware Tanzu GemFire
Поддержка GemFire – коммерческой версии Apache Geode.
### Интеграция с BigData
#### 30. Spring for Apache Hadoop (устарел)
Компонент для интеграции с Apache Hadoop – распределенной файловой системой, с поддержкой распределенных вычислений. Поддержка компонента скоро будет прекращена.
---
Уровень сетевого обмена данными
-------------------------------
Компоненты для обмена по сети данными с другими функциональными модулями:
* браузерами,
* фронтэнд и мобильными приложениями,
* собственными приложениями компании-разработчика, в том числе микросервисами,
* коробочными системами, поддерживающими интеграцию,
* коммерческими облачными сервисами.
#### 31. Spring Framework – Web MVC (Web Servlet)
Включает компоненты:
**31.1. Контроллер HTML** – используется в связке с шаблонизаторами для формирования пользовательских web-интерфейсов.
Шаблонизатор – компонент, загружающий данные из Java в HTML-шаблоны страниц пользовательского интерфейса. В документации заявлена поддержка около 15 [технологий](https://docs.spring.io/spring-framework/docs/current/reference/html/web.html#mvc-view) визуализации, в том числе, реализующие JSR-223.
В Spring, шаблонизатор по умолчанию – Thymeleaf, но поддерживается и React. Учитывая, количество «воды» в документации по Thymeleaf, возникает мысль, не проще ли освоить синтаксис JavaScript и писать сразу на React ([пример](https://www.baeldung.com/react-nashorn-isomorphic-app)). В Java 8 движок JavaScript Nashorn, уже встроен. В следующих версиях Java, – Nashorn можно [подключить](https://github.com/openjdk/nashorn).
**31.2. REST контроллер** – используется для приема HTTP запросов и отправки ответов.
Основные сценарии использования: обработки запросов фронтенда – приложений SPA (Single Page Application) на JavaScript, мобильных приложений и сайтов на других технологиях. Для не-enterprise систем, может реализовывать связь между микросервисами. Этот подход является базовым для Spring Cloud компонентов на основе Netflix.
**31.3. Клиент REST** (restTemplate) – используется для отправки HTTP запросов и приема ответов.
Основные сценарии использования: скачивание данных с сайтов и тестирования REST сервисов. Примечание: в документации «Spring Framework – Web MVC», клиент REST только заявлен, но реализован и описан в модуле «Spring Framework – Integration».
**31.4. WebSockets** – протокол для двухстороннего канала связи на уровне TCP.
Отказ от HTTP снижает накладные расходы, повышая пропускную способность сети. Но его применение обычно ограничено корпоративной сетью, так как требует определенных настроек сетевых устройств на всем пути передачи данных.
**31.5. Поддержка устаревших фреймворков**: JSF, Struts, Tapestry.
#### 32. Spring Framework – WebFlux (Web Reactive)
Реактивный аналог модуля «Spring Framework – Web MVC».
Включает компоненты:
**32.1. Контроллер HTML** – реактивный,
**32.2. REST контроллер** – реактивный,
**32.3. REST клиент** (WebClient) – реактивный,
**32.4. WebSockets**,
**32.5. RSocket** – реактивный аналог WebSockets.
#### 33. Spring Framework – Integration
Включает компоненты:
**33.1. Клиент REST** (restTemplate) – в документации «Spring Framework – Web MVC» клиент REST только упомянут, но реализован и описан этом модуле (глава REST Endpoints).
**33.2. Web Services** – базовая поддержка устаревающих, но еще использующихся протоколов обмена данными на основе семейства XML (SOAP, XML-RPC). Активно вытесняется очередями сообщений (MQ – Message Queue).
**33.3. EJB** – интеграция с Enterprise JavaBeans. Старая, редко используемая технология.
**33.4. JMS** (Java Message Service) – поддержка брокеров сообщений, использующих протокол JMS для обмена данными через очереди сообщений (MQ). Ограничен поддержкой только java сервисов. Spring рекомендует для протокола JMS использовать брокеры ActiveMQ (classic) или ActiveMQ Artemis. С ними реализована наиболее плотная интеграция – конфигурирование через property файлы для реализации третьего принципа 12-факторных приложений.
**33.5. JMX** (Java Management Extensions) – протокол управления приложением. Позволяет на работающем приложении вызывать непосредственно методы классов для передачи в них данных (управление) или считывания информации (мониторинг состояния). Spring для его замены рекомендует использовать [Spring Boot Actuator](#Spring%20Boot%20Actuator).
**33.6. Email** – компонент для отправки e-mail из Spring.
**33.7. Task Execution and Scheduling** – поддержка планирования и асинхронного запуска задач через Quartz Scheduler.
**33.8. Cache Abstraction** – кэш для java методов. Сохраняет в памяти пары значений «параметры вызова java метода и результат выполнения», перехватывает последующие запросы и ищет в памяти «готовый ответ», без выполнения метода. Для хранения пар запрос-ответ поддерживает: ConcurrentMap, Ehcache 2.x, Gemfire, Caffeine и реализации, совместимые с JSR-107 (например, Ehcache 3.x).
#### 34. Spring Web Flow
Организует «поток пользовательских интерфейсов» в виде последовательности шагов. Расширение для контроллеров HTML и шаблонизаторов в модулях Web MVC и WebFlux.
#### 35. Spring HATEOAS
Расширение для Web MVC и WebFlux для поддержки формата сообщений HATEOAS в REST контроллерах. На просторах Хабра не удалось найти людей, умеющих извлекать пользу из этой технологии. Формально она помогает реализовать GRASP паттерн «Low Coupling», за счет усложнения формирования запросов.
#### 36. Spring for GraphQL
Расширение для Web MVC и WebFlux для поддержки формата сообщений GraphQL в контроллерах, WebSocket и RSocket.
GraphQL – язык запросов для API, конкурирующий в REST. Позволяет одним запросом получить ограниченный набор полей из разных объектов предметной области. Это снижает нагрузку на сеть и сервер – уменьшает количество запросов и объем передаваемых данных. Недостатки GraphQL – не поддерживает кэширование и загрузку файлов.
В приложении могут одновременно использоваться и REST, и GraphQL контроллеры. На мой взгляд, большую часть преимуществ GraphQL можно получить, используя только REST в паре с DTO (Data Transfer Object). А безальтернативен GraphQL в тех случаях, которые требуют использования динамических запросов к БД, например через Hibernate Criteria.
#### 37. Spring Web Services
Расширенная поддержка SOAP.
Примечание: базовая поддержка реализована в компоненте «Spring Framework – Integration».
#### 38. Spring REST Docs
Автоматической генерирует документацию Open API (Swagger) для REST API.
### MQ (Message Queue)
Очереди сообщений (MQ) – современный способ надежной интеграции функциональных подсистем и обмена данными между микросервисами. От Web Services (SOAP) он отличается снижением трудозатрат на разработку интеграционных взаимодействий, а от REST – надежностью, отвечающей требованиям enterprise приложений.
MQ поддерживают работу в рамках глобальных транзакций, одновременно включающих и JPA запросы к БД. Если в серии MQ и JPA запросов, при взаимодействии микросервисов, произойдет сбой, состояние откатится транзакционными механизмами.
К классу MQ относятся протоколы:
1. JMS – реализован в «Spring Framework – Integration», поддерживает обмен только между java приложениями.
2. AMQP – поддерживает приложения, написанные на разных языках.
3. Kafka (свой уникальный протокол) – поддерживает приложения, написанные на разных языках, отличается высокой производительностью и масштабируемостью.
#### 39. Spring AMQP
AMQP (Advanced Message Queuing Protocol – расширенный MQ протокол). Отличается от JMS поддержкой приложений, написанных на разных языках.
Для протокола AMQP, Spring рекомендует использовать брокер RabbitMQ, с которым реализована наиболее плотная интеграция – конфигурирование через property файлы для реализации третьего принципа 12-факторных приложений.
По отзывам, от Kafka отличается меньшими требованиями к администрированию – при умеренных нагрузках «просто работает, не требуя внимания».
#### 40. Spring for Apache Kafka
Apache Kafka – самый популярный брокер сообщений. Поддерживает приложения, написанные на разных языках. Отличается рекордной производительностью и масштабируемостью.
---
Фреймворк корпоративной интеграции
----------------------------------
#### 41. Spring Integration
Предназначен для связи систем, использующих разные протоколы интеграции, и промежуточного преобразования данных.
Включает библиотеки для:
* обработки данных в XML,
* организации транзакций,
* авторизации доступа,
* обработки ошибок,
* тестирования,
* коллекцию из 30 интеграционных модулей, содержащих 92 адаптера.
Код приложения взаимодействует с адаптерами через абстракцию Message. Роль адаптеров - преобразование Message в сообщение требуемого протокола и обратно.
Поддерживаемые протоколы и типы данных:
| | |
| --- | --- |
| **Web**- TCP и UDP- HTTP- WebFlux- WebSockets- RSocket- Web Services- FTP/FTPS- SFTP- Mail- XMPP (интернет-чаты)- Feed Adapter (RSS и ATOM)- RMI**Data**- JDBC- R2DBC- JPA- Redis- MongoDb- Apache Geode (Grid)- Pivotal GemFire (Grid) | **Messaging**- JMS- AMQP- Apache Kafka- ZeroMQ- MQTT – брокер издатель-подписчик для IoT- STOMP (Simple Text Orientated Messaging Protocol) – используется в WebSockets.**Прочее**- File- Resource- Stream – обмен данными между Java Stream в разных системах.- Spring ApplicationEvent- Zookeeper- JMX- Syslog – записи системного журнала других хостов. |
По отзывам, борьбу за популярность, этот фреймворк проиграл конкуренту - Apache Camel. В то же время, он стал основой для микро-фреймворка Spring Cloud Stream.
### Заключение
В первой части обзора были представлены компоненты Spring Boot и фреймворка корпоративной интеграции. Во [второй части](https://habr.com/ru/post/674882/) будут описаны компоненты Spring Cloud.
Наверняка среди читателей будут те, кто глубоко знает тот или иной компонент. Поправки и уточнения приветствуются. | https://habr.com/ru/post/674858/ | null | ru | null |
# Опыт разработки игры для Android. От идеи до реализации
В данной статье хочу представить вам опыт разработки игры-тренажера английского языка для платформы Android, рассказать какие трудности возникли в процессе разработки, а также какие ошибки были допущены.
#### Предыстория
С 2011 года я работал Android-разработчиком в разных компаниях, в том числе и на фрилансе. За все это время участвовал в разработке различных проектов, но так и не нашел времени написать собственное приложение. Получается «сапожник без сапог» – программист, у которого есть аккаунт на Google Play и опыт участия в различных проектах, но нет собственных приложений.
#### Идея
В мае 2015 года задумал сделать игру-тренажер для запоминания слов на английском языке. В Google Play существует огромное множество таких игр и приложений, но хотелось сделать что-нибудь свое, не похожее на других. Для этого нужно было добавить какую-нибудь «изюминку», которая отличала бы мою игру от других. Этим ключевым отличием стало ограничение времени, за которое пользователь должен успеть перевести слова. Наличие таймера должно добавить в игру элемент напряжения.
Основная концепция игры схожа с другими играми – пользователь переводит слова, получает за это «звездочки», которые позволяют открывать новые уровни сложности. Для дальнейшей разработки необходимо было провести более глубокую детализацию проекта.
Первым делом решил разделить слова по классическим для игр 3-м уровням сложности: легкий, средний и тяжелый, где в легком – наиболее простые и часто употребляемые в английском языке слова, а в сложном уровне – редко употребляемые слова, либо редкие варианты перевода.
После определения уровня сложности, нужно было понять, что будет представлять собой игровой уровень. Было принято решение, что уровень будет содержать 5 слов, на перевод которых дается ограниченное время. Каждому слову дается 4 варианта перевода. Чтобы усложнить задачу, слова для перевода будут выбраны либо созвучные с русским переводом, либо переводы слов, созвучных с оригинальным английским словом. Всё это сделано для того, чтобы пользователь полностью сосредоточился на приложении и внимательно (и в то же время быстро) выбирал ответы.
Если время, отведенное на уровень, закончилось, либо пользователь ошибся с переводом, уровень должен начинаться заново, при этом пользователю доступна возможность просмотра правильного ответа.
При ответе правильно на все 5 слов, выставляется рейтинг (от 1-й до 3-х звезд, в зависимости от затраченного времени). При наборе определенного количества слов должен открываться новый уровень сложности, в котором будет меньше времени на ответы.
В итоге у нас 3 уровня сложности, в каждом из которых 36 карточек по 5 слов в каждой. Получается, при полном прохождении игры пользователь выучит 540 английских слов различного уровня сложности, если полностью пройдет игру. Довольно неплохо для начала.
#### Нэйминг
Название приложения само пришло на ум – сочетание английских слов “Fun” и “English”, которые описывают всю суть игры – нескучное изучение английских слов.
#### Дизайн
Для начала на обычной бумаге были нарисованы скетчи будущих экранов приложения с указанием последовательности переходов между экранами и комментариями для дизайнера. Получилось всего 10 экранов:
* заставка
* главное меню
* выбор уровня сложности
* выбор игрового уровня
* игра
* окно «победа»
* окно «поражение»
* настройки
* информация
* обучение
Этот материал был передан знакомому [дизайнеру](http://pgraphics.ru/), который принялся за работу. Он разработал логотип, иконку, выбрал основные цвета, шрифты, размеры кнопок и др. Затем представил готовое решение интерфейса, нарисованное в векторе, и нарезку. Подготовил материалы для релиза («превьюшки», рекламные изображения и т.д.).
**Результат работы можете увидеть на скриншотах**
#### Разработка
##### Основные моменты
Минимально поддерживаемой версией Android был выбран API 15 (Android 4.0.3).
Приложению не нужны дополнительные разрешения (Android Permissions), т.к. в приложении нет ни рекламы, ни сбора статистики.
В проекте всего 2 Activity: SplashActivity и GameActivity, в последнем экраны меняются путем изменения различных фрагментов, которых всего 7:
* InfoFragment — информация о разработчике
* MainFragment — главное меню
* PlayFragment — игра
* SelectDifficultFragment — выбор уровня сложности
* SelectLevelFragment — выбор игрового уровня
* SettingsFragment — настройки
* TutorialFragment — обучение
База данных по своей структуре очень проста, поэтому сделана традиционным для Android способом, без использования каких-либо вспомогательных библиотек (greenDao или др.).
**Структура базы данных**
```
public static abstract class BaseTable {
public static final String _ID = BaseColumns._ID;
}
public static class LevelResultTable extends BaseTable {
private static final String TABLE_NAME = "LevelResult";
public static final String DIFFICULT = "difficult";
public static final String LEVEL_NUMBER = "level_number";
public static final String STARS = "stars";
private static final String CREATE_TABLE = "CREATE TABLE " + TABLE_NAME + " (" + _ID + " INTEGER PRIMARY KEY UNIQUE, " +
DIFFICULT + " INTEGER NOT NULL, " +
LEVEL_NUMBER + " INTEGER NOT NULL, " +
STARS + " INTEGER NOT NULL, " +
" UNIQUE (" + DIFFICULT + ", " + LEVEL_NUMBER + ")" +
") ;";
}
public static class WordTable extends BaseTable {
private static final String TABLE_NAME = "Word";
public static final String ORIGINAL = "original";
public static final String DIFFICULT = "difficult";
public static final String LEVEL = "level";
public static final String ANSWER = "answer";
public static final String TRANSLATE1 = "translate1";
public static final String TRANSLATE2 = "translate2";
public static final String TRANSLATE3 = "translate3";
public static final String TRANSLATE4 = "translate4";
public static final String TRANSLATE5 = "translate5";
private static final String CREATE_TABLE = "CREATE TABLE " + TABLE_NAME + " (" + _ID + " INTEGER PRIMARY KEY UNIQUE, " +
DIFFICULT + " INTEGER NOT NULL, " +
LEVEL + " INTEGER NOT NULL, " +
ORIGINAL + " TEXT UNIQUE NOT NULL, " +
ANSWER + " TEXT NOT NULL, " +
TRANSLATE1 + " TEXT NOT NULL, " +
TRANSLATE2 + " TEXT NOT NULL, " +
TRANSLATE3 + " TEXT NOT NULL, " +
TRANSLATE4 + " TEXT NOT NULL, " +
TRANSLATE5 + " TEXT NOT NULL " +
");";
}
```
Можно заметить, что в таблице WordTable присутствует поле answer и поля translate1, translate2, translate3, translate4, translate5, что в сумме дает 6 вариантов ответа, хотя в приложении на экране отображается всего 4. Дополнительные 2 варианта ответа используются для того, чтобы пользователь при повторном прохождении уровня увидел частично другие варианты ответа.
При разработке первой версии ориентировались только на телефоны, поэтому в AndroidManifest была дописана строчка чтобы ограничить список поддерживаемых устройств.
##### Контент
Популярность любого приложения (если не брать в расчет какие-либо утилиты или узконаправленные профессиональные приложения) напрямую зависит от качества его контента.
Как уже упоминал выше, в приложении 3 уровня сложности. Слова для каждого уровня подбирались вручную, причем сложность оценивалась субъективно. Для дополнительного усложнения игры при поиске слов старался использовать созвучные и схожие по написанию или смыслу слова, например, если оригинальное слово «Something», то вариантами перевода будут:
* Что-то
* Где-то
* Куда-то
* Кого-то
* Зачем-то
* Почему-то
##### Блюр
Когда по окончанию уровня появляется окно результата («поражение» или «успех»), задний фон становится «заблюренным». Эффект блюр реализован классическим способом: сохраняем Bitmap игрового Layout’а, обрабатываем его и ставим фоном в окно результата.
Обработка изображения была реализована с помощью кода Mario Klingemann (mario@quasimondo.com), который был найден по [ссылке](http://stackoverflow.com/questions/2067955/fast-bitmap-blur-for-android-sdk). Обработка изображения является очень долгим процессом, поэтому для ускорения обработки изображение предварительно уменьшается. Как это часто бывает, теряя в качестве выигрываем во времени. В данном случае потери качества не критичны.
**Код метода для создания скриншота**
```
public class ScreenShot {
public static Bitmap getScaledScreenshot(View v, float scaleFactor) {
Bitmap b = Bitmap.createBitmap((int) (v.getWidth() / scaleFactor), (int) (v.getHeight() / scaleFactor), Bitmap.Config.RGB_565);
Canvas c = new Canvas(b);
c.scale(1.f / scaleFactor, 1.f / scaleFactor);
v.draw(c);
return b;
}
}
```
**Код класса для уменьшения изображения**
```
public class Resize {
private static Paint sPaint = new Paint(Paint.FILTER_BITMAP_FLAG);
public static Bitmap scale(Bitmap bmp, float scaleFactor, boolean recycleOriginalBmp) {
Bitmap overlay = Bitmap.createBitmap((int) (bmp.getWidth()/scaleFactor),
(int) (bmp.getHeight()/scaleFactor), Bitmap.Config.RGB_565);
Canvas canvas = new Canvas(overlay);
canvas.scale(1 / scaleFactor, 1 / scaleFactor);
Paint paint = new Paint();
paint.setFlags(Paint.FILTER_BITMAP_FLAG);
canvas.drawBitmap(bmp, 0, 0, paint);
if(recycleOriginalBmp) {
bmp.recycle();
bmp = null;
}
return overlay;
}
}
```
##### CustomView
Для повышения производительности и для улучшения отображения некоторых экранов были написано несколько собственных View и ViewGroup, например, кнопка ответа на вопрос.
Текст кнопок со словами должен быть максимально большими, но в то же время количество букв в слове может отличаться от слова к слову. Поэтому был сделан автоматический подгон размера текста, если он превышает некоторую ширину (ширина View за вычетом отступа).
**Код кнопки**
```
public class AnswerButton extends View {
//private final static String TAG = AnswerButton.class.getSimpleName();
public final static int STATE_NORMAL = 0;
public final static int STATE_SUCCESS = 1;
public final static int STATE_FAILED = 2;
public final static int STATE_PRESSED = 3;
private Paint mTextPaint = new Paint(Paint.ANTI_ALIAS_FLAG);
private Paint mBackgroundPaint = new Paint(Paint.ANTI_ALIAS_FLAG);
private static Bitmap sBackgroundBitmap, sPressedBitmap, sSuccessBitmap, sFailedBitmap;
private int mState = STATE_NORMAL;
private int mWidth;
private int mHeight;
private float mTextLeftX, mTextTopY;
private float mLeftRightPadding;
private Rect mBackgroundRect = new Rect(), mTextBounds = new Rect();
private float mTextSize;
private String mText;
public AnswerButton(Context context) {
super(context);
init();
}
public AnswerButton(Context context, AttributeSet attrs) {
super(context, attrs);
init();
}
public AnswerButton(Context context, AttributeSet attrs, int defStyle) {
super(context, attrs, defStyle);
init();
}
private void init() {
if(sBackgroundBitmap == null) {
sBackgroundBitmap = BitmapFactory.decodeResource(getResources(), R.drawable.btn_answer_normal);
}
if(sSuccessBitmap == null) {
sSuccessBitmap = BitmapFactory.decodeResource(getResources(), R.drawable.btn_answer_success);
}
if(sFailedBitmap == null) {
sFailedBitmap = BitmapFactory.decodeResource(getResources(), R.drawable.btn_answer_failed);
}
if(sPressedBitmap == null) {
sPressedBitmap = BitmapFactory.decodeResource(getResources(), R.drawable.btn_answer_pressed);
}
setOnTouchListener(new OnTouchListener() {
@Override
public boolean onTouch(View v, MotionEvent event) {
int action = event.getAction() & MotionEvent.ACTION_MASK;
if(action == MotionEvent.ACTION_DOWN || action == MotionEvent.ACTION_MOVE) {
if(mState == STATE_PRESSED) {
return false;
}
mState = STATE_PRESSED;
invalidate();
} else {
if(mState != STATE_PRESSED) {
return false;
}
mState = STATE_NORMAL;
invalidate();
}
return false;
}
});
mLeftRightPadding = getResources().getDimension(R.dimen.view_answer_button_left_right_padding);
mTextSize = getResources().getDimension(R.dimen.answer_button_text_size);
mTextPaint.setTextSize(mTextSize);
mTextPaint.setColor(getResources().getColor(R.color.answer_button_text_color));
mTextPaint.setTypeface(FontManager.VDS_COMPENSATED_LIGHT);
}
public void setText(String text) {
setState(STATE_NORMAL);
mText = text;
recalculate();
invalidate();
}
public String getText() {
return mText;
}
@Override
protected void onSizeChanged(int w, int h, int oldw, int oldh) {
super.onSizeChanged(w, h, oldw, oldh);
mWidth = w;
mHeight = h;
mBackgroundRect.left = 0;
mBackgroundRect.top = 0;
mBackgroundRect.right = w;
mBackgroundRect.bottom = h;
recalculate();
invalidate();
}
public void setState(int state) {
mState = state;
invalidate();
}
private void recalculate() {
mTextPaint.setTextSize(mTextSize);
mTextPaint.getTextBounds(mText, 0, mText.length(), mTextBounds);
if(mWidth != 0) {
while (mTextBounds.width() >= mWidth - mLeftRightPadding * 2) {
mTextPaint.setTextSize(mTextPaint.getTextSize() - 2);
mTextPaint.getTextBounds(mText, 0, mText.length(), mTextBounds);
}
}
mTextLeftX = (mWidth - mTextBounds.width()) / 2 - mTextBounds.left;
mTextTopY = (mHeight - mTextBounds.height()) / 2 - mTextBounds.top;
}
@Override
protected void onDraw(Canvas canvas) {
super.onDraw(canvas);
if(mState == STATE_NORMAL) {
canvas.drawBitmap(sBackgroundBitmap, null, mBackgroundRect, mBackgroundPaint);
} else if(mState == STATE_PRESSED) {
canvas.drawBitmap(sPressedBitmap, null, mBackgroundRect, mBackgroundPaint);
} else if(mState == STATE_SUCCESS) {
canvas.drawBitmap(sSuccessBitmap, null, mBackgroundRect, mBackgroundPaint);
} else {
canvas.drawBitmap(sFailedBitmap, null, mBackgroundRect, mBackgroundPaint);
}
canvas.drawText(mText, mTextLeftX, mTextTopY, mTextPaint);
}
}
```
##### Анимация
Статический Splash-screen выглядел скучно. Поэтому решили добавить к нему анимацию, а именно вращающийся британский флаг в букве g логотипа. Можно было сделать обычную gif-анимацию, но мы легких путей не ищем, поэтому всё реализовано в коде.
Реализована анимация была достаточно просто: в разметке первым слоем идет изображение британского флага, выравненное по центру относительно контейнера, следующим слоем идет изображение слова funglish, тоже выравненное по центру. При открытии Activity запускается анимация, которая выполняет 2 оборота изображения британского флага. Также был изменен стандартный интерполятор анимации на *AccelerateDecelerateInterpolator*, чтобы вращение нелинейно ускорялось и замедлялось.
Анимация получилась достаточно симпатичной и запоминающейся и понравилась всем опрошенным людям.
##### Tutorial
Большинство статей и книг про разработку и продвижение приложений в один голос твердят, что одним из самых важных моментов является обучение пользователя использованию продукта. Для обучения был создан экран Tutorial, в котором на 3-х страницах пользователю в вкратце рассказываются ключевые моменты игры. Данный экран появляется один раз перед первым началом игры.
**Скриншот**
#### Публикация
Публикация приложения была сделана 7 августа. Думаю, не имеет смысла описывать процесс получения ключа и выкладывания приложения на Play Market.
Приложение доступно для скачивания только в нескольких странах, где можно встретить большое число русскоговорящего населения, это, конечно же, Россия и Беларусь, Болгария, Казахстан и Украина. Как вы уже поняли, в приложении имеется поддержка только русского языка.
#### Тестирование
Когда большая часть игры была сделана, контент был найден, а игра уже готовилась к релизу, было проведено тестирование. Для этого были найдены добровольцы, которые согласились поиграть в альфа-версию игры.
Ожидания оправдались – концепция отгадывания слов на время понравилась пользователям. По их словам, постоянно обновляющийся таймер держит в напряжении, а похожие переводы слов сбивают с толку.
При этом был обнаружен эффект «Flappy Bird», когда пользователь не успевает до окончания таймера ответить на слова или в последний момент отвечает неправильно – он очень злится. Эмоции, хоть в данном случае они негативные, несут положительный эффект. Пользователь не может успокоиться, пока не пройдет уровень, а значит, выучит незнакомое ему слово.
#### Распространение
По некоторым причинам у меня не было возможности вплотную заняться распространением приложения. Единственное, что было сделано в первый день – выкладывание ссылки в соц. сеть ВКонтакте, и рассказ друзьям с просьбой скачать приложение. Первый день принес 17 скачиваний. Затем количество скачиваний упало до 1 в день.
20 августа была создана тема на форуме сайта 4pda.ru, где было выложено описание приложения и ссылка на Play Market. На сегодняшний день эту тему посмотрели более 700 человек. Чуть позже сайт [r-android.ru](http://r-android.ru/soft/fany/791-funglish.html) приятно удивил и написал обзор игры на своем сайте. В эти дни количество скачиваний поднялось до 30.
**Статистика скачиваний**
Надо отметить, что [4pda.ru](http://4pda.ru) принес большую аудиторию пользователей. И, скорее всего, авторы сайта [r-android.ru](http://r-android.ru) именно оттуда узнали про игру и написали на нее обзор.
#### Вывод
Если оглянуться назад, можно понять, что многое было сделано не так или не вовремя. Например, можно было лучше продумать концепцию приложения, чтобы на середине разработки дизайна не переделывать половину работы дизайнера.
Тестирование UX можно и нужно было провести в первую очередь на быстро собранном концепте, чтобы проверить идею. Но это было сделано уже перед самым релизом.
Из-за отсутствия времени, не стал добавлять статистику Flurry, хотя сейчас она дала бы очень много полезной и необходимой информации об использовании приложения.
Также очень хотелось добавить рекламу AdMob, чтобы посмотреть какие доходы он может принести и принесет ли. Но снова не хватило времени.
К релизу тоже не был готовы: не были написаны ни пресс-релизы, ни статьи, ничего. Если бы лучше подошел к этому вопросу, в день выкладывания приложения можно было бы распространить сообщения на тематических форумах, сделать страницу приложения в соц.сетях, разослать статьи на различные сайты. Всё это могло бы в теории принести большое количество скачиваний, что положительно сказалось бы на положении приложения в рейтинге Play Market’а.
Тема изучения английского языка является очень актуальной, поэтому сейчас стою перед выбором: сделать небольшое обновление (обновить контент), сделать концептуальное обновление (добавить новые виды уровней, например аудио-перевод), либо сделать пакет приложений для изучения английского языка (времена, неправильные глаголы и др.).
Говорят, «первый блин – комом». Но думаю, что к Funglish это не относится. Разработка этой игры – бесценный опыт. Игра имеет хорошие рейтинги, люди пишут отзывы, просят добавить некоторые новые возможности. Очень приятно осознавать, что кому-то действительно нравится твое приложение. Это воодушевляет делать новые игры и приложения. | https://habr.com/ru/post/265793/ | null | ru | null |
# Сам себе Microsoft
Мы [уже рассмотрели](https://habrahabr.ru/post/327096/) способ создания встраиваемого скриптового движка на основе CodeDom.Compiler и класса CSharpCodeProvider. Поставим теперь более амбициозную задачу, где не будем полагаться на готовый компилятор. Будем писать свой собственный генератор, который строит MSIL-код «на лету» и исполняет его.
Для начала, попробуем сложить два числа и распечатать результат как бы на C#, но не пользуясь его языковыми конструкциями:
```
using System;
using System.IO;
using System.Reflection;
using System.Reflection.Emit;
namespace ConsoleApplication2
{
class Program
{
static void Main(string[] args)
{
Type[] par = new Type[] { typeof(Int32), typeof(Int32) };
DynamicMethod func = new DynamicMethod("AddTwoValues", typeof(Int32), par, false);
ILGenerator il = func.GetILGenerator();
// это то же самое как: int AddTwoValues(int x, int y) { return x+y; }
il.Emit(OpCodes.Ldarg_0);
il.Emit(OpCodes.Ldarg_1);
il.Emit(OpCodes.Add);
il.Emit(OpCodes.Ret);
Object[] param = new Object[] { 13, 12 }; // готовим параметры 12 и 13
int iRet=(int)func.Invoke(null, param); // выполняем
// выводим что получилось
Console.WriteLine("{0}+{1}={2}", param[0], param[1], iRet);
}
}
}
```
Запускаем на исполнение:
Итак, в простейшем случае мы уже смогли сгенерировать свой собственный MSIL-код для сложения двух чисел. На этом уже вполне можно было бы написать приложение с функциональностью старого калькулятора «Электроника», который с 80-х годов прошлого века пылится у меня в столе.
Теперь добавим в сгенерированный код вызовы функций, например, пусть параметры распечатываются непосредственно в том коде, который создавался нами «на лету»:
```
using System;
using System.IO;
using System.Reflection;
using System.Reflection.Emit;
namespace ConsoleApplication2
{
class Program
{
static void Main(string[] args)
{
Type[] par = new Type[] { typeof(Int32), typeof(Int32) };
DynamicMethod func = new DynamicMethod("AddTwoValues", typeof(Int32), par, false);
ILGenerator il = func.GetILGenerator();
MethodInfo fnWriteLine = typeof(Console).
GetMethod("WriteLine", new Type[] { typeof(Int32) });
il.Emit(OpCodes.Ldarg_0);
il.Emit(OpCodes.Call, fnWriteLine);
il.Emit(OpCodes.Ldarg_1);
il.Emit(OpCodes.Call, fnWriteLine);
il.Emit(OpCodes.Ldarg_0);
il.Emit(OpCodes.Ldarg_1);
il.Emit(OpCodes.Add);
il.Emit(OpCodes.Ret);
Object[] param = new Object[] { 13, 12 }; // готовим параметры 12 и 13
int iRet=(int)func.Invoke(null, param); // выполняем
// выводим что получилось
Console.WriteLine("{0}+{1}={2}", param[0], param[1], iRet);
}
}
}
```
Запускаем на исполнение:
Итак, теперь мы умеем генерировать MSIL-код таким образом, что из него можно вызывать функции. Обратите внимание, что мы генерируем непосредственно MSIL в памяти без всяких промежуточных файлов. И в нашей власти теперь всё, мы можем менять генерацию кода как угодно – например, для нотификации чего-либо вставлять через строчку вызов какого-либо callback-метода или что-то ещё.
Что нас ещё отделяет от написания собственного языка программирования? Да только формальный синтаксис и его парсер! Если мы напишем соответствующий парсер, то ничто нам не сможет помешать создать свой собственный язык программирования, например, с таким синтаксисом:
`ЕСЛИ КЛИЕНТ АКТИВЕН
НАЧАЛО БЛОКА
КУПИТЬ БИЛЕТ НА ПОЕЗД 120 на 31/12/2017 КУПЕЙНЫЙ НИЖНЕЕ
РАСПЕЧАТАТЬ БЛАНК
КОНЕЦ БЛОКА`
О парсере и формальном синтаксисе разговор пойдёт в следующий статье.
*Аркадий Пчелинцев, архитектор проектов* | https://habr.com/ru/post/327580/ | null | ru | null |
# JNI: Подружим Java и C++
### Введение
Бывают моменты, когда в Java некоторые действия выполняются за пределами обычных Java-классов. Например, необходимо исполнить код, написанный на C/C++ или другом каком-нибудь языке.
В данной статье рассмотрим данный вопрос с практической точки зрения, а именно напишем простой пример взаимодействия кода Java с кодом C++, используя JNI. Статья не содержит чего-то сверхестественного, это скорее памятка для тех, кто с этим не работал.
Для наших целей существует возможность динамической загрузки нативных библиотек, вызываемая методом `System.load()`, о чем более подробно можно прочитать [здесь](https://habrahabr.ru/post/118027/).
### Постановка задачи
Пусть нам необходимо реализовать класс, содержащий в себе нативный метод, выводящий на экран “Hello world”.
JNIHelloWorld.java
```
package ru.forwolk.test;
public class JNIHelloWorld {
native void printHelloWorld();
}
```
### Генерация заголовков
Сгенерируем заголовки данного класса для C++.
Сначала создадим папку в корне проекта, где будем собирать бинарники:
```
mkdir bin
```
Затем, скомпилируем наш класс в данную директорию
```
javac -d bin/ src/ru/forwolk/test/JNIHelloWorld.java
```
В папке bin у нас появился class-файл. Вернее, в bin/ru/forwolk/test/. Переидем в папку bin и сгенерируем заголовки.
```
cd bin/
javah ru.forwolk.test.JNIHelloWorld
```
Как видно, в нашей папке bin появился файл ru\_forwolk\_test\_JNIHelloWorld.h. Для простоты переименуем его в JNIHelloWorld.h
```
mv ru_forwolk_test_JNIHelloWorld.h JNIHelloWorld.h
```
Открыв его, видим следующую картину:
```
JNIHelloWorld.h
/* DO NOT EDIT THIS FILE - it is machine generated */
#include
/\* Header for class ru\_forwolk\_test\_JNIHelloWorld \*/
#ifndef \_Included\_ru\_forwolk\_test\_JNIHelloWorld
#define \_Included\_ru\_forwolk\_test\_JNIHelloWorld
#ifdef \_\_cplusplus
extern "C" {
#endif
/\*
\* Class: ru\_forwolk\_test\_JNIHelloWorld
\* Method: printHelloWorld
\* Signature: ()V
\*/
JNIEXPORT void JNICALL Java\_ru\_forwolk\_test\_JNIHelloWorld\_printHelloWorld
(JNIEnv \*, jobject);
#ifdef \_\_cplusplus
}
#endif
#endif
```
### Реализация на C++
Создадим файл с исходниками JNIHelloWorld.cpp. Я для этой цели создал проект в Clion, в который вставил необходимый файл. Реализуем наш метод.
```
JNIHelloWorld.cpp
#include
#include "JNIHelloWorld.h"
JNIEXPORT void JNICALL Java\_ru\_forwolk\_test\_JNIHelloWorld\_printHelloWorld
(JNIEnv \*, jobject) {
std::cout << "Hello world!";
}
```
Чтобы в Clion все работало корректно, необходимо в файл CMakeLists.txt добавить библиотеки Java:
```
// Вместо $JAVA_HOME -- путь до Java
include_directories($JAVA_HOME/include)
include_directories($JAVA_HOME/include/linux)
link_directories($JAVA_HOME/include)
link_directories($JAVA_HOME/include/linux)
```
Далее компилируем
```
g++ -I"$JAVA_HOME/include" -I"$JAVA_HOME/include/linux" -fPIC JNIHelloWorld.cpp -shared -o helloworld.so -Wl,-soname -Wl,--no-whole-archive
```
### Загрузка в Java
В корневой папке проекта появился файл helloworld.so. Переместим его в папку bin/ проекта Java.
Теперь необходимо загрузить нашу библиотеку. Хорошей практикой будет статическая загрузка библиотеки прямо в классе. Добавим загрузку прямо в класс JNIHelloWorld
```
static {
// $PROJECT_ROOT -- абсолютный путь до библиотеки
System.load("$PROJECT_ROOT/bin/helloworld.so");
}
```
Теперь мы можем полноценно использовать данный класс. Давайте проверим.
```
public static void main(String[] args) {
JNIHelloWorld p = new JNIHelloWorld();
p.printHelloWorld();
}
```
На выходе получаем
```
Hello world!
Process finished with exit source 0
```
### Передача параметров
А что делать, если нам надо не только выполнять какой-то код, а также передавать параметры и получать ответ? Рассмотрим еще один метод, выполняющий умножение двух чисел. Добавим в класс JNIHelloWorld метод
```
native int multiply(int a, int b);
```
Выполняем те же самые действия, описанные выше по генерации заголовков. Как видим, сгенерировалось следующее
```
/*
* Class: ru_forwolk_test_JNIHelloWorld
* Method: multiply
* Signature: (II)I
*/
JNIEXPORT jint JNICALL Java_ru_forwolk_test_JNIHelloWorld_multiply
(JNIEnv *, jobject, jint, jint);
```
Реализуем метод в JNIHelloWorld.cpp
```
JNIEXPORT jint JNICALL Java_ru_forwolk_test_JNIHelloWorld_multiply
(JNIEnv *, jobject, jint a, jint b) {
return a * b;
}
```
Опять же произведем описанные выше действия по подтягиванию библиотеки, добавим строку в main по выводу результата произведения двух чисел и запустим
```
public static void main(String[] args) {
JNIHelloWorld p = new JNIHelloWorld();
System.out.println(p.multiply(2, 2));
p.printHelloWorld();
}
```
Что получаем в консоли
```
4
Hello world!
Process finished with exit source 0
```
### Заключение
Мы с вами рассмотрели возможность Java использовать код, написанный на C/C++. Это можно применять в различных целях, например, для увеличения скорости исполнения кода, для защиты кода от прямого вмешательства и для прочих целей. Очень надеюсь, что данная статья поможет вам разобраться в основах JNI.
Весь код я выложил в [открытый доступ](https://bitbucket.org/Forwolk/jnihelloworld). В директории cpp разместил класс C++ без лишних файлов проекта Clion.
### Дополнительная литература
Также для большего кругозора по данной теме рекомендую обратить внимание на следующие статьи:
[JNI, загрузка нативных библиотек. Меняем java.library.path на лету](https://habrahabr.ru/post/118027/)
[Дорог ли native метод? «Секретное» расширение JNI](https://habrahabr.ru/post/222997/) | https://habr.com/ru/post/353294/ | null | ru | null |
# Perl & MS Excel
Возникла необходимость создания красивых отчетов в MS Excel? Так сделаем это с помощью языка perl! :)
Итак, приступим:
`use OLE; *// используем модуль Win32::OLE*
my $excel = CreateObject OLE 'Excel.Application' or die $!; *// открываем Excel*
$excel->{'Visible'} = 1; *// советую Excel делать видимым, чтобы он не висел мертвым грузом в фоне, если вдруг случится косяк*
my $workbook = $excel -> Workbooks -> Add(); *// создаем новый документ*
$workbook -> ActiveSheet -> Range("A1")-> {'Value'} = sprintf("Тест"); *// заносим в ячейку A1 значение «Тест»*
$workbook -> ActiveSheet -> Columns -> AutoFit; *// очень полезная вещь – выравнивание ширины всех столбцов по содержимому*
$workbook -> SaveAs("$file"); *// сохраняем документ*
$workbook -> ActiveSheet -> PrintOut; *// если надо - распечатываем*
$excel -> Quit; *// закрываем Excel*`
Вуаля!
Ну и некоторые полезняшки напоследок:
`$workbook -> ActiveSheet -> Range("A1")-> Font -> {FontStyle} = 'Bold'; *// устанавливаем жирный шрифт в ячейке*
$workbook -> ActiveSheet -> Range("A1")-> {HorizontalAlignment} = 3; *// равнение в ячейке – по центру*
$workbook -> ActiveSheet -> Range("A1")-> Borders -> {LineStyle} = 1; *// рисуем границы ячейки*
$workbook -> ActiveSheet -> Range("A1")-> Interior -> {ColorIndex} = 15; *// делаем серую заливку ячейки*
$workbook -> ActiveSheet -> Range("A1")-> EntireRow -> Delete; *// удаляем строку с данной ячейкой*
$workbook -> ActiveSheet -> Range("A1:A10") -> Merge; *// объединяем ячейки*` | https://habr.com/ru/post/57294/ | null | ru | null |
# Синглтон и время жизни объекта
Эта статья является продолжением моей первой статьи [“Использование паттерна синглтон” [0]](http://habrahabr.ru/blogs/cpp/116577/). Сначала я хотел все, что связано со временем жизни, изложить в этой статье, но объем материала оказался велик, поэтому решил разбить ее на несколько частей. Это — продолжение целого цикла статей про использование различных шаблонов и методик. Данная статья посвящена времени жизни и развитию использования синглтона. Перед прочтением второй статьи настоятельно рекомендуется ознакомиться с [моей первой статьей [0]](http://habrahabr.ru/blogs/cpp/116577/).
В предыдущей статье была использована следующая реализация для синглтона:
```
template
T& single()
{
static T t;
return t;
}
```
Функция single возвращала нам заветный синглтон. Однако данный подход имеет изъян: в этом случае мы не контролируем время жизни объекта и он может удалиться в тот момент, когда мы хотим этим объектом воспользоваться. Поэтому следует использовать другой механизм создания объекта, используя оператор new.
Так уж получилось, что в языке C++ отсутствует сборщик мусора, поэтому необходимо следить за созданием и уничтожением объекта. И хотя эта проблема уже давно известна и даже понятны методы как ее решать, подобного рода ошибки не редкий гость в наших программах. В целом можно выделить следующие виды ошибок, которые делают программисты:
1. Использование памяти при не созданном объекте.
2. Использование памяти уже удаленного объекта.
3. Неосвобождение памяти, занимаемой объектом.
Как следствие таких ошибок программа либо начинать «течь», либо начинает вести себя непредсказуемо, либо просто «падает». Можно, конечно, поговорить о том, что хуже, но ясно одно: подобные ошибки являются достаточно серьезными.
На примере синглтона можно с легкостью показать, как делаются такие ошибки. Открываем статью в [Википедии [1]](http://ru.wikipedia.org/wiki/%D0%9E%D0%B4%D0%B8%D0%BD%D0%BE%D1%87%D0%BA%D0%B0_(%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)) и находим реализацию для C++:
```
class OnlyOne
{
public:
static OnlyOne* Instance()
{
if(theSingleInstance==0)
theSingleInstance=new OnlyOne;
return theSingleInstance;
}
private:
static OnlyOne* theSingleInstance;
OnlyOne(){};
};
OnlyOne* OnlyOne::theSingleInstance=0;
```
Видно, что для синглтона память выделяется, однако по какой-то причине не освобождается. Можно, конечно, сказать, что для синглтона это не является серьезной проблемой, так как его время жизни совпадает с временем работы программы. Однако тут есть ряд но:
1. Программы по поиску утечек памяти будут все время показывать эти утечки для синглтонов.
2. Синглтоном может быть достаточно сложный объект, обслуживающий открытый конфигурационный файл, связь с базой данных и проч. Неправильное уничтожение таких объектов может вызывать проблемы.
3. Все начинается с малого: сначала не следим за памятью для синглтонов, а потом и для остальных объектов.
4. И главные вопрос: зачем делать неправильно, если можно сделать правильно?
Можно, конечно, сказать, что данные аргументы несущественны. Однако давайте все-таки сделаем так, как надо. Я всегда использую следующий принцип для работы с объектами: **созданный объект должен быть уничтожен**. И не важно, синглтон это или нет, это общее правило без исключений, которое задает определенное качество программы.
Анализируя исходный код различных программных продуктов я для себя выделил еще 2 важных правила:
1. Не использовать new.
2. Не использовать delete.
Тут стоит немного пояснить, что я имею в виду. Понятно, что где-то все равно будет вызываться new и delete. Речь про то, что это должно находиться строго в одном месте, лучше в одном классе, чтобы это не распылять по программе. Тогда, при правильной организации такого класса, не надо будет следить за временем жизни объектов. И я сразу скажу, что это возможно! Стоит сразу оговориться, что такой подход мне нигде не встречался. Так что будем своего рода первооткрывателями.
#### Умные указатели
К счастью, в C++ есть замечательное средство, которое называется «умный указатель». Их умность заключается в том, что, хотя они и ведут себя как обычные указатели, при этом контролируют время жизни объектов. Для этого они используют счетчик, который самостоятельно подсчитывает количество ссылок на объект. При достижении счетчиком нуля объект автоматически уничтожается. Будем использовать умный указатель из стандартной библиотеки std::shared\_ptr заголовочного файла memory. Стоит отметить, что такой класс доступен для современных компиляторов, которые поддерживают стандарт C++0x. Для тех, кто использует старый компилятор, можно использовать boost::shared\_ptr. Интерфейсы у них абсолютно идентичны.
Возложим на наш класс An следующие обязанности:
1. Контроль времени жизни объектов, используя умные указатели.
2. Создание экземпляров, в том числе и производных классов, не используя операторов new в вызывающем коде.
Этим условиям удовлетворяет следующая реализация:
```
template
struct An
{
template
friend struct An;
An() {}
template
An(const An& a) : data(a.data) {}
template
An(An&& a) : data(std::move(a.data)) {}
T\* operator->() { return get0(); }
const T\* operator->() const { return get0(); }
bool isEmpty() const { return !data; }
void clear() { data.reset(); }
void init() { if (!data) reinit(); }
void reinit() { anFill(\*this); }
T& create() { return create(); }
template
U& create() { U\* u = new U; data.reset(u); return \*u; }
template
void produce(U&& u) { anProduce(\*this, u); }
template
void copy(const An& a) { data.reset(new U(\*a.data)); }
private:
T\* get0() const
{
const\_cast(this)->init();
return data.get();
}
std::shared\_ptr data;
};
```
Стоит остановиться поподробнее на предложенной реализации:
1. Конструктор использует [move-семантику [6]](http://en.wikipedia.org/wiki/C%2B%2B0x#Rvalue_reference_and_move_semantics) из C++0x стандарта для увеличения быстродействия при копировании.
2. Метод **create** создает объект нужного класса, по умолчанию создается объект класса T.
3. Метод **produce** создает объект в зависимости от принимаемого значения. Назначение этого метода будет описано позднее.
4. Метод **copy** производит глубокое копирование класса. Стоит отметить, что для копирования в качестве параметра необходимо указывать тип реального экземпляра класса, базовый тип не подходит.
При этом синглтон перепишется в следующем виде:
```
template
struct AnAutoCreate : An
{
AnAutoCreate() { create(); }
};
template
T& single()
{
static T t;
return t;
}
template
An anSingle()
{
return single>();
}
```
Вспомогательные макросы будут такими:
```
#define PROTO_IFACE(D_iface, D_an) \
template<> void anFill(An& D\_an)
#define DECLARE\_IMPL(D\_iface) \
PROTO\_IFACE(D\_iface, a);
#define BIND\_TO\_IMPL(D\_iface, D\_impl) \
PROTO\_IFACE(D\_iface, a) { a.create(); }
#define BIND\_TO\_SELF(D\_impl) \
BIND\_TO\_IMPL(D\_impl, D\_impl)
#define BIND\_TO\_IMPL\_SINGLE(D\_iface, D\_impl) \
PROTO\_IFACE(D\_iface, a) { a = anSingle(); }
#define BIND\_TO\_SELF\_SINGLE(D\_impl) \
BIND\_TO\_IMPL\_SINGLE(D\_impl, D\_impl)
#define BIND\_TO\_IFACE(D\_iface, D\_ifaceFrom) \
PROTO\_IFACE(D\_iface, a) { anFill(a); }
#define BIND\_TO\_PROTOTYPE(D\_iface, D\_prototype) \
PROTO\_IFACE(D\_iface, a) { a.copy(anSingle()); }
```
Небольшим изменениям подвергся макрос BIND\_TO\_IMPL\_SINGLE, который теперь использует вместо функции single функцию anSingle, которая, в свою очередь, возвращает уже заполненный экземпляр An. О других макросах я расскажу позже.
#### Использование синглтона
Теперь рассмотрим использование описанного класса для реализации синглтона:
```
// header file
struct X
{
X() { x = 1; }
int x;
};
// декларация заливки реализации
DECLARE_IMPL(X)
// cpp file
struct Y : X
{
Y() { x = 2; }
int y;
};
// связывание декларации X и реализации Y используя синглтон
BIND_TO_IMPL_SINGLE(X, Y)
```
Теперь это можно использовать следующим образом:
```
An x;
std::cout << x->x << std::endl;
```
Что на экране даст цифру 2, т.к. для реализации использовался класс Y.
#### Контроль времени жизни
Рассмотрим теперь пример, который показывает важность использования умных указателей для синглтонов. Для этого разберем следующий код:
```
struct A
{
A() { std::cout << "A" << std::endl; a = 1; }
~A() { std::cout << "~A" << std::endl; a = -1; }
int a;
};
struct B
{
B() { std::cout << "B" << std::endl; }
~B() { std::cout << "~B" << std::endl; out(); }
void out() { std::cout << single().a << std::endl; }
};
```
Теперь посмотрим, что выведется на экран при таком вызове функции out:
```
single**().out();
// вывод на экран
B
A
1
~A
~B
-1**
```
Разберемся, что здесь происходит. В самом начале мы говорим, что хотим реализацию класса B, взятую из синглтона, поэтому создается класс B. Затем вызываем фукнцию out, которая берет реализацию класса A из синглтона и берет значение a. Величина a задается в конструкторе A, поэтому на экране появится цифра 1. Теперь программа заканчивает свою работу. Объекты начинают уничтожатся в обратной последовательности, т.е. сначала разрушается класс A, созданный последним, а потом разрушается класс B. При разрушении класса B мы снова зовем фукнцию out из синлтона, но т.к. объект A уже разрушен, то на экране мы видим надпись -1. Вообще говоря, программа могла и рухнуть, т.к. мы используем память уже разрушенного объекта. Таким образом, данная реализация показывает, что без контроля времени жизни программа может благополучно упасть при завершении.
Давайте теперь посмотрим, как можно сделать то же самое, но с контролем времени жизни объектов. Для этого будем использовать наш класс An:
```
struct A
{
A() { std::cout << "A" << std::endl; a = 1; }
~A() { std::cout << "~A" << std::endl; a = -1; }
int a;
};
// связывание декларации A с собственной реализацией используя синглтон
BIND_TO_SELF_SINGLE(A)
struct B
{
Ana;
B() { std::cout << "B" << std::endl; }
~B() { std::cout << "~B" << std::endl; out(); }
void out() { std::cout << a->a << std::endl; }
};
// связывание декларации B с собственной реализацией используя синглтон
BIND\_TO\_SELF\_SINGLE(B)
// код
An **b;
b->out();**
```
Данный код практически ничем не отличается от предыдущего, за исключением следующих важных деталей:
1. Объекты A и B используют класс An для синглтонов.
2. Класс B явно декларирует зависимость от класса A, используя соответствующий публичный член класса (подробнее об этом подходе можно узнать из предыдущей статьи).
Посмотрим, что теперь выведется на экран:
```
B
A
1
~B
1
~A
```
Как видно, теперь мы продлили время жизни класса A и изменили последовательность уничтожения объектов. Отсутствие значения -1 говорит о том, что объект существовал во время доступа к его данным.
#### Итого
На этом первая часть статьи, посвященная времени жизни объектов, подошла к концу. В следующей части (или частях) будут разобраны остальные порождающие шаблоны проектирования с использованием разработанного функционала и сделаны общие выводы.
#### P.S.
Многие спрашивают, а в чем, собственно, смысл? Почему нельзя просто сделать синглтон? Зачем использовать какие-то дополнительные конструкции, которые ясности не добавляют, а лишь усложняют код. В принципе, при внимательном прочтении [первой статьи [0]](http://habrahabr.ru/blogs/cpp/116577/) уже можно понять, что данный подход более гибок и устраняет ряд существенных недостатков синглтона. В следующей статье будет отчетливо понятно, зачем я это так расписывал, т.к. в ней речь уже будет идти не только о синглтоне. А через статью будет вообще понятно, что синглтон тут абсолютно не при чем. Все, что я пытаюсь показать — это использование [Dependency inversion principle [4]](http://en.wikipedia.org/wiki/Dependency_inversion_principle) (см. также [The Principles of OOD [5]](http://butunclebob.com/ArticleS.UncleBob.PrinciplesOfOod)). Собственно, именно после того, как я увидел впервые этот подход на Java, мне стало обидно, что в C++ это слабо используют (в принципе, есть фреймворки, которые предоставляют подобный функционал, но хотелось бы чего-то более легковесного и практичного). Приведенная реализация — это лишь маленький шажок в этом направлении, который уже приносит огромную пользу.
Также хотелось бы отметить еще несколько вещей, отличающих приведенную реализацию от классического синглтона (вообще говоря, это следствия, но они важны):
1. Класс, описывающий синглтон, можно использовать в нескольких экземплярах без каких-либо ограничений.
2. Синглтон заливается неявно посредством функции anFill, которая контролирует количество экземпляров объекта, при этом можно использовать конкретную реализацию вместо синглтона при необходимости (показано в [первой статье [0]](http://habrahabr.ru/blogs/cpp/116577/)).
3. Есть четкое разделение: интерфейс класса, реализация, связь между интерфейсом и реализацией. Каждый решает только свою задачу.
4. Явное описание зависимостей от синглтонов, включение этой зависимости в контракт класса.
#### Update
Почитав комментарии я понял, что есть некоторые моменты, которые стоит прояснить, т.к. многие не знакомы с принципом обращения зависимостей (dependency inversion principle, DIP или inversion of control, IoC). Рассмотрим следующий пример: у нас есть база данных, в которой содержится необходимая нам информация, например список пользователей:
```
struct IDatabase
{
virtual ~IDatabase() {}
virtual void beginTransaction() = 0;
virtual void commit() = 0;
...
};
```
У нас есть класс, который выдает нужную нам информацию, в том числе и необходимого пользователя:
```
struct UserManager
{
An aDatabase;
User getUser(int userId)
{
aDatabase->beginTransaction();
...
}
};
```
Здесь мы создаем член aDatabase, который говорит о том, что ему необходима некая база данных. Ему не важно знать, что это будет за база данных, ему не нужно знать, кто и когда это будет заполнять/заливать. Но класс UserManager знает, что ему туда зальют то, что нужно. Все, что он говорит, это: «дайте мне нужную реализацию, я не знаю какую, и я сделаю все, что вам нужно от этой базы данных, например, предоставлю необходимую информацию о пользователе из этой базы данных».
Теперь мы делаем хитрый трюк. Так как у нас есть одна лишь база данных, которая содержит всю нашу информацию, то мы говорим: ок, раз есть только одна база данных, давайте сделаем синглтон, и чтобы не париться каждый раз в заливке реализации, сделаем так, чтобы синглтон сам заливался:
```
struct MyDatabase : IDatabase
{
virtual void beginTransaction();
...
};
BIND_TO_IMPL_SINGLE(IDatabase, MyDatabase)
```
Т.е. мы создаем реализацию MyDatabase и говорим, что для синглтона будем использовать именно ее, используя макрос BIND\_TO\_IMPL\_SINGLE. Тогда следующий код автоматически будет использовать MyDatabase:
```
UserManager manager;
User user = manager.getUser(userId);
```
С течением времени оказалось, что у нас есть еще одна база данных, в которой тоже есть пользователи, но, скажем, для другой организации:
```
struct AnotherDatabase : IDatabase
{
...
};
```
Мы конечно же хотим использовать наш UserManager, но уже с другой базой данных. Нет проблем:
```
UserManager manager;
manager.aDatabase = anSingle();
User user = manager.getUser(userId);
```
И как по волшебству, теперь мы берем пользователя из другой базы данных! Это достаточно грубый пример, но он отчетливо показывает принцип обращения зависимостей: это когда объекту UserManager заливают реализацию IDatabase вместо традиционного подхода, когда UserManager сам ищет себе необходимую реализацию. В рассмотренной статье используется этот принцип, при этом синглтон для реализации берется как **частный случай**.
#### Литература
[0] [Использование паттерна синглтон](http://habrahabr.ru/blogs/cpp/116577/)
[1] [Википедия: синглтон](http://ru.wikipedia.org/wiki/%D0%9E%D0%B4%D0%B8%D0%BD%D0%BE%D1%87%D0%BA%D0%B0_(%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))
[2] [Inside C++: синглтон](http://insidecpp.ru/patterns/singleton)
[3] [Порождающие шаблоны: Одиночка (Singleton)](http://andrey.moveax.ru/post/patterns-oop-creational-singleton.aspx)
[4] [Dependency inversion principle](http://en.wikipedia.org/wiki/Dependency_inversion_principle)
[5] [The Principles of OOD](http://butunclebob.com/ArticleS.UncleBob.PrinciplesOfOod)
[6] [Wikipedia: Rvalue reference and move semantics](http://en.wikipedia.org/wiki/C%2B%2B0x#Rvalue_reference_and_move_semantics) | https://habr.com/ru/post/118368/ | null | ru | null |
# Асинхронные функции 101
Одним из основных преимуществ JavaScript является то, что всё асинхронно. По большей части различные части вашего кода не влияют на выполнение других.
```
doALongThing(() => console.log("I will be logged second!"));
console.log("I will be logged first!");
```
К сожалению, это также один из основных недостатков JavaScript. Задача выполнения синхронного кода становится сложнее, так как по умолчанию всё асинхронно.
Первым решением проблемы были колбэки. Если часть нашего кода зависит от какого-то результата, мы должны были вложить наш код —
```
doSomething((response) => {
doSomethingElse(response,(secondResponse) => {
doAThirdThing(secondResponse);
});
})
```
Вложенные колбэки в колбэках, как мы знаем, становятся непригодными. Таким образом, были созданы промисы (Promise). Они позволили нам работать с синхронными кодом более чистым и плоским способом.
```
doSomething()
.then((response) => doSomethingElse(response));
.then((secondResponse) => doAThirdThing(secondResponse));
// Even cleaner
doSomething().then(doSomethingElse).then(doAThirdThing);
```
Как и всё, промисы тоже не идеальны. Таким образом, в рамках спецификации ES2017 был определен другой метод для работы с синхронным кодом: Асинхронные функции. Это позволяет нам писать асинхронный код, как если бы он был синхронным.
Создание асинхронной функции
----------------------------
Асинхронная функция определяется выражением асинхронной функции. Базовая функция выглядит так:
```
async function foo() {
const value = await somePromise();
return value;
}
```
Мы определяем функцию как асинхронную с помощью `async`. Это ключевое слово может использоваться с любым синтаксисом объявления функции —
```
// Basic function
async function foo() { … }
// Arrow function
const foo = async () => { … }
// Class methods
class Bar {
async foo() { … }
}
```
Как только мы определили функцию как асинхронную, мы можем использовать ключевое слово `await`.
Это ключевое слово помещается перед вызовом промиса, оно приостанавливает выполнение функции до тех пор, пока промис не будет выполнен или отклонён.
Обработка ошибок
----------------
Обработка ошибок в асинхронных функциях выполняется с помощью блоков `try` и `catch`.
Первый блок (try) позволяет нам попробовать совершить действие. Второй блок (catch), вызывается, если действие не выполняется. Он принимает один параметр, содержащий любую ошибку.
```
async function foo() {
try {
const value = await somePromise();
return value;
}
catch (err) {
console.log("Oops, there was an error :(");
}
}
```
Использование Асинхронных функций
---------------------------------
Асинхронные функции не являются заменой промисов. Они идентичны по своей природе. Так, асинхронная функция ожидает исполнения обещания и всегда возвращает промис.
Промис, возвращаемый асинхронной функцией, будет разрешен с любым значением, возвращаемым функцией.
```
async function foo() {
await somePromise();
return ‘success!’
}
foo().then((res) => console.log(res)) // ‘success!’
```
Если будет выброшена ошибка, промис будет отклонён с этой ошибкой.
```
async function foo() {
await somePromise();
throw Error(‘oops!’)
}
foo()
.then((res) => console.log(res))
.catch((err) => console.log(err)) // ‘oops!’
```
Выполнение Асинхронных функций в параллельно
--------------------------------------------
С промисами мы можем выполнять несколько обещаний параллельно с помощью метода `Promise.all ().`
```
function pause500ms() {
return new Promise((res) => setTimeout(res, 500));
}
const promise1 = pause500ms();
const promise2 = pause500ms();
Promise.all([promise1, promise2]).then(() => {
console.log("I will be logged after 500ms");
});
```
С асинхронными функциями нам нужно немного поработать, чтобы получить такой же эффект. Если мы просто перечислим каждую функцию, ожидающую в очереди, они будут выполняться последовательно, так как `await` приостанавливает выполнение оставшейся части функции.
```
async function inSequence() {
await pause500ms();
await pause500ms();
console.log("I will be logged after 1000ms");
}
```
Это займет 1000 мс, так как второе ожидание не запустится, пока не завершится первое. Чтобы обойти это, мы должны ссылаться на функции таким образом:
```
async function inParallel() {
const await1 = await pause500ms();
const await2 = await pause500ms();
await await1;
await await2;
console.log("I will be logged after 500ms");
}
```
Теперь это займет всего 500 мс, потому что обе функции `pause500ms ()` выполняются одновременно.
### Промисы или Асинхронные функции?
Как я уже упоминала, асинхронные функции не заменяют промисов. Они идентичны по своей природе. Асинхронные функции предоставляют альтернативный, а в некоторых случаях и лучший способ работы с основанными на промисах функциями. Но они всё ещё используют и производят промисы.
Поскольку возвращается промис, асинхронная функция может быть вызвана другой асинхронной функцией или промисом. Мы можем смешивать и сочетать в зависимости от того, какой синтаксис лучше всего подходит для каждого случая.
```
function baz() {
return new Promise((res) => setTimeout(res, 1000));
}
async function foo() {
await baz();
return 'foo complete!';
}
async function bar() {
const value = await foo();
console.log(value);
return 'bar complete!';
}
bar().then((value) => console.log(value));
```
Происходит следующее:
* ждём 1000мс
* лог «foo complete!»
* лог «bar complete!»
Поддержка
---------
На момент написания статьи, асинхронные функции и промисы доступны в текущих версиях всех основных браузеров, за исключением Internet Explorer и Opera Mini.
 | https://habr.com/ru/post/326442/ | null | ru | null |
# VoiceOver на iOS: каждый контрол ведёт себя по-разному
Привет, Хабр! Недавно я говорил про адаптацию приложений для незрячих и неподвижных людей. И не договорил!
Сегодня расскажу, как изменить поведение контролов с помощью `accessibilityTraits` и сделать жизнь незрячих чуть удобней. Знать работу этих трейтов (traits) важно, чтобы не писать свои костыли.
> Адаптация iOS-приложения — большая тема, в одну статью всё не влезло, поэтому выпускаю их серией.
>
>
>
> 1. **Voice Control и VoiceOver: как адаптировать приложение для незрячих или неподвижных**.
> 2. [VoiceOver на iOS: каждый контрол ведёт себя по-разному.](https://habr.com/ru/company/dodopizzadev/blog/488246/)
> 3. [VoiceOver на iOS: решение типовых проблем.](https://habr.com/ru/company/dodopizzadev/blog/491810/)
> 4. Разница между реализацией VoiceOver, Voice Control и UI тестов. (In progress)
>
[В первой части](https://habr.com/ru/company/dodopizzadev/blog/481200/) мы начали разбираться с адаптацией приложений для незрячих с помощью VoiceOver: подписали контролы, сгруппировали их, исправили навигацию. В этой статье пойдём дальше и рассмотрим «особенности», которые можно дать контролам, чтобы улучшить их работу для незрячих людей и в целом повысить удобство использования приложения.
Особенности элементов управления — Trait collection
---------------------------------------------------
VoiceOver имеет стандартный набор «особенностей» `UITraitCollection`, которые вы можете применять к контролам. Важно знать о них заранее, чтобы не придумывать своих решений. Я поделил их на три типа:
1. [Тип контрола.](#Q0)
2. [Состояние контрола.](#Q1)
3. [Особые свойства контролов.](#Q2)
Сразу буду показывать на примере экрана с карточкой пиццы:
#### Тип контрола
VoiceOver знает про несколько базовых типов элементов. Часть из них уже настроена в вашем проекте, но всё равно расскажу про них.
Типы контролов используются для навигации: по ним можно быстро перемещаться [с помощью ротора](https://support.apple.com/ru-ru/HT204783).
* `.staticText`— для надписей, которые не меняются. Текст просто прочитается.
* `.header` — заголовок: *Добавить в пиццу, заголовок.*
* `.button` — кнопка. Основной способ подписывать активные контролы: *Изменить состав, кнопка.*
* `.image` — картинка.
* `.link` — ссылка. Редкий гость в приложениях, частый на сайтах.
* `.searchField` — поиск.
Смотрим на примере:
1. Указываем заголовок. `.staticText` ставится автоматически для всех надписей, а вот `.header` для заголовка нужно поставить вручную. При этом нужен и `.header` и `.staticText`.
2. Отмечаем место под картинку. В прошлый раз все маленькие картинки мы скрыли от VoiceOver, информативность не потеряли. В этот раз картинка большая, ее так просто не скрыть: место станет пустым, это странно. Помечаем картинку как `.image` и подписываем `.accessibilityLabel = "Пицца Пепперони Фреш с перцем"`.
Конечно, кнопки закрытия и корзины надо подписать, об этом было [в прошлой статье.](https://habr.com/ru/company/dodopizzadev/blog/481200/)
#### Состояние контрола
У контрола может быть три состояния: обычный, выбранный и отключенный. Интересно, что произносятся они в разное время и могут быть выбраны одновременно:
* `.selected` — добавляет «выбрано» перед названием контрола. Подходит для всех свитчеров и чекбоксов.
* `.notEnabled` — добавляет «недоступно». Эта настройка не видна в `Interface Builder` и управляется только программно.
Пример с добавлением топпингов в пиццу:
С помощью состояний можно объяснить пользователю, что топпинг добавлен. Удобно поправить прямо внутри ячейки. `accessibilityTraits` это `OptionSet`, поэтому к нему можно применять методы вставки `.formUnion` и удаления `.formIntersection`:
```
class ToppingCell: UICollectionViewCell {
override var isSelected: Bool {
didSet {
if isSelected {
accessibilityTraits.formUnion(.selected)
} else {
accessibilityTraits.formIntersection(.selected)
}
}
}
...
}
```
#### Особые свойства контролов
Есть ещё несколько необычных свойств. В нашем случае к экрану с пиццей они не подходят, но я всё равно расскажу про них, потому что информации о них мало. Возможно, это сэкономит вам время.
* `.summaryElement` — первое, что скажет приложение после запуска. Например, приложение погоды после запуска может сразу рассказать о температуре, а музыкальный плеер расскажет о включенной песне и исполнителе. В нашем случае можно говорить статус доставки, если заказа уже оформлен.
* `.updatesFrequently` — штука для таймеров. Новое значение будет проговариваться раз в несколько секунд.
* `.causesPageTurn` — скролит после прочтения. Вызовется `accessibilityScroll(.next)` у того контрола, который сможет это обработать. Смотрит по `.firstResponder`.
* `.startsMediaSession` — обычно VoiceOver повторяет название нажатой кнопки, чтобы подтвердить действие. Это мешает, если контрол проигрывает звук. Включите этот трейт, чтобы VoiceOver не повторял название контрола.
* `.playsSound` — стоит включить, если вы проигрываете собственный звук при фокусировании на контроле (если я всё правильно понял, сам ни разу не использовал).
* `.allowsDirectInteraction` — для рисования и обработки жестов. Контрол сразу обрабатывает касание, будто VoiceOver выключен.
* `.keyboardKey` — контрол начинает реагировать, как кнопка на клавиатуре. У VoiceOver есть несколько режимов ввода текста для таких случаев:
— `standart typing` — как простая кнопка в VoiceOver: сначала наведите фокус на букву, а затем нажмите дважды в любом месте, чтобы написать её. Набирать можно быстрее двумя руками: одним пальцем водить по клавиатуре (буквы будут озвучиваться) и касаться другим пальцем, чтобы подтвердить выбор клавиши.
— `touch typing` — однорукий ускоренный набор: водите пальцем по клавиатуре, чтобы озвучить кнопки. Отпустите палец, чтобы написать букву.
— `direct touch typing` — как обычный набор, будто VoiceOver выключен.
Видео про разные способы ввода:
Достаточно поставить галочку в IB, чтобы добавить поведение. С трейтом .adjustable так просто не получится, о нём отдельно.
Настраиваем могучий трейт .adjustable
-------------------------------------
И последний, особенно важный трейт `.adjustable` — элемент, который можно регулировать: так работают `UIStepper` и `UISlider`. Свайпните такой контрол *вверх* или *вниз*, чтобы изменить значение (не забывайте, что свайп *влево/вправо* переключит фокус на соседний элемент). Если у контрола есть UIPanGestureRecognizer, то можно тапнуть дважды и задержать второй тап, так жест сработает и можно управлять им напрямую, будто VoiceOver выключен.
Примеры применений для `.adjustable`:
**Переключатель теста.** Настройка теста состоит из пяти кнопок: три для выбора размера пиццы и две для типа теста. Их стоит сгруппировать и подписать, чтобы вместо пяти осталось две: *«Размер, средний. Элемент регулировки»* и *«Тесто, традиционное. Элемент регулировки».*
Нужно сделать в 4 шага:
1. Сделать контейнер с кнопками доступным.
2. Поставить трейт `.adjustable`.
3. Реализовать методы увеличения и уменьшения.
4. Возвращать новое значение для `.accessibilityValue`.
```
override public func awakeFromNib() {
super.awakeFromNib()
isAccessibilityElement = true // 1
accessibilityTraits = .adjustable // 2
}
```
```
extension SegmentedControl {
override public func accessibilityIncrement() { // 3
controller.selectNext(increment: +1)
}
override public func accessibilityDecrement() { // 3
controller.selectNext(increment: -1)
}
public override var accessibilityValue: String? { // 4
get {
return selectedSegment?.accessibilityValue
} set { }
}
}
```
Теперь после свайпа вверх вызовется `accessibilityIncrement()`, вы увеличите внутренний счётчик, и VoiceOver прочитает новое значение из `accessibilityValue.`
**Счетчик количества всего на свете.** В данном блоке мы видим четыре контрола: кнопка минус, количество, кнопка плюс и цена. Можно объединить их в одну `view` и превратить в один контрол: «Количество, 1, 575 рублей. Элемент регулировки». После вертикального свайпа изменится количество, а затем произнесётся новое значение вместе с ценой.
**Горизонтальные `UICollectionView`.** Оказалось, что `.adjustable` удобно применять и для горизонтальных `UICollectionView`. Например, выбрать акцию в меню или машину в такси.
Заключение
----------
В этот раз мы разобрали трейты: их типы, состояния и поведение. Это стандартный набор для **типовых задач**. Для сложных контролов можно использовать .adjustable.
В следующий раз посмотрим на решение **типовых проблем**: порядок обхода, модальные окна, индикаторы загрузки.
> Чтобы не пропустить следующую статью, подписывайтесь [на мой канал Dodo Pizza Mobile](https://telegram.im/dodomobile).
>
>
>
> А ещё у нас сейчас открыта одна вакансия в мобильном направлении. Так что я просто оставлю это здесь: [Senior iOS Developer (Нижний Новгород).](https://apply.workable.com/dodopizza/j/F5003C7FAC/) | https://habr.com/ru/post/488246/ | null | ru | null |
# Понимание критического пути рендеринга
Браузеру предстоит пройти много шагов, прежде чем HTML-ответ от сервера будет преобразован в пиксели на экране. Последовательность этих шагов, необходимая для первого отображения страницы, называется «Критический путь рендеринга» (ориг. Critical Rendering Path).
Знание о CRP (Critical Rendering Path) невероятно полезно для понимания того, как улучшить производительность сайта.
***Существует 6 этапов CRP:***
* построение DOM-дерева,
* построение CSSOM-дерева,
* запуск JavaScript,
* создание Render-дерева,
* генерация раскладки,
* отрисовка.
Построение DOM-дерева
---------------------
DOM (объектная модель документа) дерево это объект, представляющий полностью разобранную HTML-страницу. Начиная с корневого элемента , узлы создаются для каждого элемента/текста на странице. Элементы, вложенные в другие элементы, представлены в виде дочерних узлов, и каждый узел содержит полный набор атрибутов для этого элемента. Например, элемент будет иметь атрибут `href`, связанный с узлом.
Возьмём для примера такой документ:
```
Understanding the Critical Rendering Path
Understanding the Critical Rendering Path
=========================================
Introduction
------------
Lorem ipsum dolor sit amet
Copyright 2017
```
Из него будет построено такое DOM-дерево:
Хорошая новость, касательно HTML, заключается в том, что он может быть исполнен по частям. Документ не должен быть загружен полностью для того, чтобы контент начал появляться на странице. Однако, другие ресурсы, такие как CSS и JavaScript, могут блокировать отрисовку страницы.
Построение CSSOM-дерева
-----------------------
CSSOM (объектная модель CSS) — это объект, представляющий стили, связанные с DOM. Он выглядит так же как DOM, но с соответствующими стилями для каждого узла. Не имеет значения были ли стили объявлены явно или наследуются.
В файле `style.css`, подключающемся в ранее упомянутом документе, мы имеем следующий набор стилей:
```
body { font-size: 18px; }
header { color: plum; }
h1 { font-size: 28px; }
main { color: firebrick; }
h2 { font-size: 20px; }
footer { display: none; }
```
С его помощью получится следующее CSSOM-дерево:
CSS считается «блокирующим обработку ресурсом». Это значит, что Render-дерево (см. ниже) не может быть построено без полного первоначального разбора CSS.
В отличии от HTML, CSS не может быть использован по частям в силу своей каскадной природы. Стили, описанные в документе ниже, могут переопределять и изменять стили, определённые ранее. Так что если мы начнём использовать CSS-стили до того, как будет разобрана таблица стилей, мы можем столкнуться с ситуацией, когда стили будут применяться неверно. Это означает, что для перехода к следующему шагу, необходимо полностью разобрать CSS.
CSS-файлы блокируют рендер только если они применяются. может принимать медиа-атрибут, в котором мы можем указать любое медиавыражение, к которому будут относиться вложенные внутрь стили. Если, например, мы имеем таблицу стилей с медиа-атрибутом `orientation:landscape`, а мы просматриваем страницу в портретном режиме, то этот ресурс не будет считаться блокирующим обработку.
CSS также может являться «блокирующим скрипты», потому что JavaScript-файлы должны дождаться построения CSSOM, прежде чем начать исполняться.
Запуск JavaScript
-----------------
JavaScript является блокирующим ресурсом для парсера. Это означает, что JavaScript блокирует разбор самого HTML-документа.
Когда парсер доходит до тега `</code> (не важно внутренний он или внешний), он останавливается, забирает файл (если он внешний) и запускает его. Вот почему, если мы имеем JavaScript-файл, который ссылается на элементы документа, мы обязательно должны поместить его после их появления.</p><br/>
<p>JavaScript можно загружать асинхронно, указав атрибут <code>async</code>, для того, чтобы избежать блокировки парсера.</p><br/>
<pre><code><script async src="script.js"> </code></pre><br/>
<h2 id="sozdanie-render-dereva">Создание Render-дерева</h2><br/>
<p>Render-дерево — это совокупность DOM и CSSOM. Это дерево, которое даёт представление о том, что в конечном итоге будет отображено на странице. Это означает, что оно захватывает только видимый контент и не включает, например, элементы, которые были скрыты с помощью CSS-правила <code>display: none</code>.</p><br/>
<p>На примерах DOM и CSSOM, представленных выше, будет построено такое Render-дерево:</p><br/>
<img src="https://habrastorage.org/r/w1560/files/26c/384/b4b/26c384b4b75f410d936037ad160ca3ac.png" alt="Render-дерево" data-src="https://habrastorage.org/files/26c/384/b4b/26c384b4b75f410d936037ad160ca3ac.png"/><br/>
<h2 id="generaciya-raskladki">Генерация раскладки</h2><br/>
<p>Раскладка — это то, что определяет размер видимой области документа (<a href="https://github.com/web-standards-ru/dictionary/blob/master/dictionary.md#viewport">viewport</a>), которая обеспечивает контекст для стилей CSS, зависимых от него, например, проценты или единицы вьюпорта. </p><br/>
<p>Размер вьюпорта определяется метатэгом, находящемся в <code><head></code> документа или, если тэг не представлен, будет использовано стандартное значение вьюпорта шириною в 980 пикселей.</p><br/>
<p>Например, наиболее частым значением для этого метатэга является размер, соответствующий с шириной устройства.</p><br/>
<pre><code class="html"><meta name="viewport" content="width=device-width,initial-scale=1"></code></pre><br/>
<p>Если пользователь посещает веб-страницу с устройства, ширина которого, например 1000 пикселей, то размеры будут опираться на это значение. Половина видимой области будет равна 500 пикселей, 10 процентов — 100 пикселей, и так далее.</p><br/>
<h2 id="otrisovka">Отрисовка</h2><br/>
<p>Наконец, на шаге отрисовки, видимый контент страницы может быть преобразован в пиксели, чтобы появиться на экране.</p><br/>
<p>Время, которое займет этот этап, зависит как от величины DOM, так и от того, какие стили применяются. Некоторые стили требуют больше усилий, чтобы быть применёнными, чем другие. Например, сложное градиентное фоновое изображение потребует больше времени, чем простой сплошной цвет на фоне.</p><br/>
<h2 id="sobiraem-vsyo-vmeste">Собираем всё вместе</h2><br/>
<p>Чтобы увидеть как происходит критический путь рендеринга, мы можем воспользоваться инструментами разработчика. В Chrome это можно сделать во вкладке «Timeline» (в Canary, а так же скоро в стабильных версия Chrome, вкладка переименована в «Performance»).</p><br/>
<p>Возьмем для примера наш HTML-образец, упомянутый выше (с добавленным тэгом <code><script></code>).</p><br/>
<pre><code class="html"><html>
<head>
<title>Understanding the Critical Rendering Path</title>
<link rel="stylesheet" href="style.css">
</head>
<body>
<header>
<h1>Understanding the Critical Rendering Path</h1>
</header>
<main>
<h2>Introduction</h2>
<p>Lorem ipsum dolor sit amet</p>
</main>
<footer>
<small>Copyright 2017</small>
</footer>
<script src="main.js">`
Если мы посмотрим в Event Log для этой страницы, то увидим следующее:
1. **Send Request** — GET-запрос, отправленный для index.html;
2. **Parse HTML and Send Request** — начать разбор HTML и построение DOM. Отправить GET запрос для style.css и main.js;
3. **Parse Stylesheet** — CSSOM, созданный для style.css;
4. **Evaluate Script** — вычислить (выполнить) main.js;
5. **Layout** — генерация раскладки, основанной на значении метатега viewport;
6. **Paint** — отрисовка пикселей в документе.
Опираясь на эту информацию, мы можем принимать решения, направленные на оптимизацию критического пути рендеринга. Я расскажу о некоторых таких техниках в дальнейших публикациях. | https://habr.com/ru/post/320430/ | null | ru | null |
# Roundcube + hMailServer или своя почта в маленькой организации
Не каждая организация может позволить себе покупку дорогостоящего почтового сервера как Microsoft Exchange Server, да и в силу своей «наворочености», не каждой организации он нужен. Некоторое время назад передо мной встала задача запустить почту внутри организации для обмена документами между отделами. Сразу оговорюсь, что организация, в которой я работаю небольшая, имеет 1 сервер и около 50 клиентских машин. Опыта работы с почтовыми серверами – нет. После недолгих поисков по просторам сети было решено использовать связку RoundCube + hMailServer. В этой статье **не будут** рассмотрены и описаны все сильные и слабые стороны такой связки, а просто описано как все это заставить работать, но скажу что основные достоинства этого решения – бесплатность и простота в настройке.
#### Немного теории
С чем имеем дело…
**Почтовый сервер** – в системе пересылки электронной почты так обычно называют агент пересылки сообщений. Это компьютерная программа, которая передаёт сообщения от одного компьютера к другому. Обычно почтовый сервер работает «за кулисами», а пользователи имеют дело с другой программой — клиентом электронной почты.
**hMailServer** — бесплатный почтовый сервер под платформу Windows. Работает как служба Windows и включает в себя инструменты администрирования и резервного копирования. Поддерживает почтовые протоколы IMAP, POP3 и SMTP. Для хранения настроек и индексов использует базы данных типа MySQL, MS SQL или PostgreSQL, сами же почтовые сообщения хранятся на жестком диске в формате MIME.
**RoundCube Webmail** — это клиент для работы с электронной почтой с веб-интерфейсом, написанный на PHP с использованием CSS и XHTML и технологии AJAX. RoundCube Webmail устанавливается практически на любой сервер с поддержкой PHP и MySQL и предоставляет возможность работы с почтовыми ящиками по протоколам IMAP и SMTP. Имеет множество расширений.
Для начала работы необходимо скачать следующие компоненты:
1) [hMailServer](http://www.hmailserver.com/index.php?page=download)
2) [RoundCube Webmail](http://roundcube.net/)
3) Веб-сервер [VertrigoServ](http://vertrigo.sourceforge.net/) (можно использовать и любой другой)
И так, скачав все необходимое или удостоверившись, что оно есть в наличии, можно смело переходить к началу установки.
#### Практика
**Этап нулевой:** Задать сетевой карте статический IP адрес. В данной статье будет использован IP `192.168.0.45`.
**Этап первый:** Установка VertrigoServ.
Не думаю, что стоит детально расписывать установку этого веб-сервера, т.к. ничего замысловатого в этом процессе нет.
**Этап второй:** Установка hMailServer.
Полностью процесс установки описывать не буду, рассмотрим только основные моменты. На этапе «Select Components» выбираем «Full Installation», далее на этапе «Database type» выбираем «Use external database engine (MSSQL, MySQL or PostgreSQL) и еще пару раз нажав «Далее» начнется установка. Ближе к завершению установки, запуститься приложение hMailServer Database Setup, в котором необходимо указать тип базы данных и прописать реквизиты для подключения.
Рассмотрим настройку подключения пошагово:
Step 1 of 7 – просто жмем «Next»
Step 2 of 7 – выбираем «Create a new hMailServer database»
Step 3 of 7 – выбираем «MySQL» и для того, чтобы на 6 шаге не возникло проблем, копируем файл libmysql.dll находящийся в папке с установленным VertrigoServ в папку `\hMailServer\Bin\`
Step 4 of 7 – вводим следующие данные:
Database server address – `127.0.0.1` (или `localhost`)
Port – 3306
Database name – hmail (как пример)
Username – root
Password – vertrigo
Step 5 of 7 – пропускаем
Step 6 of 7 – просто жмем «Next» (при условии, что данные на 4 шаге введены верно, создается база данных)
Step 7 of 7 – «Close»
Заключительный этап установки hMailServer — это «Specify main password», на котором задается «главный» пароль для доступа к программе. После того как пароль задан, установка считается завершенной.
Теперь займемся русификацией программы, если считаете, что Ваших познаний в английском языке достаточно для работы с программой, то смело пропускайте данный пункт. Для русификации необходимо временно остановить службу hMailServer, для этого идем в «Пуск – Панель управления – Администрирование – Службы». В списке находим hMailServer, вызываем правой кнопкой мыши выпадающее меню, в котором выбираем команду «Стоп».
Все, служба остановлена. Теперь [скачиваем](http://games.16mb.com/image/russian.ini) файл с русификацией и помещаем его в папку `\hMailServer\Languages\`. Остается только вписать имя файла локализации в файл конфигурации hMailServer, для этого открываем файл `\hMailServer\Bin\hMailServer.ini` и дописываем `«ValidLanguages=english,swedish,russian»`. Сохраняем и закрываем файл. Запускаем службу hMailServer (вызываем правой кнопкой мыши выпадающее меню, в котором выбираем команду «Пуск»).
**Этап третий:** Начальное конфигурирование hMailServer.
Запускаем утилиту hMailServer Administrator. Появляется окно «Connect», в котором, выделив единственную запись, жмем на кнопку «Connect»
Программа просит ввести пароль, который был задан на заключительном этапе установке hMailServer. Введя пароль, попадаем в главное окно административной части hMail. В меню «File – Select language…» выбираем «russian» и жмем «ОК», программа автоматически перезапустится, после чего «заговорит» по русски.
Настройка интуитивно понятна, для начала необходимо нажать на кнопку «Добавить домен», в качестве имени домена, выберем «**test.loc**» и нажмем кнопку «Сохранить» (более детальная настройка почтового домена в этой статье рассматриваться не будет).
Создаем учетную запись, для этого переходим в левой части программы в папку «Учетные записи», а в правой части программы жмем кнопку «Добавить…». Вводим любое имя пользователя (например test), указываем пароль и жмем кнопку «Сохранить» (более детальная настройка пользователей в этой статье рассматриваться не будет). И так, на нашем почтовом сервере появляется первый пользователь **test@test.loc**.
Собственно на этом предварительную настройку hMailServer можно считать законченной, переходим дальше.
**Этап четвертый:** Установка RoundCube.
Для начала необходимо содержимое архива roundcubemail перенести в папку `\VertrigoServ\www\` (предварительно можно удалить всю «начинку»). Теперь в веб-приложении phpMyAdmin создаем MySQL базу данных для RoundCubeMail, для этого открываем браузер и в адресной строке вводим «`127.0.0.1/phpmyadmin`» в качестве логина вводим: root, пароль: vertrigo (стандартные реквизиты для VertrigoServ). В поле «Новая база данных» вводим название, например «roundcube» и нажимаем кнопку «Создать».
База данных создана, переходим непосредственно к установке скрипта RoundCubeMail. В адресной строке браузера вводим «`127.0.0.1/installer/index.php`» и жмем «Enter». Попав на страницу «Roundcube Webmail Installer» жмем кнопку «Start installation». Установка проходит в три этапа.
*1. Check environment*. Происходит проверка, удовлетворяет ли ваша система требованиям скрипта. Жмем кнопку «Next», если она недоступна, внимательно читаем информацию на странице и исправляем недочеты.
*2. Create config*. Рассмотрим пункты, которые следует задать/изменить.
Блок General configuration:
`product_name – Имя почтового сервера`
Блок Database setup:
`Database type – MySQL
Database server – localhost
Database name – roundcube
Database user name – root
Database password – vertrigo`
Блок IMAP Settings:
`default_host – 192.168.0.45
username_domain – test.loc`
Блок SMTP Settings:
`smtp_server – localhost`
Блок Display settings & user prefs:
`language – ru_RU`
После того как внесли все необходимые изменения жмем на кнопку «Create config» нас перенаправляет на страницу на которой предлагается скачать созданные конфигурационные файлы.
Скачиваем сгенерированные конфигурационные файлы и копируем их в папку `\VertrigoServ\www\config\`. Возвращаемся в браузер и жмем кнопку «Continue».
*3. Test config*. Это заключительный этап установки, на нем можно проверить правильность конфигурации. Для этого служба hMailServer должна быть запущена.
В блоке «Test SMTP config», в полях «Sender» и «Recipient» введем адрес нашего единственного пользователя test@test.loc, жмем на кнопку «Send test mail», если появляется сообщение «SMTP send: OK» – значит эта часть настроена верно, в противном случае перепроверьте в конфигурационном файле main.inc.php параметр `$rcmail_config['smtp_server'] = 'localhost';`.
Теперь проверяем, работает ли IMAP, в блоке «Test IMAP config» в качестве сервера выбираем 192.168.0.45, Username: test@test.loc, Password: пароль который ввели при создании пользователя. Жмем на кнопку «Check login» если в результате получаем сообщение «IMAP connect: OK» значит все сконфигурировано верно, иначе перепроверьте в конфигурационном файле main.inc.php параметр `$rcmail_config['default_host'] = '192.168.0.45';`.
Убедившись, что все работает, идем в директорию `\VertrigoServ\www\` и удаляем папку «Installer».
На этом установка RoundCube Webmail завершена.
**Этап пятый:** Авторизация в Roundcube.
Этот этап является заключительным, здесь мы авторизуемся под реквизитами пользователя, которого создали на третьем этапе test@test.loc. Для начала откроем браузер и введем в адресной строке `192.168.0.45`, нажав «Enter» попадаем на страницу авторизации Roundcube. В поле «Имя пользователя» вводим **test@test.loc** или просто test. Пароль вводим который ввели при создании пользователя. Жмем на кнопку «Войти» и оказываемся внутри вашего первого почтового ящика!
Вот собственно и все. В данной статье рассмотрены основные настройки связки RoundCube + hMailServer. Спасибо что дочитали до конца! | https://habr.com/ru/post/131179/ | null | ru | null |
# Семантика копирования и управление ресурсами в C++
---
*В C++ программист должен сам принимать решения о том, как будут освобождаться используемые ресурсы, автоматических средств типа сборщика мусора нет. В статье рассмотрены возможные варианты решения этой задачи, детально рассмотрены потенциальные проблемы, а также ряд сопутствующих вопросов.*
---
Оглавление
==========
**Оглавление** [Введение](#id-introdaction)
[1. Основные стратегии копирования-владения](#id-1)
[1.1. Стратегия запрета копирования](#id-1-1)
[1.2. Стратегия исключительного владения](#id-1-2)
[1.3. Стратегия глубокого копирования](#id-1-3)
[1.4. Стратегия совместного владения](#id-1-4)
[2. Стратегия глубокого копирования — проблемы и решения](#id-2)
[2.1. Копирование при записи](#id-2-1)
[2.2. Определение функции обмена состояниями для класса](#id-2-2)
[2.3. Удаление промежуточных копий компилятором](#id-2-3)
[2.4. Реализация семантики перемещения](#id-2-4)
[2.5. Размещение vs. вставки](#id-2-5)
[2.6. Итоги](#id-2-6)
[3. Возможные варианты реализации стратегии совместного владения](#id-3)
[4. Стратегия исключительного владения и семантика перемещения](#id-4)
[5. Стратегия запрета копирования — быстрое начало](#id-5)
[6. Жизненный цикл ресурса и объекта-владельца ресурса](#id-6)
[6.1. Захват ресурса при инициализации](#id-6-1)
[6.2. Расширенные варианты управления жизненным циклом ресурса](#id-6-2)
[6.2.1. Расширенный жизненный цикл ресурса](#id-6-2-1)
[6.2.2. Однократный захват ресурса](#id-6-2-2)
[6.2.3. Повышение уровня косвенности](#id-6-2-3)
[6.3. Совместное владение](#id-6-3)
[7. Итоги](#id-conclusion)
[Приложения](#id-apps)
[Приложение A. Rvalue-ссылки](#id-app-1)
[Приложение Б. Семантика перемещения](#id-app-2)
[Список литературы](#id-refs)
Введение
========
Управление ресурсами — это то, чем программисту на C++ приходится заниматься постоянно. К ресурсам можно отнести блоки памяти, объекты ядра ОС, многопоточные блокировки, сетевые соединения, соединения с БД и просто любой объект, созданный в динамической памяти. Доступ к ресурсу осуществляется через дескриптор, тип дескриптора обычно указатель или один из его псевдонимов (`HANDLE`, etc.), иногда целый (файловые дескрипторы UNIX). После использования ресурс необходимо освобождать, иначе рано или поздно приложение, не освобождающее ресурсы (а возможно и другие приложения), столкнется с нехваткой ресурсов. Проблема эта весьма острая, можно сказать, что одной из ключевых особенностей платформ .NET, Java и ряда других является унифицированная система управления ресурсами, основанная на сборке мусора.
Объектно-ориентированные возможности C++ естественно приводит к следующему решению: класс, управляющий ресурсом, содержит дескриптор ресурса в качестве члена, инициализирует дескриптор при захвате ресурса и освобождает ресурс в деструкторе. Но после некоторых размышлений (или опыта) приходит понимание того, что не все так просто. И главной проблемой является семантика копирования. Если класс, управляющий ресурсом, использует копирующий конструктор, сгенерированный компилятором по умолчанию, то после копирования объекта мы получим две копии дескриптора одного и того же ресурса. Если один объект освобождает ресурс, то после этого второй сможет совершить попытку использования или освобождения уже освобожденного ресурса, что в любом случае является не корректным и может привести к так называемому неопределенному поведению, то есть может произойти все, что угодно, например аварийное завершение программы.
К счастью, в C++ программист может полностью контролировать процесс копирования путем собственного определения копирующего конструктора и оператора копирующего присваивания, что позволяет решить вышеописанную проблему, причем обычно не одним способом. Реализация копирования должна быть тесно увязана с механизмом освобождения ресурса, и это все вместе будем называть стратегией копирования-владения. Хорошо известно так называемое «правило большой тройки», которое утверждает, что если программист определил хотя бы одну из трех операций — копирующий конструктор, оператор копирующего присваивания или деструктор, — то он должен определить все три операции. Стратегии копирования-владения как раз и конкретизируют, как это надо делать. Существует четыре основных стратегии копирования-владения.
1. Основные стратегии копирования-владения
==========================================
До захвата ресурса или после его освобождения дескриптор должен принимать специальное значение, указывающее на то, что он не связан с ресурсом. Обычно это ноль, иногда -1, приведенный к типу дескриптора. В любом случае такой дескриптор будем называть нулевым. Класс, управляющий ресурсом, должен распознавать нулевой дескриптор и не пытаться в этом случае использовать или освобождать ресурс.
1.1. Стратегия запрета копирования
----------------------------------
Это самая простая стратегия. В этом случае просто запрещено копировать и присваивать экземпляры класса. Деструктор освобождает захваченный ресурс. В C++ запретить копирование не сложно, класс должен объявить, но не определять закрытые копирующий конструктор и оператор копирующего присваивания.
```
class X
{
private:
X(const X&);
X& operator=(const X&);
// ...
};
```
Попытки копирования пресекаются компилятором и компоновщиком.
Стандарт C++11 предлагает для этого случая специальный синтаксис:
```
class X
{
public:
X(const X&) = delete;
X& operator=(const X&) = delete;
// ...
};
```
Этот синтаксис более нагляден и дает более понятные сообщения компилятора при попытке копирования.
В предыдущей версии стандартной библиотеки (C++98) стратегию запрета копирования использовали классы потоков ввода-вывода (`std::fstream`, etc.), а в ОС Windows многие классы из MFC (`CFile`, `CEvent`, `CMutex`, etc.). В стандартной библиотеке C++11 эту стратегию используют некоторые классы для поддержки многопоточной синхронизации.
1.2. Стратегия исключительного владения
---------------------------------------
В этом случае при реализации копирования и присваивания дескриптор ресурса перемещается от объекта-источника к целевому объекту, то есть остается в единственном экземпляре. После копирования или присваивания, объект-источник имеет нулевой дескриптор и не может использовать ресурс. Деструктор освобождает захваченный ресурс. Для этой стратегии также используются термины эксклюзивное или строгое владение [Josuttis], Андрей Александреску [Alexandrescu] использует термин разрушающее копирование. В C++11 это делается следующим образом: запрещается обычное копирование и копирующее присваивание вышеописанным способом, и реализуются семантики перемещения, то есть определяются перемещающий конструктор и оператор перемещающего присваивания. (Подробнее о семантике перемещения далее.)
```
class X
{
public:
X(const X&) = delete;
X& operator=(const X&) = delete;
X(X&& src) noexcept;
X& operator=(X&& src) noexcept;
// ...
};
```
Таким образом, стратегию исключительного владения можно считать расширением стратегии запрета копирования.
В стандартной библиотеке C++11 эту стратегию использует интеллектуальный указатель `std::unique_ptr<>` и некоторые другие классы, например: `std::thread`, `std::unique_lock<>`, а также классы, ранее использовавшие стратегию запрета копирования (`std::fstream`, etc.). В ОС Windows классы MFC, ранее использовавшие стратегию запрета копирования, также стали использовать стратегию исключительного владения (`CFile`, `CEvent`, `CMutex`, etc.).
1.3. Стратегия глубокого копирования
------------------------------------
В этом случае можно копировать и присваивать экземпляры класса. Необходимо определить копирующий конструктор и оператор копирующего присваивания, так, чтобы целевой объект копировал к себе ресурс из объекта-источника. После этого каждый объект владеет своей копией ресурса, может независимо использовать, модифицировать и освобождать ресурс. Деструктор освобождает захваченный ресурс. Иногда для объектов, использующих стратегию глубокого копирования, применяют термин объекты-значения.
Эта стратегия применима не ко всем ресурсам. Ее можно применять к ресурсам, связанным с буфером памяти, например строкам, но не очень понятно, как ее применять к объектам ядра ОС типа файлов, мьютексов и т.д.
Стратегия глубокого копирования используется во всех типах объектных строк, `std::vector<>` и других контейнерах стандартной библиотеки.
1.4. Стратегия совместного владения
-----------------------------------
В этом случае можно копировать и присваивать экземпляры класса. Необходимо определить копирующий конструктор и оператор копирующего присваивания, в которых копируется дескриптор ресурса (а также другие данные), но не сам ресурс. После этого каждый объект имеет свою копию дескриптора, может использовать, модифицировать, но не может освобождать ресурс, пока есть хотя бы еще один объект, владеющий копией дескриптора. Ресурс освобождается после того, как последний объект, владеющий копией дескриптора, выходит из области видимости. Как это может быть реализовано, описано ниже.
Стратегию совместного владения часто используют интеллектуальные указатели, ее также естественно использовать для неизменяемых (immutable) ресурсов. В стандартной библиотеке C++11 эту стратегию реализует интеллектуальный указатель `std::shared_ptr<>`.
2. Стратегия глубокого копирования — проблемы и решения
=======================================================
Рассмотрим шаблон функции обмена состояниями объектов типа `T` в стандартной библиотеке C++98.
```
template
void swap(T& a, T& b)
{
T tmp(a);
a = b;
b = tmp;
}
```
Если тип `T` владеет ресурсом и использует стратегию глубокого копирования, то мы имеем три операции выделения нового ресурса, три операции копирования и три операции освобождения ресурсов. Тогда как в большинстве случаев эту операцию можно осуществить вообще без выделения новых ресурсов и копирования, достаточно объектам обменяться внутренними данными, включая дескриптор ресурса. Подобных примеров, когда приходится создавать временные копии ресурса и тут же их освобождать, можно привести много. Столь неэффективная реализация повседневных операций стимулировала поиск решений для их оптимизации. Рассмотрим основные варианты.
2.1. Копирование при записи
---------------------------
Копирование при записи (copy on write, COW), называемое также отложенным копированием, можно рассматривать как попытку соединить стратегию глубокого копирования и стратегию совместного владения. Первоначально при копировании объекта копируется дескриптор ресурса, без самого ресурса, и для владельцев ресурс становится разделяемым и доступным в режиме «только для чтения», но как только какому-нибудь владельцу потребуется модифицировать разделяемый ресурс, выполняется копирование ресурса и далее этот владелец работает со своей копией. Реализация COW решает проблему обмена состояниями: дополнительного выделения ресурсов и копирования при этом не происходит. Использование COW достаточно популярно при реализации строк, в качестве примера можно привести `CString` (MFC, ATL). Обсуждение возможных путей реализации COW и возникающих проблем можно найти в [Meyers1], [Sutter]. В [Guntheroth] предложен вариант реализации COW с использованием `std::shared_ptr<>`. Имеются проблемы при реализация COW в многопоточной среде, из-за чего в стандартной библиотеке C++11 для строк запрещено использовать COW, см. [Josuttis], [Guntheroth].
Развитие идеи COW приводит к следующей схеме управления ресурсом: ресурс является неизменяемым (immutable) и управляется объектами, использующими стратегию совместного владения, при необходимости изменить ресурс создается новый, соответствующим образом измененный ресурс, и возвращается новый объект-владелец. Эта схема используется для строк и других неизменяемых объектов на платформах .NET и Java. В функциональном программировании она используется для более сложных структур данных.
2.2. Определение функции обмена состояниями для класса
------------------------------------------------------
Выше было показано, насколько неэффективно может работать функция обмена состояниями, реализованная прямолинейно, через копирование и присваивание. А используется она достаточно широко, например, ее применяют многие алгоритмы стандартной библиотеки. Для того, чтобы алгоритмы использовали не `std::swap()`, а другую функцию, специально определенную для класса, необходимо выполнить два шага.
1. Определить в классе функцию-член `Swap()` (имя не принципиально), реализующую обмен состояниями.
```
class X
{
public:
void Swap(X& other) noexcept;
// ...
};
```
Необходимо гарантировать, чтобы эта функция не выбрасывала исключения, в C++11 такие функции надо объявлять как `noexcept`.
2. В том же пространстве имен, что и класс `X` (обычно в том же заголовочном файле), определить свободную (не-член) функцию `swap()` следующим образом (имя и сигнатура принципиальны):
```
inline void swap(X& a, X& b) noexcept { a.Swap(b); }
```
После этого алгоритмы стандартной библиотеки будут использовать ее, а не `std::swap()`. Это обеспечивает механизм, называемый поиском, зависимым от типов аргументов (argument dependent lookup, ADL). Подробнее об ADL см. [Dewhurst1].
В стандартной библиотеке C++ все контейнеры, интеллектуальные указатели, а также другие классы реализуют функцию обмена состояниями описанным выше способом.
Функция-член `Swap()` определяется обычно легко: необходимо последовательно применять к базам и членам операцию обмена состояниями, если они ее поддерживают, и `std::swap()` в противном случае.
Приведенное описание несколько упрощено, более детальное можно найти в [Meyers2]. Обсуждение проблем, связанных с функцией обмена состояниями, также можно найти в [Sutter/Alexandrescu].
Функцию обмена состояниями можно отнести к одной из базовых операций класса. С помощью нее можно изящно определить другие операции. Например, оператор копирующего присваивания определяется через копирование и `Swap()` следующим образом:
```
X& X::operator=(const X& src)
{
X tmp(src);
Swap(tmp);
return *this;
}
```
Этот шаблон называется идиомой «копирование и обмен» или идиомой Герба Саттера, подробнее см. [Sutter], [Sutter/Alexandrescu], [Meyers2]. Его модификацию можно применить для реализации семантики перемещения, см. разделы 2.4, 2.6.1.
2.3. Удаление промежуточных копий компилятором
----------------------------------------------
Рассмотрим класс
```
class X
{
public:
X(/* параметры */);
// ...
};
```
И функцию
```
X Foo()
{
// ...
return X(/* аргументы */);
}
```
При прямолинейном подходе возврат из функции `Foo()` реализуется через копирование экземпляра `X`. Но компиляторы умеют удалять из кода операцию копирования, объект создается непосредственно в точке вызова. Это называется оптимизацией возвращаемого значения (return value optimization, RVO). RVO применяется разработчиками компиляторов достаточно давно и в настоящее время зафиксирована в стандарте C++11. Хотя решение об RVO принимает компилятор, программист может писать код в расчете на ее использование. Для этого желательно, чтобы функция имела одну точку возврата и тип возвращаемого выражения совпадал с типом возвращаемого значения функции. В ряде случаев целесообразно определить специальный закрытый конструктор, называемый «вычислительным конструктором», подробнее см. [Dewhurst2]. RVO также обсуждается в [Meyers3] и [Guntheroth].
Компиляторы могут удалять промежуточные копии и в других ситуациях.
2.4. Реализация семантики перемещения
-------------------------------------
Реализация семантики перемещения заключается в определении перемещающего конструктора, имеющего параметр типа rvalue-ссылка на источник и оператора перемещающего присваивания с таким же параметром.
В стандартной библиотеке C++11 шаблон функции обмена состояниями определен следующим образом:
```
template
void swap(T& a, T& b)
{
T tmp(std::move(a));
a = std::move(b);
b = std::move(tmp);
}
```
В соответствии с правилами разрешения перегрузок функций, имеющих параметры типа rvalue-ссылка (см. Приложение А), в случае, когда тип `T` имеет перемещающий конструктор и оператор перемещающего присваивания, будут использоваться они, и выделения временных ресурсов и копирования при этом не будет. В противном случае будут использованы копирующий конструктор и оператор копирующего присваивания.
Использование семантики перемещения позволяет избежать создания временных копий в значительно более широком контексте, чем описанная выше функция обмена состояниями. Семантика перемещения применяется к любому rvalue-значению, то есть временному, неименованному значению, а также к возвращаемому значению функции, если оно создано локально (в том числе и lvalue), и при этом не было применено RVO. Во всех этих случаях гарантируется, что объект-источник не сможет быть как-либо использован после выполнения перемещения. Семантика перемещения также применяется к lvalue-значению, к которому применено преобразование `std::move()`. Но в этом случае программист сам отвечает за то, как объекты-источники будут использоваться после перемещения (пример `std::swap()`).
Стандартная библиотека C++11 переработана с учетом семантики перемещения. Во многие классы добавлены перемещающий конструктор и оператор перемещающего присваивания, а также другие функции-члены, с параметрами типа rvalue-ссылка. Например, `std::vector` имеет перегруженную версию `void push_back(T&& src)`. Все это позволяет во многих случаях избегать создания временных копий.
Реализация семантики перемещения не отменяет определения функции обмена состояниями для класса. Специально определенная функция обмена состояниями может быть эффективнее, чем стандартная `std::swap()`. Более того, перемещающий конструктор и оператор перемещающего присваивания очень просто определяются с помощью функции-члена обмена состояниями следующим образом (вариация идиомы «копирование и обмен»):
```
class X
{
public:
X() noexcept {/* инициализация нулевого дескриптора */}
void Swap(X& other) noexcept {/* обмен состояниями */}
X(X&& src) noexcept : X()
{
Swap(src);
}
X& operator=(X&& src) noexcept
{
X tmp(std::move(src)); // перемещение
Swap(tmp);
return *this;
}
// ...
};
```
Перемещающий конструктор и оператор перемещающего присваивания относятся к тем функциям-членам, для которых крайне желательно гарантировать, чтобы они не выбрасывали исключений, и, соответственно, были объявлены как `noexcept`. Это позволяет оптимизировать некоторые операции контейнеров стандартной библиотеки без нарушений строгой гарантии безопасности исключений, подробнее см. [Meyers3] и [Guntheroth]. Предлагаемый шаблон дает такую гарантию при условии, что конструктор по умолчанию и функция-член обмена состояниями не выбрасывают исключений.
Стандарт C++11 предусматривает автоматическую генерацию компилятором перемещающего конструктора и оператора перемещающего присваивания, для этого их надо объявить с использованием конструкции `"=default"`.
```
class X
{
public:
X(X&&) = default;
X& operator=(X&&) = default;
// ...
};
```
Операции реализуются путем последовательного применения операции перемещения к базам и членам класса, если они поддерживают перемещение, и операции копирования в противном случае. Понятно, что такой вариант далеко не всегда приемлем. Сырые дескрипторы не перемещаются, но копировать их обычно нельзя. При выполнении определенных условий компилятор может самостоятельно сгенерировать подобный перемещающий конструктор и оператор перемещающего присваивания, но этой возможностью лучше не пользоваться, условия эти довольно запутаны и легко могут измениться при доработке класса. Подробнее см. [Meyers3].
Вообще реализация и использование семантики перемещения довольно «тонкая штучка». Компилятор может применить копирование там, где программист ожидает перемещение. Приведем несколько правил, позволяющих исключить или хотя бы снизить вероятность такой ситуации.
1. По возможности использовать запрет копирования.
2. Объявлять перемещающий конструктор и оператор перемещающего присваивания как `noexcept`.
3. Реализовать семантику перемещения для базовых классов и членов.
4. Применять преобразование `std::move()` к параметрам функций, имеющих тип rvalue-ссылка.
Правило 2 обсуждалось выше. Правило 4 связано с тем, что именованные rvalue-ссылки являются lvalue (см. также Приложение А). Это можно проиллюстрировать на примере определения перемещающего конструктора.
```
class B
{
// ...
B(B&& src) noexcept;
};
class D : public B
{
// ...
D(D&& src) noexcept;
};
D::D(D&& src) noexcept
: B(std::move(src)) // перемещение
{/* ... */}
```
Другой пример этого правила приведен выше, при определении оператора перемещающего присваивания. Реализация семантики перемещения рассматривается также в разделе 6.2.1.
2.5. Размещение vs. вставки
---------------------------
Идея размещения похожа на идею, лежащую в основе RVO (см. раздел 2.3), но применяется она не к возвращаемому значению функции, а к входным параметрам. При традиционной вставке объекта в контейнер сначала создается объект (часто временный), затем копируется или перемещается в место хранения, после чего временный объект уничтожается. При размещении объект создается сразу в месте хранения, передаются только аргументы конструктора. Контейнеры стандартной библиотеки C++11 имеют функции-члены `emplace()`, `emplace_front()`, `emplace_back()`, работающие таким образом. Естественно, что это шаблонные функции-члены с переменным числом шаблонных параметров — вариативные шаблоны (variadic templates), так как количество и тип параметров конструктора заранее неизвестно. Кроме того, используются и другие продвинутые техники C++11 — прямая передача и универсальные ссылки.
Размещение имеет следующие преимущества:
1. Для объектов, не поддерживающих перемещение, исключается операция копирования.
2. Для объектов, поддерживающих перемещение, размещение почти всегда более эффективно.
Приведем пример, где одна и та же задача решается разными способами.
```
std::vector vs;
vs.push\_back(std::string(3, ’X’)); // вставка
vs.emplace\_back(3, ’7’); // размещение
```
В случае вставки создается временный объект `std::string`, затем перемещается в место хранения и после этого временный объект уничтожается. При размещении объект создается сразу в месте хранения. Размещение выглядит более лаконично и, скорее всего, более эффективно. Скотт Мейерс детально рассматривает особенности размещения, прямой передачи и универсальных ссылок в [Meyers3].
2.6. Итоги
----------
Одной из главных проблем классов, реализующих стратегию глубокого копирования, является создание временных копий ресурса. Ни один из описанных способов полностью не решает эту проблему и полностью не замещает какой-то другой способ. В любом случае программист должен распознавать подобные ситуации и писать правильный код с учетом описанной проблемы и возможностей языка. Простейший пример — это передача параметров в функцию: передавать надо по ссылке, а не по значению. Эта ошибка не распознается компилятором, но при этом происходит либо ненужное копирование, либо программа работает не так, как задумано. Другой пример связан с использованием перемещения: программист должен четко соблюдать условия, при которых компилятор выбирает перемещение, иначе «молча» будет использовано копирование.
Описанные проблемы позволяют сделать следующую рекомендацию: необходимо по возможности избегать стратегии глубокого копирования, реальная потребность в глубоком копировании возникает весьма редко, это подтверждает опыт программирования на платформах .NET и Java. В качестве альтернативного варианта можно предложить реализацию глубокого копирования с помощью специальной функции, традиционное название для таких функций `Clone()` или `Duplicate()`.
Если все-таки при реализации класса-владельца ресурса принято решение использовать стратегию глубокого копирования, то кроме реализации семантики копирования можно рекомендовать следующие шаги:
1. Определить функцию обмена состояниями.
2. Определить перемещающий конструктор и оператор перемещающего присваивания.
3. Определить необходимые функции-члены и свободные функции с параметрами типа rvalue-ссылка.
На платформах .NET и Java основной стратегией копирования-владения является стратегия совместного владения, но при необходимости можно реализовать и стратегию глубокого копирования, например в .NET для этого надо реализовать интерфейс `IClonable`. Как было отмечено выше, потребность в этом возникает достаточно редко.
3. Возможные варианты реализации стратегии совместного владения
===============================================================
Довольно просто реализовать стратегию совместного владения для ресурса, имеющего внутренний счетчик ссылок. В этом случае при копировании объекта-владельца ресурса счетчик ссылок инкрементируется, а в деструкторе декрементируется. Когда его значение достигает нуля, ресурс сам себя освобождает. Внутренний счетчик ссылок используют базовые ресурсы ОС Windows: объекты ядра ОС, управляемые через `HANDLE`, и COM-объекты. Для объектов ядра счетчик ссылок инкрементируется с помощью функции `DuplicateHandle()`, а декрементируется с помощью функции `CloseHandle()`. Для COM-объектов используются функции-члены `IUnknown::AddRef()` и `IUnknown::Release()`. В библиотеке ATL есть интеллектуальный указатель `CСomPtr<>`, управляющий COM-объектами таким способом. Для файловых дескрипторов UNIX, открытых с помощью функций стандартной библиотеки C, счетчик ссылок инкрементируется функцией `_dup()`, декрементируется с помощью функции закрытия файла.
В стандартной библиотеке C++11 интеллектуальный указатель `std::shared_ptr<>` также использует счетчик ссылок. Но объект, контролируемый этим интеллектуальным указателем, может не иметь внутреннего счетчика ссылок, поэтому создается специальный скрытый объект, называемый управляющим блоком, который управляет счетчиком ссылок. Понятно, что это является дополнительным накладным расходом. Интеллектуальный указатель `std::shared_ptr<>` подробно описан в [Josuttis], [Meyers3].
Использование счетчика ссылок имеет генетический дефект: если объекты-владельцы ресурсов имеют взаимные ссылки друг на друга, то их счетчики ссылок никогда не будут равны нулю (проблема циклических ссылок). В ряде случаев ресурсы не могут иметь взаимных ссылок (например объекты ядра ОС) и поэтому эта проблема не актуальна, но в остальных случаях программист сам должен отслеживать подобные ситуации и принимать необходимые меры. При использовании `std::shared_ptr<>` для этих целей предлагается использовать вспомогательный интеллектуальный указатель `std::weak_ptr<>`. Подробнее см. [Josuttis], [Meyers3].
Андрей Александреску рассматривает реализацию стратегии совместного владения с помощью двусвязного списка объектов-владельцев [Alexandrescu]. Герберт Шилдт описывает (и приводит полный код) реализации, основанной на комбинации двусвязного списка и счетчика ссылок [Schildt]. Реализации на основе двусвязного списка также не могут освободить ресурсы, имеющие циклические ссылки.
Описание более сложных схем удаления неиспользуемых объектов (сборщиков мусора) можно найти в [Alger].
Реализация стратегии совместного владения также должна учитывать возможность многопоточного доступа к объектам-владельцам. Эта тема обсуждается в [Josuttis] и [Alexandrescu].
Стратегия совместного владения является основной стратегией копирования-владения на платформах .NET и Java. Компонент исполняющей среды, занимающейся удалением неиспользуемых объектов, называется сборщиком мусора, запускается периодически и использует сложные алгоритмы анализа графа объектов.
4. Стратегия исключительного владения и семантика перемещения
=============================================================
Безопасная реализация стратегии исключительного владения стала возможна только после того, как C++ стал поддерживать rvalue-ссылки и семантику перемещения. В стандартной библиотеке C++98 был интеллектуальный указатель `std::auto_ptr<>`, который реализовывал стратегию исключительного владения, но он имел ограниченное применение, в частности его нельзя было хранить в контейнерах. Дело в том, что он мог переместить указатель от объекта, которому этот указатель был еще нужен (попросту говоря украсть). В C++11 правила использования rvalue-ссылок гарантируют, что перемещать данные можно только от временного неименованного объекта, иначе будет ошибка компиляции. Поэтому в стандартной библиотеке C++11 `std::auto_ptr><>` объявлен устаревшим и вместо него рекомендовано использовать `std::unique_ptr<>`. Этот интеллектуальный указатель реализует стратегию исключительного владения на основе семантики перемещения, он подробно описан в [Josuttis], [Meyers3].
Стратегию исключительного владения также поддерживают некоторые другие классы: классы потоков ввода-вывода (`std::fstream`, etc.), классы для работы с потоками управления (`std::thread`, `std::unique_lock<>`, etc.). В MFC эту стратегию стали использовать классы, ранее использовавшие стратегию запрета копирования (`CFile`, `CEvent`, `CMutex`, etc.).
5. Стратегия запрета копирования — быстрое начало
=================================================
На первый взгляд стратегия запрета копирования сильно ограничивает программиста. Но в реальности оказывается, что очень многие объекты не нуждаются в копировании. Поэтому, при проектировании класса, управляющего ресурсами, в качестве начального решения можно рекомендовать выбор стратегии запрета копирования. Если потребность в копировании возникает, то компилятор сразу это обнаружит, после чего можно проанализировать, для чего нужно копирование (и нужно ли оно вообще) и сделать необходимые доработки. В ряде случаев, например, при передаче по стеку вызовов, можно использовать ссылку. При необходимости хранить объекты в контейнерах стандартной библиотеки можно использовать указатели (лучше интеллектуальные) на объекты, созданные в динамической памяти. Вообще использование динамической памяти и интеллектуальных указателей является достаточно универсальным вариантом, который может помочь и в других случаях. Более сложный вариант — реализация семантики перемещения. Детали обсуждаются в разделе 6.
Небрежный программный дизайн, при котором не реализовывается какая-либо стратегия копирования-владения, зачастую «сходит с рук», потому что объекты-владельцы ресурса в действительности не копируются. В этом случае запрет копирования или другая стратегия копирования-владения внешне ничего не меняет. Но, тем не менее, это все равно надо делать, надо всегда писать правильный код, даже если в каком-то контексте неправильный код не проявляет своих дефектов. Неправильный код рано или поздно «выстрелит».
6. Жизненный цикл ресурса и объекта-владельца ресурса
=====================================================
Во многих случаях важно понимать, как соотносится жизненный цикл ресурса и объекта-владельца ресурса. Естественно, что это тесно связано со стратегией копирования-владения. Рассмотрим несколько вариантов.
6.1. Захват ресурса при инициализации
-------------------------------------
В простейшем случае жизненный цикл ресурса и объекта-владельца ресурса совпадают. То есть для класса, управляющего ресурсом, выполняются условия:
1. Захват ресурса происходит только в конструкторе класса. При неудачном захвате выбрасывается исключение, и объект не создается.
2. Освобождение ресурса происходит только в деструкторе.
3. Копирование и перемещение запрещено.
Конструкторы таких классов обычно имеют параметры, необходимые для захвата ресурса и, соответственно, конструктор по умолчанию отсутствует. В стандартной библиотеке C++11 таким образом реализованы некоторые классы для поддержки многопоточной синхронизации.
Эта схема управления ресурсом является одним из вариантов идиомы «захват ресурса при инициализации» (resource acquisition is initialization, RAII). Идиома RAII широко обсуждается во многих книгах и в интернете (и часто трактуется немного по разному или просто не вполне четко), см., например [Dewhurst1]. Приведенный выше вариант можно назвать «строгим» RAII. В таком классе дескриптор ресурса естественно сделать константным членом, и, соответственно, можно использовать термин неизменяемое (immutable) RAII.
6.2. Расширенные варианты управления жизненным циклом ресурса
-------------------------------------------------------------
Класс, реализованный в соответствии с идиомой RAII, идеален для создания простых, короткоживущих объектов, время жизни которых блок. Но если объект должен быть членом другого класса или быть элементом массива или какого-нибудь контейнера, отсутствие конструктора по умолчанию, а также семантики копирования-перемещения может создать много проблем для программиста. Кроме того, иногда захват ресурса происходит в несколько шагов, причем их число может быть заранее неизвестно, что крайне затрудняет реализацию захвата ресурса в конструкторе. Рассмотрим возможные варианты решения этой проблемы.
### 6.2.1. Расширенный жизненный цикл ресурса
Будем говорить, что класс, управляющий ресурсом, поддерживает расширенный жизненный цикл ресурса, если для него выполнены следующие условия:
1. Имеется конструктор по умолчанию, не захватывающий ресурс.
2. Имеется механизм захвата ресурса после создания объекта.
3. Имеется механизм освобождения ресурса до уничтожения объекта.
4. Деструктор освобождает захваченный ресурс.
В стандартной библиотеке C++11 расширенный жизненный цикл ресурса поддерживают строки, контейнеры, интеллектуальные указатели, а также некоторые другие классы. Но надо иметь в виду, что функция-член `clear()`, реализованная в строках и контейнерах, уничтожает все хранимые объекты, но может не освобождать резервируемую память. Для полного освобождения всех ресурсов надо принять дополнительные меры. Например, можно использовать `shrink_to_fit()`, или просто присвоить объект, созданный конструктором по умолчанию (см. ниже).
Класс, реализованный в соответствии с идиомой RAII, можно доработать по стандартному шаблону, так, что он будет поддерживать расширенный жизненный цикл ресурса. Для этого надо дополнительно определить конструктор по умолчанию, перемещающий конструктор и оператор перемещающего присваивания.
```
class X
{
public:
// RAII
X(const X&) = delete; // запрет копирования
X& operator=(const X&) = delete; // запрет присваивания
X(/* параметры */); // захватывает ресурс
~X(); // освобождает ресурс
// добавляем
X() noexcept; // обнуляет дескриптор ресурса
X(X&& src) noexcept // перемещающий конструктор
X& operator=(X&& src) noexcept; // оператор перемещающего присваивания
// ...
};
```
После этого расширенный жизненный цикл ресурса реализуется совсем просто.
```
X x; // создание "пустого" объекта
x = X(/* аргументы */); // захват ресурса
x = X(/* аргументы */); // захват нового ресурса, освобождение текущего
x = X(); // освобождение ресурса
```
Именно так реализован класс `std::thread`.
Как было показано в разделе 2.4, стандартный способ определения перемещающего конструктора и оператора перемещающего присваивания использует функцию-член обмена состояниями. Кроме того, функция-член обмена состояниями позволяет очень легко определить отдельные функции-члены захвата и освобождения ресурса. Вот соответствующий новый вариант.
```
class X
{
// RAII
// ...
public: // добавляем, вариант с использованием обмена состояниями
X() noexcept;
X(X&& src) noexcept;
X& operator=(X&& src) noexcept;
void Swap(X& other) noexcept; // обменивает состояния
void Create(/* параметры */); // захватывает ресурс
void Close() noexcept; // освобождает ресурс
// ...
};
X::X() noexcept {/* инициализация нулевого дескриптора */}
```
Определение перемещающего конструктора и оператора перемещающего присваивания:
```
X::X(X&& src) noexcept : X()
{
Swap(src);
}
X& X::operator=(X&& src) noexcept
{
X tmp(std::move(src)); // перемещение
Swap(tmp);
return *this;
}
```
Определение отдельных функций-членов захвата и освобождения ресурса:
```
void X::Create(/* параметры */)
{
X tmp(/* аргументы */); // захват ресурса
Swap(tmp);
}
void X::Close() noexcept
{
X tmp;
Swap(tmp);
}
```
Следует обратить внимание, что в описанном шаблоне захват ресурса всегда происходит в конструкторе, а освобождение в деструкторе, функция-член обмена состояниями играет чисто техническую роль. Это упрощает и делает более надежным кодирование захвата и освобождения ресурса, так как, компилятор берет на себя часть логики реализации, особенно в деструкторе. В деструкторе компилятор обеспечивает вызов деструкторов для членов и баз в порядке обратном вызову конструкторов, что почти всегда гарантирует отсутствие ссылок на удаленные объекты.
В приведенных выше примерах определения оператора копирующего присваивания и функции-члена захвата ресурса использовалась идиома «копирование и обмен», в соответствии с которой сначала захватывается новый ресурс, потом освобождается старый. Эта схема обеспечивает так называемую строгую гарантию безопасности исключений: если при захвате ресурса произошло исключение, то объект останется в том же состоянии, что и до начала операции (транзакционная семантика). В определенных ситуациях может оказаться более предпочтительной другая схема: сначала освобождается старый ресурс, затем захватывается новый. Такой вариант обеспечивает более слабую гарантию безопасности исключений, называемую базовой: если при захвате ресурса произошло исключение, то объект уже не обязательно останется в том же состоянии, но новое состояние будет корректным. Кроме того, при определении оператора копирующего присваивания по этой схеме необходима проверка на самоприсваивание. Подробнее гарантии безопасности исключений обсуждаются в [Sutter], [Sutter/Alexandrescu], [Meyers2].
Итак, переход от RAII к расширенному жизненному циклу ресурса очень похож на переход от стратегии запрета копирования к стратегии исключительного владения.
### 6.2.2. Однократный захват ресурса
Этот вариант можно рассматривать как промежуточный между RAII и расширенным жизненным циклом ресурса. Будем говорить, что класс, управляющий ресурсом, использует однократный захват ресурса, если для него выполнены следующие условия:
1. Имеется конструктор по умолчанию, не захватывающий ресурс.
2. Имеется механизм захвата ресурса после создания объекта.
3. Повторный захват ресурса запрещен. Если такая попытка происходит, выбрасывается исключение.
4. Освобождение ресурса происходит только в деструкторе.
5. Копирование запрещено.
Это «почти» RAII, единственное отличие — это возможность формального разделения операции создания объекта и захвата ресурса. Такой класс может иметь перемещающий конструктор, но не оператор перемещающего присваивания, иначе нарушится условие п. 3. Это упрощает хранение объектов в стандартных контейнерах. Несмотря на некоторую «недоделанность», данный вариант достаточно практичен.
### 6.2.3. Повышение уровня косвенности
Другой подход к расширению жизненного цикла ресурса — это повышение уровня косвенности. В этом случае сам объект RAII рассматривается как ресурс, а указатель на него будет дескриптором ресурса. Захват ресурса сводится к созданию объекта в динамической памяти, а освобождение к его удалению. В качестве класса, управляющим таким ресурсом, можно использовать один из интеллектуальных указателей стандартной библиотеки или аналогичный по функционалу класс (подобные классы называют классами-дескрипторами). Стратегия копирования-владения определяется интеллектуальным указателем или легко реализуется (для класса-дескриптора). Этот способ значительно проще описанного в разделе 6.2.1, единственный недостаток заключается в более интенсивном использовании динамической памяти.
6.3. Совместное владение
------------------------
При использовании стратегии совместного владения, объект-владелец ресурса может быть жестко привязан к ресурсу по схеме RAII, или использовать более гибкую схему: многократно захватывать ресурс и разрывать связь с ресурсом на протяжении своей жизни. В любом случае ресурс будет жить, пока есть хоть один объект, связанный с ресурсом.
7. Итоги
========
Класс, управляющий ресурсом, не должен иметь копирующий конструктор, оператор копирующего присваивания и деструктор, сгенерированные компилятором по умолчанию. Эти функции-члены должны быть определены в соответствии со стратегией копирования-владения.
Существует 4 основные стратегии копирования-владения:
1. Стратегия запрета копирования.
2. Стратегия исключительного владения.
3. Стратегия глубокого копирования.
4. Стратегия совместного владения.
Функцию обмена состояниями следует отнести к базовым операциям класса. Она используется в алгоритмах стандартной библиотеки, а также для определения других функций-членов класса: оператора копирующего присваивания, перемещающего конструктора и оператора перемещающего присваивания, функций-членов захвата и освобождения ресурса.
Определение перемещающего конструктора и оператора перемещающего присваивания позволяет оптимизировать работу с классами, использующими стратегию глубокого копирования. Для классов, использующих стратегию запрета копирования, это позволяет расширить стратегию копирования-владения, реализовать более гибкую схему управления жизненным циклом ресурса, упростить размещение объектов в контейнерах.
При проектировании класса-владельца ресурса можно рекомендовать следующую последовательность действий. Начинать надо с запрета копирования. Если компиляция выявляет необходимость копирования и простыми средствами этого не удается избежать, то надо попробовать создавать объекты в динамической памяти и использовать интеллектуальные указатели для управления их временем жизни (см. раздел 6.2.3). Если такой вариант не устраивает, то придется реализовать семантику перемещения (см. раздел 6.2.1). Одним из основных потребителей копирования являются контейнеры стандартной библиотеки, и реализация семантики перемещения снимает практически все ограничения по их использованию. Как было сказано выше, самостоятельной реализации стратегии глубокого копирования лучше избегать, реальная потребность в ней возникает редко. Самостоятельной реализации стратегии разделяемого владения также лучше избегать, вместо этого следует использовать интеллектуальный указатель `std::shared_ptr<>`.
Приложения
==========
Приложение А. Rvalue-ссылки
---------------------------
Rvalue-ссылки это разновидность обычных C++ ссылок, отличие состоит в правилах инициализации и правилах разрешения перегрузок функций, имеющих параметры типа rvalue-ссылка. Тип rvalue-ссылки для типа `T` обозначаются через `T&&`.
Для примеров будем использовать класс:
```
class Int
{
int m_Value;
public:
Int(int val) : m_Value(val) {}
int Get() const { return m_Value; }
void Set(int val) { m_Value = val; }
};
```
Как и обычные ссылки, rvalue-ссылки необходимо инициализировать.
```
Int&& r0; // error C2530: 'r0' : references must be initialized
```
Первым отличием rvalue-ссылок от обычных С++ ссылок заключается в том, что их нельзя инициализировать с помощью lvalue. Пример:
```
Int i(7);
Int&& r1 = i; // error C2440: 'initializing' : cannot convert from 'Int' to 'Int &&'
```
Для корректной инициализации необходимо использовать rvalue:
```
Int&& r2 = Int(42); // OK
Int&& r3 = 5; // OK
```
или lvalue должно быть явно приведено к типу rvalue-ссылки:
```
Int&& r4 = static_cast(i); // OK
```
Вместо оператора приведения к типу rvalue-ссылки обычно используется функция (точнее шаблон функции) `std::move()`, делающая то же самое (заголовочный файл ).
Rvalue ссылки можно инициализировать с помощью rvalue встроенного типа, для обычных ссылок это запрещено.
```
int&& r5 = 2 * 2; // OK
int& r6 = 2 * 2; // error
```
После инициализации rvalue-ссылки можно использовать как обычные ссылки.
```
Int&& r = 7;
std::cout << r.Get() << '\n'; // Вывод: 7
r.Set(19);
std::cout << r.Get() << '\n'; // Вывод: 19
```
Rvalue-ссылки неявно приводятся к обычным ссылкам.
```
Int&& r = 5;
Int& x = r; // OK
const Int& cx = r; // OK
```
Rvalue-ссылки редко используются как самостоятельные переменные, обычно они используются как параметры функций. В соответствии с правилами инициализации, если функция имеет параметры типа rvalue-ссылок, то ее можно вызвать только для rvalue аргументов.
```
void Foo(Int&&);
Int i(7);
Foo(i); // error, lvalue аргумент
Foo(std::move(i)); // OK
Foo(Int(4)); // OK
Foo(5); // OK
```
Если имеются несколько перегруженных функций, то при разрешении перегрузки для rvalue аргумента версия с параметром типа rvalue-ссылка имеет приоритет над версией с параметром типа обычная ссылка или обычная ссылка на константу, хотя последние и могут быть допустимыми вариантами. И это правило является второй ключевой особенностью rvalue-ссылок.
Функция с параметром, передаваемым по значению, и перегруженная версия, имеющая параметр типа rvalue-ссылка, будут неразрешимы (ambiguous) для rvalue аргументов.
Для примера рассмотрим перегруженные функции
```
void Foo(Int&&);
void Foo(const Int&);
```
и несколько вариантов их вызова
```
Int i(7);
Foo(i); // Foo(const Int&)
Foo(std::move(i)); // Foo(Int&&)
Foo(Int(6)); // Foo(Int&&)
Foo(9); // Foo(Int&&)
```
Следует обратить внимание на один важный момент: именованная rvalue-ссылка сама по себе является lvalue.
```
Int&& r = 7;
Foo(r); // Foo(const Int&)
Foo(std::move(r)); // Foo(Int&&)
```
Это надо учитывать при определении функций, имеющих параметры типа rvalue-ссылка, такие параметры являются lvalue и могут потребовать использования `std::move()`. См. пример перемещающего конструктора и оператора перемещающего присваивания в разделе 2.4.
Еще одно нововведение С++11, связанное с rvalue-ссылками — это ссылочные квалификаторы для нестатических функций-членов. Они позволяют перегружать по типу (lvalue/rvalue) скрытого параметра `this`.
```
class X
{
public:
X();
void DoIt() &; // this указывает на lvalue
void DoIt() &&; // this указывает на rvalue
// ...
};
X x;
x.DoIt(); // DoIt() &
X().DoIt(); // DoIt() &&
```
Приложение Б. Семантика перемещения
-----------------------------------
Для классов, владеющих ресурсом типа буфера памяти и использующих стратегию глубокого копирования ресурса (`std::string`, `std::vector<>`, etc.) актуальна проблема предотвращения создания временных копий ресурса. Один из самых эффективных способов решения этой проблемы — это реализация семантики перемещения. Для этого определяются перемещающий конструктор, имеющий параметр типа rvalue-ссылка на источник и оператор перемещающего присваивания с таким же параметром. При их реализации данные, включая дескриптор ресурса, копируются из объекта-источника в целевой объект, и дескриптор ресурса объекта-источника обнуляется, копирование ресурса не происходит. В соответствии с описанным выше правилом перегрузки, в случае, когда класс имеет копирующий конструктор и перемещающий, то перемещающий будет использован для инициализации с помощью rvalue, а копирующий для инициализации с помощью lvalue. Если класс имеет только перемещающий конструктор, то объект можно инициализировать только с помощью rvalue. Аналогично работает оператор присваивания. Семантика перемещения также используется при возврате из функции значения, созданного локально (в том числе и lvalue), если при этом не было применено RVO.
Список литературы
=================
**Список**[Alexandrescu]
Александреску, Андрей. Современное проектирование на C++.: Пер. с англ. — М.: ООО «И.Д. Вильямс», 2002.
[Guntheroth]
Гантерот, Курт. Оптимизация программ на C++. Проверенные методы для повышения производительности.: Пер. с англ. — СПб.: ООО «Альфа-книга», 2017.
[Josuttis]
Джосаттис, Николаи М. Стандартная библиотека C++: справочное руководство, 2-е изд.: Пер. с англ. — М.: ООО «И.Д. Вильямс», 2014.
[Dewhurst1]
Дьюхерст, Стивен С. C++. Священные знания, 2-е изд.: Пер. с англ. — СПб.: Символ-Плюс, 2013.
[Dewhurst2]
Дьюхэрст, Стефан К. Скользкие места C++. Как избежать проблем при проектировании и компиляции ваших программ.: Пер. с англ. — М.: ДМК Пресс, 2012.
[Meyers1]
Мейерс, Скотт. Наиболее эффективное использование C++. 35 новых рекомендаций по улучшению ваших программ и проектов.: Пер. с англ. — М.: ДМК Пресс, 2000.
[Meyers2]
Мейерс, Скотт. Эффективное использование C++. 55 верных способов улучшить структуру и код ваших программ.: Пер. с англ. — М.: ДМК Пресс, 2014.
[Meyers3]
Мейерс, Скотт. Эффективный и современный C++: 42 рекомендации по использованию C++11 и C ++14.: Пер. с англ. — М.: ООО «И.Д. Вильямс», 2016.
[Sutter]
Саттер, Герб. Решение сложных задач на C++.: Пер. с англ. — М: ООО «И.Д. Вильямс», 2015.
[Sutter/Alexandrescu]
Саттер, Герб. Александреску, Андрей. Стандарты программирования на С++.: Пер. с англ. — М.: ООО «И.Д. Вильямс», 2015.
[Schildt]
Шилдт, Герберт. Искусство программирования на C++.: Пер. с англ. — СПб.: БХВ-Петербург, 2005.
[Alger]
Элджер, Джефф. C++: библиотека программиста.: Пер. с англ. — СПб.: ЗАО «Издательство «Питер», 1999. | https://habr.com/ru/post/425837/ | null | ru | null |
# Отлаживайте ваши приложения .NET Core в WSL 2 с Visual Studio
Вы разработчик .NET Core, которому нравится работать в Windows и Visual Studio, но вам нужно протестировать свое приложение в Linux? Вы кросс-платформенный разработчик, которому нужен простой способ тестирования большего количества целевых сред? Вы уже открыли для себя преимущества WSL 2, но вам нужен способ интегрировать его во внутренний цикл? У меня есть для вас расширение! Расширение [.NET Core Debugging с WSL 2 — Preview](https://aka.ms/wsldebug) дает вам возможность запускать и отлаживать приложения .NET Core в WSL 2, не выходя из Visual Studio.
Когда нужно отлаживать в WSL 2?
-------------------------------
Для пользователя Windows .NET, ориентированного на Linux, WSL 2 находится в правильном месте между production realism и производительностью. В Visual Studio вы уже можете отлаживать в удаленной среде Linux с помощью удаленного отладчика ([Remote Debugger](https://docs.microsoft.com/en-us/visualstudio/debugger/remote-debugging-dotnet-core-linux-with-ssh)) или с контейнерами с помощью инструментов для работы с контейнерами ([Container Tools](https://docs.microsoft.com/en-us/visualstudio/containers/overview)). Когда ваша главная забота — production realism, вам следует использовать один из них. Когда более важен простой и быстрый внутренний цикл, WSL 2 — отличный вариант.
> Необязательно выбирать только одно! У вас может быть профиль запуска для Docker и WSL 2 в одном проекте и выбрать тот, который подходит для конкретного запуска. И как только ваше приложение развернуто, вы всегда можете использовать удаленный отладчик, чтобы подключиться к нему в случае возникновения проблемы.
Начало работы с .NET Core Debugging with WSL 2 – Preview
--------------------------------------------------------
Перед использованием расширения обязательно установите [WSL 2](https://aka.ms/wsl2) и выбранный вами [дистрибутив](https://aka.ms/wslstore). После установки расширения при открытии веб-приложения ASP.NET Core или консольного приложения .NET Core в Visual Studio вы увидите новый профиль запуска с именем WSL 2:
Выбор этого профиля добавит его в файл launchSettings.json и будет выглядеть примерно так:
```
"WSL 2": {
"commandName": "WSL2",
"launchBrowser": true,
"launchUrl": "https://localhost:5001",
"environmentVariables": {
"ASPNETCORE_URLS": "https://localhost:5001;http://localhost:5000",
"ASPNETCORE_ENVIRONMENT": "Development"
},
"distributionName": ""
}
```
После выбора нового профиля расширение проверяет, настроен ли ваш дистрибутив WSL 2 для запуска приложений .NET Core, и помогает вам установить любые недостающие зависимости. После того, как все зависимости установлены, вы готовы к отладке в WSL 2. Просто запустите отладку как обычно, и теперь ваше приложение будет работать в дистрибутиве WSL 2 по умолчанию. Простой способ убедиться, что вы работаете в Linux, — это проверить значение Environment.OSVersion.
> Примечание. Только Ubuntu и Debian были протестированы и поддерживаются. Другие дистрибутивы, поддерживаемые .NET Core, должны работать, но требуют ручной установки .NET Core Runtime и Curl.
Использование определенного дистрибутива
----------------------------------------
По умолчанию профиль запуска WSL 2 будет использовать распределение по умолчанию, установленное в wsl.exe. Если вы хотите, чтобы ваш профиль запуска был нацелен на конкретный дистрибутив, независимо от этого по умолчанию, вы можете изменить свой профиль запуска. Например, если вы отлаживаете веб-приложение и хотите протестировать его на Ubuntu 20.04, ваш профиль запуска будет выглядеть так:
```
"WSL 2": {
"commandName": "WSL2",
"launchBrowser": true,
"launchUrl": "https://localhost:5001",
"environmentVariables": {
"ASPNETCORE_URLS": "https://localhost:5001;http://localhost:5000",
"ASPNETCORE_ENVIRONMENT": "Development"
},
"distributionName": "Ubuntu-20.04"
}
```
Ориентация на несколько дистрибутивов
-------------------------------------
Идя еще дальше, если вы работаете над приложением, которое нужно запускать в нескольких дистрибутивах, и вам нужен быстрый способ протестировать каждый из них, у вас может быть несколько профилей запуска. Например, если вам нужно протестировать консольное приложение в Debian, Ubuntu 18.04 и Ubuntu 20.04, вы можете использовать следующие профили запуска:
```
"WSL 2 : Debian": {
"commandName": "WSL2",
"distributionName": "Debian"
},
"WSL 2 : Ubuntu 18.04": {
"commandName": "WSL2",
"distributionName": "Ubuntu-18.04"
},
"WSL 2 : Ubuntu 20.04": {
"commandName": "WSL2",
"distributionName": "Ubuntu-20.04"
}
```
С помощью этих профилей запуска вы можете легко переключаться между целевыми дистрибутивами, не покидая комфортной среды Visual Studio:
Попробуйте сегодня!
-------------------
Итак, если вам нравится работать в Visual Studio, но вам нужно протестировать свое приложение в Linux, перейдите в [Visual Studio Marketplace](https://aka.ms/wsldebug), чтобы установить расширение сегодня. Пожалуйста, используйте маркетплейс, чтобы задать любые вопросы и оставить свой отзыв, а также чтобы сообщить нам, насколько полезно это расширение. | https://habr.com/ru/post/519852/ | null | ru | null |
# Как я завалил собеседование в Twitter
До 28 октября я должен был принять решение, буду ли я работать в Amazon по окончанию стажировки. Оставалось совсем немного времени, но мой друг Дэниел убедил меня, что если я попробую попасть в Twitter, то как раз успею пройти все интервью. Я не смог устоять.
Сначала меня попросили решить пару вопросов с [Codility](http://codility.com), дав на все про все час времени. Вопросы попались средней интересности («является ли слово анаграммой палиндрома» и «посчитать количество [седловых точек](http://www.geeksforgeeks.org/equilibrium-index-of-an-array/) в двумерном массиве»). Я был не слишком уверен в получившихся решениях, но вскоре Джуди прислала мне письмо с приглашением на телефонное интервью в среду в 17:30.
Не знаю, как вы, а я обычно сильно нервничаю перед собеседованиями — всегда боюсь, что интервьюер может подумать, что я недостаточно сообразителен. Поэтому в среду к 17:20 на моем опустевшем столе уже лежали 2 остро заточенных карандаша и блокнот, а сам я был в полной боевой готовности… Наступило 17:30, и ничего не произошло. Прождав еще пятнадцать минут, я полез в Google выяснить, правильно ли рассчитал разницу во времени и который час в Калифорнии. Ошибки не было — я отписался на почту Джуди, попросив ее разобраться с ситуацией.
Спустя десять минут раздался звонок из Сан-Франциско. Джуди извинилась за возникшую путаницу и сказала мне, что Джастин может провести со мной интервью прямо сейчас.
*Глубокий вздох*
«Отлично, я готов!»
Джастин также извинился за ошибку в расписании и сразу перешел к программированию.
> Взгляните на следующую картинку:
>
>
>
> 
>
>
>
> На этой картинке у нас есть стены различной высоты. Картинка представлена массивом целых чисел, где индекс — это точка на оси X, а значение каждого индекса — это высота стены (значение по оси Y). Картинке выше соответствует массив [2,5,1,2,3,4,7,7,6].
>
>
>
> Теперь представьте: идет дождь. Сколько воды соберется в «лужах» между стенами?
>
>
>
> 
>
>
>
> Мы считаем единицей объема воды квадратный блок 1х1. На картинке выше все, что расположено слева от точки 1, выплескивается. Вода справа от точки 7 также прольется. У нас остается лужа между 1 и 6 — таким образом, получившийся объем воды равен 10.
---
###### Для самых нетерпеливых
Ссылка на [гист](https://gist.github.com/mkozakov/59af0fd5bddbed1a0399) с правильным решением задачи, которое подробнее разъясняется в конце поста. Остальные могут спокойно читать дальше — спойлеров не будет.
---
Первым делом я попробовал определить, сколько воды мы будем иметь в каждом из индексов. На ум сразу пришла связь с математическим анализом и интегралами, — в частности, идея поиска локальных максимумов могла бы мне пригодиться. И действительно, на предыдущей картинке вода над точкой 2 ограничена меньшими из двух окружающих ее максимумов — в точках 1 и 6.
Я вслух произнес: «Что, если мы найдем все локальные максимумы и посчитаем заполненное водой пространство между ними — это сработает?»
«Да, это должно сработать», ответил Джастин.
После такого ответа я решил, что пошел в верном направлении, и закодил свое решение. Следом Джастин попросил меня написать несколько тестов, что я также проделал. Все тесты, о которых мы говорили, вроде бы отработали.
«Будут еще какие-либо вопросы ко мне?», спросил Джастин. «Ну и как я вам?» «Достаточно неплохо, хотя ваше решение делает 2 прохода, но есть другой интересный алгоритм, который делает всего один проход».
Затем мы немного пообщались на тему жизни в Twitter.
И, в тот самый момент, когда я повесил трубку, я вдруг понял: мое решение было неверным.
Возьмем следующие входные данные:
Мое решение искало всю воду между локальными максимумами и выглядело следующим образом:
Но результатом должна была быть одна «лужа» между двумя высокими башнями:
На следующий день я показал эту задачу знакомому аспиранту, занимающемуся теоретическим computer science. После 40 минут размышлений у него также ничего не получилось.
Но сегодня утром я после пробуждения меня осенило — решение оказалось красивым и простым.
Я спрашиваю себя: чему я научился в итоге? На самом деле — немногому. Я слегка расстроен из-за того, что интервьюер не задал мне направляющего вопроса. Я не знаю, почему Джастин сказал мне, что это «должно сработать», когда на самом деле мое решение было неправильным. Знаю, что это должно было вылезти в тестах, которые он просил провести, но поскольку я упустил один важный момент во время разработки алгоритма, то и протестировать его не смог догадаться.
Следующим летом я иду работать в Amazon, что не может меня не радовать, но вопрос «а что, если бы?» по-прежнему не оставляет меня.
---
Правильное решение: [gist](https://gist.github.com/mkozakov/59af0fd5bddbed1a0399).
**Посмотреть**
```
/* package whatever; // don't place package name! */
import java.util.*;
import java.lang.*;
import java.io.*;
/* Name of the class has to be "Main" only if the class is public. */
class Ideone
{
public static void main (String[] args) throws java.lang.Exception
{
int[] myIntArray = {2, 5, 1, 2, 3, 4, 7, 7, 6};
System.out.println(calculateVolume(myIntArray));
}
public static int calculateVolume(int[] land) {
int leftMax = 0;
int rightMax = 0;
int left = 0;
int right = land.length - 1;
int volume = 0;
while(left < right) {
if(land[left] > leftMax) {
leftMax = land[left];
}
if(land[right] > rightMax) {
rightMax = land[right];
}
if(leftMax >= rightMax) {
volume += rightMax - land[right];
right--;
} else {
volume += leftMax - land[left];
left++;
}
}
return volume;
}
}
```
Логика следующая:
Если мы проходим по списку слева направо, количество воды в каждом индексе будет не больше абсолютного максимума, который мы обнаружим заранее. Это означает, что если мы точно знаем, что есть что-то большее или равное где-то справа, то мы можем точно определить, сколько воды мы можем удержать без выплескивания. То же справедливо и для противоположного направления: если мы знаем, что нашли слеваа стену выше самой высокой в правой части, то это означает, что мы с уверенностью можем заполнить ее водой.
Итак, теперь решение выглядит следующим образом: найти абсолютный максимум, после чего пройти слева до максимума и затем пройти справа до максимума. Это решение требует два прохода: один для поиска максимума, и второй — разбитый на две части.
Решение в приведенном гисте работает в один проход, избегая поиска максимума проходом двух «указателей» навстречу друг другу с противоположных концов массива. Если наибольшее значение, найденное **слева от левого** указателя меньше, чем наибольшее значение найденное **справа от правого** указателя, то мы сдвигаем левый указатель на один индекс вправо. В противном случае, двигаем правый указатель на один индекс влево. Повторяем до тех пор, пока два указателя не пересекутся. (На словах звучит запутанно, код на самом деле очень простой)
Оригинал поста: [Q & What?](http://qandwhat.apps.runkite.com/i-failed-a-twitter-interview/). | https://habr.com/ru/post/200190/ | null | ru | null |
# Проверяем скорость работы промисов
В этой статье решил выложить довольно интересные, на мой взгляд, результаты бенчмарка собственного производства. Данный бенчмарк создан с целью выяснить скорость работы нативных и bluebird-промисов.
Исходный код бенчмарка (вариант №1):
```
var Promise = require('bluebird'); // Если хотите проверить скорость работы нативных промисов то необходимо закомментировать данную строку.
var crypto = require('crypto');
var iterations = 1000000;
var start = Date.now();
var arrayPromises = [];
var promiseWrap = function () {
return new Promise(function (resolve, reject) {
crypto.randomBytes(256, (err, buf) => {
if (err) reject(err);
resolve(buf);
});
});
};
for(var i = 0; i < iterations; i++){
arrayPromises.push(promiseWrap());
}
if(arrayPromises.length === iterations){
Promise.all(arrayPromises).then(function (result) {
var finish = Date.now()-start;
console.log("Бенчмарк промисов выполнен!");
console.log("Время выполнения "+finish/1000+" сек.");
});
}
```
Исходный код бенчмарка (вариант №2):
```
var Promise = require('bluebird'); // Если хотите проверить скорость работы нативных промисов то необходимо закомментировать данную строку.
var crypto = require('crypto');
var iterations = 1000000;
var start = Date.now();
var arrayPromises = [];
var promiseWrap = function () {
return new Promise(function (resolve, reject) {
setTimeout(function () {
resolve(Math.random(1));
},0)
});
};
for(var i = 0; i < iterations; i++){
arrayPromises.push(promiseWrap());
}
if(arrayPromises.length === iterations){
Promise.all(arrayPromises).then(function (result) {
var finish = Date.now()-start;
console.log("Бенчмарк промисов выполнен!");
console.log("Время выполнения "+finish/1000+" сек.");
});
}
```
Данный бенчмарк в качестве результата выводит время, за которое резолвятся все промисы. Результаты бенчмарка на моей машине:
Время выполнения:
> Нативные промисы (вариант №1 node v6.4.0) — 19.808 сек.
>
> Bluebird-промисы (вариант №1 node v6.4.0) — 9.654 сек.
>
> Нативные промисы (вариант №1 node v6.5.0) — 19.957 сек.
>
> Bluebird-промисы (вариант №1 node v6.5.0) — 9.723 сек.
>
> Нативные промисы (вариант №2 node v6.5.0) — 10.61 сек.
>
> Bluebird-промисы (вариант №2 node v6.5.0) — 2.208 сек.
Максимальное значение выделенной памяти (rss):
> Нативные промисы (вариант №2 node v6.5.0) — 1282 Мб.
>
> Bluebird-промисы (вариант №2 node v6.5.0) — 601 Мб.
Среднее значение выделенной памяти (rss):
> Нативные промисы (вариант №2 node v6.5.0) — 368 Мб.
>
> Bluebird-промисы (вариант №2 node v6.5.0) — 297 Мб.
**Вывод:** bluebird промисы работают быстрее нативных промисов в 2-5 раз, а так же требуют гораздо меньше оперативной памяти.
Если я в чем то ошибаюсь, то большая просьба сообщить в комментариях. Буду очень рад услышать от вас, какие либо поправки.
» [Ссылка на библиотеку bluebird](https://github.com/petkaantonov/bluebird/) | https://habr.com/ru/post/308944/ | null | ru | null |
# Автоматическая оптимизация настроек MySQL, PostgreSQL
Оптимизация настроек всегда дело тонкое и выставить именно те параметры, которые дадут максимальную производительность, зачастую можно только уже в процессе работы приложения, когда уже есть статистика нагрузки и видны узкие места.
Но очень полезно сделать и первичную оптимизацию при запуске СУБД. В этом посте рассмотрены пути автоматической оптимизации MySQL и PostgreSQL утилитами mysqltuner и pgtune.
##### MySQL
Для оптимизации mysql существует простая и удобная в использовании утилита mysqltuner.
Раздобыть ее в безвозмездное пользование можно на github, а именно [тут](https://github.com/rackerhacker/MySQLTuner-perl). Или загрузить одной командой:
```
wget https://raw.github.com/rackerhacker/MySQLTuner-perl/master/mysqltuner.pl
```
Пользоваться просто: загружаем mysqltuner.pl на сервер с mysql, ставим права на запуск для файла (или запускаем так: perl mysqltuner.pl), на запрос логина / пароля даем учетку с привилегированными правами и смотрим рекомендации.
Рекомендации заносим в конфиг, перезапускаем mysql-server. Или применяем «налету» через консоль mysql, если проект уже запущен и перезапуск нежелателен.
Кроме советов по настройкам mysql, утилита так же показывает информацию о индексах в таблицах и фрагментации, если mysql уже какое-то время используется.
Про индексы нередко забывают, что сильно повышает потребление ресурсов системы.
Простановку индексов лучше поручить тем, кто проектировал структуру базы, но можно и самостоятельно.
Для дефрагментации запускаем OPTIMIZE TABLE из консоли mysql, но удобнее сделать для всех таблиц разом через интерфейс типа phpMyAdmin.
По дальнейшей оптимизации в процессе работы проекта уже смотрим по ситуации и увеличиваем нужные параметры.
Полезная информация описана моим коллегой в [этой статье](http://habrahabr.ru/post/159085/).
Для большей производительности полезно использовать Percona Server на замену стандартному MySQL Server.
О пользе можно судить из [графиков производительности](http://www.percona.com/software/percona-server/benchmarks).
Про Percona Server уже достаточно много статей на Хабре, но в будущем поделюсь и своим опытом использования этой сборки.
##### PostgreSQL
Для тюнинга настроек PostgreSQL так же существует полезная утилита под названием [pgtune](https://github.com/gregs1104/pgtune.git).
В отличие от mysqltuner, утилита не дает рекомендаций, а сразу создает конфигурационный файл postgresql.conf с параметрами, оптимальными для системы, на которой запущен PostgreSQL.
Схема использования следующая:
`pgtune -i $PGDATA/postgresql.conf -o $PGDATA/postgresql.conf.pgtune`
где $PGDATA — путь к директории с конфигом сервера postgresql.conf. На выходе получаем файл postgresql.conf.pgtune, в котором выставлены подобранные утилитой параметры. Эти параметры утилита записывает в конец файла после блока
```
#------------------------------------------------------------------------------
# pgtune wizard run on YYYY-MM-DD
# Based on XXXXXXX KB RAM in the server
#------------------------------------------------------------------------------
```
Можно использовать дополнительные параметры, чтобы выставить значения параметров не на основе определенных автоматически характеристик сервера, а по своему усмотрению:
-M или --memory — полный размер ОЗУ на сервере, на основе которого выделяются ресурсы памяти для PostgreSQL;
-T или --type — Указывает тип базы данных: DW, OLTP, Web, Mixed, Desktop;
-с или --connections — Максимально возможное количество подключений к базе; Если значение не указано, определяется на основе типа базы;
-D или --debug — Включает режим отладки в PostgreSQL
-S или --settings — Устанавливает к директории, в которойрасположен конфигурационный файл.
После завершения работы утилиты редактируем сгенерированный файл postgresql.conf.pgtune при необходимости (например, выставить нестандартный порт или настроить логирование ), заменяем им конфигурационный файл postgresql.conf и перезапускаем PostgreSQL-server.
Буду рад любым вопросам / замечаниям / дополнениям! | https://habr.com/ru/post/160395/ | null | ru | null |
# О Структурном Моделировании Организационных Изменений
> 75%
> ====
>
>
>
> 3 из 4 — так Boston Consulting Group оценивает долю IT проектов, почивших по не-техническим причинам.
>
>
>
> Уже вот две подряд редакции свода знаний по управлению проектами (PMBOK) выделяют процессы по управлению стейкхолдерами в отдельную область знаний под счастливым номером 13 и настоятельно рекомендуют учитывать:
>
>
>
> 1. связи между ними,
>
> 2. центры влияния, а также
>
> 3. культуру общения — для повышения шансов на успех.
Вопрос один:
============
```
доколе инженеры о стейкхолдерах будут судить догадками?
```
ФОТО: Шариф Хамза для Dazed & Confuzed, модель — Люпита Нионго
В свете недавней безоговорочной [победы](https://nplus1.ru/material/2019/05/30/stephen-hedetniemi-refutation) русской математики над вопросом хроматических чисел рассмотрим сценарий применения стремительно набирающей популярность среди занимающихся машинным обучением теории графов к причине провала большинства IT проектов. Приложим вполне естественную науку о вычислениях к областям, ранее считавшимся '*мягкими*'. И покажем, как современные модели позволяют организацию в эпоху перемен измерить. Стратегия решения — простая, двухшаговая — строим граф связей стейкхолдеров, а из него — нейросеть сворачиваем. И пока самообучаемые алгоритмы выполняют непростые управленческие задачи, снимая менеджерских проблем ворох с плеч человеческих — пьём кофе с пироженками.
Содержание
==========
1. [Цели и задачи](#objectives)
2. [Предлагаемый подход](#method)
3. [Что изучать](#data)
4. [Как измерять](#measure)
5. [Набросок бизнес-кейса](#sketch)
6. [Скажи мне, кто твой друг (или механика работы свёртки графа)](#convolution)
7. [Уголок красный из моделей прекрасных](#stack_more_layers)
8. [Резюме вышесказанного](#summary)
9. [Выводы](#conclusions)
10. [Подборка литературы](#references)
11. [Памятка воспроизводителю](#reproduce)
12. [И в очередь запись](#request)
Задачи и незадачи
-----------------
Проекты трансформации бизнеса, например, внедрения SAP — зачастую изменяют бизнес-процессы, либо организационную структуру. Порой и то, и другое переиначивают в погоне за лучшими практиками. Однако, есть нюанс. Приверженность к существующему (status quo bias) среди людей делает трансформацию бизнеса вызовом — мы, как вид, стремимся сберечь и приумножить.
Занятный факт — примерно 80% популяции не будут рады нововведениям [1]. BCG сообщает, что три из четырёх провальных проектов в области информационных технологий завернулись по не-техническим, так называемым 'мягким' причинам. Управление Организационными Изменениями — это набор практик, которые упреждают сопротивление новому. Рецепт SAP — управляйте коммуникациями, мотивацией, правами принятия решений, и квалификациями, необходимыми для успешного внедрения и перехода в фазу непрерывного улучшения[2].
В недавнем интервью Леонид Жуков (директор российской практики BCG Gamma) упоминал правило 10-20-70. В реальных проектах внедрения машинного обучения 10% от всего затраченного времени уходит на проверку гипотезы и выбор адекватной модели. 20% трудозатрат потребляет реализация продуктива (или модный молодёжный DevOps). 70% усилий требуют перемены.
ВИДЕО: вот то интервью о буднях консалтинга, в котором мне особенно нравится история про вертолёт в бассейне
В каком-то смысле, условия достижения успеха можно выразить неравенством A + B + C > D, где A — уровень недовольства текущим состоянием дел, B — общее видение проблемы, C — выгоды от проверки гипотезы, и D — требуемое для трансформации усилие. Всё просто — создайте условия, в которых формула верна для всех и каждого — и перемены стремительно распространятся. Похоже, победа легка, верно?
Анализ стейкхолдеров — сердце проектов трансформации. Основная задача заключается в поиске и идентификации лиц и организаций, на которых перемены повлияют, либо тех, кто сам на наш проект повлиять может. Ранжирование стейкхолдеров по силе и влиянию — распространённая практика (по крайней мере, среди играющих в управление проектами). Исторически сложилось так, что задачу решали субъективно — мозговыми штурмами и прочими инструментами, происходящими из социологической исследовательской традиции. Надёжных численных метрик не существовало. До сего дня.
Недавние достижения математики в области теории графов позволяют вопрос измерить. Прежде всего, обозначим задачу формально и определим способ математической записи, который мы будем использовать в дальнейшем.
> Задача:
> =======
>
>
>
>
>
> По заданной организационной структуре и бизнес-процессам, описанным для состояний как-есть и как-будет, ранжировать стейкхолдеров по масштабу индивидуальных перемен (требуемое для трансформации усилие).
Делай так
---------
Опиши бизнес-кейс как отношения и потоки операций.
Многие зрелые организации управляют процессами структурированно (порой сподвигают к этому внешние требования, вроде сертификации ISO). У большинства предприятий организационная структура формализована. В результате построения модели из данных — получим сеть связей, которую и будем анализировать.
Шагая в ногу со временем, изобразим затеянные перемены в духе стандарта [IBCS](https://www.ibcs.com/standards), который утверждает, что палитра деловых рисунков может содержать всю гамму чёрного цвета. Слева — ситуация как-есть, справа — как будет. Стейкхолдеры пронумерованы и связаны: тонкими линиями оргструктуры, и стрелками потока операций. Смена руководства для #9 показана разрывом отношения подчинённости 4-9 в ситуации как-есть, и новой связью 5-9 для как-будет.
Представьте себе, что нам предстоит помочь лягушонку Пепе. Загрузило его начальство трансформацией процесса выхолущивания сепулек в компании — игроке второго эшелона.
Состояние дел как-есть описано, а вот с как-будет — не то, чтобы беда, но муки выбора. И книжки прочитаны, и конференции посещены, и даже пара кейсов от лидера рынка и претендента на лавры от уважаемых консалтинговых компаний изучено. Перенести чужой опыт на свой бизнес — та ещё задача.
После N, нет, пусть лучше будет M бессонных ночей видение кристаллизовалось в два варианта как-будет. Здесь, руководствуясь исключительно светлой целью сделать повествование более красочным, отойдём от требований стандарта IBCS и цветов добавим. Как-есть мы недовольны, поэтому изобразим его красным, а как-будет — зелёным и жёлтым соответственно.
Граф, обозначаемый  — это математическая модель — множество множеств — попарные отношения, называемые рёбрами (связями, арками) и обозначаемые как  для любой существующей связи между двумя вершинами (узлами)  и . Как вершины, так и рёбра могут обладать свойствами (например: профиль пользователя, сила связи, либо её тип).
> Что изучать
> -----------
>
>
>
>
>
> Характер связей в сети определяет поведение системы — как единого целого, так и её составных частей — именно рёбра описывающего ситуацию графа соединяют подразделения, распространяют нагрузку, либо же добавляют структурных напряжений. Мы будем стремиться к тому, чтобы обнаружить как можно больше связей. Организационная структура и бизнес-процессы, описанные для состояний как-есть и как-будет — это минимальное количество информации, с помощью которого наша модель выдаёт суждения на уровне человека-профессионала.
>
>
Как мерить
-----------
Анализ данных всегда был важной частью методологии проведения организационных изменений SAP. Изучение структуры организации, процессов, и стейкхолдеров — обычное дело. Исследованиями среды, в которой происходят (либо хотелось бы провести) перемены — занимаются уже не первое десятилетие. Например, BCG может похвастать 50 годами опыта в трансформации бизнеса. А первая редакция фундаментального труда Роджерса (Diffusion of Innovations), из которой выросли все современные методологии управления изменениями, увидела свет ещё в 1962.
Новая — только арифметика.
Семейство алгоритмов, вдохновлённых биологией (графовые нейронные сети) открывает нам новую забавную алгебру — мы приобретаем возможность рассуждать о характере связей и проводить вычисления в пространстве, в котором мы можем с высокой точностью измерять подобие структур.
Набросок бизнес-кейса
---------------------
Пронумеруем вершины графа и попробуем думать как хорошо образованные профессионалы в проведении организационных изменений. Оценим масштаб перемен для каждого участника организации в отдельности. В качестве примера возьмём вершину #7, украшенную мозаикой в духе Кандинского.
Жил себе стейкхолдер, не тужил. Участвовал в процессе как-есть. И было у него трое в подчинении. Двое — в прямом: #8 и #9, да один ещё подчинённый подчинённого #10.
Пришли инноваторы.
Предложили двух (#8 и #10) из троих удалить. Взамен — добавить ещё одного кадра #11 в соседний отдел. И процесс выхолущивания сепулек по-новому структурировать. Поток работ в новом дивном мире инициирует новый участник #6 — ранее это делал его руководитель #3.
Вариант 1:
Будет наш стейкхолдер в процесс вовлечён непрямо — работу работать придумали единственному из оставшихся подчинённых #9 — ранее он выполнял другую операцию (теперь её будет выполнять шеф стейкхолдера #4).
Вариант 2:
Стейкхолдер продолжит выполнять первую операцию в процессе, а вторую — вместо подчинённого #9 — будет делать его босс #4.
Проанализировав таким образом характер перемен для каждого в отдельности, уже можно делать какие-то выводы о масштабе трансформации. Здесь читатель стоит перед выбором: выполнить упражнение самостоятельно, либо же запросить ранний доступ к полному разбору кейса.
Как правило, после  итераций, хорошо образованный профессионал в проведении организационных изменений способен выдать адекватную оценку масштаба перемен для каждого стейкхолдера, и ранжировать их соответственно, где  — количество стейкхолдеров. Отличный профессионал управится за . Отличная же творческая личность, придумавшая формулу сложения всех незадач, выдающую какую-то численную оценку перемен, да к тому же ещё и умеющая в сортировку в экселе, вообще имеет все шансы асимптотически приблизиться к .
Альтернативой рассмотренного аналогового метода оценки будет использование современной математики.
Вариант 1. Масштаб изменений процесса и структуры. Архитектура модели: два слоя свёртки, симметричная матрица связности, активация — линейно. Дистанция — косинусная.
Как это нетрудно видеть, вершины #8 и #10 (удалены) и #11 (добавлена) получают наивысшую оценку по шкале изменений структуры организации. #9 и #5 получают почти равные оценки — первый лишится подчинённого, второй — приобретёт. Можно сказать, модель полагает, что без работника оказаться — немногим хуже, чем с новым. Для верхушки иерархии #0, #1, и #2 ситуация практически не меняется. Отметим то, что для #2 заметно незначительное отличие — все изменения структуры происходят среди её подчинённых.
Сравним сценарии затеянной трансформации. Ради простоты интерпретации результата используем идентичную организационную структуру как-будет для обоих вариантов процесса.
Базовый случай — оцениваем только структурные изменения. Персональные данные не используются. Вообще. Оргструктура и процессы. И всё.
С персональными данными веселее. Во всех смыслах.
Метод похож на наблюдение за физической системой из множества масс, соединённых множеством пружин — при переменах рисунка соединения, либо сил натяжения объекты меняют положение в пространстве. О масштабе индивидуальных перемен мы судим по сдвигу между состояниями как-есть и как-будет. И измеряем этот сдвиг на интервале [0,1], где нулю соответствует отсутствие каких-либо перемен (полное сходство состояний как-есть и как-будет), а единице — максимально возможные изменения.
Скажи мне, кто твой друг (или механика работы свёртки графа)
------------------------------------------------------------
Одним из подходов к измерению масштаба перемен может быть анализ того, насколько переменится окружение для отдельного индивидуума — включая, но не ограничиваясь: связями подчинённости/управления, спецификацией процесса работы, или интерфейса выполнения транзакций — всё это позволяет новая арифметика из Амстердама.
Рассмотрим механику её работы.
Интуиция: свойства окружающих определяют индивидуума.
Для каждого сотрудника соберём информацию о коллегах и пропустим её через нейронную сеть (аггрегатор). В результате получим представление (координаты в многомерном пространстве), которое отражает относительное расположение в системе для каждого. В каком-то смысле процесс напоминает попытку человека выучить все связи и свойства, а потом забыть что-то из выученного.
Масштаб перемен — это дистанция между полученными представлениями для состояний как-есть и как-будет.
Теория социального научения утверждает, что мы обучаемся, наблюдая поведение коллег, и привыкая к нему. Трансформация бизнеса меняет характер связей и окружение встряхивает. Возникает потребность переучиваться. Измерим эту перемену психологического климата (предположив, что мы уже провели профилирование сотрудников и данные у нас есть).
В пространстве масштаба индивидуальных перемен всё выглядит так:
Как видим, добавление данных профилирования повысило разрешающую способность модели — теперь мы учитываем не только трансформацию структур и процессов, но и особенности участников.
Первый вариант изменения процесса в наибольшей степени затронет #7. Альтернатива же больше всего повлияет на #9. Оба варианта окажут примерно равный эффект на вершины #3 и #6 — между ними произойдёт передача роли инициатора процесса. Идентично базовому случаю, верхушку иерархии (#0, #1, и #2) перемены заденут незначительно.
Таким образом, с помощью графовой свёрточной нейросети мы ранжировали стейкхолдеров согласно масштабу трансформации бизнеса в их ближайшем окружении.
Результат близок к оценке, которую выдаст хорошо обученный и весьма дорогой специалист в области проведения организационных изменений.
Всё это возможно уже при наличии минималистичной информации о структуре организации и бизнес-процессах. Добавление малого количества персональных данных повысило разрешающую способность метода. Очевидно, что добавление большего количества данных позволяет надеяться на прогресс и в дальнейшем.
Уголок красный из моделей прекрасных
------------------------------------
Рассмотренные в данной публикации методы в контексте задачи ранжирования стейкхолдеров относятся к обучению без учителя — мы пытаемся выявить закономерности и как-то о них рассуждать. Заглядывая в будущее, отмечу, что у больших транснациональных компаний уже есть наборы данных, позволяющие реализовать обучение с учителем. Поэтому, помянув Free Lunch Theorem, вскользь напомню о альтернативных методах описания графов, вроде вейвлетов, которые могут пригодиться исследователям.
Год назад, когда писал о том, [где и как врубиться в эмбеддинги графов](https://habr.com/ru/company/ods/blog/418727/), за кадром осталась пара моделей, требующих освещения — уж очень хороши:
### VERSE — вот [github](https://github.com/xgfs/verse)
Как вы наверняка помните, первая волна методов эмбеддинга графов основывалась на случайных блужданиях. Лучшие умы планеты соревновались в том, кто придумает наиболее выразительную стратегию перемещения бродяги. И оптимизировали логарифм вероятности попадания двух вершин в один маршрут. Идея — смотреть на вопрос шире и изучать распределение вероятностей в общем. Один параметр вместо кучи, SOTA в задаче предсказания связей, и впечатляюще сформулированная функция потерь.
Ещё у автора есть много интересных проектов, среди которых затесалась одна замечательная [модель](https://github.com/xgfs/NetLSD). На всякий случай замечу, что в названии программы, предлагающей слушать форму графа, явно просматривается и вполне однозначно выражена негативная позиция по отношению к рискованным практикам и призыв следовать здоровому образу жизни.
### Графовая свёрточная сеть
Всё гениальное — просто. Вместо того чтобы делать выборку по окружению, соберём свойства всех соседей. И свои тоже. Реализуется перемножением [матриц, описывающих граф](https://habr.com/ru/company/ods/blog/418727/#randomwalker) — модифицированных степеней вершин и связности, и свойств вершин. В общем виде для каждого слоя преобразование записывается как:
### $H^{(k+1)} = Dropout \{ReLU [(D+I)^{-½} (A+I) (D+I)^{-½} H^{(k)} W^{(k)} ]\} , $
Где:
 — регуляризация обнулением случайно выбранных параметров — то самое 'забывание', запатентованное Google,
 — нелинейная функция активации ,
 — диагональная матрица степеней вершин (количество связей),
 — диагональная матрица из единиц,
 — матрица связности,
 — сигнал с предыдущего слоя аггрегации, , где  — матрица свойств вершин,
 — веса k-го слоя нейросети, которые мы можем:
* выучить в режиме обучения с учителем;
* заполнить выбранными наугад значениями;
* выбросить (функция от этого станет чуть-чуть линейнее).
В деталях механику работы рассмотрел сам автор [здесь](https://tkipf.github.io/graph-convolutional-networks/). Кроме того, пошагово и с примерами, метод рассмотрен ещё и [здесь](https://towardsdatascience.com/how-to-do-deep-learning-on-graphs-with-graph-convolutional-networks-7d2250723780).
Прекрасная в своей простоте, эта модель показывает отличные результаты. Держите вариант реализации большей части выражения из квадратных скобок в три строки от [iggisv9t](https://habr.com/ru/users/iggisv9t/) :
```
D = sparse.csgraph.laplacian(A, normed=True)
shape1 = X.shape[1]
X = np.hstack((X, (D @ X[:, -shape1:])))
```
Сниппет года, на мой взгляд.
В чате обсуждали вариант применения такой свёртки для двудольного графа и подготовленный читатель увидит здесь сходство с алгоритмом [RolX](https://www.google.com/url?sa=t&source=web&rct=j&url=https://research.google.com/pubs/archive/46591.pdf&ved=2ahUKEwiD4uOZ5pHmAhVLzYUKHcfVBlwQFjAJegQIAxAB&usg=AOvVaw2N3OIJWgP0pFfeGy8Oo_kk), двойным. В три строки.
ФОТО: сделал кто-то в Кремле для кого-то в Кремле, модель — Фиде́ль Алеха́ндро Ка́стро Рус
Учитывая то, что разделяющая способность свёртки графа идентична [WL тесту изоморфизма](http://arxiv.org/abs/1101.5211), равно как и то, что обобщающая способность однослойной нейронной сети с нелинейной активацией неимоверна (оба утверждения доказаны строго) — получается очень заманчивый инструмент исследования сложносвязанных систем.
Стоит отметить, что метод желательно реализовывать на разреженных матрицах — так лапласиан в памяти уместить проще, а иногда — единственный способ. Если уж совсем лень — конвертер есть в репозитории VERSE. А уж коли вас занесло в область очень больших графов, то [рассмотренный здесь GraphSAGE](https://habr.com/ru/company/ods/blog/418727/#GraphSAGE) по-прежнему остаётся актуальным.
Резюме вышесказанного
---------------------
Масштаб изменения — это расстояние между состояниями как-есть и как-будет.
Эта дистанция аппроксимируется без использования персональных данных.
Добавление персональных данных улучшает модель.
Попытка описать культуру организации (ту самую, что ест стратегии на завтрак) — чем-то похожа на порыв прибить порцию желе к стенке (или натянуть сову на глобус) — поиск универсального набора шагов для реализации трансформации бизнеса — та ещё задача. Всё, что мы знаем наверняка — сопротивляться переменам люди будут. Каждая ситуация по-своему уникальна и требует понимания местных условностей и реалий.
НЕМОЕ КИНО: ранний прототип модели оценивает масштаб изменений. 0-30 секунда — увольнение #8 и #9. 31-40 — восстановление #8. Переход к описанию состояния как-будет на 40 секунде. Перевод #9 в подчинение к #5 с 41 по 50. Возврат к описанию состояния как-есть и определение потока операций 7-4-5-2 с 1:00 по 1:11. Переход к как-будет и определение целевого потока операций с 1:18 по 1:35. Завершается всё увольнением #7
> ### Позаимствуем интуицию из арсенала классической механики:
>
>
>
> 1) Перемены требуют воздействия
>
> 2) Импульс воздействия определяет скорость перемен
>
> 3) Действие провоцирует противодействие
>
>
>
> Три закона Ньютона, упомянутые выше, вместе взятые, позволяют описать и смоделировать любое движение физического тела. Их вполне достаточно для того, чтобы отправить человека на Луну.
>
>
>
> Подобным образом, учёт всех сил, что придают форму организации — структур и потоков операций — позволяет лучше контролировать переход к новому, желаемому состоянию дел. Классификация стейкхолдеров, полученная совмещением масштаба перемен (требуемое для трансформации усилие) и влиянием, помогает сосредоточиться на том, что действительно важно.
>
>
>
>
Выводы
------
В работе руководителя продукта (или проекта) вопрос стейкхолдеров занимает от трети до половины времени. Некоторых инициатив с большой организационной сложностью попросту избегают — держать все связи в голове — достаточно болезненно.
Современная математика позволяет оценить ситуацию. И решает задачу построением модели. Входные данные — описание бизнес-процессов и организационной структуры — это стандартные артефакты методологии внедрения SAP.
Говорят, сегодняшние реалии требуют от бизнеса способности стремительно изменяться и адаптироваться к переменчивой окружающей среде. Данный метод сокращает время анализа масштаба трансформации до нескольких секунд и позволяет сравнить несколько вариантов задуманного быстро.
Литература
----------
[1] Diffusion of Innovations, Fifth Edition, Rogers, 2003 (1962)
[2] Organizational Change Management in SAP Projects, Rothenpieler, SAP, 2009
[3] TRANSFORMATION Delivering and Sustaining Breakthrough Performance, Fæste and Hemerling, BCG, 2016
[4] Overcoming Resistance to Organizational Change: Strong Ties and Affective Cooptation, Battilana & Casciaro, 2013
[5] Inductive Representation Learning on Large Graphs, Hamilton & Ying, 2017
[6] Semi-Supervised Classification with Graph Convolutional Networks, Kiph & Welling, 2017
[7] A Guide to the Project Management Body of Knowledge (PMBOK Guide), PMI, 2017
[8] International Business Communication Standards (IBCS), Hichert & Faisst, 2017
Памятка воспроизводителю
-------------------------
Привет, воспроизводитель!
Если ты это читаешь, то скорее всего любимое начальство уже ждёт от тебя реестра стейкхолдеров, свёрнутого по всем правилам.
Порыв донести важность случайных блужданий в оценке человеческого фактора — то ещё приключение. Интерпретируемые модели вроде RolX (к слову, этот алгоритм нужно было реализовать в домашней работе cs224w образца 2018 года) позволят установить уровень ожиданий.
Бонус — способные донести начальству тождественность одного из возможных вариантов реализации RolX и свёртки графа уже получили тот самый сниппет, который всё это делает.
Успехов!
Альтернатива — есть!
--------------------
```
Повторюсь,
напоследок,
доколе?
Стейкхолдеров,
мерять,
методом
тыка?
```
ФОТО: Тим Уолкер для календаря Pirelli, модель — Симона Мария Томпсон
```
Напомню -
задача решается,
(свёрткой графа)
за 2 минуты,
и 53 клика.
```
Успеть запросить ранний доступ к среде взаимодействия с моделью можно [здесь](https://forms.gle/je4MFdVTWwDkHd3LA). | https://habr.com/ru/post/465845/ | null | ru | null |
# Nemesida WAF: Docker-контейнер
[Nemesida WAF](https://waf.pentestit.ru/about/4079) - комплексная защита сайтов, интернет-магазинов, личных кабинетов, порталов, маркетплейсов, API и других веб-приложений от хакерских атак на основе машинного обучения Nemesida AI. Особенностью Nemesida WAF является высокая точность выявления атак при минимальном количестве ложных срабатываний. Наличие сканера уязвимостей, модулей машинного обучения, виртуального патчинга и масштабируемость позволяет обеспечивать безопасность веб-приложений как на этапе разработки, так и при полноценном использовании. Поставляется в виде:
* установочный [дистрибутив](https://waf.pentestit.ru/category/manuals) для ОС Linux (Debian, Ubuntu, CentOS);
* [виртуальный диск](https://repository.pentestit.ru/vm/NemesidaWAF-VA.zip) для KVM/VMware/VirtualBox;
* [docker-образ](https://waf.pentestit.ru/manuals/6387).
Сегодня мы рассмотрим установку и настройку Nemesida WAF из Docker-образа.
> [Docker](https://www.docker.com/) - программное обеспечение для автоматизации развертывания и управления приложениями в средах с поддержкой контейнеризации. В свою очередь, контейнер - это запакованное, вместе со своим окружением и зависимостями, приложение, которое можно без особых усилий развернуть и запустить на готовом сервере и при этом не переживать за установку дополнительных зависимостей.
>
>
Устанавливаем Docker
--------------------
Работа с Docker-контейнерами начинается с установки [Docker'а](https://docs.docker.com/engine/install/debian/). Для примера установка будет производиться на сервер с Debian 10.
Добавим информацию о репозитории и GPG ключ:
```
# echo "deb [arch=amd64 signed-by=/usr/share/keyrings/docker-archive-keyring.gpg] https://download.docker.com/linux/debian $(lsb_release -cs) stable" | tee /etc/apt/sources.list.d/docker.list > /dev/null
# curl -fsSL https://download.docker.com/linux/debian/gpg | gpg --dearmor -o /usr/share/keyrings/docker-archive-keyring.gpg
```
Обновим список пакетов, установим зависимости и пакет Docker:
```
# apt update
# apt install apt-transport-https ca-certificates curl gnupg lsb-release
# apt install docker-ce docker-ce-cli containerd.io
```
После окончания установки можно производить развертывание контейнера с Nemesida WAF.
Разворачиваем контейнер с Nemesida WAF
--------------------------------------
### Динамический модуль Nemesida WAF и Nemesida AI
Динамический модуль Nemesida WAF предназначен для выявления и блокировки запросов, содержащих "полезную" нагрузку. Но помимо этого в Nemesida WAF реализована защита от атак методом перебора и DDoS, которые, как правило, не блокируются средствами WAF, ведь изначально отправляют к веб-приложению легитимные запросы. Однако, это тоже является серьезной угрозой для веб-приложения. Так по статистике компании Acunetix за [2019-2020](https://www.acunetix.com/white-papers/acunetix-web-application-vulnerability-report-2020/) год среди проанализированных веб-приложений у 28% отсутствует защита от перебора пароля и у 1% используются пароли по умолчанию. К тому же, 11% веб-приложений уязвимы для DDoS атак. Эти, и не только, аномалии выявляются и блокируются модулем Nemesida AI - модулем машинного обучения, позволяющим увеличить точность выявления атак. В Nemesida AI используются классические алгоритмы машинного обучения, не требующие, в отличие от нейронных сетей, больших вычислительных мощностей. Таким образом, при относительно невысоком требовании к аппаратной части сервера (до 32 Гб ОЗУ) достигается оптимальное время обработки запросов (что напрямую влияет на время ответа веб-приложения), а количество ложных срабатываний составляет 0.01%.
К примеру:
```
http://example.com/?cmd=; cat /etc/passwd
```
Такой запрос будет заблокирован средствами сигнатурного анализа. Но если видоизменить запрос, например:
```
http://example.com/?cmd=; cat+/e?c/pa??wd
```
Уже не будет попадать под какую-нибудь сигнатуру и будет рассматриваться как легитимный запрос. Но с помощью модуля машинного обучения Nemesida AI MLC подобные аномалии и выявляются. Более подробно про обход WAF можно прочитать в [статье](https://habr.com/ru/company/pentestit/blog/540188/).
Загружаем образ c динамическим модулем Nemesida WAF и Nemesida AI:
```
# docker pull nemesida/nwaf-dyn-1.18
```
В процессе развертывания Docker-контейнеров может возникать ошибка
```
ERROR: Get https://registry-1.docker.io/v2/: net/http: request canceled while waiting for connection (Client.Timeout exceeded while awaiting headers)
```
Ошибка связана с использованием прокси-сервера в системе. Однако Docker не использует системный прокси-сервер и ему нужно указать его отдельно. Для этого нужно создать файл **/etc/systemd/system/docker.service.d/http-proxy.conf** с содержимым:
```
[Service]
Environment="HTTP_PROXY=http://"
"HTTPS\_PROXY=http://"
```
И перезапустить сервис:
```
# systemctl daemon-reload
# systemctl restart docker
```
Для будущих конфигурационных файлов создаем директории и файл для первого запуска **first\_launch**:
```
# mkdir /opt/nwaf/waf-config
# touch /opt/nwaf/waf-config/first-launch
```
Запускаем контейнер:
```
# iptables -t filter -N DOCKER
# docker run --rm -d -v /opt/nwaf/waf-config:/nginx.configs -p 80:80 nemesida/nwaf-dyn-1.18
```
После первого запуска контейнер автоматически завершит работу, создав необходимый набор конфигурационных файлов в соответствующей директории.
Настройка модулейПосле развертывания контейнера необходимо задать некоторые настройки в файлах **/opt/nwaf/waf-config/nwaf/conf/global/nwaf.conf:**
* nwaf\_license\_key - лицензионный ключ. Запросить 14-дневную пробную версию можно [тут](https://waf.pentestit.ru/about/4079#contact_form_pop_up);
* nwaf\_api\_conf - настройка взаимодействия с модулем Nemesida WAF API (заполнятся после развертывания контейнера Nemesida WAF API+Cabinet);
* sys\_proxy - конфигурация системного прокси-сервера (если используется);
**/etc/nginx/nwaf/mla.conf:**
* st\_enable - отправка спорных запросов на сервер Nemesida WAF Signtest для последующей обработки;
* st\_uri - URI сервера Nemesida WAF Signtest для обработки результатов работы Nemesida AI.
**/opt/nwaf/waf-config/mlc/mlc.conf:**
* nwaf\_license\_key - лицензионный ключ;
* vhosts\_list - список виртуальных хостов, для которых модуль машинного обучения Nemesida AI MLC будет создавать поведенческие модели;
* api\_uri, api\_proxy - конфигурация взаимодействия с модулем Nemesida WAF API;
* sys\_proxy - конфигурация системного прокси-сервера (если используется);
* st\_enable - отправка спорных запросов, получаемых от модуля Nemesida WAF, на сервер Nemesida WAF Signtest для последующей обработки;
* st\_uri - URI сервера Nemesida WAF Signtest для отправки спорных запросов.
После внесения изменений запускаем контейнер.
### Nemesida WAF API и Личный кабинет Nemesida WAF
Nemesida WAF API предназначен для взаимодействия всех модулей Nemesida WAF. В личном кабинете Nemesida WAF отображается информация о заблокированных запросах к защищаемому веб-приложению.
Загружаем образ c модулем Nemesida WAF API и Личный кабинет Nemesida WAF:
```
# docker pull nemesida/nwaf-api-cabinet
```
Для будущих конфигурационных файлов создаем директории и внутри директории с конфигурацией файл для первого запуска **first\_launch**:
```
# mkdir /opt/nwaf/api-cab-config
# mkdir /opt/nwaf/api-cab-base
# touch /opt/nwaf/api-cab-config/first-launch
```
Запускаем контейнер с образом Nemesida WAF API и Личным кабинетом Nemesida WAF:
```
# iptables -t filter -N DOCKER
# docker run --rm -d -v /opt/nwaf/api-cab-config:/nwaf-api -v /opt/nwaf/api-cab-base:/var/lib/postgresql -p 8080:8080 -p 8090:80 nemesida/nwaf-api-cabinet
```
где:
* **--run** - удаление контейнера после завершения работы;
* **-d** - запуск контейнера в фоновом режиме;
* **-v /opt/nwaf/api-cab-config:/nwaf-api** - монтируем каталог с конфигурационными файлами внутри контейнера;
* **-v /opt/nwaf/api-cab-base:/var/lib/postgresql** - монтируем каталог с базой данных внутри контейнера;
* **-p 8080:8080** - проброс порта контейнера 8080 (правый) на внешний порт сервера 8080 (левый);
* **-p 8090:80** - проброс порта контейнера 8090 на внешний порт сервера 80.
Для директории **/opt/nwaf/api-cab-config** устанавливаем права на чтение:
```
# chmod -R 0555 /opt/nwaf/api-cab-config
```
Получим ID контейнера выполнив команду:
```
# docker ps -a
```
Выполняем миграцию и создаем учетную запись администратора:
```
# docker exec -ti /ID контейнера/ bash -c "bash /opt/migrate.sh"
```
Для внесения изменений в конфигурацию модулей необходимо остановить контейнер командой:
```
# docker stop /ID контейнера/
```
и отредактировать конфигурационные файлы модулей **/opt/nwaf/api-cab-config/settings\_api.py**:
Настройка модуля Nemesida WAF API* HTTP\_PROXY\_CONF - адрес прокси-сервера (если используется).
и **/opt/nwaf/api-cab-config/settings\_cabinet.py**:
Настройка модуля Личный кабинет Nemesida WAF* PROXY - адрес прокси-сервера (если используется).
После внесения изменений перезапускаем контейнер.
```
# iptables -t filter -N DOCKER
# docker run --rm -d -v /opt/nwaf/api-cab-config:/nwaf-api -v /opt/nwaf/api-cab-base:/var/lib/postgresql -p 8080:8080 -p 8090:80 nemesida/nwaf-api-cabinet
```
#### Nemesida WAF Signtest
Nemesida WAF Signtest предназначен для обработки спорных запросов.
Загружаем образ c модулем Nemesida WAF Signtest:
```
# docker pull nemesida/nwaf-st
```
Для будущих конфигурационных файлов создаем директории и внутри директории с конфигурацией файл для первого запуска **first\_launch**:
```
# mkdir /opt/nwaf/nwaf-signtest-config
# mkdir /opt/nwaf/nwaf-signtest-base
# touch /opt/nwaf/api-signtest-config/first-launch
```
Запускаем контейнер с образом Nemesida WAF Signtest:
```
# iptables -t filter -N DOCKER
# docker run --rm -d -v /opt/nwaf/nwaf-signtest-config:/nwaf-signtest -v /opt/nwaf/nwaf-signtest-base:/var/lib/postgresql -p 8081:8088 -p 82:80 nemesida/nwaf-st
```
где:
* **--run** - удаление контейнера после завершения работы;
* **-d** - запуск контейнера в фоновом режиме;
* **-v /opt/nwaf/nwaf-signtest-config:/nwaf-signtest** - монтируем каталог с конфигурационными файлами внутри контейнера;
* **-v /opt/nwaf/nwaf-signtest-config:/nwaf-signtest** - монтируем каталог с базой данных внутри контейнера;
* **-p 8081:8088** - проброс порта контейнера 8088 на внешний порт сервера 8081;
* **-p 82:80** - проброс порта контейнера 80 на внешний порт сервера 82.
Для директории **/opt/nwaf/nwaf-signtest-config** устанавливаем права на чтение:
```
# chmod -R 0555 /opt/nwaf/nwaf-signtest-config
```
Получим ID контейнера выполнив команду:
```
# docker ps -a
```
Выполняем миграцию и создаем учетную запись администратора:
```
# docker exec -ti /ID контейнера/ bash -c "bash /opt/migrate.sh"
```
Для внесения изменений в конфигурацию модуля необходимо остановить контейнер командой:
```
# docker stop /ID контейнера/
```
и отредактировать конфигурационный файл модуля **/opt/nwaf/nwaf-signtest-config/settings\_signtest.py:**
Настройка модуля Nemesida WAF Signtest* HTTP\_PROXY - адрес прокси-сервера ( если используется).
После внесения изменений перезапускаем контейнер.
```
# iptables -t filter -N DOCKER
# docker run --rm -d -v /opt/nwaf/nwaf-signtest-config:/nwaf-signtest -v /opt/nwaf/nwaf-signtest-base:/var/lib/postgresql -p 8081:8088 -p 82:80 nemesida/nwaf-st
```
Учимся пользоваться
-------------------
После развертывания контейнеров с Nemesida WAF может потребоваться дополнительная проверка, что все работает так как нужно. Для этого можно заглядывать в сами контейнеры:
```
# docker ps -a
# docker exec -ti /ID контейнера/ bash -c "/bin/bash"
```
После выполнения попадем в консоль контейнера, где можем проверить логи, конфигурацию и работу модулей в целом. Если требуется доработка или исправление конфигурации, то необходимо каждый раз останавливать контейнер, вносить изменения и запускать контейнер заново.
Если все работает корректно, то после запуска контейнеров атаки на веб-приложение будут блокироваться с записью в лог Nginx
 и отображаться в личном кабинете:
### Личный кабинет
В личном кабинете Nemesida WAF есть два основных раздела для работы: Summary и Attacks. И неосновные разделы, где можно произвести настройку учетной записи пользователя, сгенерировать отчет по заблокированным запросам, посмотреть результат работы модуля Nemesida WAF Scanner и тд.
### Summary
Отображает статистическую информацию по атакам:
* количество атак (сегодня/последние сутки/неделя/месяц);
* атаки по типам (заблокированные сигнатурным анализом, модулем машинного обучения Nemesida AI MLC, brute-force, DDoS и тд);
* сводка по IP-адресам, осуществляющим атаки.
### Attacks
Отображает заблокированные запросы. При клике на атаку развернется окно с описанием, где:
* указан пейлоад, который привел к блокировке запроса;
* чем было заблокировано (сигнатурный анализ, модуль машинного обучения и т.д.);
* прочая информация о запросе.
Если запрос был заблокирован сигнатурным анализом, то при клике на идентификатор сигнатуры (Rule ID) развернется окно с детальной информацией и инструкцией для создания правила исключения сигнатуры.
Справа находятся 2 кнопки "R" (Recheck) и "U" (Unlock). Recheck отвечает за проверку пейлоада модулем [Nemesida WAF Scanner](https://waf.pentestit.ru/manuals/5564), а Unlock - за разблокировку запроса, который, по мнению администратора, был ошибочно заблокирован.
Если атак на веб-приложение много, то навигация по ним может быть затруднительной. Для этого существуют различные фильтры, с помощью которых можно производить поиск интересующих атак. Например, для разделов Summary и Attacks доступны следующие фильтры:
* **h** - виртуальный хост, доменное имя;
* **t** - тип атаки (SQLi, XSS, RCE, LFI, MLA, DDoS, MLC и т.д.);
* **ip** - IP-адрес атакующего;
* **group\_id** - идентификатор группы запросов, определенных Nemesida AI MLC как brute-force или DDoS-атака;
* **recheck** - статус выполнения операции recheck (processed, confirmed, not confirmed);
* **rule** - идентификатор сигнатуры;
* **mz** - зона выявления уязвимости (URL, ARGS, BODY, HEADERS и т.д.).
Пример:
Мы хотим найти все заблокированные запросы, исключив из выборки IP-адрес атакующего 189.11.53.158:
```
ip:!189.11.53.158
```
Теперь необходимо отсортировать все запросы, которые были заблокированы с идентификатором сигнатуры 1087:
```
rule:1087
```
Фильтры можно комбинировать для более точного поиска. Например, нам необходимо отсортировать запросы с атаками типа SQLi, исключив из выборки те из них, в которых IP-адрес атакующего 189.11.53.158:
```
t:SQLi and ip:!189.11.53.158
```
Полноценно ознакомиться с работой Личного кабинета Nemesida WAF можно на [демонстрационном стенде](https://demo.lk.nemesida-waf.com/waf/personal/login/?next=/) (логин: demo@pentestit.ru, пароль: pentestit).
Заключение
----------
Docker является отличным решением в тех случаях, когда необходимо протестировать возможности того или иного продукта, без его полноценного внедрения в инфраструктуру компании. Ознакомиться с подробной инструкцией по развертыванию Docker-образов Nemesida WAF можно в нашей [документации](https://waf.pentestit.ru/manuals/6387). | https://habr.com/ru/post/556114/ | null | ru | null |
# Колобок в гостях у Windows 8: дневники разработки (часть 1)
Пару недель назад мы опубликовали наш первый материал "[Колобок в гостях у Windows 8: дневники разработки (введение)](http://habrahabr.ru/post/167613/)", сегодня мы продолжаем эту тему и рассказываем более детально структуру абстрактного уровня нашей архитектуры, в том виде как мы ее на сегодня организовали.
#### Первые эскизы
Недавно мы получили первые картинки от художника. Вот такой концепт на данный момент:
#### Абстрактный класс BaseGame
Этот класс берет на себя обязанности по управлению основным жизненным циклом игры, а также включает в себя логику и физику игры.
**public abstract class BaseGame:DisposeSupport**
```
///
/// Describes an abstract game
///
public abstract class BaseGame:DisposeSupport
{
///
/// The game Logic
///
protected abstract ILogic Logic { get; }
///
/// The game Physics
///
protected abstract IPhysics Physics { get; }
///
/// Initialize the game
///
public void Initialize(){}
///
/// Start the new game
///
public void StartNewGame(){}
///
/// Activate the game
///
public void ActivateGame(){}
///
/// Pause on game
///
public void Pause(){}
///
/// Restart the game
///
public void Restart(){}
///
/// Resume the game
///
public void Resume(){}
///
/// Exit the game
///
public void Exit(){}
public event Action Win;
public event Action GameOver;
public event Action Lose;
}
```
Жизненный цикл можно представить так:
#### Визуализация
Визуализация на верхнем уровне не привязана к игре. Связь с рендерингом происходит только в конкретной реализации игры.
За визуализацию отвечает интерфейс IRenderer, который обеспечивает реализацию трех методов:
* **Initialize** выполняется во время инициализации устройства,
* **Render** вызывается при отрисовке каждого кадра,
* **SizeChanged** вызывается во время смены размеров экрана, и в этот момент возможна инициализация.
**public interface IRenderer: IDisposable**
```
///
/// Describes a renderer class
///
/// Type that used for method Initialize parameter
/// Type that used for methods Render and ScreenSizeChanged parameters
public interface IRenderer: IDisposable
{
///
/// On initialize a device
///
/// Initialize parameter
void Initialize(TInit initParameter);
///
/// On render per frame
///
/// Render parameter
void Render(TRender renderParameter);
///
/// On screen size changed
///
/// Render parameter
void ScreenSizeChanged(TRender renderParameter);
}
```
Цикл визуализации:
**IRenderer** также наследует интерфейс IDisposable, что обеспечивает реализацию комплектом методов по детерминированному уничтожению объектов. В нашей реализации объекты по рисованию также наследуются от класса Component из библиотеки SharpDX, у которого можно использовать методы связанные с помещением ресурсов в список удаления, по которому проходит объект перед уничтожением, и мы получаем готовую реализацию IDisposable.
#### Логика
В нашей игре представлена интерфейсом ILogic
**public interface ILogic**
```
///
/// Describes a game logic
///
public interface ILogic
{
///
/// Start game
///
void StartGame();
///
/// Stop game
///
void StopGame();
///
/// Pause game
///
void PauseGame();
///
/// Resume game
///
void ResumeGame();
///
/// Fire game event
///
void FireEvent(IGameEvent @event);
///
/// Win game event
///
event Action Win;
///
/// Lose game event
///
event Action Lose;
///
/// Delete game object event
///
event Action ObjectDeleted;
///
///Character moved event
///
event Action CharacterMoved;
///
///Character moved by path event
///
event Action> CharacterMovedPath;
///
///Character patrol by path event
///
event Action> CharacterPatrolPath;
///
///Character patrol event
///
event Action CharacterPatrol;
///
///Character moved to object event
///
event Action CharacterMovedToObject;
///
///Character in chase for object event
///
event Action CharacterChase;
///
/// watch if the one object look at another;
///
event Action WatchedLook;
///
/// watch the distance between two objects;
///
event Action WatchedDistance;
///
/// character stop;
///
event Action ActionStopped;
///
///The rules factory
///
IRuleFactory RuleFactory { get; }
}
```
При возникновении игрового события логика обрабатывает набор правил, проверяет условия и возможность их выполнения, и потом инициирует события Win, Lose или Game Over, которые передаются в игру.
Рабочий цикл логики игры:
#### Физика
**public interface IPhysics**
```
public interface IPhysics
{
///
/// add object to simulation
///
/// object
void AddObject(IObject obj);
///
/// remove object from simulation
///
/// object
void RemoveObject(IObject obj);
///
/// simulate world on specified time after start
///
/// seconds
void Simulate(float time);
///
/// signal that initialization starts
///
void BeginInitialization();
///
/// signal that initialization included adding of objects is finished
///
void EndInitialization();
///
/// getting movement observer for observing different events related to movement of
objects
///
/// moevement observer
IMovementObserver GetMovementObserver();
///
/// get object factory
///
/// getting object factory
IObjectFactory GetObjectFactory();
}
```
Интерфейс для физики предоставляет методы для добавления, удаления физических объектов,
симуляции мира на определенное время, получение фабрики объектов и слушателя событий
передвижения объектов. Интерфейс физического объекта представлен ниже
**public interface IObject**
```
public interface IObject
{
///
/// getting transformation matrix of object
///
/// matrix
Matrix GetTransform();
float X { get; set; }
float Y { get; set; }
float Z { get; set; }
}
```
С помощью данного интерфейс можно задать и получить начальные координаты объекта, а также
матрицу преобразования в результате симуляции мира.
#### Выводы:
Хотим сказать, что знакомство с DirectX и самой разработкой игр — это очень интересная и новая для нас сфера.
По C# 5.0 и разработке под Windows Store хотим выделить такие вот особенности:
* очень много изменений в .Net;
* нет синхронных операций чтения файлов, теперь все асинхронное (тут нету ничего плохого, иногда такой дизайн не подходит и приходится превращать асинхронный код в синхронный);
* нет многих стандартных для .Net 4.0 классов;
* внесены изменения в работу с метаданными типов и рефлексией;
* немного отличается Xaml набором полезных классов от WPF;
* чтобы писать под Windows Store нужно обязательно работать в среде Windows 8. | https://habr.com/ru/post/169981/ | null | ru | null |
# Дайджест новостей из мира PostgreSQL. Выпуск №14
*Мы продолжаем знакомить вас с самыми интересными новостями по PostgreSQL.*
Новости
-------
**Microsoft приобрела Citus Data**
Безусловно, главная новость в мире PostgreSQL. Об этом есть [сообщение на сайте](https://www.citusdata.com/blog/2019/01/24/microsoft-acquires-citus-data/) Citus, равно как и [на сайте MS](https://blogs.microsoft.com/blog/2019/01/24/microsoft-acquires-citus-data-re-affirming-its-commitment-to-open-source-and-accelerating-azure-postgresql-performance-and-scale/).
**Postgres Pro Enterprise Certified**
СУБД Postgres Pro Enterprise получила сертификат ФСТЭК, и теперь в наборе Postgres Pro есть и «Сертифицированная версия Postgres Pro Enterprise». До этого сертификат, необходимый для работы с персональными данными, имела только Postgres Pro Standard («Сертифицированная версия Postgres Pro»). Подробности [на сайте](https://postgrespro.ru/products/postgrespro/enterprisecertified).
**credativ: PostgreSQL Competence Center**
Германская фирма *credativ*, до того известная в Европе и Азии, [приобрела](https://www.credativ.com/blog/credativ-massively-expands-us-footprint?fbclid=IwAR2DP3h6NCIVmoLlM1v4hJJHxUhYEpp_JuOYVRJsLP--rrfw06kJgfnDwsQ) фирму **OmniTI**, чтобы выйти на американский рынок. **credativ** специализируется на развертывании и поддержке проектов `open source`. Теперь в США откроется PostgreSQL Competence Center, который будет заниматься высококритичными проектами и поддерживать БД в течение всего их жизненного цикла.
Конференции
-----------
**Postgres On The Beach (Ibiza)**
Пляжи Ибицы [ждут](https://pgibz.io/) докладчиков и слушателей 21-22 июня, а еще лучше прилететь 20-го и остаться до вечера 24-го из-за богатой развлекательной программы на уикэнд.
**PGConf.Russia 2019**
[Конференция прошла](https://postgrespro.ru/blog/company/3867085) 4-6 февраля на Экономическом факультете МГУ, собрав рекордное число участников — более 700. Было много нового. В отдельный поток выделили доклады по теме **Postgres и 1С**. Всего же в трех потоках состоялось 55 докладов, 9 мастер-классов и 3 круглых стола. Самую бурную дискуссию вызвал круглый стол **«Импортозамещение системного и инфраструктурного программного обеспечения»**, организованный при поддержке АРПП «Отечественный софт».
Призы за лучшие доклады на конференции получили:
* **Иван Фролков**, Postgres Professional
[Типичные ошибки приложений при работе с Postgres](https://pgconf.ru/2019/242878)
* **Иван Муратов**, «Первая Мониторинговая Компания»
[PostgreSQL + PostGIS + TimescaleDB — хранилище для систем мониторинга транспорта](https://pgconf.ru/2019/242909)
* **Николай Самохвалов**, Nombox LLC
[Промышленный подход к тюнингу PostgreSQL: эксперименты над базами данных](https://pgconf.ru/2019/242809)
О некоторых докладах мы планируем написать подробнее. Пока можно посмотреть [презентации](https://pgconf.ru/2019/talks).
**Turkish PostgreSQL**
Конференция [пройдет](https://postgresql.tubitak.gov.tr/) уже 24 февраля в Анкаре.
**PostgreSQL@SCaLE**
Двухдневная двухпоточная конференция [пройдёт](https://www.socallinuxexpo.org/scale/17x/postgresscale) 7-8 марта в городе Пасадена (США) как часть SCaLE 17X.
**Postgres Conference 2019**
Конференция [состоится](https://postgresconf.org/conferences/2019) в Нью-Йорке 18-22 марта.
**Prague PostgreSQL Developer Day 2019**
Конференция P2D2 2019 в Праге [уже идёт](https://p2d2.cz/) 13-14 февраля.
Релизы
------
**PostgreSQL 11.2**
Вышли все апдейты поддерживаемых версий PostgreSQL: 11.2, 10.7, 9.6.12, 9.5.16 и 9.4.21. В этих версиях есть важные поправки: прежде всего, изменено поведение PostgreSQL при вызове `fsync()`. Также исправлены некоторые недостатки секционирования и 70 других ошибок, накопившихся за последние 3 месяца. Подробности [здесь](https://www.postgresql.org/about/news/1920/).
**pgAdmin4 4.2**
[Вышел](https://www.pgadmin.org/) pgAdmin 4 v4.2:
* панель статистики не подвисает, даже когда таблиц больше тысячи;
* браузер предупреждает перед тем, как закрыться или обновить страничку;
* результат запроса будет показан, даже если окошко результатов (Data Output) отсоединено от окошка запросов (Query Tool);
* улучшена навигация и оптимизированы виджеты.
Исправлено 40 багов (а в v4.1 — 7, v4.0 — 26). Список багфиксов [здесь](https://www.pgadmin.org/docs/pgadmin4/dev/release_notes_4_2.html).
Загружать [отсюда](https://www.pgadmin.org/download/).
**pgBadger 10.2**
Сразу две новости по поводу pgBadger (перлового графического анализатора логов). Вышла версия 10.2. Но если вы пойдете по ссылке (например, в новостной ленте Дэвида Феттера), вы не придете никуда. Потому что проект переехал с гитхаба *Dalibo* на гитхаб [github.com/darold/pgbadger](https://github.com/darold/pgbadger) и сайт [pgbadger.darold.net](http://pgbadger.darold.net/) разработчика — *Жиля Дароля* (Gilles Darold). Из [чейнджлога](https://github.com/darold/pgbadger/blob/master/ChangeLog) следует, что в новой версии:
* добавлена опция `exclude-db`, то есть можно пропускать информацию, относящуюся к указанной БД;
* добавлена возможность работы с логами через `ftp` и `http`. При этом лог анализируется при загрузке и на диск не сохраняется. Можно задать адреса логов на разных серверах (на удаленном и на локальном, например);
* по `ssh` лог разбирается на месте. Можно задавать файлы для анализа, используя **\***. Опция `-r` для удаленных серверов пока сохранена для совместимости, но будет упразднена.
И исправлены баги, разумеется.
**barman 2.6**
*2ndQuadrant* [сообщила](https://sourceforge.net/projects/pgbarman/files/2.6/) о выходе нового релиза. Что в нём есть:
* географическая избыточность для катастрофоустойчивости (disaster recovery);
* добавлена команда `put-wal`, чтобы можно было запускать `archive_command` СУБД, используя скрипт `barman-wal-archive`, который есть в пакете `barman-cli`;
* операция `check` теперь поддерживает ANSI-коды цветов;
* исправлены баги.
Все изменения и багфиксы по [этому адресу](https://sourceforge.net/projects/pgbarman/files/2.6/). Исходники [здесь](http://sourceforge.net/projects/pgbarman/files/2.6/barman-2.6.tar.gz/download).
**Ora2Pg**
Вышла юбилейная — 20.0 — версия утилиты Ora2Pg. Это произведение того же автора — *Жиля Дароля*. Из нового:
* экспорт BFILE в тип `bytea` теперь делается при помощи функции PL/SQL, которая извлекает данные из BFILE и преобразует их к виду, подходящему для INSERT или COPY в PostgreSQL;
* появилась директива DATA\_EXPORT\_ORDER, теперь можно экспортировать не в алфавитном порядке, а учитывая размеры таблиц;
* добавилась директива NO\_BLOB\_EXPORT (название говорит само за себя).
Есть и другие изменения, исправлено много багов. Чейнджлог [здесь](https://github.com/darold/ora2pg/blob/master/changelog). О релизе на гитхабе разработчика [здесь](https://github.com/darold/ora2pg/releases).
**pg\_probackup 2.0.26**
Новая версия утилиты для бэкапа и восстановления от *Postgres Professional*. В ней, кроме исправленных багов:
* во время валидации теперь сверяются текущая версия `pg_probackup` и версия, созданная резервной копией. Работа `pg_probackup` с копией более свежей версии явно запрещена (то есть отсутствие прямой совместимости);
* улучшена поддержка Windows;
* улучшена поддержка табличных пространств в пределах `PGDATA`.
Об изменениях можно прочитать [здесь](https://www.postgresql.org/message-id/flat/42acfbcd-3152-c729-f706-664a36218ef4%40postgrespro.ru). Документация по `pg_probackup` [здесь](https://postgrespro.ru/docs/enterprise/10/app-pgprobackup).
**datasketches 1.0.0 и другие новинка PGXN**
На [PGXN](https://pgxn.org) выложено новое расширение — `datasketches 1.0.0` авторства [*Александра Сайдакова*](https://github.com/AlexanderSaydakov). Это расширение [подключает](https://pgxn.org/dist/datasketches/1.0.0/) библиотеки `Datasketches`, в которых есть алгоритмы приблизительных оценок для Big Data. На сайте [PGXN](https://pgxn.org), созданном *Дэвидом Уилером* (David Wheeler), можно найти еще много новых расширений. Например, [Citus 8.1.1](https://pgxn.org/dist/citus/8.1.1/) — СУБД, которая работает как расширение PostgreSQL. Там же можно увидеть расширение [tsvector2 1.0.0](https://pgxn.org/dist/tsvector2/1.0.0/) — это альтернатива типу `tsvector`, который используют для полнотекстового поиска (улучшена компрессия и нет ограничения в 1 МБ). tsvector2 выложен на PGXN в декабре, а двумя месяцами раньше там появилась [последняя версия](https://pgxn.org/dist/tsvector2/1.0.0/) расширения **pg\_pathman** — 1.5.2, тоже разработки Postgres Professional. Одновременно с `pg_pathman` выложена и [последняя версия](https://pgxn.org/dist/pg_partman/4.0.0/) **pg\_partman** — 4.0.0 *Кита Фиске* (Keith Fiske).
**PAF v2.2.1**
Вышла новая версия PostgreSQL Automatic Failover (PAF). Исправлены баги, в том числе, вызывавшие распухание логов. Загружать исходники, RPMы или DEBы можно [с гитхаба проекта](https://github.com/ClusterLabs/PAF/releases/latest). Документация лежит [здесь](https://clusterlabs.github.io/PAF/documentation.html). Имеется [демо](https://blog.ioguix.net/postgresql/2019/01/24/Build-a-PostreSQL-Automated-Failover-in-5-minutes.html). Лицензия PostgreSQL.
**check\_pgactivity v2.4**
Это плагин для [Nagios](https://ru.wikipedia.org/wiki/Nagios). В новой версии можно, например, фильтровать результаты по `application_name` в `longest_query` и `oldest_idlexact`. Подробности [здесь](https://github.com/OPMDG/check_pgactivity/releases/latest). Лицензия BSD.
**pgCenter 0.6.0 и 0.6.1**
Это `Go-`утилита *Алексея Лесовского* (Alexey Lesovsky) из *Data Egret*. В версии 0.6.0 [появились](https://blog.dataegret.com/2019/02/pgcenter-060-released.html):
* новый профайлер, работающий с атрибутом `wait_event` представления [`pg_stat_activity`](https://www.postgresql.org/docs/current/monitoring-stats.html#WAIT-EVENT-TABLE), который помогает исследовать долгоиграющие запросы и выяснять, где они проводят время;
* поддержка утилиты [**GoReleaser**](https://goreleaser.com/), которая помогает собирать бинарные пакеты `.rpm` и `.deb`;
* pgCenter получил статус *A+* [**Go Report Card**](https://goreportcard.com/) — шаг к признанию верности pgCenter стилю языка `Go`;
* другие изменения.
Релиз 0.6.1. минорный и не рассматривается как несущий важные изменения. Гитхаб pgCenter [здесь](https://github.com/lesovsky/pgcenter/releases/tag/v0.6.0).
Образование
-----------
**Учебник «Основы технологий баз данных»**
Вслед за учебником [«PostgreSQL. Основы языка SQL»](https://postgrespro.ru/blog/news/3515147) вышла из печати первая часть учебника *Б.А. Новикова* и *Е.А.Горшковой* [«Основы технологий баз данных»](https://postgrespro.ru/education/books/dbtech). Учебник можно приобрести в издательстве [ДМК Пресс](https://dmkpress.com/catalog/computer/databases/978-5-94074-820-5/), в интернет-магазинах [ozon.ru](https://www.ozon.ru/search/?text=%D0%9E%D1%81%D0%BD%D0%BE%D0%B2%D1%8B%20%D1%82%D0%B5%D1%85%D0%BD%D0%BE%D0%BB%D0%BE%D0%B3%D0%B8%D0%B9%20%D0%B1%D0%B0%D0%B7%20%D0%B4%D0%B0%D0%BD%D0%BD%D1%8B%D1%85), [Labirint.ru](https://www.labirint.ru/books/676754/) и розничных книжных сетях. В формате PDF первую часть книги можно [скачать](https://edu.postgrespro.ru/dbtech_part1.pdf) свободно с сайта *Postgres Professional*. Вторая часть книги готовится к публикации. Учебник охватывает теорию баз данных, методы и алгоритмы, применяемые при реализации СУБД, а также их особенности в системе PostgreSQL.
**Видео учебного курса «Основы технологий баз данных»**
[Выложены](https://postgrespro.ru/education/university/dbtech) слайды и видео первых двух частей курса *Б.А.Новикова*.
**Книжка-малютка «Postgres: первое знакомство»**
[Вышло](https://edu.postgrespro.ru/introbook_v5.pdf) новое, уже 5-е издание книжки-малютки [«Postgres: первое знакомство»](https://postgrespro.ru/education/books/introbook). Начиная с 4-го издания эта книга издается и на английском.
**Обновление курса DBA2**
Прежний курс DBA2 по версии PostgreSQL 9.5 назывался «расширенным» и включал в себя темы, дополняющие и углубляющие материал DBA1. Новый курс DBA2 по версии PostgreSQL 10 получился более сфокусированным за счет выделения части материала в самостоятельные курсы и получил название «Настройка и мониторинг». Если в DBA1 рассматривается механизм настройки сервера, то в этом курсе объясняется, какие именно параметры нужно настраивать и как это делать осмысленно, с пониманием внутреннего устройства PostgreSQL и на основе обратной связи от мониторинга. Материал курса [существенно обновлен](https://postgrespro.ru/education/courses/DBA2), добавлен модуль про различные виды блокировок.
**Новый курс QPT**
Оптимизация запросов, ранее рассматривавшаяся в курсе DBA2 по версии PostgreSQL 9.5, теперь выделена в [отдельный курс](https://postgrespro.ru/education/courses/QPT), одинаково необходимый как администраторам, так и прикладным разработчикам. Курс обновлен с учетом новой версии PostgreSQL, в частности, добавлен материал по параллельному выполнению запросов. Все примеры курса теперь используют [демонстрационную базу данных](https://postgrespro.ru/education/demodb).
**Postgres в ретроспективе**
Елена Индрупская [перевела](https://habr.com/ru/company/postgrespro/blog/438890/) главу **«Looking Back at Postgres»** *Джозефа Хеллерстайна* (Joseph M. Hellerstein) из [сборника](http://www.morganclaypoolpublishers.com/stonebraker/) о Майкле Стоунбрейкере. Оригинал этой главы в PDF [можно бесплатно прочитать](https://arxiv.org/pdf/1901.01973.pdf) на arXiv.org.
Статьи и блоги
--------------
**Three Factors of Authentication**
*Брюс Момджан* [обнародовал](https://momjian.us/main/blogs/pgblog/2019.html#January_14_2019) в своем блоге короткую, но концептуальную заметку о принципах аутентификации в PostgreSQL. По его словам, из трёх факторов:
* то, что ты знаешь (пароль, PIN);
* то, что у тебя есть (телефон, устройство для аутентификации);
* то, кем ты являешься (отпечаток пальца, радужка, голос);
в PostgreSQL напрямую используются только разновидности первого. С некоторыми ухищрениями, однако, можно использовать PIV-устройства, например [**YubiKey**](https://www.yubico.com/solutions/smart-card/). Предлагается подумать, встраивать ли в PostgreSQL прямую поддержку аутентификации вида 2 и 3 или просто подробно просветить желающих при помощи документации. Обратите внимание, перед этим Брюс писал аж [о 15 методах аутентификации](https://momjian.us/main/blogs/pgblog/2019.html#January_2_2019).
**One Security System for Application, Connection Pooling and PostgreSQL — The Case for LDAP**
Здесь [рассматривается](https://severalnines.com/blog/one-security-system-application-connection-pooling-and-postgresql-case-ldap) конфигурация корпоративной системы с
PostgreSQL 10, сервером приложений Wildfly, LDAP, pgbouncer. Даны примеры с конфигурационными файлами и кодом.
**Миграция с Mongo на Postgres: опыт газеты The Guardian**
Это [перевод](https://habr.com/ru/company/itsumma/blog/436416) статьи [**Bye bye Mongo, Hello Postgres**](https://www.theguardian.com/info/2018/nov/30/bye-bye-mongo-hello-postgres) из самой *Guardian*.
**Scheduling Backups En Masse with the Postgres Operator**
*Джонатан Кац* (Jonathan S. Katz) [рассказывает](https://info.crunchydata.com/blog/schedule-pgbackrest-backups-with-the-postgres-operator), как делать по расписанию полный и дифференциальный бэкап. Пишет о политиках резервного копирования, как создать само расписание, приводит примеры команд.
**An Overview of JSON Capabilities Within PostgreSQL**
*Венката Наготи* (Venkata Nagothi) [пишет](https://severalnines.com/blog/overview-json-capabilities-within-postgresql) в том числе о полнотекстовом поиске и приводит примеры правильного и неправильного использования операторов `@>` и `#>`
**Lessons learned scaling PostgreSQL database to 1.2bn records/ month**
[Статья](https://medium.com/@gajus/lessons-learned-scaling-postgresql-database-to-1-2bn-records-month-edc5449b3067?fbclid=IwAR3bSUy9YPfGnA4VaipEgs368jdOcsv7ZPMoyMx4jShJ0YX7yqK494q4-Ps) *Гайуса Кюзинаса* (Gajus Kuizinas) — это история воплощения крупного проекта с `Kubernetes`-кластером. Исследовали четыре варианта размещения данных: Google, Amazon, Aiven.io и у себя. Баг в **Cloud SQL for PostgreSQL** и вялая реакция службы поддержки заставил отказаться от *Google*; **Amazon RDS** не поддерживает [расширение **TimescaleDB**](https://www.timescale.com/), которое решили использовать для секционирования; у [*Aiven.io*](https://aiven.io/) не обнаружилось решающих недостатков, но и с преимуществами слабовато. В результате развернули проект собственными силами. Для резервного копирования в этом проекте используют [**barman**](https://www.pgbarman.org/), детище *2ndQuadrant*. Напоминаем, что только что вышел `barman 2.6`.
**PostgreSQL Performance in AWS, GCP, Azure, DO and UpCloud**
Эта [статья](https://aiven.io/blog/postgresql-cloud-performance/), конечно, ангажированная: ее написал CEO компании *Aiven.io* **Оскари Сааренмаа** (Oskari Saarenmaa), но в ней немало информации об облачных решениях с **PostgreSQL 10** от пяти облачных провайдеров.
**pg\_sampletolog: An extension to log a sample of statements**
[Статья](https://blog.anayrat.info/en/2019/01/28/pg_sampletolog-an-extension-to-log-a-sample-of-statements/) *Адриена Найра* (Adrien Nayrat) из французской компании [*Doctolib*](https://www.doctolib.fr/) рассказывает, зачем автор сделал расширение [`pg_sampletolog`](https://github.com/anayrat/pg_sampletolog) и как оно семплирует транзакции в логи (выбирая, например, 10% транзакций).
**The most useful Postgres extension: pg\_stat\_statements**
*Крейг Керстенс* (Craig Kerstiens) [сделал выжимку](https://www.citusdata.com/blog/2019/02/08/the-most-useful-postgres-extension-pg-stat-statements/) из своего доклада о расширениях PostgreSQL на конференции **FOSDEM** в Брюсселе, касающуюся `pg_stat_statements`, так как именно это расширение вызвало наибольший интерес.
**Серия статей *Postgres 12 highlight* Мишеля Пакье**
В своём `standalone`-[блоге](https://paquier.xyz/) *Мишель* рассказывает о:
* Functions for partitions;
* SKIP\_LOCKED for VACUUM and ANALYZE;
* pg\_promote;
* wal\_sender\_timeout now user-settable;
* Controlling SSL protocol;
* New PGXS options for isolation and TAP tests;
* DOS prevention.
**Maintaining feature branches and submitting patches with Git**
*Питер Айзентраут* (Peter Eisentraut) из *2ndQuadrant* [делится опытом](https://blog.2ndquadrant.com/maintaining-feature-branches-submitting-patches-git/) использования `git`, советует, как работать в собственных ветках, как мерджить и коммитить.
**Eye or the Tiger: Benchmarking Cassandra vs. TimescaleDB for time-series data**
Разработчики TimescaleDB, расширения PostgreSQL для работы с временными рядами, [утверждают](https://medium.com/timescale/time-series-data-cassandra-vs-timescaledb-postgresql-7c2cc50a89ce), что их детище работает на 5 узлах быстрее, чем Cassandra на 30, что вставка работает быстрее, а запросы ускорились до 5800 раз. И это при в 10 раз меньшей стоимости аренды узлов Azur, более гибкой модели данных и полной поддержке SQL.
**DudeTx: Durable Transactions Made Decoupled**
Эта теоретическая [статья](http://madsys.cs.tsinghua.edu.cn/publications/TS2018-liu.pdf) рассказывает о японской разработке DudeTx. Авторы стремились соединить лучшее в подходах **UNDO** и **REDO**. При этом новая концепция опирается на возможности NVM (non-volatile memory).
**Who Contributed to PostgreSQL Development in 2018?**
*Роберт Хаас* (Robert Haas)
[опубликовал](http://rhaas.blogspot.com/2019/01/who-contributed-to-postgresql.html) подсчеты — свои и *Стивена Фроста* (Stephen Frost) — вклада в PostgreSQL за 2018 год. В номинации **«авторство патчей»** лауреаты упорядочены по числу строк кода:
| Рейтинг | Разработчик | Общее число строк | Вклад в % | Число патчей |
| --- | --- | --- | --- | --- |
| 18 | Александр Коротков | 2671 | 1.07 | 24 |
| 20 | Анастасия Лубенникова | 2345 | 0.94 | 2 |
| 22 | Антон Быков | 2118 | 0.85 | 2 |
| 24 | Никита Глухов | 1890 | 0.76 | 5 |
Автором примерно четверти всех новых строк кода является *Том Лейн*.
В номинации **«деятельность коммитеров»** из России только два коммитера, и оба из Postgres Professional:
| Рейтинг | Разработчик | Общее число строк | Вклад в % | Число коммитов |
| --- | --- | --- | --- | --- |
| 3 | Фёдор Сигаев | 13646 | 11.28 | 44 |
| 9 | Александр Коротков | 2345 | 1.94 | 15 |
Стоит отметить, что *Александр Коротков* стал коммитером только в середине 2018 года, так что эти результаты он успел набрать за полгода.
Третья номинация — это **«активность в переписке **hackers**»** (порог >100 писем). В top мастеров эпистолярного жанра вошли:
| Разработчик | Число писем |
| --- | --- |
| Александр Коротков | 301 |
| Дмитрий Долгов | 226 |
| Константин Книжник | 223 |
| Андрей Бородин | 159 |
| Фёдор Сигаев | 152 |
| Артур Закиров | 111 |
| Сергей Корнилов | 106 |
#### На этом все. До новых встреч!
---
*Подписывайтесь на канал [postgresso](https://t.me/postgresso)!*
*Идеи и пожелания присылайте на почту: news\_channel@postgrespro.ru*
Предыдущие выпуски: [#13](https://habr.com/ru/company/postgrespro/blog/434760/), [#12](https://habr.com/company/postgrespro/blog/428275/), [#11 (спец)](https://habr.com/company/postgrespro/blog/426745/), [#10](https://habr.com/topic/edit/422527/), [#9](https://habr.com/company/postgrespro/blog/420283/), [#8](https://habr.com/company/postgrespro/blog/415675/), [#7](https://habr.com/company/postgrespro/blog/413419/), [#6](https://habr.com/company/postgrespro/blog/358560/), [#5](https://habr.com/company/postgrespro/blog/353736/), [#4](https://habrahabr.ru/company/postgrespro/blog/351650/), [#3](https://habrahabr.ru/company/postgrespro/blog/349100/), [#2](https://habrahabr.ru/company/postgrespro/blog/347858/), [#1](https://habrahabr.ru/company/postgrespro/blog/345652/) | https://habr.com/ru/post/436352/ | null | ru | null |
# Как изменить закрытую информационную систему под себя без привлечения вендора. Решение нерешаемых задач с Google Chrome
В крупном бизнесе нередко случаются ситуации, когда внедряются и используются заведомо ущербные информационные системы. Эти проекты начинаются как крутая собственная разработка компании, под её процессы, с учётом всех особенностей. Но уже после сдачи выясняется, что то тут, то там недоделки, несуразности. Что необходимые отчёты и графики получить невозможно, поскольку их не смогли или забыли учесть в ТЗ. Руководство требует, потом просит что-нибудь сделать, но система закрыта для изменений, а подрядчик находится с нами в процессе арбитражной тяжбы. Однако, безвыходных ситуаций конечно же не бывает.
Эта статья появилась, как продолжение давно начатого разговора о том, [как быстро поднять систему управленческого учёта (СУУ) «без бюджета»](https://habrahabr.ru/post/307310/). Всё описанное ниже делали не профессиональные программисты и не подрядчики. Основная идея заключается в том, что опытный менеджер осваивает навыки программирования и делает решение конкретной задачи используя хорошо документированные технологии. Результат такого подхода позволяет сэкономить значительные деньги и время. Как показывает опыт, таким «прокаченным менеджерам» намного проще самим сделать модель того, что понадобится в будущем заказать у поставщика уже для масштабного решения.
Итак, у нас уже была простенькая СУУ на базе MS Access + MS SQL, с необходимым набором полей и всеми требуемыми отчётами. Доработка её велась постоянно, поскольку всё время возникали новые требования по удобству, дополнительным функциям.
Вскоре пришло понимание некоторой ограниченности MS Access в плане front-end. То есть можно было конечно же делать кастомные контролы, писать библиотеки, но как-то не хотелось ввязываться в эту непростую историю. Изначально цель проекта была найти максимально простое и быстрое решение конкретной задачи – учёта. Раздувать Access в полноценный аналог 1С или чего-то подобного было бы ошибкой. Access не предназначен для построения серьёзных систем. Кстати, именно по этой причине мы решили не масштабировать систему на все департаменты агентства, а ограничились только подразделением Digital-рекламы.
Появились, также, проблемы с совместимостью. Access Runtime решал вопрос запуска СУУ у пользователей без установленного полноценного платного MS Access. Однако, версии Windows и Office у многих оказались разные, как и подключённые библиотеки. В результате пришлось потанцевать с бубном для запуска системы у сотрудников с установленным Office 2016.
В довершение ко всему, имелась двойная работа по внесению данных в СУУ на базе Access и «большую систему» документооборота компании, поскольку часть вносимой информации всё же была общей. Пока наша система испытывалась на небольшом отделе внутри департамента Digital эта проблема была не так актуальна: пользователи были заинтересованные. Раньше они сами вели такую вторую «базу» со всеми необходимыми им данными в формате Excel. После распространения СУУ на все баинговые отделы (контекстная реклама, SMM, продакшн и прочие), народ начал потихоньку нас ненавидеть. Двойной работы стало многовато в масштабе департамента.
Главное затруднение при этом состояло в том, что «большая система», куда обязательно нужно было вносить часть данных, стоившая компании миллионы рублей и годы работы, **была для нас абсолютно закрыта**. Исходников не было. Доступ к базе был, но поскольку от работоспособности этого решения зависел бизнес компании, и мы не всегда могли понять, как она работает (закрытые исходники), было решено не влезать в базу.
Упрощённо говоря, требовался единый терминал для заполнения информации в двух базах одновременно: «большой» (с меньшим числом полей) и «маленькой» (с большим числом полей). Причём, как уже говорилось выше, без возможности доступа к одной из баз иначе чем через веб-интерфейс пользователя.
Казалось бы, неразрешимая задача. Но тут попалось мне расширение Google Chrome, уже не помню как оно называлось, суть которого была в том, что оно изменяло форму отображения информации на веб-странице, дополняя её отсутствующими ранее полями. При этом для пользователя практически ничего не менялось. Он заходил по тому же самому URL, но видел гораздо более удобную форму. Это расширение брало информацию из полей и сохраняло на другом сервере, где потом можно было увидеть эти дополнительные данные. Идея нам понравилась. Фактически требовалось примерно то же и в нашем случае.
Схема хранения данных выглядит следующим образом:
На фронт-энде была выбрана связка: Расширение Google Chrome+Bootstrap+Angular. Почему так? [Bootstrap](http://getbootstrap.com/getting-started/) избавил от необходимости долго прорабатывать вёрстку. Мы использовали дефолтную тему и пользователям она вполне понравилась. [Angular](https://docs.angularjs.org/tutorial) позволил быстро выстроить логику поведения формы и взаимодействия с бэк-эндом. Удобные контролы настраивались на раз. Практически не было проблем с совместимостью между Bootstrap и Angular. Для контролов использовалась библиотека [UI Bootstrap](https://angular-ui.github.io/bootstrap/). Для интерактивных таблиц использовали [Angular UI Grid](http://ui-grid.info/) совместно с [Angular JS dropdown multi-select](https://www.npmjs.com/package/ng-dropdown-multiselect), которая и добавляла данные в таблицу. Кроме того, были использованы другие библиотеки Angular, среди которых [ngDialog](http://github.com/likeastore/ngDialog) для прорисовки всплывающих диалогов и некоторые вспомогательные (зависимости), для указанных выше модулей.
Настройка самого расширения Google Chrome заняла не более пары дней копаний документации. Этот вопрос разберём более подробно. Начать следует с того, что для нормальной дистрибуции новых версий расширения необходимо приобрести (разово) доступ к [интернет-магазину Chrome](https://chrome.google.com/webstore/developer/dashboard?authuser=1&hl=ru). Ограничений на разработку и выкладывание расширений в настоящий момент нет, хотя выкладывание новых приложений Google Chrome [недавно обрубили](https://blog.chromium.org/2016/08/from-chrome-apps-to-web.html). Вроде как планов относительно выключения расширений пока не было. Выкладка новой версии представляет собой выгрузку зазипованной папки в которой идёт разработка (файл «manifest.json» в корне).
Для тестирования расширения необходимо зайти: «Главное меню» -> «Дополнительные инструменты» -> «Расширения» -> «Загрузить распакованное расширение». При обновлении кода нужно каждый раз нажимать «Обновить расширения», чтобы изменения вступили в силу и отобразились. Если для разработки использовать [Chrome Dev Editor](https://github.com/GoogleChrome/chromedeveditor), то обновление расширений происходит автоматически. Впрочем, мы уже перешли с него на [Visual Studio Code](https://code.visualstudio.com/), он нам показался гораздо более удобным.
Простейшее расширение можно создать при помощи конструктора: [Extensionizr](http://extensionizr.com/). Оно будет включать в себя минимальный набор файлов:
1. «manifest.json» — включает основные параметры расширения, права доступа к браузеру, указания на «контент скрипты», о которых ещё будет сказано ниже
2. «page\_action.html» — представление расширения. В нашем случае оно открывалось в виде модального окна поверх формы «большой системы». Логику контроллера Angular мы вынесли в отдельный файл «page\_action.js», а потом ещё в другие файлы
3. «inject.js» – тот самый «контент-скрипт», который позволяет совершить [некое чудо](https://developer.chrome.com/extensions/content_scripts) с страницей поверх которой открывается расширение. Можно вообще полностью её перерисовать
4. «background.js» — отслеживает что происходит на странице, поверх которой будем открывать форму. Содержит правила показа расширения
В нашем случае расширение активировалось только когда пользователь открывал определённую форму. Чтобы «узнать» эту форму было задано следующее правило в background.js:
```
var rule1 = {
conditions: [
//На какой id присутствующий на странице реагировать активацией значка расширения
new chrome.declarativeContent.PageStateMatcher({
css: ["textarea[id='id_поля_на_которое_реагируем_активацией_значка_расширения']"]
})
],
actions: [ new chrome.declarativeContent.ShowPageAction() ]
};
chrome.runtime.onInstalled.addListener(function () {
chrome.declarativeContent.onPageChanged.removeRules(undefined, function () {
//Добавляем правило в Chrome
chrome.declarativeContent.onPageChanged.addRules([rule1]);
});
});
```
Чтобы по клику на кнопку расширения открывалось окно, в том же background.js был такой код:
```
chrome.pageAction.onClicked.addListener(function (tab) {
//Получаем id таба
tabid = tab.id;
var w = 1400;
var h = 900;
var vleft = (screen.width/2)-(w/2);
var vtop = (screen.height/2)-(h/2);
chrome.tabs.create({
url: chrome.extension.getURL('/src/page_action/page_action.html'),
active: false
}, function (tab) {
//Свойства диалога, который открывается по клику на кнопку расширения
chrome.windows.create({
tabId: tab.id,
width: w,
height: h,
type: 'popup',
focused: true,
left: vleft,
top: vtop
},
function(window) {
}
);
});
})
```
Сам файл page\_action.html это обычная HTML-страничка, но в нашем случае она ещё содержала директивы Angular:
```
```
Контроллер у нас был один и как уже было написано выше, он жил в файле page\_action.js (основная логика) и куче других файлов .js, содержавших конкретную реализацию каждого участка логики.
Для связи записей в базах использовалось поле «Комментарий» в форме «большой системы» (поверх которой открывалось расширение). При добавлении новой записи, расширение вставляло в поле комментарий запись вида: {”ext\_id”:”1233”}. Далее, при открытии расширения поверх любой записи в «большой системе», оно сразу подгружало сохранённые ранее данные в свою форму.
Отдельно хотелось бы затронуть тему контент-скриптов (файл «inject.js»). Дело в том, что это уникальная возможность Google Chrome, позволяющая полностью перерисовывать оригинальную страничку. Приведу пример. В «большой системе» отсутствовала табличка с некими сводными данными по рекламным размещениям в рамках проекта. Эта табличка сильно упростила бы жизнь сотрудникам, работающим с формой, поскольку конкретное размещение сразу было бы видно в контексте. Для реализации был создан контент-скрипт, который выводил кнопку открывающую модальное окно с табличкой и содержал логику самой таблички, а также код подгрузки данных в неё.
Вначале вставляем кнопку на страничку, поверх которой работает расширение Google Chrome:
```
//Определяем HTML-элемент в который будет вставлена наша кнопка
var parent_node = document.getElementsByTagName("id_родительской_ноды");
//Определяем новый HTML-элемент, который и будет нашей кнопкой (на самом деле ссылкой)
var elem = document.createElement('a');
elem.setAttribute("href", "#");
elem.setAttribute("class", "dyn");
elem.setAttribute("ng-click", "openTotalsBySellers()");
var html_code = '**[Итого селлеры]**' + "\n";
elem.innerHTML = html_code;
//Добавляем новый элемент в родительский
parent_node.appendChild(elem);
//Перекомпилируем страничку с помощью Angular, чтобы кнопка появилась
$compile(elem)($scope);
```
Вы могли заметить функцию «openTotalsBySellers», которая собственно и открывает нужную нам табличку. Приведу код функции контент-скрипта, которая вставляет нужный JavaScript на исходную страничку (на которой мы только что поместили кнопку:
```
function defineDialogTableTotalsBySellers($scope, $compile, uiGridConstants, parent_node) {
//Определяем таблицу, которая будет в всплывающем окне (используется ui-grid)
$scope.totalsBySellersG = {
showGridFooter: true,
showColumnFooter: true,
enableFiltering: true
};
//Определяем колонки таблицы
$scope.totalsBySellersG.columnDefs = [
{ name: 'seller', displayName:'Площадка'},
{ name: 'totals_agency', displayName:'Сумма', aggregationType: uiGridConstants.aggregationTypes.sum, type: 'number'},
];
//Переменная для данных
$scope.totalsBySellersG.data = [];
//Волшебная функция без которой таблица не появится в диалоге
$scope.totalsBySellersG.onRegisterApi = function(gridApi){
//set gridApi on scope
$scope.gridApi = gridApi;
};
//JavaScript код диалога, в котором будет таблица (используется ngDialog)
var dialog = document.createElement('script');
dialog.setAttribute("id", "openTotalsBySellers");
dialog.setAttribute("type", "text/ng-template");
html_code = "";
html_code += '';
html\_code += 'Итоги по селлерам (Resolution Money)
------------------------------------
';
html\_code += '
';
//Переменная $scope.total\_sum пересчитывается каждый раз при открытии формы
html\_code += '
**Полная стоимость (с НДС):** {{total\_sum}}
';
html\_code += '';
html_code += '';
html\_code += '';
html\_code += '';
dialog.innerHTML = html_code;
parent_node.appendChild(dialog);
$compile(dialog)($scope);
}
```
На бэк-энде работала связка Apache + PHP + MS SQL. Подробно расписывать, наверное, смысла нет, но основные идеи были в следующем. Мы решили не извращаться с шифрованием данных: всё-таки расширение работало только внутри компании. Чтобы не пересылать сырой JSON, данные упаковывались в Base64 и так уходили на сервер и обратно. Использовался метод POST, поскольку он не содержит ограничений по объёму данных. Изначально архитектура приложения PHP была выстроена на базе шаблона ApplicationHelper, описанного в замечательной [книге Мэтта Зандстра «PHP объекты, шаблоны и методики программирования»](http://www.ozon.ru/context/detail/id/33506422) (Вильямс, 2015).
Общая архитектура системы выглядит следующим образом:
В результате менее чем через месяц было получено рабочее решение, которое действует до сих пор. За этот год у нас появилось чёткое представление о желаемой функциональности и формах. Фактически менеджерами, которые разбираются в нюансах бизнеса, самостоятельно была создана модель «идеальной» Системы управленческого учёта, полностью адаптированной под наши задачи. Благодаря этому, мы с гораздо меньшей кровью скоро заменим расширение Google Chrome на большую информационную систему, включающую workflow, которая выстроена совсем иначе и масштабируется на всё агентство. Описанное в этой статье расширение позволило на протяжении полутора лет вести управленческий учёт без дублирования работы. Неотъемлемой частью СУУ являются отчёты о которых хотелось бы рассказать подробно, но уже за рамками этой статьи. | https://habr.com/ru/post/323328/ | null | ru | null |
# Как мы на React 16 переезжали
Facebook переписал большую часть React'а и выпустил 16 версию. React 16 был очень ожидаемым обновлением, особенно ввиду нового способа рендеринга Fiber, который сильно повышает производительность. Команда разработчиков React в последней версии усердно помечала методы и пакеты устаревшими (deprecated), и мы видели их предупреждения в консоли. В действительности же, миграция не так проста для большого проекта.
Мы в Discord только что запустили обновление нашего приложения на основе React 16 и хотим поделиться нашим опытом, который мы получили в ходе миграции.
### Зачем мы это сделали?
Архитектура Fiber выглядит так, что она сможет сильно повысить плавность и скорость работы как рендеринга DOM-дерева, так и Native-компонентов путем разбиения процесса рендеринга на составляющие, давая предпочтение более быстрым частям. Прямо сейчас не очень ясно, являются ли эти преимущества существенными (например, асинхронный рендеринг все еще не включен), но эти изменения прокладывают путь в светлое будущее.
В конечном счете, вам **придется** обновиться. React находится в движении, и 16+ сообщество обязательно оставит вас брошенным наедине с багами. А в качестве бонуса React 16 приносит новые фичи, например, ErrorBoundary. [В нем множество изменений](https://github.com/facebook/react/issues/10294), к которым вам придется привыкнуть.
### Геморрой начинается здесь
Как и все миграции, уровень боли будет прямо коррелировать с давностью вашей кодовой базы. Facebook сделал хорошую работу в течение последних месяцев, помечая deprecated-методы ошибками, но не все библиотеки хорошо разработаны, и если вы зависите от таких библиотек или же от библиотек, которые вы форкнули, вам придется не сладко.
Также придется вашей команде решить пришло ли время полностью переходить на ES6-классы или на функциональные компоненты. Мы *строго* рекомендуем делать это *после* успешной миграции, так что вы сможете понять, что сломалось (а еще лучше, покрывая тестами) до того, как вы обновите проект.
Мы писали качественный код, но этого оказалось недостаточно, чтобы легко перейти с миксинов и React.createClass. Мы также использовали конкретные версии пакетов, что давало нам стабильность и уверенность, но наши зависимости стали старыми и покрылись мхом.
Вот здесь мы и столкнулись с болью от миграции.
### Запуск codemod
Прежде всего вы должны использовать codemod, чтобы переехать с React.PropTypes на prop-types, и мигрировать с React.createClass. Codemod поможет в правильном выборе: использовать class Component где это возможно (или PureComponent в случае простого миксина), а где использовать create-react-class.
Установите [jscodeshift](https://github.com/facebook/jscodeshift), а склонируйте react-codemod [репозиторий](https://github.com/reactjs/react-codemod). Затем запустите следующие команды для вашего проекта:
1. Переход на prop-types
```
jscodeshift -t ./react-codemod/transforms/React-PropTypes-to-prop-types.js /path/to/your/repo
```
2. Переход на Component, PureComponent или createReactClass:
```
jscodeshift -t ./react-codemod/transforms/class.js --mixin-module-name=react-addons-pure-render-mixin --flow=true --pure-component=true --remove-runtime-proptypes=false /path/to/your/repo
```
Последнее — это последовать хорошо описанным [советам](https://github.com/reactjs/react-codemod) в репозитории react-codemod. Наиболее важные из них:
* Переход на ES6-классы, если нет миксинов, и на PureComponent, в случае простых миксинов.
* Убедиться, что если в созданных классах присутствуют все static-параметры.
* Созданы аннотации из React.propTypes.
* Перенесены привязывание контекста
```
this.method.bind(this)
```
методов из конструкторов в стрелочные функции (если, конечно, это вам по душе).
* Пропущены все компоненты, которые используют устаревшее API, например, `isMounted()` метод, и так далее.
Codemod найдет много ошибок в проекте, которые должны быть записаны и затем исправлены вручную.
Если вам не понравится это автоизменение, вы можете поправить вручную что угодно на свой вкус. Codemod — это прекрасный инструмент, но не волшебная палочка. Он не мигрирует проект полностью за вас!
### Поиск и замена
Мы обнаружили множество мест в коде, которые пропустил codemod. Судя по всему, там, где мы импортировали и вызывали PropTypes напрямую. Больше всего ручных исправлений пришлось на выискивание вызовов метода `isMounted()` и создание свойства \_isMounted, которая равнялась `true` внутри `componentDidMount` и `false` внутри `componentWillUnmount` ([но, возможно, вам так делать не стоит](https://facebook.github.io/react/blog/2015/12/16/ismounted-antipattern.html))
### Отказ от использования приватного API
Конечно же, вы не используете внутренние API фреймворка React, верно? Те, которые лежат в `react/lib/*`. Если вы в своем проекте полагаетесь на них, то для вас плохие новости: вы за бортом.
Некоторые API были перемещены во внешние библиотеки (Семейство пакетов «react-addons-»), а некоторые, вовсе, были удалены.
В нашем проекте мы полагались на самописный TransitionGroup, которые зависел от flattenChildren-функции из недр `react/lib`. Но теперь этой функции нет, как и childMapping и mergeCildMapping. Разработчики фреймворка в таком случае рекомендуют просто взять и скопировать эти недостающие функции. Это мы в итоге и сделали. Однако, мы встроили новые версии тех функций из пакета react-transition.
Таким образом, мы столкнулись с первой серьезной проблемой. Но наше приложение по прежнему не работало.
### Обновление зависимостей
Этот пункт оказался одним из самых утомительных. И если вы не лихорадите обновлением до 16 версии, разумно будет подождать, пока большинство библиотек обновятся. Если вы хотите заняться обновлением, то это поможет каждому.
Консоль по прежнему показывает предупреждения о пакетах, которые используют React.PropTypes или React.createClass. Вам нужно будет обновить эти пакеты. Либо придется их заменить, либо как-то обойти, написав свое решение. Или же, форкнуть и поправить их, если пакеты кажутся заброшенными.
Основные проблемы, которые нужно решить:
1. React.PropTypes
2. React.createClass
3. Зависимости от внутренностей фреймворка версии меньше 16
К сожалению, не все ошибки легко найти, и здесь кроется настоящий геморрой.
Столкнувшись с ошибкой, целых два дня ушло на поиск искомой библиотеки. И у вас будет тоже самое. Консоль продолжала говорить нам, что reactRiberChild не может зарендерить элемент, потому что атрибут `ref` был `undefined`. Мы рвали волосы на голове, выискивая что могло пойти не так, и в конечном счете копнули внутрь кода React, где увидели причину ошибки. Оказалось, что 16-й версии React не нравится `ref: undefined`, а вот `null` вполне себе ок. После этого стало понятно, что создаваемые элементы с помощью одной внешней библиотеки имели атрибут `ref: undefined`. После того, как мы форкнули библиотеку, модифицировав ее код, все заработало прекрасно.
### Особый геморрой
Что же, мы еще обнаружили и трудноуловимые ошибки. Опять же, в большинстве случаев требовался переход на новые версии библиотек или же их модификацию. Часто бывает, что при обновлении достаточно старой библиотеки, она меняет поведение элементов, и мы получаем полный швах в наших прекрасно написанных CSS-правилах.
Большинство библиотек только фиксировала свои проблемы, связанные с предупреждениями в React 15. И только самые последние их версии будут работать в React 16. Это утомительная работа по поиску и обнаружению ошибок.
Переход на ES6-классы означает, что вам теперь нужно осторожным и не менять атрибут props. Раньше было просто предупреждение в консоль об этом, теперь это падает с ошибкой “Cannot assign to read only property XXX of object ‘#’”. Если вы деструктурируете атрибут props, и пытаетесь изменить его свойства, эта ошибка вас ударит по рукам. Вместо этого используйте Object.assign или его синтаксический сахар:
```
const newProp = {...prop, propertyToOverride: overrideValue}
```
Также React 16 будет предупреждать о получении bolean-значения у onClick-метода. Это случится, если вы напишете
```
onClick={!disabled && this.handleOnClick}
```
Поэтому придется управлять поведением внутри назначенной функции.
### И тут выходит на связь React Native
У нас ведь есть еще iOs приложение, которое делит stores, utils и некоторые action creators с веб-приложением. Переход на React 16 также смотивировал нас использовать последний релиз React Native, который зависит на альфа-версии React 16.
К сожалению, нам нужны специальны таймеры для видео, и у нас был форк React Native, и мы вернулись на версию 0.34. React 16 совместимость пришла в React Native только с версии 0.48.0, так что это время для обновления…
Это оказалось особенно болезненным. Наибольшей головной болью оказалось, что мы использовали React Native Webpack Server, который позволял повторно использовать код между нашими проектами. Так что мы пересмотрели взгляды на использование сборщика и стали переходить на [Haul](https://github.com/callstack/haul).
Haul держит нас по-прежнему во вселенной Webpack, но было не так просто его настроить на существующий проект. Рассказ об этом тянет на отдельную статью.
Мы раньше импортировали изображения для iOs с помощью webpack `require(‘image!image_src’)`, но теперь нет возможности использовать его в новых версиях React Native. Это была изнурительная работа — нам требовалось перемещать изображения и менять способ доступа к ним. Даже после использования codemod, эта часть работы была проделана в основном вручную.
Также мы обнаружили множество устаревших классов, и сейчас мы советуем использовать костыль в виде [react-native-deprecated-custom-components](https://github.com/facebookarchive/react-native-custom-components). Вам понадобится самая последняя версия, так как они недавно обновили пакет для React 16.
### Берем в работу новые фичи
Самом лучшим нововведением для нас оказался новый [ErrorBoundary](https://facebook.github.io/react/blog/2017/07/26/error-handling-in-react-16.html). React 16 теперь прекращает рендер дерева в случае ошибки (что хорошо), и вы сможете отрендерить какое-то сообщение об ошибке. Дополнительно, ограничения дают хорошую возможность иметь отдельное место для логирования хорошо описанных ошибок с информацией о стеке вызовов и о компонентах.
### Это запустилось!
Итак, теперь это работает, и пользовательский опыт стал полон восторга и удовлетворения? Нет. Мы обнаружили, что быстрее работать не стало. Но будет, так как новая архитектура дает нам новые возможности.
Самое большое преимущество при игре в долгую. Наш код был обновлен, что позволило нам нормализовать большую часть кода, пересматривая некоторые из основных инструментов. Это хорошо скажется на будущих модернизациях.
Производительность — это неплохой бонус. | https://habr.com/ru/post/339742/ | null | ru | null |
# Генератор жанровых постеров для фильмов и перенос стиля картинки — проекты студентов курса «Нейронные сети» Техносфера
Мы рассказали про выпускные проекты выпускников семестровых курсов по мобильной разработке Технопарка (МГТУ им. Баумана) (предыдущие публикации: «[Разработка приложений на iOS](https://habr.com/ru/company/mailru/blog/509900/)», «[Разработка приложений на Android](https://habr.com/ru/company/mailru/blog/511858/)»). Сегодня делимся интересными проектами студентов второго семестра Техносферы — совместного с МГУ образовательного проекта с годовой программой обучения в области анализа и работы с большими объемами данных. Студенты проходят курсы по машинному обучению, инфопоиску, нейронным сетям и другим дисциплинам. В обучении применён проектный метод, поэтому итоги семестра мы подводим на защитах студенческих проектов.
В образовательном процессе большую роль играют эксперименты. Студенческие проекты без них не обходятся: ребята пробуют разные подходы, методы, архитектуры, инструменты. Часто после эксперимента студенты отказываются от выбора технологии и алгоритма в пользу нового подхода. Это большая часть опыта и обучения. Ниже мы расскажем о таких этапах в разработке двух студенческих проектах.
* Проект Movie posters GAN/embed.
* Проект Cyrclegan on cartoon series.
CycleGAN on cartoon series
--------------------------
Авторы этого проекта решили использовать технику CycleGAN для перевода картинок из одного анимационного фильма в другой. GAN (Generative adversarial network) — методика обучения моделей image-to-image. Обучаются две нейронные сети: дискриминатор и генератор, которые находятся в соперничающих отношениях. Генератор пытается увеличить ошибку классификации, дискриминатор — уменьшить. А CycleGAN — методика передачи обучения imag-to-image в режиме без учителя.
Допустим, есть два домена картинок — A и В. Создаются два генератора и два дискриминатора: gen\_A2B, gen\_B2A, disc\_A, disc\_B. Нужно, чтобы по картинке из A генератор gen\_A2B создавал эту же картинку, но так, чтобы она была в домене B. Для этого вводят cycle consistency loss:
```
l1loss(gen_b2a(gen_a2b(a)), a)
```
В этом случае генератор будет генерировать картинки, которые обманывают дискриминатор, но при этом сохраняют изначальный контент.
Архитектура решения:
Генератор:
Resnet-блоки позволяют запоминать изначальную картинку. Также использовались instance normalization вместо batch normalization, потому что последний добавляет шумы из других картинок.
Дискриминатор:
Готового набора изображений не нашлось, поэтому выбрали картинки из ключевых кадров анимешных полнометражек: для А использовали «Унесенные призраками» Хаяо Миядзаки, а для B — «Твоё имя» Макото Синкая. Поскольку CycleGAN не очень подходят для кардинальных изменений (например, формы), авторы взяли оба домена из аниме.
В качестве функции потерь использовали сначала LSGAN, а потом WGAN GP, потому что LSGAN в процессе обучения создавал странные артефакты и терял цвета.
Для обучения использовали предобученную на horse2zebra модель (веса найдены лишь для генераторов). Она уже имеет понимание, что ей надо сохранять содержимое картинки, поэтому авторы в самом начале получили неплохой autoencoder, который оставалось только научить обманывать дискриминатор.
В самом начале обучения выставляли большое значение для cycle loss identity loss и gradient clipping, но когда прошло достаточно эпох, решили понемногу уменьшать эти значения, чтобы генератор стал чуть больше пытаться обманывать дискриминатор.
Также пытались в качестве дискриминатора использовать большие предобученные сети (VGG, RESNET, Inception), но они очень большие и обучение сильно замедлялось.
В результате работе удалось достичь того, что, стиль переносится близко к оригиналу, с сохранением общей цветовой гаммы (сверху оригиналы, снизу сгенерированные картинки):
Код проекта: <https://github.com/IlyasKharunov/Cyclegan_project>
Команда проекта: Ильяс Харунов, Олег Вербин.
[Видео с защитой проекта](https://www.youtube.com/watch?v=2__hPM5AwpU).
Movie posters GAN/embed
-----------------------
Следующий проект интересен как раз с точки зрения пути, который проделал студент. В отличие от других студенческих проектов, Дмитрий выполнял работу самостоятельно. Такой путь оказался сложнее, чем у других, но результаты и выводы интересные.
Автор решил сделать сеть, которая генерировала бы постеры к фильмам по заданным жанрам. Например, чтобы постеры для фильмов ужасов были в тёмных тонах, для комедий — в светлых, и тому подобное.
С сайта IMDB автор взял 41 тыс. постеров для фильмов в двадцати жанрах за период 1970-2020. Позднее выяснилось, что для некоторых жанров изображений слишком мало, поэтому Дмитрий сбалансировал набор по жанрам, и в итоге осталось 32 тыс. постеров.
Затем для безжанрового генерирования картинок студент применил нейросеть с архитектурой DCGAN. Она работала с постерами размера 64x128.
Результаты получились криповатые:
Затем автор попробовал архитектуру CVAE+DCGAN:
А также VAE без GAN и GAN с классификатором. Пришел к заключению, что собранный набор постеров слишком сложен для этих методов. Тогда автор применил conditional GAN: это то же самое, что и DCGAN, только жанры теперь подавались и в генератор, и в дискриминатор. Латентный вектор z был взят длиной 100, жанры в hot-формате длиной 20, в результате получился вектор длиной 120. К ответу был добавлен жанр и выполнялся дополнительный прогон по одному линейному слою.
Удалось добиться такого результата:
Как видите, студенту было интересно пробовать различные подходы, результаты получились интересными. Авто получил много нового опыта, пришел к выводу, что для реализации такой идеи необходимо сразу брать более сложную нейронную сеть, например, StyleGAN.
Процесс обучения сети:
Команда проекта: Дмитрий Питеркин.
[Видео с защитой проекта](https://www.youtube.com/watch?v=jd5unKzy1x8).
---
В скором времени мы расскажем и о самых интересных дипломных проектах по разработке на C++ и Go, фронтенд-разработке и созданию интерфейсов. Подробнее о наших образовательных проектах вы можете почитать по [этой ссылке](https://corp.mail.ru/ru/company/education/). И почаще заходите на канал [Технострим](https://www.youtube.com/user/TPMGTU), там регулярно появляются новые обучающие видео о программировании, разработке и других дисциплинах. | https://habr.com/ru/post/512874/ | null | ru | null |
# Использование API Gateway в качестве единой точки входа для веб-приложений и API
***Перевод статьи подготовлен специально для студентов курса [«Архитектор высоких нагрузок»](https://otus.pw/Gjr0/).***
---
### Введение
Преимущества AWS, такие как высокая доступность, масштабируемость и эластичность, уже доказали свою эффективность для SaaS-провайдеров (Software-as-a-Service). При модернизации SaaS-приложений, AWS помогает плавно перейти на микросервисную архитектуру с предоставлением API-доступа внешним приложениям.
Инструменты управления API, такие как [Amazon API Gateway](https://aws.amazon.com/api-gateway/) — это естественный выбор для предоставления безопасного и масштабируемого внешнего API. Однако, при переводе своих приложений в облака, SaaS-провайдеры часто сталкиваются с необходимостью быстрого развертывания своих сервисов для нескольких разных клиентов. И, конечно, со специфическими требованиями каждого из них.
API Gateway помогает в создании мультитенантной микросервисной архитектуры. В такой архитектуре для обслуживания разных клиентов используется один экземпляр микросервиса, что позволяет более оптимально использовать ресурсы и оптимизировать затраты. В такой конфигурации для обслуживания своих клиентов от провайдеров требуется поддержка “white-label”-доменов, а также возможность идентификации клиентского домена для привязки специфичной бизнес-логики к конкретному клиенту в бэкенде.
В этой статье рассказывается об эталонной архитектуре, которая позволяет использовать API Gateway как единую точку входа для веб-приложений и микросервисов, основанных на API, с несколькими внешними клиентами, используя для каждого из них разные поддомены.
### Amazon API Gateway — единая точка входа
Построение архитектуры с использованием единого API Gateway для множества веб-приложений и микросервисов является важным фактором для повторного использования компонент и оптимизации затрат.
Amazon API Gateway предоставляет высокомасштабируемое решение для создания и публикации RESTful API и WebSocket API. Для бэкенда можно выбрать различные технологии: функции [AWS Lambda](https://aws.amazon.com/lambda/), конечные автоматы [AWS Step Functions](https://aws.amazon.com/step-functions/) или вызов конечных точек HTTP, размещенных на [AWS Elastic Beanstalk](https://aws.amazon.com/elasticbeanstalk/), [Amazon EC2](https://aws.amazon.com/ec2/) или вне AWS.
API Gateway берет на себя такие типовые задачи по управлению API, как безопасность, кэширование, троттлинг и мониторинг. Хотя его основной задачей является построение абстрактного слоя поверх вашего внутреннего API и микросервисов, но он также может упростить ваши бэкэнд-приложения или обеспечить доступ к статическим веб-страницам и документам, которые хранятся в бакетах [Amazon S3](https://aws.amazon.com/s3/).
Создать описанную здесь архитектуру, помимо вышеперечисленного, помогают следующие ключевые функции API Gateway.
### 1. Поддержка пользовательских доменных имен:
При развертывании API с использованием API Gateway, доменное имя конечной точки API по умолчанию не очень удобно для конечного пользователя:
```
https://api-id.execute-api.region.amazonaws.com/stage
```
* `api-id` генерируется API Gateway;
* `region` указывается вами при создании API;
* `stage` указывается вами при развертывании API.
С конечной точкой API по умолчанию может быть трудно работать. Но благодаря интеграции с AWS Certificate Manager, который позволяет выполнять проверку поддоменов на основе SSL-сертификатов, можно предоставить пользователям вашего API более простой и интуитивно понятный URL, например, `customer1.example.com`. API Gateway позволяет сопоставить несколько поддоменов с одной конечной точкой API, что позволяет использовать “white label”-имена в соответствии с требованиями внешних клиентов.
### 2. Модификация запросов/ответов API
API Gateway позволяет для каждой части адреса конечной точки API настроить отдельную обработку. Благодаря этому можно маршрутизировать запросы API в отдельные конечные точки бэкэнда, а также одновременно с этим изменять заголовки в запросе/ответе для более гибкой обработки API-запросов.
Преимущества такой архитектуры
------------------------------
Описанные в этой статье возможности показаны на диаграмме ниже.
Здесь приведена архитектура для типичного SaaS-провайдера, который предлагает свои услуги другим организациям и должен поддерживать “white-label”-домены для веб- и API — инфраструктуры. Подобная архитектура достигается с помощью следующих шагов:
1. Домен `example.com` может быть зарегистрирован у регистратора доменов, а вы можете создавать поддомены через CNAME-записи, например, `customer1.example.com`, `customer2.example.com`. Это можно сделать в AWS с помощью сервиса [Amazon Route 53](https://aws.amazon.com/route53/) или через любого стороннего DNS-провайдера.
2. После этого можно воспользоваться [AWS Certificate Manager](https://aws.amazon.com/certificate-manager/) (ACM) для создания сертификата доменов `example.com` и `*.example.com`. Что необходимо для возможности обслуживания поддоменов ACM-сертификатом, примененным к API Gateway.
3. Используя сертификат, созданный в ACM, можно создать свой домен для конечной точки API. В нашем примере конечная точка API обслуживает два поддомена у разных клиентов с настройкой необходимых сопоставлений. Для этого создаются два поддомена: `customer1.example.com` и `customer2.example.com`.
***Примечание:** не забудьте добавить CNAME-записи для customer1 и customer2 в DNS, чтобы указать эти имена в настройках API Gateway.*
### 4. API Endpoint настраивается следующим образом
* `/service1` — integration type HTTP, маршрутизация трафика на конечную точку микросервиса ELB, размещенного в кластере ECS
* `/service2` — integration type HTTP, маршрутизация трафика на конечную точку веб-приложения ELB, размещенного в кластере EC2
* `/docs` — integration type AWS S3, для статических документов
### 5. API Gateway может обрабатывать полное доменное имя (FQDN) в URL-адресе и сопоставлять его с пользовательскими заголовками или параметрами в строке запроса для отправки на соответствующий бэкенд.
Например, мы можем создать пользовательский заголовок “Customer” для перенаправления customer1 или customer2 в специфичное для клиента бэкэнд-приложение. Это делается с помощью параметров Method Request и Integration Request в API Gateway.
Итог
----
Как видите, это только один из примеров использования API Gateway в качестве единой точки входа для микросервисов, основанных на API, и статических ресурсов веб-приложений. API Gateway позволяет более эффективно использовать инфраструктуру без потери масштабирования при увеличении нагрузки на ваши приложения. Подробнее о работе с [API Gateway](https://docs.aws.amazon.com/apigateway/latest/developerguide/welcome.html) и [Route 53 DNS](https://docs.aws.amazon.com/Route53/latest/DeveloperGuide/Welcome.html) можно прочитать в документации AWS и использовать эти возможности для создания архитектур, соответствующих вашим требованиям. | https://habr.com/ru/post/493306/ | null | ru | null |
# SQL HowTo: обход дерева иерархии «по курсору» через двойную рекурсию
Порядок обхода узлов дерева иерархииВ предыдущих статьях ["PostgreSQL Antipatterns: навигация по реестру"](/ru/post/498740/), ["PostgreSQL 13: happy pagination WITH TIES"](/ru/post/520294/) и ["SQL HowTo: курсорный пейджинг с неподходящей сортировкой"](/ru/post/517920/) я уже рассматривал проблемы навигации по данным, представленных в виде **плоского реестра**.
Но что если мы хотим выводить данные не простым "бесконечным списком", а **в виде иерархической структуры** с быстрой навигацией по узлам - например, обширный каталог товаров или меню ресторана, как это делает [Presto - наш продукт для автоматизации заведений питания](https://sbis.ru/presto)?
Иерархичное меню ресторанаФормируем датасет
-----------------
Для начала сгенерируем наш тестовый иерархичный каталог на **100K позиций**:
```
CREATE TABLE hier(
id -- PK
integer
PRIMARY KEY
, pid -- ссылка на "предка"
integer
REFERENCES hier
ON DELETE CASCADE
, ord -- пользовательский порядковый номер внутри раздела
integer
);
INSERT INTO hier
SELECT
id
, nullif((random() * id)::integer, 0) pid
, (random() * 1e5)::integer ord
FROM
generate_series(1, 1e5) id; -- 100K записей
```
Из размера уже становится понятно, что решения вроде "*Давайте все сразу развернем в нужном порядке* [*как описано тут*](/ru/post/523812/)*, а потом спозиционируемся через* `OFFSET`" адекватно работать не будут.
Теперь договоримся, что порядок вывода записей внутри одного раздела, определяемый полем `ord`, будет уникальным. Для этого нам надо вычистить все дубли пар `(pid, ord)`, как мы делали это в статье ["DBA: вычищаем клон-записи из таблицы без PK"](/ru/post/481352/):
```
DELETE FROM
hier
WHERE
ctid = ANY(ARRAY(
SELECT
unnest((array_agg(ctid))[2:]) ctids
FROM
hier
GROUP BY
pid, ord
HAVING
count(*) > 1
));
-- теперь никто не мешает индексу по разделу быть уникальным
CREATE UNIQUE INDEX ON hier(pid, ord);
```
Алгоритм обхода
---------------
Давайте формализуем описание алгоритма, как он должен набрать `N` записей для следующей "страницы", начиная с конкретного ключа - пары `(pid, ord)`. Он будет состоять всего из 3 разных вариантов, которые надо проверить последовательно.
1. Взять первого по порядку потомка на уровень ниже:
Спуск на уровень
2. Если такого нет, взять "соседа" на текущем уровне:
На одном уровне
3. Если такого нет, взять "соседа" у ближайшего предка, у которого он есть:
Подъем на уровень
Если же ни у одного предка не оказалось "соседа" - все, мы обошли все дерево.
Собираем SQL
------------
1. наш алгоритм итеративно переходит от одной записи к другой - то есть для SQL это будет рекурсивным запросом;
2. паттерн *"если такого нет, возьми следующий вариант"* легко реализуется с помощью кейса `UNION ALL + LIMIT 1` (см. [статью](/ru/post/667998/#union));
3. "ближайшего предка с соседом" придется искать тоже рекурсивно;
4. для ограничения количества набираемых `N` записей разумнее всего использовать обычный счетчик.
Звучит не слишком страшно, но надо учесть, что п.3 разделится еще на два - когда узел находится где-то в глубине дерева, и когда он находится в корне (`pid IS NULL`):
```
WITH RECURSIVE T AS(
SELECT
h -- тут будет лежать сразу цельная запись, чтобы не перечитывать ее повторно
, 0 i -- счетчик найденных записей
FROM
hier h
WHERE
id = 10000 -- последняя прочитанная на предыдущей итерации запись
UNION ALL
SELECT
X._h
, i + 1
FROM
T
, LATERAL (
-- первый потомок
(
SELECT
_h
FROM
hier _h
WHERE
pid = (T.h).id
ORDER BY
ord
LIMIT 1
)
UNION ALL
-- ближайший "сосед"
(
SELECT
_h
FROM
hier _h
WHERE
pid = (T.h).pid AND
ord > (T.h).ord
ORDER BY
ord
LIMIT 1
)
UNION ALL
-- ближайший "сосед" ближайшего предка
(
WITH RECURSIVE _T AS(
SELECT
T.h p -- берем текущую запись в качестве "предка"
, NULL::hier _h -- "соседа" у нее заведомо нет
UNION ALL
SELECT
__h
, (
-- сработает только один из блоков с противоположными условиями
(
SELECT
__h
FROM
hier __h
WHERE
(_T.p).pid IS NOT NULL AND -- мы еще не в корне
pid = (_T.p).pid AND
ord > (_T.p).ord
ORDER BY
pid, ord -- подгоняем под индекс
LIMIT 1
)
UNION ALL
(
SELECT
__h
FROM
hier __h
WHERE
(_T.p).pid IS NULL AND -- уже в корне
pid IS NULL AND
ord > (_T.p).ord
ORDER BY
pid, ord -- подгоняем под индекс
LIMIT 1
)
LIMIT 1
)
FROM
_T
INNER JOIN
hier __h
ON __h.id = (_T.p).pid -- рекурсивный обход "вверх" по иерархии
)
SELECT
_h
FROM
_T
WHERE
_h IS DISTINCT FROM NULL
LIMIT 1
)
LIMIT 1
) X
WHERE
X._h IS DISTINCT FROM NULL AND
i < 20 -- количество записей на странице
)
SELECT
(h).* -- разворачиваем поля записи
FROM
T
WHERE
i > 0; -- убираем "стартовую" запись
```
Проверим [план запроса](https://explain.tensor.ru/archive/explain/46b4b410ed3fe8e827da01911246cae0:0:2022-06-28) на *explain.tensor.ru*:
Отличный дважды рекурсивный планВсе выполнение для поиска 20 записей заняло **меньше полмиллисекунды**! При этом никаких `Seq Scan` или `Sort`, все исключительно по индексам (всего 58 обращений):
Сводная статистика планаА разве попроще нельзя?..
-------------------------
Конечно, можно! Достаточно заметить, что случаи `#2` и `#3` логически одинаковы - нужно взять ближайшего "соседа" по всей цепочке предков, но начиная с самой же записи. Поэтому второй блок из `UNION ALL` можно просто убрать - и результат останется ровно тем же самым!
Но вот план - [немного ухудшится](https://explain.tensor.ru/archive/explain/3abb2b9a7c27226176645d68b9c91bd5:0:2022-06-29), и вместо 150 страниц данных для тех же записей придется читать уже 163, поскольку рекурсивный поиск первого предка теперь будет производиться для каждой записи - даже для той, у которой есть "сосед". | https://habr.com/ru/post/673856/ | null | ru | null |
# Spring AOP и JavaConfig в плагинах для Atlassian Jira
 В этой статье разработаем плагин для Atlassian Jira, где с помощью JavaConfig определим бин с областью видимости прототип, залогируем вызовы методов бина, используя AOP, и выведем информацию из внешних бинов (ApplicationProperties, JiraAuthenticationContext и ConstantsManager).
Исходный код плагина можно взять вот [здесь](https://bitbucket.org/alex1mmm/spring-tutorial).
#### 1. Создадим плагин.
Для этого нужно открыть терминал и ввести:
```
atlas-create-jira-plugin
```
На заданные в терминале вопросы нужно ответить вот так:
```
Define value for groupId: : ru.matveev.alexey.plugins.spring
Define value for artifactId: : spring-tutorial
Define value for version: 1.0.0-SNAPSHOT: :
Define value for package: ru.matveev.alexey.plugins.spring: :
groupId: ru.matveev.alexey.plugins.spring
artifactId: spring-tutorial
version: 1.0.0-SNAPSHOT
package: ru.matveev.alexey.plugins.spring
Y: : Y
```
#### 2. Внесем изменения в pom.xml
Необходимо изменить область видимости atlassian-spring-scanner-annotation с compile на provided.
```
com.atlassian.plugin
atlassian-spring-scanner-annotation
${atlassian.spring.scanner.version}
compile
```
Удалить зависимость atlassian-spring-scanner-runtime.
Изменить свойство atlassian.spring.scanner.version на 2.0.0
Добавить следующие зависимости:
```
org.springframework
spring-core
4.2.5.RELEASE
provided
org.springframework
spring-context
4.2.5.RELEASE
provided
```
Добавить в maven-jira-plugin в тэг instructions следующую строчку:
```
\*
```
Данная строчка позволит плагину находить классы Spring во время исполнения.
#### 3. Создадим интерфейс и имплементацию сущности HelloWorld.
*HelloWorld.java*
```
package ru.matveev.alexey.plugins.spring.api;
public interface HelloWorld {
String getMessage();
void setMessage(String value);
}
```
*HelloWorldImpl.java*
```
package ru.matveev.alexey.plugins.spring.impl;
import com.atlassian.jira.config.ConstantsManager;
import com.atlassian.jira.security.JiraAuthenticationContext;
import com.atlassian.sal.api.ApplicationProperties;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import ru.matveev.alexey.plugins.spring.api.HelloWorld;
public class HelloWorldImpl implements HelloWorld {
private static final Logger LOG = LoggerFactory.getLogger(HelloWorldImpl.class);
private String message = "Hello World!!!";
private final ApplicationProperties applicationProperties;
private final ConstantsManager constantsManager;
private final JiraAuthenticationContext jiraAuthenticationContext;
public HelloWorldImpl(ApplicationProperties applicationProperties, JiraAuthenticationContext jiraAuthenticationContext, ConstantsManager constantsManager) {
this.applicationProperties = applicationProperties;
this.constantsManager = constantsManager;
this.jiraAuthenticationContext = jiraAuthenticationContext;
}
public String getMessage() {
LOG.debug("getMessage executed");
return applicationProperties.getDisplayName() + " logged user: " + jiraAuthenticationContext.getLoggedInUser().getName() + " default priority: " + constantsManager.getDefaultPriority().getName() + " " + this.message;
}
public void setMessage(String value) {
LOG.debug("setMessage executed");
message = value;
}
}
```
Класс принимает три внешних бина и выводит в методе getMessage данные из этих бинов.
#### 4. Создадим класс для импотра экспортируемых Jira бинов.
*JiraBeansImporter.java*
```
import com.atlassian.jira.config.ConstantsManager;
package ru.matveev.alexey.plugins.spring.impl;
import com.atlassian.jira.security.JiraAuthenticationContext;
import com.atlassian.plugin.spring.scanner.annotation.imports.ComponentImport;
import com.atlassian.sal.api.ApplicationProperties;
import javax.inject.Inject;
import javax.inject.Named;
@Named
public class JiraBeansImporter {
@Inject
public JiraBeansImporter(@ComponentImport ApplicationProperties applicationProperties,
@ComponentImport JiraAuthenticationContext jiraAuthenticationContext,
@ComponentImport ConstantsManager constantsManager
) {
}
}
```
Данный класс нужен лишь для того, чтобы JavaConfig увидел требуемые нам внешние бины.
#### 5. Создадим классы для логирования данных о вызываемых методах объектов.
*HijackBeforeMethod.java*
Данный класс логирует информацию перед вызовом метода объекта.
```
package ru.matveev.alexey.plugins.spring.aop;
import java.lang.reflect.Method;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.aop.MethodBeforeAdvice;
public class HijackBeforeMethod implements MethodBeforeAdvice
{
private static final Logger LOG = LoggerFactory.getLogger(HijackBeforeMethod.class);
public void before(Method method, Object[] objects, Object o) throws Throwable {
LOG.debug("HijackBeforeMethod : method {} in", method.toString());
}
}
```
*HijackAroundMethod.java*
Данный класс логирует информацию перед вызовом и после вызова метода объекта.
```
package ru.matveev.alexey.plugins.spring.aop;
import org.aopalliance.intercept.MethodInterceptor;
import org.aopalliance.intercept.MethodInvocation;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.util.Arrays;
public class HijackAroundMethod implements MethodInterceptor {
private static final Logger LOG = LoggerFactory.getLogger(HijackAroundMethod.class);
public Object invoke(MethodInvocation methodInvocation) throws Throwable {
LOG.debug("HijackAroundMethod : Method name : "
+ methodInvocation.getMethod().getName());
LOG.debug("HijackAroundMethod : Method arguments : "
+ Arrays.toString(methodInvocation.getArguments()));
LOG.debug("HijackAroundMethod : Before method hijacked!");
try {
Object result = methodInvocation.proceed();
LOG.debug("HijackAroundMethod : Before after hijacked!");
return result;
} catch (IllegalArgumentException e) {
LOG.debug("HijackAroundMethod : Throw exception hijacked!");
throw e;
}
}
}
```
#### 6. Создадим JavaConfig
```
package ru.matveev.alexey.plugins.spring.config;
import com.atlassian.jira.config.ConstantsManager;
import com.atlassian.jira.security.JiraAuthenticationContext;
import org.springframework.context.annotation.Scope;
import org.springframework.stereotype.Component;
import ru.matveev.alexey.plugins.spring.aop.HijackAroundMethod;
import ru.matveev.alexey.plugins.spring.aop.HijackBeforeMethod;
import com.atlassian.sal.api.ApplicationProperties;
import org.springframework.aop.framework.ProxyFactoryBean;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import ru.matveev.alexey.plugins.spring.api.HelloWorld;
import ru.matveev.alexey.plugins.spring.impl.HelloWorldImpl;
@Component
@Configuration
public class Config{
@Bean(name = "helloWorld")
@Scope("prototype")
public HelloWorld helloWorld(ApplicationProperties applicationProperties,
JiraAuthenticationContext jiraAuthenticationContext,
ConstantsManager constantsManager) {
return new HelloWorldImpl(applicationProperties, jiraAuthenticationContext, constantsManager);
}
@Bean(name="hijackBeforeMethodBean")
public HijackBeforeMethod hijackBeforeMethod() {
return new HijackBeforeMethod();
}
@Bean(name="hijackAroundMethodBean")
public HijackAroundMethod hijackAroudnMethod() {
return new HijackAroundMethod();
}
@Bean (name = "helloWorldBeforeProxy")
@Scope("prototype")
public ProxyFactoryBean proxyBeforeFactoryBean(ApplicationProperties applicationProperties,
JiraAuthenticationContext jiraAuthenticationContext,
ConstantsManager constantsManager) {
ProxyFactoryBean proxyFactoryBean = new ProxyFactoryBean();
proxyFactoryBean.setTarget(helloWorld(applicationProperties,jiraAuthenticationContext,constantsManager));
proxyFactoryBean.setProxyTargetClass(true);
proxyFactoryBean.setInterceptorNames("hijackBeforeMethodBean");
return proxyFactoryBean;
}
@Bean (name = "helloWorldAroundProxy")
@Scope("prototype")
public ProxyFactoryBean proxyAroundFactoryBean(ApplicationProperties applicationProperties,
JiraAuthenticationContext jiraAuthenticationContext,
ConstantsManager constantsManager) {
ProxyFactoryBean proxyFactoryBean = new ProxyFactoryBean();
proxyFactoryBean.setTarget(helloWorld(applicationProperties,jiraAuthenticationContext,constantsManager));
proxyFactoryBean.setProxyTargetClass(true);
proxyFactoryBean.setInterceptorNames("hijackAroundMethodBean");
return proxyFactoryBean;
}
}
```
В JavaConfig мы создаем:
* бин helloWorld с областью видимости прототип, что означает, что инстанс бина будет создаваться каждый раз при обращении к нему.
* бины hijackBeforeMethodBean и hijackAroundMethodBean, которые логируют информацию перед и после вызовов методов объектов.
* бины helloWorldBeforeProxy и helloWorldAroundProxy, которые проксируют бин helloWorld и при обращении к методам бина helloWorld логируют информацию с помощью бинов hijackBeforeMethodBean и hijackAroundMethodBean
#### 7. Создадим два сервелета.
Сервлеты будем использовать для тестирования нашего приложения.
Открываем терминал и выполняем:
```
atlas-create-jira-plugin-module
```
Когда будет задан вопрос о типе создаваемого модуля, то выбираем 21 (Сервлет):
```
Choose a number (1/2/3/4/5/6/7/8/9/10/11/12/13/14/15/16/17/18/19/20/21/22/23/24/25/26/27/28/29/30/31/32/33/34): 21
```
Далее на вопросы отвечаем следующим образом:
```
Enter New Classname MyServlet: : MyServlet1
Enter Package Name ru.matveev.alexey.plugins.spring.servlet: :
Show Advanced Setup? (Y/y/N/n) N: : N
Add Another Plugin Module? (Y/y/N/n) N: : Y
Choose a number (1/2/3/4/5/6/7/8/9/10/11/12/13/14/15/16/17/18/19/20/21/22/23/24/25/26/27/28/29/30/31/32/33/34): 21
Enter New Classname MyServlet: : MyServlet2
Enter Package Name ru.matveev.alexey.plugins.spring.servlet: :
Show Advanced Setup? (Y/y/N/n) N: : N
Add Another Plugin Module? (Y/y/N/n) N: : N
```
В результате у нас сформируются файлы MyServlet1.java и MyServlet2.java. Меняем код в этих файлах:
*MyServlet1.java*
Мы передаем в сервлет наш прокси бин helloWorldBeforeProxy. То есть при обращении к HelloWorld будет логироваться информация перед вызовом методов HelloWorld.
```
package ru.matveev.alexey.plugins.spring.servlet;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Qualifier;
import ru.matveev.alexey.plugins.spring.api.HelloWorld;
import javax.inject.Inject;
import javax.servlet.*;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
public class MyServlet1 extends HttpServlet{
private static final Logger log = LoggerFactory.getLogger(MyServlet1.class);
private final HelloWorld helloWorld;
@Inject
public MyServlet1(@Qualifier("helloWorldBeforeProxy") HelloWorld helloWorld) {
this.helloWorld = helloWorld;
}
@Override
protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException
{
log.debug("MyServlet1 called");
resp.setContentType("text/html");
String message = "" + helloWorld.getMessage() + "";
helloWorld.setMessage("message changed MyServlet");
resp.getWriter().write(message);
}
}
```
*MyServlet2.java*
Мы передаем в сервлет наш прокси бин helloWorldAroundProxy. То есть при обращении к HelloWorld будет логироваться информация перед и после вызова методов HelloWorld.
```
package ru.matveev.alexey.plugins.spring.servlet;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Qualifier;
import ru.matveev.alexey.plugins.spring.api.HelloWorld;
import javax.inject.Inject;
import javax.servlet.*;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
public class MyServlet2 extends HttpServlet{
private static final Logger log = LoggerFactory.getLogger(MyServlet2.class);
private final HelloWorld helloWorld;
@Inject
public MyServlet2(@Qualifier("helloWorldAroundProxy") HelloWorld helloWorld) {
this.helloWorld = helloWorld;
}
@Override
protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException
{
log.debug("MyServlet2 called");
resp.setContentType("text/html");
String message = "" + helloWorld.getMessage() + "";
helloWorld.setMessage("message changed MyServlet");
resp.getWriter().write(message);
}
}
```
#### 8. Проверим результат.
Мы должны проверить следующее:
1. Наш плагин запускается.
2. Выдается информации из имортируемых нами внешних бинов (ApplicationProperties, JiraAuthenticationContext, ConstantsManager)
3. helloWorld рабоает в области видимости прототип.
4. Логируется информация о вызовах методов helloWorld.
Откроем терминал и введем:
```
atlas-run
```
После того, как Jira запустилась, откроем Jira в браузере по адресу [localhost](http://localhost):2990/jira/ и залогинимся в Jira.
Установим уровень логирования пакета ru.matveev.alexey в DEBUG. Для этого нужно зайти в System-> Logging and Profiling:
Переходим по адресу [localhost](http://localhost):2990/jira/plugins/servlet/myservlet1 для вызыва MyServlet1.java.
Из скриншота мы видим, что наш плагин работает, и информация из внешних бинов передается. Мы успешно проверили первые два пункта.
Для проверки того, что helloWorld имеет область видимости прототип, мы обновим страницу в браузере:
Мы видим, что сообщение «Hello World!!!» заменилось на «message changed MyServlet». Так как у нас у helloWorld область видимости прототип, то при обращении к MyServlet2.java мы должны получить значение «Hello World!!!» (если ли бы область видимости была синглетон, то мы получили бы сообщение «message changed MyServlet»).
Обращаемся к MyServlet2.java по адресу [localhost](http://localhost):2990/jira/plugins/servlet/myservlet2:
Мы видим, что в надписи появилось сообщение «Hello World!!!», а значит действительно область видимости helloWorld прототип.
Дальше проверим была ли залогирована информация при обращении к методам helloWorld. В логах мы находим:
```
[INFO] [talledLocalContainer] 2018-04-01 17:06:52,609 http-nio-2990-exec-4 DEBUG admin 1026x406x1 1fz8ddf 127.0.0.1 /plugins/servlet/myservlet1 [r.m.a.p.spring.servlet.MyServlet1] MyServlet1 called
[INFO] [talledLocalContainer] 2018-04-01 17:06:52,610 http-nio-2990-exec-4 DEBUG admin 1026x406x1 1fz8ddf 127.0.0.1 /plugins/servlet/myservlet1 [r.m.a.p.spring.aop.HijackBeforeMethod] HijackBeforeMethod : method public java.lang.String ru.matveev.alexey.plugins.spring.impl.HelloWorldImpl.getMessage() in
[INFO] [talledLocalContainer] 2018-04-01 17:06:52,610 http-nio-2990-exec-4 DEBUG admin 1026x406x1 1fz8ddf 127.0.0.1 /plugins/servlet/myservlet1 [r.m.a.p.spring.impl.HelloWorldImpl] getMessage executed
[INFO] [talledLocalContainer] 2018-04-01 17:06:52,611 http-nio-2990-exec-4 DEBUG admin 1026x406x1 1fz8ddf 127.0.0.1 /plugins/servlet/myservlet1 [r.m.a.p.spring.aop.HijackBeforeMethod] HijackBeforeMethod : method public void ru.matveev.alexey.plugins.spring.impl.HelloWorldImpl.setMessage(java.lang.String) in
[INFO] [talledLocalContainer] 2018-04-01 17:06:52,611 http-nio-2990-exec-4 DEBUG admin 1026x406x1 1fz8ddf 127.0.0.1 /plugins/servlet/myservlet1 [r.m.a.p.spring.impl.HelloWorldImpl] setMessage executed
[INFO] [talledLocalContainer] 2018-04-01 17:06:55,024 http-nio-2990-exec-3 DEBUG admin 1026x407x1 1fz8ddf 127.0.0.1 /plugins/servlet/myservlet2 [r.m.a.p.spring.servlet.MyServlet2] MyServlet2 called
[INFO] [talledLocalContainer] 2018-04-01 17:06:55,025 http-nio-2990-exec-3 DEBUG admin 1026x407x1 1fz8ddf 127.0.0.1 /plugins/servlet/myservlet2 [r.m.a.p.spring.aop.HijackAroundMethod] HijackAroundMethod : Method name : getMessage
[INFO] [talledLocalContainer] 2018-04-01 17:06:55,026 http-nio-2990-exec-3 DEBUG admin 1026x407x1 1fz8ddf 127.0.0.1 /plugins/servlet/myservlet2 [r.m.a.p.spring.aop.HijackAroundMethod] HijackAroundMethod : Method arguments : []
[INFO] [talledLocalContainer] 2018-04-01 17:06:55,026 http-nio-2990-exec-3 DEBUG admin 1026x407x1 1fz8ddf 127.0.0.1 /plugins/servlet/myservlet2 [r.m.a.p.spring.aop.HijackAroundMethod] HijackAroundMethod : Before method hijacked!
[INFO] [talledLocalContainer] 2018-04-01 17:06:55,026 http-nio-2990-exec-3 DEBUG admin 1026x407x1 1fz8ddf 127.0.0.1 /plugins/servlet/myservlet2 [r.m.a.p.spring.impl.HelloWorldImpl] getMessage executed
[INFO] [talledLocalContainer] 2018-04-01 17:06:55,026 http-nio-2990-exec-3 DEBUG admin 1026x407x1 1fz8ddf 127.0.0.1 /plugins/servlet/myservlet2 [r.m.a.p.spring.aop.HijackAroundMethod] HijackAroundMethod : Before after hijacked!
[INFO] [talledLocalContainer] 2018-04-01 17:06:55,026 http-nio-2990-exec-3 DEBUG admin 1026x407x1 1fz8ddf 127.0.0.1 /plugins/servlet/myservlet2 [r.m.a.p.spring.aop.HijackAroundMethod] HijackAroundMethod : Method name : setMessage
[INFO] [talledLocalContainer] 2018-04-01 17:06:55,026 http-nio-2990-exec-3 DEBUG admin 1026x407x1 1fz8ddf 127.0.0.1 /plugins/servlet/myservlet2 [r.m.a.p.spring.aop.HijackAroundMethod] HijackAroundMethod : Method arguments : [message changed MyServlet]
[INFO] [talledLocalContainer] 2018-04-01 17:06:55,026 http-nio-2990-exec-3 DEBUG admin 1026x407x1 1fz8ddf 127.0.0.1 /plugins/servlet/myservlet2 [r.m.a.p.spring.aop.HijackAroundMethod] HijackAroundMethod : Before method hijacked!
[INFO] [talledLocalContainer] 2018-04-01 17:06:55,026 http-nio-2990-exec-3 DEBUG admin 1026x407x1 1fz8ddf 127.0.0.1 /plugins/servlet/myservlet2 [r.m.a.p.spring.impl.HelloWorldImpl] setMessage executed
[INFO] [talledLocalContainer] 2018-04-01 17:06:55,026 http-nio-2990-exec-3 DEBUG admin 1026x407x1 1fz8ddf 127.0.0.1 /plugins/servlet/myservlet2 [r.m.a.p.spring.aop.HijackAroundMethod] HijackAroundMethod : Before after hijacked!
```
Из логов мы видим, что логирование информации о вызываемых методах произошло.
Таким образом мы успешно справились с поставленными целями. | https://habr.com/ru/post/352558/ | null | ru | null |
# Android. Выпадающий список (Spinner) с индикатором загрузки
Приветствую тебя, читатель!
Представляю твоему вниманию небольшой очерк о том, как захотелось мне видеть прогресс-бар («infinite circle») во время загрузки данных в выпадающий список, который в Андроиде называется Spinner.
Необходимость такая возникла при разработке небольшой утилиты по работе с веб-сервисом. Параметры некоего расчёта хранятся на централизованном сервере. Веб-сервис .NET отдаёт списки возможных параметров в виде массивов разной длины (от 2 до 50 элементов). Для отображения этих параметров и был выбран выпадающий список. Инициализация списков, как и положено, происходит асинхронно. И в то время, пока данные загружаются, смотреть на пустые статичные элементы безо всякого прогресса скучно, уныло и вообще.
Собственно цель
---------------
Стандартный Spinner выглядит так:
После небольшой доработки получается нечто такое (CustomSpinner):
«В чём же соль!?» — спросите вы? А соль в промежуточном состоянии (загрузка данных):
в светлой теме:
Для получения такого эффекта я вижу 2 пути:
1 Унаследоваться от Spinner; переопределить onDraw() и, возможно, какие-то другие методы; реализовать обработку состояний (загружается/загружен)
2 Унаследоваться от Layout; расположить на нём Spinner и ProgressBar; организовать работу контрола в соответствии со своими требованиями.
Первый путь, наверное, более правильный. Но каждый раз ступая на него я упирался в Exception'ы и вылеты приложения. Хотя с Android знаком достаточно давно, честно признаюсь — до сих пор не могу понять что именно нужно делаеть в методе onDraw(). Коврыться в исходниках очень не хочется, хотя иногда полезно. В-общем этот путь закончился, так тольком и не начавшись.
Второй путь подробнее описан в сети. По нему я прошёл быстро и непринуждённо. И был он таков…
XML-layout
----------
Для начала нам нужно «набросать» наш новый контрол (custom\_spinner.xml). В этом нет ничего сложного — корневой лэйаут и два дочерных элемента (спиннер и прогресс-бар). Для этого хорошо подойдёт RelativeLayout. У меня он получился вот таким:
```
xml version="1.0" encoding="utf-8"?
```
Класс CustomSpinner
-------------------
Для работы с контролом нужно реализовать класс CustomSpinner. Создаём класс, унаследованный от RelativeLayout:
```
public class CustomSpinner extends RelativeLayout {
Context context;
Spinner spinner;
ProgressBar progress;
public CustomSpinner(Context c, AttributeSet attrs) {
super(c, attrs);
this.context = c;
//Отрисовываем внещний вид из нашего ранее определённого ресурса custom_spinner.xml
LayoutInflater.from(context).inflate(R.layout.custom_spinner, this,
true);
initViews();
}
//Инициализируем дочерние контролы для дальнейшей работы с ними
private void initViews() {
spinner = (Spinner) findViewById(R.id.spinner);
progress = (ProgressBar) findViewById(R.id.progress);
}
}
```
Управление состоянием
---------------------
Для достижения первоначальной цели (показ прогресс-бара при загрузке данных) модифицируем класс CustomSpinner:
```
public class CustomSpinner extends RelativeLayout {
Context context;
Spinner spinner;
ProgressBar progress;
ArrayAdapter emptyAdapter;
public CustomSpinner(Context c, AttributeSet attrs) {
super(c, attrs);
this.context = c;
LayoutInflater.from(context).inflate(R.layout.custom\_spinner, this,
true);
String[] strings = new String[] {};
List items = new ArrayList(Arrays.asList(strings));
emptyAdapter = new ArrayAdapter(c,
android.R.layout.simple\_spinner\_item, items);
initViews();
}
private void initViews() {
spinner = (Spinner) findViewById(R.id.spinner);
progress = (ProgressBar) findViewById(R.id.progress);
}
public void loading(boolean flag) {
if (flag)
spinner.setAdapter(emptyAdapter);
progress.setVisibility(flag ? View.VISIBLE : View.GONE);
}
}
```
В случае когда контрол находится в процессе загрузки нужно скрыть возможные имеющиеся в нём значения списка — `spinner.setAdapter(emptyAdapter);`. И, собственно, показать прогресс-бар.
Теперь при асинхронной загрузке, для которой я иcпользую AsyncTask, мы можем управлять поведением контрола:
```
CustomSpinner spinner;
...
@Override
protected void onPreExecute() {
spinner.loading(true);
}
...
@Override
protected SpinnerAdapter doInBackground(Map... params) {
//Здесь данные, полученные от веб-сервиса укладываются в SpinnerAdapter, которы впоследствии назначется нашему CustomSpinner
return null;
}
...
@Override
protected void onPostExecute(SpinnerAdapter result) {
spinner.loading(false);
if (result != null)
spinner.setAdapter(result);
}
```
«Костыли»
---------
Ну конечно, а куда ж без них!
Вспомним, что значально мы хотели именно Spinner. Поэтому поведение контрола должно быть соответствующим. При выбранной реализации нужно реализовать несколько затычек:
```
public class CustomSpinner extends RelativeLayout {
...
//Обработчик события выбора значения выпадающего списка
public void setOnItemSelectedListener(OnItemSelectedListener l) {
spinner.setTag(getId());
spinner.setOnItemSelectedListener(l);
}
//Назначаем адаптер выпадающему списку
public void setAdapter(SpinnerAdapter adapter) {
spinner.setAdapter(adapter);
}
// Возвращаем индекс выбранного в списке элемента
public int getSelectedItemPosition() {
return this.spinner.getSelectedItemPosition();
}
//Получение адаптера выпадающего списка
public SpinnerAdapter getAdapter() {
return this.spinner.getAdapter();
}
}
```
Методы `getAdapter(), setAdapter(), getSelectedItemPosition()` просто «пробрасывают» действия на внутренний Spinner.
Внимание следует уделить методу `setOnItemSelectedListener(OnItemSelectedListener l)`. Я использую один обработчик (listener) для всех контролов (думаю так правильней) в котором с помощью `switch(*some_unique_value*)...case(R.id.model)` определяю, что делать далее. Так как у выпадающего списка внутри нашего контрола нет уникального глобального идентификатора (он для всех R.id.spinner), то в тэг выпадающего списка записываем идентификатор родительского контрола (`spinner.setTag(getId());`). Теперь при вызове обработчика смены значения в выпадающем списке сможем идентифицировать, какой именно список изменился:
Оработчик выпадающего списка:
```
class SpinnerItemSelectedListener implements OnItemSelectedListener {
@Override
public void onItemSelected(AdapterView paramAdapterView,
View paramView, int paramInt, long paramLong) {
int id = ((SimpleParameter) paramAdapterView.getAdapter().getItem(
paramInt)).getId();
switch ((Integer) paramAdapterView.getTag()) {
case R.id.city:
initCityDependant(id);
break;
case ...:
otherMethod();
break;
default:
break;
}
}
@Override
public void onNothingSelected(AdapterView paramAdapterView) {
}
}
```
Если бы наш кастомный контрол был унаследован непосредственно от Spinner, то этих костылей могло бы и не быть. Но увы.
CustomSpinner на форме
----------------------
Осталось вставить наш новый элемент в интерфейс (лэйаут) приложения:
```
```
Таких контролов у меня на форме 25 штук. Когда-то вроде читал, что можно указывать нэймспейс своего приложения в заголовке лэйаута и тогда вроде не будет необходимости прописывать полное имя класса `org.solo12zw74.app.CustomSpinner`. Но сейчас почему-то не получилось.
Послесловие
-----------
Спасибо за внимание. Буду очень рад, если кто-нибудь даст ссылки на толковые статьи реализации такого контрола первым способом (унаследовать от Spinner). Или объяснит, как в методе onDraw() нарисовть прогресс-бар, а потом скрывать его при необходимости. | https://habr.com/ru/post/151285/ | null | ru | null |
# RegExp Unicode Property Escapes в JavaScript: штрихи к портрету
[RegExp Unicode Property Escapes](https://github.com/tc39/proposal-regexp-unicode-property-escapes) перешли на 4-ю ступень и [будут включены в ES2018](https://github.com/tc39/proposals/blob/master/finished-proposals.md).
В V8 они доступны [без флага начиная с v6.4](https://bugs.chromium.org/p/v8/issues/detail?id=4743&desc=2), поэтому готовы к использованию во всех текущих каналах Google Chrome от стабильного до Canary.
В Node.js они будут доступны без флага уже в v10 (выходит в апреле). В других версиях требуется флаг `--harmony_regexp_property` (Node.js v6–v9) или `--harmony` (Node.js v8–v9). Сейчас без флага их можно испробовать или [в ночных сборках](https://nodejs.org/download/nightly/), или [в ветке v8-canary](https://nodejs.org/download/v8-canary/).
При этом нужно иметь в виду, что сборки Node.js, скомпилированные без поддержки ICU, будут лишены возможности использовать этот класс регулярных выражений (подробнее см. [Internationalization Support](https://github.com/nodejs/node/blob/master/doc/api/intl.md)). Например, это касается популярной сборки под Android от сообщества [Termux](https://termux.com/).
Подробнее о поддержке в других движках и средах см. [в известной таблице](http://kangax.github.io/compat-table/es2016plus/#test-RegExp_Unicode_Property_Escapes) (после перехода проскрольте чуть выше).
Я не буду повторять описания этой долгожданной возможности, лишь сошлюсь на несколько статей известных специалистов:
* Mathias Bynens. [Unicode property escapes in JavaScript regular expressions](https://mathiasbynens.be/notes/es-unicode-property-escapes) (от самого автора предложения).
* Mathias Bynens. ECMAScript regular expressions are getting better! [#Unicode property escapes](https://mathiasbynens.be/notes/es-regexp-proposals#unicode-property-escapes)
* Dr. Axel Rauschmayer. Exploring ES2018 and ES2019. [#RegExp Unicode property escapes](http://exploringjs.com/es2018-es2019/ch_regexp-unicode-property-escapes.html)
* Nicolás Bevacqua. Regular Expressions in a post-ES6 world. [#Unicode Property Escapes](https://ponyfoo.com/articles/regular-expressions-post-es6#unicode-property-escapes)
* К сожалению, [страница RegExp на MDN](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/RegExp) пока лишена всякого упоминания о нововведении, но это, наверняка, скоро будет исправлено.
Мне же захотелось рассказать о паре не совсем очевидных мелочей.
Когда я начинал знакомство с этой новой возможностью, то пожалел о двух недостающих удобствах: способе программно получить список всех допустимых вариантов в этом самом обширном теперь классе регулярных выражений и способе получить список подходящих свойств для конкретного символа Юникода.
Если кто-то почувствует такую же нужду, пусть эти заметки сэкономят ему время :)
### Список всех доступных свойств для регулярного выражения
На данный момент, авторитетным и исчерпывающим источником, перечисляющим все возможные свойства, служит сама текущая спецификация ECMAScript, в частности таблицы (осторожно, по ссылкам тяжеловесная страница) в разделах [Runtime Semantics: UnicodeMatchProperty ( p )](https://tc39.github.io/ecma262/#sec-runtime-semantics-unicodematchproperty-p) и [Runtime Semantics: UnicodeMatchPropertyValue ( p, v )](https://tc39.github.io/ecma262/#sec-runtime-semantics-unicodematchpropertyvalue-p-v).
Если кому-то неудобно загружать всю спецификацию, можно ограничиться [спецификацией предложения](https://tc39.github.io/proposal-regexp-unicode-property-escapes/) с теми же таблицами. И совсем облегчённый вариант: эти таблицы существуют в виде четырёх отдельных файлов [в корне репозитория спецификации ECMAScript](https://github.com/tc39/ecma262). Собственно, только они и существуют в виде отдельных файлов, импортируемых в спецификацию, — уже одно это, наверное, может свидетельствовать об их беспрецедентном объёме. Таблицы можно с относительным удобством просмотреть при помощи родного [подсервиса](http://htmlpreview.github.io/).
Я же извлёк эти данные и набросал [крохотную библиотечку](https://gist.github.com/vsemozhetbyt/893044264a088b96025b2d51ed17aec3), содержащую структурированный список всех возможных имён и значений и экспортирующую этот объект в виде уплощённого массива всех возможных членов из данного класса регулярных выражений.
Все подразделы представлены в алфавитном порядке за исключением общих свойств (тут удобнее и привычнее порядок [документа из базы Юникода](http://unicode.org/reports/tr44/#GC_Values_Table)). Список не содержит синонимов, а сокращения используются только для общих свойств, что существенно экономит место в последующих операциях с библиотекой.
При помощи нехитрого скрипта и упомянутой библиотеки можно получить список в формате JSON, содержащий источники для регулярных выражений. Пример такого скрипта и его вывода можно посмотреть [там же в комментарии](https://gist.github.com/vsemozhetbyt/893044264a088b96025b2d51ed17aec3#gistcomment-2369719) — всего 372 варианта в текущей версии спецификации.
### Получение свойств символов
Описанная библиотека позволяет нам использовать этот класс регулярок с не совсем обычной целью: не искать символы на основании свойств, а получать свойства на основании имеющегося символа. С ходу можно придумать несколько применений.
Должен оговориться, что ради иллюстративной простоты я не добавлял в скрипты обработку ошибок, так что об этом стоит позаботиться отдельно.
#### 1. Характеристика отдельного символа.
Небольшая утилита получает в качестве параметра командной строки единичный символ или его шестнадцатеричный номер в базе Юникода (code point) и выдаёт список свойств, которые в будущем можно использовать при поиске данного символа или общего ему класса символов.
**re-unicode-properties.character-info.js**
```
'use strict';
const reUnicodeProperties = require('./re-unicode-properties.js');
const RADIX = 16;
const PAD_MAX = 4;
const [, , arg] = process.argv;
let character;
let codePoint;
if ([...arg].length === 1) {
character = arg;
codePoint = `U+${character.codePointAt(0).toString(RADIX).padStart(PAD_MAX, '0')}`;
} else {
character = String.fromCodePoint(Number.parseInt(arg, RADIX));
codePoint = `U+${arg.padStart(PAD_MAX, '0')}`;
}
const characterProperties = reUnicodeProperties
.filter(re => re.test(character))
.map(re => re.source)
.join('\n')
.replace(/\\p\{|\}/g, '');
console.log(
`${JSON.stringify(character)} (${codePoint})\n${characterProperties}`,
);
```
Пример вывода:
```
$ node re-unicode-properties.character-info.js ё
"ё" (U+0451)
gc=Letter
gc=Cased_Letter
gc=Lowercase_Letter
sc=Cyrillic
scx=Cyrillic
Alphabetic
Any
Assigned
Cased
Changes_When_Casemapped
Changes_When_Titlecased
Changes_When_Uppercased
Grapheme_Base
ID_Continue
ID_Start
Lowercase
XID_Continue
XID_Start
```
#### 2. Получение списка всех символов Юникода с доступными для них свойствами.
Этот вариант скрипта работает на моей машине 2–3 минуты и отъедает около гигабайта памяти, так что будьте осторожны. Для однократного запуска, дающего нам полную базу, это терпимо, при необходимости же можно настроить постепенный вывод в файл вместо построения всей базы в памяти и вывода в один присест.
Скрипт можно запускать без параметров, тогда он выводит базу в упрощённом текстовом формате, по одному символу со свойствами на строку. Если же добавить параметр `json`, на выходе мы получим читабельную базу в JSON (кстати, использовать в виде ключей шестнадцатеричные цифры в строчном представлении не выходит: сортировка результата перестаёт быть детерминированной порядком создания ключей; поэтому к числовому ключу мы добавим префикс `U+` — так и сортировка сохраняется, и искать символ в сети будет удобнее, если понадобится полный набор свойств и подробное описание, а не только подходящий для регулярного выражения список; в обычном текстовом представлении префикс мы удалим, раз уж берёмся экономить на размере файла).
**re-unicode-properties.code-points.js**
```
'use strict';
const { writeFileSync } = require('fs');
const reUnicodeProperties = require('./re-unicode-properties.js');
const [, , format] = process.argv;
const LAST_CODE_POINT = 0x10FFFF;
const RADIX = 16;
const PAD_MAX = LAST_CODE_POINT.toString(RADIX).length;
const data = {};
let codePoint = 0;
while (codePoint <= LAST_CODE_POINT) {
const character = String.fromCodePoint(codePoint);
data[`U+${codePoint.toString(RADIX).padStart(PAD_MAX, '0')}`] = [
character,
...reUnicodeProperties
.filter(re => re.test(character))
.map(re => re.source.replace(/\\p\{|\}/g, '')),
];
codePoint++;
}
if (format === 'json') {
writeFileSync(
're-unicode-properties.code-points.json',
`\uFEFF${JSON.stringify(data, null, 2)}\n`,
);
} else {
writeFileSync(
're-unicode-properties.code-points.txt',
`\uFEFF${
Object.entries(data)
.map(([k, v]) => `${k.replace('U+', '')} ${JSON.stringify(v.shift())} ${v.join(' ')}`)
.join('\n')
}\n`,
);
}
```
Примеры фрагментов в обоих форматах:
```
000020 " " gc=Separator gc=Space_Separator sc=Common scx=Common ASCII Any Assigned Grapheme_Base Pattern_White_Space White_Space
000021 "!" gc=Punctuation gc=Other_Punctuation sc=Common scx=Common ASCII Any Assigned Grapheme_Base Pattern_Syntax Sentence_Terminal Terminal_Punctuation
000022 "\"" gc=Punctuation gc=Other_Punctuation sc=Common scx=Common ASCII Any Assigned Grapheme_Base Pattern_Syntax Quotation_Mark
000023 "#" gc=Punctuation gc=Other_Punctuation sc=Common scx=Common ASCII Any Assigned Emoji Emoji_Component Grapheme_Base Pattern_Syntax
000024 "$" gc=Symbol gc=Currency_Symbol sc=Common scx=Common ASCII Any Assigned Grapheme_Base Pattern_Syntax
000025 "%" gc=Punctuation gc=Other_Punctuation sc=Common scx=Common ASCII Any Assigned Grapheme_Base Pattern_Syntax
000026 "&" gc=Punctuation gc=Other_Punctuation sc=Common scx=Common ASCII Any Assigned Grapheme_Base Pattern_Syntax
000027 "'" gc=Punctuation gc=Other_Punctuation sc=Common scx=Common ASCII Any Assigned Case_Ignorable Grapheme_Base Pattern_Syntax Quotation_Mark
000028 "(" gc=Punctuation gc=Open_Punctuation sc=Common scx=Common ASCII Any Assigned Bidi_Mirrored Grapheme_Base Pattern_Syntax
000029 ")" gc=Punctuation gc=Close_Punctuation sc=Common scx=Common ASCII Any Assigned Bidi_Mirrored Grapheme_Base Pattern_Syntax
00002a "*" gc=Punctuation gc=Other_Punctuation sc=Common scx=Common ASCII Any Assigned Emoji Emoji_Component Grapheme_Base Pattern_Syntax
00002b "+" gc=Symbol gc=Math_Symbol sc=Common scx=Common ASCII Any Assigned Grapheme_Base Math Pattern_Syntax
00002c "," gc=Punctuation gc=Other_Punctuation sc=Common scx=Common ASCII Any Assigned Grapheme_Base Pattern_Syntax Terminal_Punctuation
00002d "-" gc=Punctuation gc=Dash_Punctuation sc=Common scx=Common ASCII Any Assigned Dash Grapheme_Base Pattern_Syntax
00002e "." gc=Punctuation gc=Other_Punctuation sc=Common scx=Common ASCII Any Assigned Case_Ignorable Grapheme_Base Pattern_Syntax Sentence_Terminal Terminal_Punctuation
00002f "/" gc=Punctuation gc=Other_Punctuation sc=Common scx=Common ASCII Any Assigned Grapheme_Base Pattern_Syntax
```
```
[
"U+000020": [
" ",
"gc=Separator",
"gc=Space_Separator",
"sc=Common",
"scx=Common",
"ASCII",
"Any",
"Assigned",
"Grapheme_Base",
"Pattern_White_Space",
"White_Space"
],
"U+000021": [
"!",
"gc=Punctuation",
"gc=Other_Punctuation",
"sc=Common",
"scx=Common",
"ASCII",
"Any",
"Assigned",
"Grapheme_Base",
"Pattern_Syntax",
"Sentence_Terminal",
"Terminal_Punctuation"
]
]
```
Полные базы в архивах можно при желании скачать: [`.txt`](https://vsemozhetbyt.github.io/var/uniprops/re-unicode-properties.code-points.txt.zip) (5 MB в архиве, ~60 MB текста) или [`.json`](https://vsemozhetbyt.github.io/var/uniprops/re-unicode-properties.code-points.json.zip) (5.5 MB в архиве, ~112 MB текста). При просмотре не забудьте использовать хорошие шрифты.
#### 3. Список используемых в файле символов с их свойствами.
Это вариант предыдущего скрипта, предоставляющего не полную базу символов, а лишь тот набор, который встречается в заданном файле. Первым параметром скрипта задаётся путь к файлу, вторым необязательным — формат (текстовый используется по умолчанию, также можно задать `json`). Вывод аналогичный предыдущему, только меньший по объёму. Поскольку файл читается в режиме потока, можно обрабатывать тексты любого разумного размера. У меня гигабайтный файл обрабатывался пять минут, на протяжении всей работы скрипт занимал около 60 мегабайт памяти.
**re-unicode-properties.file-info.js**
```
'use strict';
const { createReadStream, writeFileSync } = require('fs');
const { basename } = require('path');
const reUnicodeProperties = require('./re-unicode-properties.js');
const [, , filePath, format] = process.argv;
const LAST_CODE_POINT = 0x10FFFF;
const RADIX = 16;
const PAD_MAX = LAST_CODE_POINT.toString(RADIX).length;
const data = {};
(async function main() {
const fileStream = createReadStream(filePath);
fileStream.setEncoding('utf8');
const characters = new Set();
for await (const chunk of fileStream) {
[...chunk].forEach((character) => { characters.add(character); });
}
[...characters].sort().forEach((character) => {
data[`U+${character.codePointAt(0).toString(RADIX).padStart(PAD_MAX, '0')}`] = [
character,
...reUnicodeProperties
.filter(re => re.test(character))
.map(re => re.source.replace(/\\p\{|\}/g, '')),
];
});
if (format === 'json') {
writeFileSync(
`re-unicode-properties.file-info.${basename(filePath)}.json`,
`\uFEFF${JSON.stringify(data, null, 2)}\n`,
);
} else {
writeFileSync(
`re-unicode-properties.file-info.${basename(filePath)}.txt`,
`\uFEFF${
Object.entries(data)
.map(([k, v]) => `${k.replace('U+', '')} ${JSON.stringify(v.shift())} ${v.join(' ')}`)
.join('\n')
}\n`,
);
}
})();
```
На этом, пожалуй, всё. Спасибо за уделённое время. | https://habr.com/ru/post/350448/ | null | ru | null |
# Мьютексы и захват замыканиями в Swift
*Перевод [статьи Мэтта Галлагера](https://www.cocoawithlove.com/blog/2016/06/02/threads-and-mutexes.html).*
В этой статье речь пойдёт об отсутствии потокового выполнения (threading) и инструментов синхронизации потоков в Swift. Мы обсудим предложение о внедрении «многопоточности» (concurrency) в Swift и то, как до появления этой возможности потоковое выполнение в Swift будет подразумевать использование традиционных мьютексов и общего изменяемого состояния (shared mutable state).
Использовать мьютекс в Swift не особенно сложно, но на этом фоне хотелось бы выделить тонкие нюансы производительности в Swift — динамическое выделение памяти во время захвата замыканиями. Мы хотим, чтобы наш мьютекс был быстрым, но передача замыкания для исполнения внутри мьютекса может снизить производительность в 10 раз из-за дополнительных расходов памяти. Давайте рассмотрим несколько способов решения данной проблемы.
Отсутствие потокового выполнения (threading) в Swift
----------------------------------------------------
Когда Swift был впервые анонсирован в июне 2014 года, у него было два очевидных упущения:
* обработка ошибок,
* потоковое выполнение и синхронизация потоков.
Обработка ошибок была реализована в Swift 2 и являлась одной из ключевых особенностей этого релиза.
А потоковое выполнение по большей части всё ещё игнорируется Swift. Вместо языковых средств обеспечения потокового выполнения, Swift включает в себя модуль `Dispatch` (libdispatch, aka Grand Central Dispatch) на всех платформах, и неявно предлагает нам использовать `Dispatch` вместо того, чтобы ожидать помощи от языка.
Делегирование ответственности библиотеке, идущей в поставке, кажется особенно странным по сравнению с другими современными языками, такими как Go и Rust, в которых примитивы (primitives) потокового выполнения и строгая потокобезопасность (соответственно) стали основными свойствами своих языков. Даже свойства `@synchronized` и `atomic` в Objective-C кажутся щедрым предложением по сравнению с отсутствием чего-либо подобного в Swift.
Какова причина такого очевидного упущения в этом языке?
Будущая «многопоточность» в Swift
---------------------------------
Ответ вкратце рассмотрен в [предложении о внедрении «многопоточности» в репозитории Swift](https://github.com/apple/swift/blob/c760f6dfbf0179e9aff90f7bf7375f3af5331318/docs/proposals/Concurrency.rst).
*Я упоминаю это предложение, чтобы подчеркнуть, что разработчики Swift в будущем хотели бы сделать что-то в отношении многопоточности, но прошу иметь в виду, что говорит разработчик Swift Джо Грофф: «этот документ — всего лишь предложение, а не официальное заявление о направлении развития».*
Это предложение появилось с целью описать ситуацию, когда, например, в [Cyclone](http://homes.cs.washington.edu/~djg/papers/cycthreads.pdf) или [Rust](http://blog.rust-lang.org/2015/04/10/Fearless-Concurrency.html) ссылки не могут быть разделены между потоками выполнения. Независимо от того, похож ли результат на эти языки, кажется, в Swift планируется устранить общую память потоков, за исключением типов, реализующих `Copyable` и передаваемых через строго управляемые каналы (в предложении называемые `Stream`’ами). Также появится разновидность сопрограммы (coroutine) (в предложении называемая `Task`’ами), которая будет вести себя как асинхронные блоки отправки (asynchronous dispatch blocks), которые можно ставить на паузу/возобновлять.
Далее в предложении утверждается, что в **библиотеках** поверх примитивов `Stream / Task / Copyable` могут быть реализованы самые распространенные **языковые** средства потокового выполнения (по аналогии с `chan` в Go, `async / await` в .NET, `actor` в Erlang).
Звучит хорошо, но когда ожидать многопоточность в Swift? В Swift 4? В Swift 5? Не скоро.
Таким образом, сейчас нам это не помогает, а скорее даже мешает.
Влияние будущих функций на текущую библиотеку
---------------------------------------------
Проблема в том, что Swift избегает использования простых многопоточных примитивов в языке, или потокобезопасных версий языковых функций на том основании, что они будут заменены или устранены какими-то будущими средствами.
Можно найти этому явные свидетельства, читая список рассылок Swift-Evolution:
* [Ссылки на объекты (как сильные, так и слабые) не определены «при наличии в переменной гонок данных read/write, write/write или anything/destroy»](https://github.com/apple/swift/pull/1454). Здесь нет намерения изменить такое поведение или предложить встроенный «атомный» подход, поскольку это «одно из немногих неопределенных правил поведения, которые мы принимаем». Возможное «исправление» этого неопределенного поведения будет новой моделью многопоточности.
* Получившиеся типы (или другие средства перебрасывания (`throw`), отличные от функциональных интерфейсов) были бы полезны для многочисленных алгоритмов «в стиле передачи продолжений» (continuation passing style) и были бы тщательно обсуждены, но в конечном счете они будут игнорироваться до тех пор, пока Swift не «обеспечит надлежащую языковую поддержку [для сопрограмм или асинхронных промисов]» как часть изменений в сфере многопоточности.
Пытаемся найти быстрый мьютекс мьютекса общего назначения
---------------------------------------------------------
Вкратце: если нам нужно многопоточное поведение, то необходимо построить его самостоятельно, используя уже существующие средства потоковой передачи и свойства мьютекса.
Стандартный [совет по мьютексам в Swift](http://stackoverflow.com/questions/24045895/what-is-the-swift-equivalent-to-objective-cs-synchronized): используйте `DispatchQueue` и вызывайте применительно к нему `sync`.
Мне нравится libdispatch, но в большинстве случаев использование `DispatchQueue.sync` в качестве мьютекса — это самый медленный способ устранения проблемы, более чем **на порядок** медленнее других решений из-за неизбежных издержек на захват замыканием, которое передаётся функции `sync`. Это происходит из-за того, что замыкание мьютекса должно захватывать окружающее состояние (в частности, захватывать ссылку на защищенный ресурс), и этот захват подразумевает использование контекста замыкания, находящегося в динамической памяти. Пока Swift не получит возможность оптимизировать изолирующие (non-escaping) замыкания в стеке, единственный способ избежать дополнительных расходов на помещение замыканий в динамическую память — убедиться, что они встроены. К сожалению, это невозможно в границах модуля, таких как границы модуля Dispatch. Это делает `DispatchQueue.sync` излишне медленным мьютексом в Swift.
Следующим по частоте предлагаемым вариантом можно считать `objc_sync_enter` / `objc_sync_exit`. Будучи в 2-3 раза быстрее, чем libdispatch, он всё ещё немного медленнее идеала (потому что он всегда является мьютексом **повторного входа** (re-entrant)), и зависит от рантайма Objective-C (поэтому ограничен платформой Apple).
Самый быстрый вариант для мьютекса — `OSSpinLock` — более чем в 20 раз быстрее, чем `dispatch_sync`. Помимо общих ограничений спин-блокировки (высокая нагрузка на ЦП, если несколько потоков пытаются войти одновременно), [в iOS есть серьёзные проблемы, которые делают его полностью непригодным для использования на этой платформе. Соответственно, он может быть использован только на Mac](https://lists.swift.org/pipermail/swift-dev/Week-of-Mon-20151214/000372.html).
Если вы нацелены на iOS 10 или macOS 10.12, или на нечто более новое, то можете использовать `os_unfair_lock_t`. Это решение по производительности должно быть близко к `OSSpinLock`, при этом лишено его самых серьёзных проблем. Тем не менее, эта блокировка не является FIFO. Вместо этого мьютекс предоставляется произвольному ожидающему (следовательно, «нечестно» (unfiar)). Вам нужно решить, является ли это проблемой для вашей программы, хотя в целом означает, что этот вариант не должен быть вашим первым выбором для мьютекса общего назначения.
Все эти проблемы делают `pthread_mutex_lock` / `pthread_mutex_unlock` единственным разумным, производительным и портируемым вариантом.
Мьютексы и подводные камни захвата замыканием
---------------------------------------------
Как и большинство вещей в чистом языке C, `pthread_mutex_t` имеет довольно неуклюжий интерфейс, что помогает использовать обертку Swift (особенно для построения и автоматической очистки). Кроме того, полезно иметь “scoped”-мьютекс — который принимает функцию и выполняет её внутри мьютекса, обеспечивая сбалансированную «блокировку» и «разблокировку» с любой стороны функции.
Назовём нашу обертку `PThreadMutex`. Ниже приведена реализация простой функции scoped-мьютекса в этой обёртке:
```
public func sync(execute: () -> R) -> R {
pthread\_mutex\_lock(&m)
defer { pthread\_mutex\_unlock(&m) }
return execute()
}
```
Должно работать быстро, но это не так. Вы видите, почему?
Проблема возникает из-за реализации повторно используемых функций, вроде той, что представлена в отдельном модуле `CwlUtils`. Это приводит к точно такой же проблеме, что и в случае с `DispatchQueue.sync`: захват замыканием приводит к выделению динамической памяти. Из-за накладных расходов в ходе этого процесса функция будет работать более чем в 10 раз медленнее, чем нужно (3,124 секунды для 10 миллионов вызовов, по сравнению с идеальным 0,263 секунды).
Что именно «захвачено»? Давайте рассмотрим следующий пример:
```
mutex.sync { doSomething(&protectedMutableState) }
```
Чтобы сделать что-то полезное внутри мьютекса, ссылка на `protectedMutableState` должна храниться в «контексте замыкания», который представляет собой данные, находящиеся в динамической памяти.
Это может показаться достаточно безобидным (в конце концов, захват — то, чем занимаются замыкания). Но если функция `sync` не может быть встроена в то, что её вызывает (потому что она находится в другом модуле или файле, а оптимизация всего модуля выключена), то при захвате будет выделяться динамическая память.
А мы этого не хотим. Чтобы избежать этого, передадим замыканию соответствующий параметр вместо того, чтобы его захватывать.
**ПРЕДУПРЕЖДЕНИЕ**: следующие несколько примеров кода становятся всё более нелепыми, и в большинстве случаев я предлагаю не следовать им. Я делаю это, чтобы продемонстрировать глубину проблемы. Прочтите главу «Другой подход», чтобы увидеть, что я использую на практике.
```
public func sync_2(\_ p: inout T, execute: (inout T) -> Void) {
pthread\_mutex\_lock(&m)
defer { pthread\_mutex\_unlock(&m) }
execute(&p)
}
```
Так-то лучше… теперь функция работает на полной скорости (0,282 секунды для теста из 10 миллионов вызовов).
Мы решили проблему с помощью значений, переданных функциями. Аналогичная проблема возникает с возвратом результата. Следующая функция:
```
public func sync_3(\_ p: inout T, execute: (inout T) -> R) -> R {
pthread\_mutex\_lock(&m)
defer { pthread\_mutex\_unlock(&m) }
return execute(&p)
}
```
демонстрирует такую же низкую скорость оригинала, даже когда замыкание ничего не захватывает (на 1,371 секунде скорость падает ещё ниже). Для обработки своего результата это замыкание выполняет динамическое выделение памяти.
Мы можем исправить это, внеся в результат параметр `inout`.
```
public func sync_4(\_ p1: inout T, \_ p2: inout U, execute: (inout T, inout U) -> Void) -> Void {
pthread\_mutex\_lock(&m)
execute(&p, &p2)
pthread\_mutex\_unlock(&m)
}
```
и вызвать так,
```
// Предполагается, что `mutableState` и `result` являются валидными, изменяемыми значениями в текущей области видимости
mutex.sync_4(&mutableState, &result) { $1 = doSomething($0) }
```
Мы вернулись к полной скорости, или достаточно близкой к ней (0,307 секунды для 10 миллионов вызовов).
Другой подход
-------------
Одним из преимуществ захвата замыканием является то, насколько легким он кажется. Элементы внутри захвата имеют одинаковые **имена** внутри и снаружи замыкания, и связь между ними очевидна. Когда мы избегаем захвата замыканием, и вместо этого пытаемся передать все значения в качестве параметров, мы вынуждены либо переименовывать все наши переменные, либо давать им теневые имена (shadow names) — что не способствует простоте понимания — и мы по-прежнему рискуем случайно захватить переменную, опять ухудшив производительность.
Давайте всё отложим и решим проблему по-другому.
Мы можем создать в нашем файле свободную функцию `sync`, которая берёт мьютекс в качестве параметра:
```
private func sync(mutex: PThreadMutex, execute: () throws -> R) rethrows -> R {
pthread\_mutex\_lock(&mutex.m)
defer { pthread\_mutex\_unlock(&mutex.m) }
return try execute()
}
```
Если поместить функцию в файл, из которого она будет вызываться, то всё **почти** работает. Мы избавляемся от расходов на динамическое выделение памяти, при этом скорость выполнения падает с 3,043 до 0,374 секунды. Но мы до сих пор не достигли уровня в 0,263 секунды, как при прямом вызове `pthread_mutex_lock` / `pthread_mutex_unlock`. Что опять не так?
Оказывается, несмотря на наличие приватной функции в том же файле, — где Swift может полностью инлайнить эту функцию, — Swift не устраняет избыточные удержания и освобождения (retains and releases) параметра `PThreadMutex` (типом которого является `class`, чтобы `pthread_mutex_t` не ломался при копировании).
Мы можем заставить компилятор избежать этих удержаний и освобождений, сделав функцию расширением `PThreadMutex`, а не свободной функцией:
```
extension PThreadMutex {
private func sync(execute: () throws -> R) rethrows -> R {
pthread\_mutex\_lock(&m)
defer { pthread\_mutex\_unlock(&m) }
return try execute()
}
}
```
Это заставляет Swift обрабатывать параметр `self` как `@guaranteed`, устраняя расходы на удержание/освобождение, и мы наконец-то доходим до значения в 0,264 секунды.
Семафоры, не мьютексы?
----------------------
Почему было бы не использовать `dispatch_semaphore_t`? Преимущество `dispatch_semaphore_wait` и `dispatch_semaphore_signal` заключается в том, что для них не требуется замыкание — это отдельные, unscoped-вызовы.
Вы можете использовать `dispatch_semaphore_t` для создания конструкции наподобие мьютекса:
```
public struct DispatchSemaphoreWrapper {
let s = DispatchSemaphore(value: 1)
init() {}
func sync(execute: () throws -> R) rethrows -> R {
\_ = s.wait(timeout: DispatchTime.distantFuture)
defer { s.signal() }
return try execute()
}
}
```
Оказывается, это примерно на треть **быстрее** мьютекса `pthread_mutex_lock` / `pthread_mutex_unlock` (0,168 секунды против 0,244). Но, несмотря на увеличение скорости, использование семафора для мьютекса является не самым лучшим вариантом для общего мьютекса.
Семафоры склонны к ряду ошибок и проблем. Наиболее серьезными из них являются формы [инверсии приоритета](https://en.wikipedia.org/wiki/Priority_inversion). Инверсия приоритета — это тот же тип проблемы, из-за которого `OSSpinLock` стал использоваться под iOS, но проблема для семафоров немного сложнее.
При спин-блокировке инверсия приоритета означает:
1. Высокоприоритетный поток активен, вращается (spinning) и ожидает снятия блокировки, удерживаемой потоком с более низким приоритетом.
2. Низкоприоритетный поток никогда не снимает блокировку, потому что он истощён потоком с более высоким приоритетом.
При наличии семафора инверсия приоритета означает:
1. Высокоприоритетный поток ожидает семафора.
2. Среднеприоритетный поток не зависит от семафора.
3. Ожидается, что низкоприоритетный поток сигнализирует семафором, что высокоприоритетный поток может продолжать.
Среднеприоритетный поток будет истощать низкоприоритетный (это нормально для приоритета потоков). Но поскольку высокоприоритетный поток ждёт, когда низкоприоритетный поток сигнализирует семафором, то высокоприоритетный **тоже** истощается среднеприоритетным. В идеале этого не должно происходить.
Если вместо семафора был использован правильный мьютекс, то приоритет высокоприоритетного потока будет передан в поток с более низким приоритетом, пока высокоприоритетный ожидает мьютекса, удерживаемого низкоприоритетным потоком, — это позволяет низкоприоритетному потоку завершить свою работу и разблокировать высокоприоритетный поток. Однако семафоры не удерживаются потоком, поэтому передачи приоритета произойти не может.
В конечном счете, семафоры — это хороший способ связывания уведомлений о завершениях между потоками (то, что нелегко сделать с помощью мьютексов), но конструкция семафоров сложна и несёт в себе риски, поэтому их использование нужно ограничить ситуациями, когда вам заранее известны все задействованные потоки и их приоритеты — когда известно, что приоритет ожидающего потока равен или **ниже** приоритета сигналящего потока.
Всё это может показаться немного запутанным — поскольку вы, вероятно, не создаете намеренно в своих программах потоки с разными приоритетами. Тем не менее, фреймворки Cocoa добавляют немного сложностей: они повсеместно используют очереди отправки (dispatch queues), и каждая очередь имеет «класс QoS». А это может привести к тому, что очередь будет работать с другим приоритетом потока. Если вы не знаете очередность каждой задачи в программе (включая пользовательский интерфейс и другие задачи, поставленные в очередь с помощью фреймворков Cocoa), то неожиданно можете столкнуться с ситуацией многопоточного приоритета. Лучше этого избегать.
Применение
----------
*Проект, содержащий реализации `PThreadMutex` и `DispatchSemaphore`, доступен на [Github](https://github.com/mattgallagher/CwlUtils).*
Файл [CwlMutex.swift](https://github.com/mattgallagher/CwlUtils/blob/master/Sources/CwlUtils/CwlMutex.swift?ts=3) полностью самодостаточен, поэтому можно просто скопировать его, если это всё, что вам нужно.
Или же файл [ReadMe.md](https://github.com/mattgallagher/CwlUtils/blob/master/README.md) содержит подробную информацию о клонировании всего репозитория и добавлении создающего его фреймворка в ваши проекты.
Заключение
----------
Лучшим и безопасным вариантом мьютекса в Swift как под Mac, так и под iOS, остается [pthread\_mutex\_t](https://github.com/mattgallagher/CwlUtils/blob/master/README.md). В будущем Swift, вероятно, обзаведётся возможностью оптимизировать изолирующие (non-escaping) замыкания в стеке, или инлайнить за границами модулей. Любое из этих нововведений устранит присущие проблемы с [Dispatch.sync](https://github.com/mattgallagher/CwlUtils/blob/master/README.md), вероятно, сделав его лучшим вариантом. Но пока что он слишком неэффективен.
В то время как семафоры и другие «легкие» блокировки являются обоснованными подходами в некоторых сценариях, они не являются мьютексами общего назначения и при проектировании подразумевают дополнительные соображения и риски.
Независимо от выбора машинерии мьютексов, вам необходимо быть осторожными, обеспечивая инлайнинг ради максимальной производительности, иначе чрезмерное количество захватов замыканиями могут замедлить мьютексы в 10 раз. В текущей версии Swift это может означать копирование и вставку кода в файл, в котором он используется.
Потоковое выполнение, инлайнинг и оптимизация — всё это темы, в которых мы можем ожидать значительных изменений за рамками Swift 3. Однако, текущим пользователям Swift приходится работать в Swift 2.3 и Swift 3 — и в этой статье описывается текущее поведение в этих версиях при попытке получить максимум производительности при использовании scoped-мьютекса.
Дополнение: показатели производительности
-----------------------------------------
10 миллионов раз был прогнан простой цикл: ввод мьютекса, увеличение счетчика и вывод мьютекса. «Медленные» версии DispatchSemaphore и PThreadMutex оказались скомпилированы как часть динамической структуры, отдельно от тестового кода.
Результаты:
| Вариант мьютекса | Секунды (Swift 2.3) | Секунды (Swift 3) |
| --- | --- | --- |
| PThreadMutex.sync (захват замыканием) | 3,043 | 3,124 |
| DispatchQueue.sync | 2,330 | 3,530 |
| PThreadMutex.sync\_3 (возвращаемый результат) | 1,371 | 1,364 |
| objc\_sync\_enter | 0,869 | 0,833 |
| sync(PThreadMutex) (функция в том же файле) | 0,374 | 0,387 |
| PThreadMutex.sync\_4 (Двойные параметры inout) | 0,307 | 0,310 |
| PThreadMutex.sync\_2 (единичный параметр inout) | 0,282 | 0,284 |
| PThreadMutex.sync (инлайновый не-захват) | 0,264 | 0,265 |
| Прямые вызовы pthread\_mutex\_lock/unlock | 0,263 | 0,263 |
| OSSpinLockLock | 0,092 | 0,108 |
Использованный тестовый код является частью связанного проекта [CwlUtils](https://github.com/mattgallagher/CwlUtils), но тестовый файл, содержащий эти тесты производительности (CwlMutexPerformanceTests.swift), по умолчанию не подключен к тестовому модулю и должен быть включен намеренно. | https://habr.com/ru/post/336260/ | null | ru | null |
# Распределенные имитационные системы
Для возможности объединения отдельных имитаторов в распределенную систему имитации в настоящий момент используются следующие стандарты и технологии:
* IEEE1516 (также заменяет HLA и DIS);
* OPC;
* CAPE-OPEN и другие «отраслевые» стандарты.
Наибольший интерес представляет стандарт IEEE 1516, т. к. данный стандарт напрямую относится к имитаторам, направлен на построение систем распределенной имитации (протоколы, рекомендованные методы управления и обратной связи, системная архитектура и т.д).
Семейство программных технологий OPC (OLE for Process Control) предоставляющих единый интерфейс для управления объектами автоматизации и технологическими процессами также представляет значительный интерес, но только в том случае, если необходима интеграция с объектами автоматизации и технологическими процессами. Стандарт CAPE-OPEN используется для взаимодействия имитаторов, разработанных специально для химической промышленности.
В области стандартизации моделирования и имитации значительный вклад внес Институт инженеров по электротехнике и электронике (IEEE). Распределенное моделирование (имитация) – технология обмена данными между тренажерами по локальным или глобальным вычислительным сетям. Это позволяет обеспечить совместную работу отдельных имитаторов как одной управляемой системы моделирования или имитации. Концепция распределенного моделирования опирается на использовании высокоуровневой архитектуры (HLA). Практически стандарт IEEE 1516 определяет архитектуру путем использования единого API (программного интерфейса приложений). Отправными постулатами стандарта являются:
1. простые «монолитные» имитационные модели не могут удовлетворить потребности профессиональных пользователей;
2. все возможные сферы применения имитационного моделирования заранее неизвестны;
3. должны быть предусмотрены возможности произвольного комбинирования отдельных имитаторов в сложные имитационные системы;
4. архитектура распределенного моделирования должна быть максимально открыта для будущих технологий моделирования и имитации.
На данный IEEE 1516 является абсолютным стандартом для взаимодействия тренажеров и имитаторов в военных приложениях, что обусловлено жесткими требованиями совместимости с имитаторами, разрабатываемыми и используемыми Министерством обороны США и НАТО. В настоящее время IEEE 1516 находит все большее применение и в гражданской сфере, при разработке имитаторов для тренировки персонала сложных технических систем, в авиации, космонавтике, транспорте и т.д.
Семейство программных технологий OPC разрабатывалось с целью сокращения затрат на создание и сопровождение приложений промышленной автоматизации. В начале 90-х у разработчиков промышленного программного обеспечения возникла потребность в универсальном инструменте обмена данными с устройствами разных производителей или с разными протоколами взаимодействия. OPC предоставляет разработчикам промышленных программ универсальный фиксированный интерфейс обмена данными с любыми устройствами. В то же время разработчики устройств предоставляют программу, реализующую этот интерфейс.
Для создания сложных имитационных систем можно комбинировать использование IEEE 1516 и OPC, получая возможность использования реального оборудования и SCADA-систем (рисунок ), что может быть достаточно полезным во многих задачах.
Обеспечение связи стандартов IEEE 1516 (являющегося базовым для имитаторов) и OPC (применяемого в SCADA-системах) может быть реализовано, как напрямую в имитаторе, так и посредством посредника. Роль такого посредника, например у меня, выполняет пакет National Instruments LabView. LabView может поддерживать математические модели любой сложности, имеет встроенную поддержку OPC, может выступать в роли OPC-сервера, имеет эффективную поддержку взаимодействия с различными платами ввода вывода, что позволяет использовать необходимое оборудование напрямую, но не имеет, к сожалению, средств взаимодействия с IEEE 1516, что требует написания соответствующих программных компонентов.
В результате использования IEEE 1516 и OPC возможно создание относительно сложных распределенных систем имитации, включающих в себя множество имитаторов, реальное оборудование, SCADA-системы и т. д.
Отдельного рассмотрения заслуживает вопрос сертификации имитатора или имитаторов относительно поддержки стандарта IEEE 1516. Сертифицируются как имитаторы (федераты в терминологии IEEE 1516), так и программные библиотеки, реализующие взаимодействие. Но целью данной сертификации не является выявление функциональных дефектов программы (только сертификация поддержки стандарта IEEE 1516).
Организации, способные провести сертификацию:
* США. The Department of Defense (DoD) Modeling and Simulation Coordination Office (M&S CO). Сайт: [www.msco.mil](http://www.msco.mil/)
* Франция. ONERA. (Office National d’Etudes et Recherches Aérospatiales) is the French national aerospace research center. Сайт: [www.onera.fr](http://www.onera.fr)
* Швеция. Pitch Technologies AB. Сайт: [www.pitch.se](http://www.pitch.se)
Рассмотрим вопросы построения распределенных имитационных систем на основе стандарта IEEE 1516. Базовые термины, используемые в информационном обеспечении, соответствуют терминологии стандарта на системы распределенной интерактивной имитации IEEE 1516 – это федерация, федерат, объект, атрибут и интеракция. Понятие объекта определяется как модель отдельного явления реального мира. Объекты не имеют методов, а имеют только состояния (только структура данных без функций их обработки). Состояния объектов характеризуется фиксированным набором атрибутов — точных значений, которые могут изменяться с течением времени. Каждый объект в любой момент времени характеризуется своим состоянием, которое определяется набором текущих значений его атрибутов. Федераты представляют собой математические описания поведения объектов – имитационные модели, заданные программно (реализованные на директивном языке) или представленные значениями датчиков аппаратных средств. Фактически федератами могут быть как имитаторы, так и реальное оборудование или специальное программное обеспечение. Единственным требованием является обеспечение единого интерфейса для взаимодействия. Федераты могут управлять объектами, меняя (обновления) или получая (отображая) значения их атрибутов. В частности, пользователи имитаторов также являются федератами. Совокупность всех участвующих в имитационном моделировании федератов образует федерацию.
Термин «интеракция» определяется как мгновенное сообщение (событие), не привязанное к конкретному экземпляру объекта или федерату, происходящее на уровне федерации (т.е. невозможно определить отправителя). Интеракции, в отличие от состояний объектов, не поддерживаются в системе постоянно, а имеют мгновенную природу. Примером может служить односторонняя широковещательная передача текстового сообщения всем заинтересованным участникам федерации. Иерархическая схема федерации (HLA / IEEE 1516) показана на рисунке
Взаимодействие федератов осуществляется при помощи общего механизма взаимодействия (RTI), реализованного в виде подписки. Федерат, заинтересованный в получении определенных атрибутов и интеракций другого федерата, должен подписаться на них через RTI. Механизм запроса, предоставления и изменения значений атрибутов представлен на рисунке. Механизм организации распределенной имитации и совместной работы представлен на рисунке.
*Рисунок. Иерархическая схема федерации*
Объекты в имитаторе, это, как правило, 3D модели, источники звука, соответственно атрибутами таких объектов являются положение и ориентация в пространстве, размер, громкость и т.д. Применительно к имитаторам, в качестве интеракций можно рассматривать действия пользователя (федерата), например – включение какой-либо клавиши.
*Рисунок. Общий механизм взаимодействия (RTI)*
*Рисунок. Общий механизм взаимодействия (RTI)*
*Рисунок. Организация распределенной имитации и совместной работы*
При создании распределенных имитационных систем, взаимодействующих через RTI, необходимо учитывать следующие важные особенности. Все элементы федератов и федерации должны быть документированы в определенных файлах (для описания федерации используются FOM (federation object model) файлы), федераты описываются в SOM-файлах (Simulation Object Model). Все данные хранятся только в федератах, RTI не хранит никаких данных, а только передает их. HLA позволяет в любой момент времени только одному федерату изменять значение какого либо атрибута (для передачи прав имеется специальый механизм управления правами). Федераты могут управлять локальным временем, в HLA используются различные внутренние механизмы управления временем (синхронизацией).
В целом, стандарт IEEE 1516 затрагивает огромное количество вопросов, связанных с созданием распределенных имитационных систем, таких как сохранение состояния федерации, возобновление состояния, различные механизмы синхронизации времени, области взаимодействия федератов и т.д. В связи со значительным объемом самого стандарта и, тем более, объемом программного кода для демонстрации всех аспектов, описанных в стандарте, далее будет продемонстрирована только принципиальная реализация «базовых» возможностей (рисунок ).
*Рисунок. Блок-схема реализации базовых возможностей IEEE 1516*
Более подробное изложение реализации сопряжено с необходимостью представления достаточно большого листинга программы, по этой причине, читатель может самостоятельно воспользоваться примерами программ, которые поставляются вместе с программным обеспечением для поддержки RTI. Достаточно простые примеры, содержащие множество комментариев, входят в состав библиотеки The Portico Project и свободно доступны на сайте [porticoproject.org](http://porticoproject.org/). Практически все коммерческие реализации стандарта также содержат в своем составе множество примеров.
В качестве примера можно рассмотреть следующую федерацию, состоящую из двух федератов: радиоуправляемая машина и пульт управления. Предположим, что управления осуществляется путем установки оборотов каждого из 4-х двигателей машины и поворота передних колес. На машине установлен датчик, определяющий расстояние до препятствия и передающий сигнал на пульт управления. Для этого необходимо определить два класса объектов, cYpravlenie для пульта управления и cDatchik для датчика дистанции. Атрибутами класса cYpravlenie являются wheel1, wheel2, wheel3, wheel4, wheel\_angle. Атрибутом класса cDatchik является distance. Далее показан файл описания федерации, в формате HLA 1.3 (интеракции приведены как пример).
```
;; комментарий — файл федерации (FED файл) для HLA 1.3
(Fed
(Federation Test)
(FedVersion v1.3)
(Federate "fed" "Public")
(Spaces
(Space "Geo"
(Dimension X)
(Dimension Y)
)
)
(Objects
(Class cYpravlenie
(Attribute wheel1 reliable timestamp)
(Attribute wheel2 reliable timestamp)
(Attribute wheel3 reliable timestamp)
(Attribute wheel4 reliable timestamp)
(Attribute wheel_angle reliable timestamp)
)
(Class cDatchik
(Attribute distance reliable timestamp)
)
)
(Interactions
(Class reaction BEST_EFFORT RECEIVE
(Sec_Level "Public")
(Parameter dx)
(Parameter dy)
(Parameter dz)
)
)
)
```
Далее, имитатор, представляющий управление создает федерат и объект, на основе класса cYpravlenie. Имитатор, представляющий машину, также создает федерат и объект, на основе класса cDatchik. Также федераты подписываются на интересующие их изменения, т.е. федерат-машина подписывается на получение данных объектов от класса cYpravlenie (т.е. на класс cYpravlenie), а федерат-управление на класс cDatchik. Таким образом машина получает изменения от пульта управления, а пульт получает данные от датчика в машине.
Построение более сложных имитационных систем предполагает достаточно серьезное проектирование. Сначала необходимо определить принципиальный состав федерации в первом приближении, т. е. федераты, объекты федератов и атрибуты объектов. При составлении схемы федерации необходимо учитывать и аппаратные компоненты распределенной имитационной систем, т. е. датчики и управляющие аппаратные устройства также должны быть представлены в виде федератов, объектов и атрибутов. На рисунке. показана структура федерации имитатора установки штангового скважинного насоса.
*Рисунок. Структура федерации*
После состава федерации необходимо определение связей, т. е. отражения того, какие федераты публикуют (т. е. изменяют) атрибуты объектов, а какие подписываются на изменения этих атрибутов. Как правило на этапе определения связей устанавливается большое количество «поправок» для структуры федерации. После необходимого количества итераций «уточнения» структуры и связей, проектировщики должны установить факт «правильности модели» федерации. Пример определения связей показан на рисунке (объекты, не имеющие связей скрываются).
*Рисунок. Пример первого этапа определения связей*
На следующем этапе происходит определение необходимого количества компьютеров и соответствующее распределение федератов. Например, федерат «A» будет функционировать на компьютере «1», федераты «B, C, D» будет функционировать на компьютере «2».
*Рисунок. Распределение федератов по компьютерам*
Как правило распределение федератов основано на экономичности их математической модели, если математические модели федератов не требуют значительных вычислительных ресурсов, то можно использовать один компьютер, если математические модели федератов требуют значительных вычислительных ресурсов, необходимо определение числа компьютеров и соответствующее распределение федератов.
На следующем этапе составляются файл описания федерации (см. пример выше), отражающий утвержденную «правильную модели» федерации. Затем создается программная реализация федератов, путем написания соответствующего кода для взаимодействия с RTI и кода, реализующего математическую модель федерата. На заключительном этапе необходимо тестирование распределенной имитационной системы, выявление ошибок, «перегрузок» определенных компонентов в системе (на основе статистики), правильность синхронизации и т. д.
Статистика по каждому федерату отдельно, так и по федерации в целом показывает количество и типы выполненных запросов и позволяет определить возможные проблемы в ходе работы системы.
Пример статистики по федерату:
```
RTIA: Statistics (processed messages)
Joined federation as car_federate
Synchronization point announced: ReadyToRun
Achieved sync point: ReadyToRun, waiting for federation...
Federation Synchronized: ReadyToRun
Time Policy Enabled
Published and Subscribed
Add instance object: obj_datchik
Removing temporary file _RTIA_3033_ExampleFederation.fed on resign federation.
Resigned from Federation
Didn't destroy federation, federates still joined
List of federate initiated services
--------------------------------------------------
1 Message::CLOSE_CONNEXION (MSG#1)
1 Message::DESTROY_FEDERATION_EXECUTION (MSG#3)
1 Message::JOIN_FEDERATION_EXECUTION (MSG#4)
1 Message::RESIGN_FEDERATION_EXECUTION (MSG#5)
1 Message::SYNCHRONIZATION_POINT_ACHIEVED (MSG#10)
1 Message::PUBLISH_OBJECT_CLASS (MSG#28)
1 Message::SUBSCRIBE_OBJECT_CLASS_ATTRIBUTES (MSG#32)
1 Message::SUBSCRIBE_INTERACTION_CLASS (MSG#34)
1 Message::REGISTER_OBJECT_INSTANCE (MSG#40)
1708 Message::UPDATE_ATTRIBUTE_VALUES (MSG#41)
855 Message::TIME_ADVANCE_REQUEST (MSG#91)
3 Message::GET_OBJECT_CLASS_HANDLE (MSG#112)
6 Message::GET_ATTRIBUTE_HANDLE (MSG#114)
1 Message::GET_INTERACTION_CLASS_HANDLE (MSG#116)
120516 Message::TICK_REQUEST (MSG#141)
2564 Message::TICK_REQUEST_NEXT (MSG#142)
List of RTI initiated services
--------------------------------------------------
1 NetworkMessage::ANNOUNCE_SYNCHRONIZATION_POINT (MSG#13)
1 NetworkMessage::FEDERATION_SYNCHRONIZED (MSG#15)
1 NetworkMessage::DISCOVER_OBJECT (MSG#43)
1711 NetworkMessage::REFLECT_ATTRIBUTE_VALUES (MSG#45)
49 NetworkMessage::GET_FED_FILE (MSG#84)
Number of Federate messages : 125662
Number of RTIG messages : 1763
RTIA: Federate destroyed
TCP Socket 3 : total = 122015 Bytes sent
TCP Socket 3 : total = 340249 Bytes received
UDP Socket 4 : total = 0 Bytes sent
UDP Socket 4 : total = 0 Bytes received
Пример статистики по федерации в целом:
CERTI RTIG up and running ...
New federation: ExampleFederation
Looking for FOM file...
Trying... open_test.fed --> cannot access.
Now trying.../usr/local/share/federations/open_test.fed... opened.
TCP Socket 7 : total = 340400 Bytes sent
TCP Socket 7 : total = 122015 Bytes received
UDP Socket 4 : total = 0 Bytes sent
UDP Socket 4 : total = 0 Bytes received
TCP Socket 6 : total = 258616 Bytes sent
TCP Socket 6 : total = 283044 Bytes received
UDP Socket 4 : total = 0 Bytes sent
UDP Socket 4 : total = 0 Bytes received
```
### Синхронизация времени
Как показала практика проектирования и реализации распределенных имитационных систем, наибольшее затруднение вызывают вопросы, связанные с управлением течения времени (синхронизация времени).
Как правило, при установке способа синхронизации времени федерата задаются два параметра — TimeRegulating и TimeConstrained. Практически данные режимы влияют на процесс получения сообщений от других федератов и напрямую связаны с механизмом упорядочивания сообщений:
* по порядку получения (сообщения передаются в порядке их получения без контроля времени);
* приоритетный (поступающие сообщения располагаются в очереди с приоритетами, для определения приоритета сообщения используется его временная метка);
* каузальный (обеспечивает отправку сообщений федератам в порядке, согласованном с предшествующими и последующими событиями, представленными этими сообщениями);
* по временным меткам (при использовании этого сервиса сообщения будут переданы федератам в порядке их временных меток).
Также стоит отметить возможность использования различными федератами различных методов синхронизации.
### Программные библиотеки для реализации RTI
Список доступных реализации HLA\IEE1516 доступен на странице [en.wikipedia.org/wiki/Run-Time\_Infrastructure](http://en.wikipedia.org/wiki/Run-Time_Infrastructure). На сегодняшний день доступно достаточно большое количество реализаций, как коммерческих, так и не-коммерческих. Большинство из реализаций выполнены на языках JAVA и C++ (именно эти языки используются в стандарте), но также существуют реализации для MatLab, Питона (проект CERTI) и др.
При выборе библиотеки отдельное внимание следуют уделять «сертификации» на поддержку IEEE 1516. Как правило, все коммерческие реализации имеют «сертификат», свободные — не имеют (многие из свободных реализаций готовятся к такой сертификации).
Таблица Коммерческие реализации:
* CAE RTI CAE Inc.
* [en.wikipedia.org/wiki/CAE\_Inc](http://en.wikipedia.org/wiki/CAE_Inc).
* Chronos RTI Magnetar Games
* [www.magnetargames.com/Products/Chronos](http://www.magnetargames.com/Products/Chronos/)
* MÄK High Performance RTI MÄK Technologies
* [www.mak.com/products/rti.php](http://www.mak.com/products/rti.php)
* HLA Direct General Dynamics C4 Systems
* [en.wikipedia.org/wiki/General\_Dynamics\_C4\_Systems](http://en.wikipedia.org/wiki/General_Dynamics_C4_Systems)
* Openskies RTI Cybernet Systems
* [www.openskies.net](http://www.openskies.net/)
* Pitch pRTI Pitch Technologies
* [www.pitch.se/products/pitch-prti/pitch-prti-overview.html](http://www.pitch.se/products/pitch-prti/pitch-prti-overview.html)
* RTI NG Pro Raytheon Virtual Technology Corporation
* [www.raytheonvtc.com/products.jsp](http://www.raytheonvtc.com/products.jsp)
Таблица Не-коммерческие реализации:
* CERTI ONERA
* [savannah.nongnu.org/projects/certi](http://savannah.nongnu.org/projects/certi/)
* [en.wikipedia.org/wiki/ONERA](http://en.wikipedia.org/wiki/ONERA)
* The Portico Project littlebluefrog labs
* [porticoproject.org](http://porticoproject.org/)
* GERTICO (German RTI based on Corba) Fraunhofer IITB
* [www.iitb.fraunhofer.de/servlet/is/2920](http://www.iitb.fraunhofer.de/servlet/is/2920/)
* Rendezvous RTI National University of Science and Technology (NUST), Pakistan
* [www.mcs.edu.pk/PDC-RG.html](http://www.mcs.edu.pk/PDC-RG.html)
* Open HLA (ohla)
* [sourceforge.net/projects/ohla](http://sourceforge.net/projects/ohla)
Я лично для поддержки инфраструктуры распределенных приложений использую проект CERTI от ONERA (https://savannah.nongnu.org/projects/certi).
### Замеры скорости взаимодействия федератов через RTI
Такие тесты очень важны при проектировании распределенных имитационных систем, особенно, если различные федераты расположены в различных вычислительных сетях, и тем более важны при взаимодействии федератов через сеть Internet.
Для достижения минимальных временных задержек необходимо выбирать сервер с наименьшими временными задержками прохождения пакетов (можно проверить при помощи команды ping). В качестве примера рассмотрим работу одной из созданных в НИИ ЭОР ТюмГНГУ распределенных систем. Используется 100 мегабитная сеть (задержки ping'a < 0.231 ms), временная синхронизация отсутствует (для уменьшения задержек внутри RTI), 2 компьютера, сервер (rtig) запущен на одной из машин. Параметры федерации — 2 объекта содержит по 5 атрибутов (по одному объекту на федерат/компьютер), взаимодействие между федератами двухстороннее. В результате обработки замеров получена зависимость количества взаимодействий в секунду от размера передаваемых данных.
Результаты таких замеры позволяют сделать множество выводов, например, если имитатор должен работать в заданном «реальном времени», т.е. обновляться, например, не менее 60 раз в секунду, то за одно взаимодействие (для Fast Ethernet) должно передаваться не больше 300 килобайт (если например 5 атрибутов, то по 60 килобайт каждый). В тоже время, 300 килобайт данных, передаваемых 60 раз в секунду, также указывает на возможность использования RTI для передачи голосовых и видео данных между имитаторами, а также для взаимодействия с устройствами VR.
При взаимодействии федератов через Internet минимальные задержки в большей степени определяются задержками передачи пакетов. Например, если задержки прохождения пакета между сервером и имитатором составляют 300 мсек, то максимальное количество взаимодействий в секунду не будет превышать 3.
Применение более скоростных решений, таких как IpoIB (IP over InfiniBand, RFC 4392), 10G Ethernet, Myrinet-10G и др. позволит увеличить пропускную способность и значительно снизить задержки (существующие решения позволяют производить 30 миллионов взаимодействий в секунду и более).
### Взаимодействие с реальными системами
В качестве федератов могут выступать не только математические модели объектов, т. е. искусственные системы, но и реальные системы и устройства. Примерами могут служить:
* микрофон, предоставляющий звуковые данные;
* видеокамера, предоставляющая видео-данные;
* различные устройства ввода/вывода, например джойстики (рисунок ), принтеры и т.д.
* различные датчики и управляющие механизмы, подключенные к компьютеру через платы АЦП/ЦАП;
* реальное оборудования и SCADA-системы (рисунок 2.10.1., глава 1.4.1.) через промышленный интерфейс OPC;
* Интерфейсы к «рабочему столу» реальной операционной системы, функционирующей на отдельном компьютере или виртуальной машине (рисунок );
* устройств VR (глава 4.5.9.);
* Интерфейс к базе данных и т. д.
Такие возможности представляют значительный интерес для имитаторов и имитационных систем в целом. | https://habr.com/ru/post/509504/ | null | ru | null |
# Google Apps script: получение данных из Flurry
Всем привет
Вариантов использования Google Apps Scripts множество. Мой друг работал с иностранным заказчиком и тот просил каждый день отчет ему на почту с текстом кто и что делал. В результате он попросил сотрудников трэкать все в гугл таблицу не позднее 21:00, потом стартовал скрипт и собирал данные и слал по нужному адресу.
В статье я приведу простой и, как мне кажется, полезный пример использования Google Apps Scripts.
#### Что такое Google Apps Scripts?
Если коротко, то это сервис который позволяет на JavaScript писать скрипты, работающие в облаке Google. Сервис предоставляет широкий API, к примеру в данной статье мы создадим гугл таблицу на основе метрик приложения из Flurry.
#### В чем состоит решаемая проблема и что хотелось бы получить?
Я работаю в компании которая занимается разработкой игр под мобильные платформы для статистики мы используем данные своего сервера + данные от Flurry. Чтобы как-то все это совместить я решил использовать сервисы предоставляемые Google и в результате получить один отчет с данными и графиками.
#### Что вы получите в конце этой статьи?
Скрипт который по расписанию запрашивает метрики приложения от Flurry сервиса, парсит их и делает простую гугл таблицу(аналог Microsoft excel) c этими данными и простым графиком.
#### Основная цель
Я не ставлю цели создания эталонного отчета статистики. Я был удивлен доступностью такого функционала и решил поделиться небольшим опытом виде тестового скрипта.
#### Начнем с простых шагов
##### Что понадобится?
* gmail аккаунт
* Flurry аккаунт
##### Настройка gmail
1. Зайти на вкладку “Google drive”
2. Нажать кнопку “Create”
3. Нажать кнопку “Connect more apps”
4. Откроется окошко и в нем в строке поиска ввести “google script”
5. На приложении “Google Apps Script” нажать “+ connect”
6. На диалоговых окнах нажать Ok
7. На вкладке “Google drive” нажать кнопку “Create” и создать “Script”
8. Выберем “Blank project”
9. Откроется окно с проектом. В верхнем правом углу два раза кликните на имени проекта и переименуйте его в “Flurry statistic”, в левой панели правой кнопкой кликните на имени скрипта и переименуйте его в ”createStatisticReport”
10. В корне своего “Google Drive“ создайте папку “Statistic”
11. Теперь у нас все готово чтобы написать первый Google apps script
##### Настройка Flurry
Я подразумеваю, что у вас уже есть сконфигурированный аккаунт Flurry с данными.
Для программного доступа к данным от Flurry выполните инструкции по ссылке:
[support.flurry.com/index.php?title=API/GettingStarted](http://support.flurry.com/index.php?title=API/GettingStarted)
В итоге вы получите ключ, который нужно сохранить для использования в скрипте.
Еще понадобится “ProjectApiKey” от Flurry, который вы уже используете в мобильном приложении.
#### Пишем скрипт
Точнее уже все написано, тут я просто опишу, как это запустить.
Идем по ссылке и забираем тексты скриптов [github.com/chapayGhub/flurrymetricstospreadsheet](https://github.com/chapayGhub/flurrymetricstospreadsheet)
В проекте, который мы создали до этого, нужно создать такие же.
Теперь, после того как все сделали, откройте Settings.gs и в нем
Введите свои ключи от Flurry
```
//store Flurry credentials
FlurryCredentials = (function()
{
var obj = {};
obj.AccessCode = '?????';
obj.ApiKies = {
iPad: '????',
};
return obj;
})();
```
Тут введите свое имя электронной почты, лучше от гугл(другие я не проверял)
```
obj.emails = ["?????email1", "?????email2", "?????email3"];
```
Скрипт настроен на получение метрик приложения из Flurry + на ваш почтовый ящик придет письмо, что вы добавлены как редактор.
#### Запускаем и дебажим
В левой панели выберем скрипт «СreateStatisticReport»
В верхней панели около кнопки с жуком в выпадающем списке выбираем «makeStatisticReport»
Теперь все просто верхняя панель имеет две «супер» кнопки понятные любому программисту.
#### Запуск по расписанию
Выполните действия на картинках
#### Нюансы
##### Сделать так чтобы скрипт работал каждый раз с одним документом
Сразу запустите на выполнение не на дебаг. Должен создаться документ в папке «Statistic» и к вам на почту придут письма, в одном из которых будет идентификатор созданного документа
Присвойте его переменной расположенной в скрипте Settings.gs.
```
obj.mainStatisticDocID
```
Теперь скрипт будет обнолять именно этот документ, а не создавать каждый раз новый. Если данный параметр не введен, то при старте скрипт пытается найти документ по несуществующему идентификатору, естественно не находит его, бросает исключение(в дебаге может быть остановка в этом месте выполнения), но это исключение отлавливается и создается новый документ.
##### Логирование
Используйте следующий метод
```
Logger.log("ТЭКСТ!");
```
Чтобы просмотреть вывод выберите следующий пункт из меню
#### Нужна помощь
Браузерный редактор вещь удобная, но вот если скрипт будет более объемным то в нем не совсем удобно работать.
По этой ссылке ниже описано как можно выгружать и загружать проект.
[developers.google.com/apps-script/import-export](https://developers.google.com/apps-script/import-export)
У меня появилась идея написать скрипт который на входе получал идентификатор проекта выгружал его на локальный диск в отдельные файлы. Эти файлы затем можно было бы по человечески отрефакторить и в конце опять через этот скрипт загрузить обратно.
Вроде все и описано, но вот что-то не выстрелило у меня ).
Может уже кто-то сделал такое или есть полезные ссылки? Буду благодарен.
#### Ссылки
Заглавная из этой точки можно начинать искать ответы на вопросы по Google Apps Scripts
[developers.google.com/apps-script](https://developers.google.com/apps-script/)
Ссылка на то как работать именно с Google Sheets
[developers.google.com/apps-script/guides/sheets](https://developers.google.com/apps-script/guides/sheets)
Справка по API Google Sheets
[developers.google.com/apps-script/reference/spreadsheet](https://developers.google.com/apps-script/reference/spreadsheet/)
P.S.
Я никогда не работал с подобными сервисами и обладаю поверхностным знанием JavaScript, буду рад конструктивным замечаниям. | https://habr.com/ru/post/193376/ | null | ru | null |
# Змейка на Haskell с циклом Гамильтона
После прохождения курса по Haskell решил закрепить знания первым проектом. Писать будем змейку для терминала. Чтобы придать игре уникальности, добавим бота, который сам будет проходить игру.
Проект написан на haskell-platform, Ubuntu 20.04.
[GitHub проекта](https://github.com/letov/terminal-snake-hamilton/)
Игровой цикл
------------
Начнем с реализации игрового цикла. Змея может двигаться независимо от нажатия клавиш, следовательно нам понадобится два параллельных потока. Используем модуль Control.Concurrent. Ответвляемся от основного процесса при помощи forkIO и синхронизируем потоки через MVar. С каждой итерацией игрового цикла, tryInput будет содержать Maybe Char значение, в зависимости от ввода пользователя. Потоки при этом не блокируются и работают параллельно. Для настройки буферизации ввода воспользуемся System.IO - отключим ожидание EOL символа при вводе и уберем отображение пользовательского вывода. Интересно, что hSetBuffering stdin NoBuffering не работает для Windows консоли - getChar будет ждать EOL и запустить игру в форточках в текущем виде не получится. Также подключим System.Console.ANSI для очистки экрана и перемещения курсора терминала.
#### UPDATE
Можно было не форкать процесс и обойтись hReady, спасибо [@GospodinKolhoznik](/users/gospodinkolhoznik)
```
import Control.Concurrent
import System.Console.ANSI
import System.IO
gameLoop :: ThreadId -> MVar Char -> IO ()
gameLoop inputThId input = do
tryInput <- tryTakeMVar input
gameLoop inputThId input
inputLoop :: MVar Char -> IO ()
inputLoop input = (putMVar input =<< getChar) >> inputLoop input
main = do
hSetBuffering stdin NoBuffering
hSetEcho stdin False
clearScreen
input <- newEmptyMVar
inputThId <- forkIO $ inputLoop input
gameLoop inputThId input
```
Мир для змеи
------------
Определим типы данных. У игры будет 4 состояния: Process - змеей управляет игрок, Bot - змеей рулит игра, GameOver и Quit. Мир игры определен типом data World, он будет каким-то образом меняться в игровом цикле gameLoop. Сейчас он содержит змею, направление ее движения, координату фрукта и текущее игровое состояние. Далее по мере разработки будет добавлять в него новые поля. Начальная точка (0,0) будет верхним левым краем консоли. Змея двигается параллельно осям, следовательно у нас 4 возможных направления движения.
```
data StepDirection = DirUp
| DirDown
| DirLeft
| DirRight deriving (Eq)
type Point = (Int, Int)
type Snake = [Point]
data WorldState = Process
| GameOver
| Quit
| Bot deriving (Eq)
data World = World { snake :: Snake
, direction :: StepDirection
, fruit :: Point
, worldState :: WorldState
}
gameLoop :: ThreadId -> MVar Char -> World -> IO ()
{-- … --}
```
Таймер
------
Для анимации движения змеи нам потребуются функции работы со временем. Воспользуемся модулем Data.Time.Clock. Добавим в наш мир 3 поля: lastUpdateTime - время последнего обновления мира, updateDelay - сколько ждем до следующего обновления и isUpdateIteration - флаг необходимости обновить мир в текущей итерации. Укажем начальные значения мира и напишем для него первый обработчик timerController. Он принимает текущее время и устанавливает флаг isUpdateIteration, если пришло время обновляться.
```
import Data.Time.Clock
data World = World {
{-- … --}
, lastUpdateTime :: UTCTime
, updateDelay :: NominalDiffTime
, isUpdateIteration :: Bool
}
initWorld :: UTCTime -> World
initWorld timePoint = World { snake = [(10, y) | y <- [3..10]]
, direction = DirRight
, fruit = (3, 2)
, lastUpdateTime = timePoint
, updateDelay = 0.3
, isUpdateIteration = True
, worldState = Process
}
timerController :: UTCTime -> World -> World
timerController timePoint world
| isUpdateTime timePoint world = world { lastUpdateTime = timePoint
, isUpdateIteration = True
}
| otherwise = world where
isUpdateTime timePoint world =
diffUTCTime timePoint (lastUpdateTime world) >= updateDelay world
gameLoop inputThId input oldWorld = do
{-- … --}
timePoint <- getCurrentTime
let newWorld = timerController timePoint oldWorld
gameLoop inputThId input newWorld { isUpdateIteration = False }
main = do
{-- … --}
timePoint <- getCurrentTime
gameLoop inputThId input (initWorld timePoint)
```
Контроллер ввода
----------------
Далее добавим обработчик ввода inputController. Клавиши WSAD меняют направление нашей змеи. Стоит обратить внимание, что змея не может двигаться назад, за исключением случая, когда она состоит из 1 сегмента. Поэтому если новое направление ведет ко второму от головы сегменту змеи, мы игнорируем такой ввод. Также если текущее направление совпадает с предыдущим, то есть пользователь зажал клавишу управления, ускорим движение змеи уменьшив updateDelay. Функция pointStep принимает направление и точку, возвращая новую точку, перемещенную на один шаг в заданном направлении.
```
pointStep :: StepDirection -> Point -> Point
pointStep direction (x, y) = case direction of
DirUp -> (x, y - 1)
DirDown -> (x, y + 1)
DirLeft -> (x - 1, y)
DirRight -> (x + 1, y)
inputController :: Maybe Char -> World -> World
inputController command world = let
boost dir1 dir2 = if dir1 == dir2 then 0.05 else 0.3
filterSecondSegmentDir (x:[]) dirOld dirNew = dirNew
filterSecondSegmentDir (x:xs) dirOld dirNew | pointStep dirNew x == head xs = dirOld
| otherwise = dirNew in
case command of
Just 'w' -> world { direction = filterSecondSegmentDir (snake world) (direction world) DirUp
, updateDelay = boost (direction world) DirUp
, worldState = Process
}
Just 's' -> world { direction = filterSecondSegmentDir (snake world) (direction world) DirDown
, updateDelay = boost (direction world) DirDown
, worldState = Process
}
Just 'a' -> world { direction = filterSecondSegmentDir (snake world) (direction world) DirLeft
, updateDelay = boost (direction world) DirLeft
, worldState = Process
}
Just 'd' -> world { direction = filterSecondSegmentDir (snake world) (direction world) DirRight
, updateDelay = boost (direction world) DirRight
, worldState = Process
}
Just 'q' -> world { worldState = Quit }
Just 'h' -> world { worldState = Bot }
_ -> world { updateDelay = 0.3 }
```
Двигаем змею
------------
Следующий контроллер moveController сдвинет нашу змею, если пришло время isUpdateIteration для обновления мира.
```
snakeStep :: StepDirection -> Snake -> Snake
snakeStep direction snake = (pointStep direction $ head snake):(init snake)
moveController :: World -> World
moveController world
| not $ isUpdateIteration world = world
| otherwise = world { snake = snakeStep (direction world) (snake world) }
```
Столкновения с препятствиями
----------------------------
#### Границы поля
Последний контроллер будет обрабатывать столкновения змеи с препятствиями. В текущий момент ими могут быть только сама змея и фрукт, поэтому добавим стены. Они статичны, поэтому не будет добавлять их в мир и объявим отдельно. Первый элемент пары (1,1) — верхняя левая точка стены и (20,20) — нижняя правая.
```
initWalls :: Walls
initWalls = ((1,1),(20,20))
```
#### ГСЧ
Фрукт появляется на поле в случайном месте, следовательно нам нужен ГСЧ. В Haskell он реализован в модуле System.Random, функция randomR. Так как мы работаем с чистыми функциями, которые возвращают при одинаковых аргументах одинаковый результат, вторым аргументом randomR служит генератор, который обновляется с каждым вызовом. Добавим его как поле нашего мира и зададим ему начальное значение. Когда змея ест фрукт, она растет в хвосте. Сохраним координату крайней точки хвоста при обновлении мира.
```
import System.Random
data World = World {
{-- … --}
, oldLast :: Point
, rand :: StdGen
}
initWorld timePoint = World {
{-- … --}
, oldLast = (0, 0)
, rand = mkStdGen 0
}
{-- … --}
timerController timePoint world
| isUpdateTime timePoint world = world {
{-- … --}
, oldLast = last $ snake world
}
{-- … --}
```
#### Контроллер столкновений
Добавим функции проверки столкновений змеи с телом и головы со стеной.
```
collisionSnake :: Snake -> Bool
collisionSnake (x:xs) = any (== x) xs
collisionWall :: Point -> Walls -> Bool
collisionWall (sx,sy) ((wx1,wy1),(wx2,wy2)) =
sx <= wx1 || sx >= wx2 || sy <= wy1 || sy >= wy2
```
Все готово для контроллера столкновений collisionController. Переводим состояние мира в GameOver при столкновении с препятствиями и увеличим длину змеи в хвосте при съедании фрукта, также сгенерив новый в пределах стен. Если координата нового фрукта является координатой тела змеи, пробуем новую координату. Также, если длина змеи стала на 1 меньше емкости поля, выходим в GameOver с победой.
```
collisionController :: World -> World
collisionController world
| not $ isUpdateIteration world = world
| collisionSnake $ snake world = world { worldState = GameOver }
| collisionWall (head $ snake world) initWalls = world { worldState = GameOver }
| checkWin (snake world) initWalls = world { worldState = GameOver }
| collisionFruit (snake world) (fruit world) = world { snake =
(snake world) ++ [oldLast world]
, fruit = newFruit
, rand = newRand
}
| otherwise = world where
checkWin snake ((x1, y1),(x2, y2)) = (x2 - x1 - 1) * (y2 - y1 - 1) - length snake == 1
collisionFruit snake fruit = fruit == head snake
(newFruit, newRand) = freeRandomPoint world (rand world)
randomPoint ((minX, minY), (maxX, maxY)) g = let
(x, g1) = randomR (minX + 1, maxX - 1) g
(y, g2) = randomR (minY + 1, maxY - 1) g1 in
((x, y), g2)
freeRandomPoint world g | not $ elem point ((fruit world):(snake world)) =
(point, g1)
| otherwise = freeRandomPoint world g1 where
(point, g1) = randomPoint initWalls g
```
Графика
-------
Перейдем к отображению мира. Базовая функция нашей графики drawPoint принимает символ и отображает его в заданной координате экрана. Функция renderWorld отображает наш мир. Без установленного флага isUpdateIteration, контроллеры moveController, collisionController и renderWorld не производят никаких изменений. Рендер отображает наш фрукт, новое положение змеи и затирает ее хвост. Стены отображаются один раз при старте и не обновляются.
```
renderWorld :: World -> IO ()
renderWorld world
| not $ isUpdateIteration world = return ()
| otherwise = do
drawPoint '@' (fruit world)
drawPoint ' ' (oldLast world)
mapM_ (drawPoint 'O') (snake world)
setCursorPosition 0 0
drawPoint :: Char -> Point -> IO ()
drawPoint char (x, y) = setCursorPosition y x >> putChar char
drawWalls :: Char -> Walls -> IO ()
drawWalls char ((x1, y1),(x2, y2)) = do
mapM_ (drawPoint char) [(x1, y)| y <- [y1..y2]]
mapM_ (drawPoint char) [(x, y1)| x <- [x1..x2]]
mapM_ (drawPoint char) [(x2, y)| y <- [y1..y2]]
mapM_ (drawPoint char) [(x, y2)| x <- [x1..x2]]
main = do
{-- … --}
drawWalls '#' initWalls
{-- … --}
```
Подключаем все контроллеры и добавляем рендер в игровом цикле.
```
gameLoop inputThId input oldWorld = do
{-- … --}
let newWorld = collisionController . moveController $ timerController timePoint (inputController tryInput oldWorld)
renderWorld newWorld
{-- … --}
```
На текущем этапе у нас есть рабочая змейка с контролем от пользователя. Добавим возможность игре проходить себя самостоятельно. Задачу идеального прохождения змейки очень подробно в своих видео разобрал австралийский кодер CodeBullet. Также об этом можно почитать у [@RussianDragon](/users/russiandragon) [тут](https://habr.com/ru/post/544696/). Позаимствуем идею с циклом Гамильтона и приступим.
Цикл Гамильтона
---------------
Немного теории: цикл Гамильтона в контексте нашей игры - замкнутый путь, проходящий через каждую точку поля ровно один раз. Мы сможем его найти сделав проход по часовой стрелке. Добавим пару синонимов типов: Path - путь по игровому полю, ClosedPath - замкнутый путь или цикл Гамильтона для нашего поля.
```
type Path = [Point]
type ClosedPath = [Point]
```
Напишем несколько вспомогательных функций, wallsFirstPoint вернет нулевую точку игрового поля внутри стен. С нее мы начнем составление цикла Гамильтона и соответственно в нее мы должны вернуться. isPathContain аналогично проверки столкновения змеи с телом, проверяет содержит ли путь точку. clockwise вернет список возможных направлений по часовой стрелке. distBetweenPoints - расстояние между двумя точками, учитывая что змея не может двигаться по диагонали.
```
clockwise = [DirUp, DirRight, DirDown, DirLeft]
wallsFirstPoint :: Point
wallsFirstPoint = ((fst $ fst initWalls) + 1, (snd $ fst initWalls) + 1)
isPathContain :: Path -> Point -> Bool
isPathContain path point = any (== point) path
distBetweenPoints :: Point -> Point -> Int
distBetweenPoints (x1, y1) (x2, y2) = abs (x1 - x2) + abs (y1 - y2)
```
И сама функция поиска цикла Гамильтона getHamPath. Она принимает начальную точку цикла, второй аргумент является аккумулятором рекурсии, при вызове указываем пустой список. Функция проверяет, равна ли площадь нашего поля длине найденного пути Гамильтона и равно ли расстояние между первой и последней точкой пути единице, то есть пусть замкнулся и является циклом. Если нет, ищем следующую точку при помощи nextHamPathPoint. Даем ей текущий найденный путь и 4 возможных направления движения. Если точка не имеет коллизий со стеной и найденным путем, выбираем ее и включаем в путь. Вариант, что nextHamPathPoint не нашел ни одной точки крашит программу, так как цикл Гамильтона гарантированно должен быть найден. В нашем случае это может произойти только при условии, что у поля обе стороны четные и у пути нет возможности вернуться к начальной точке.
```
getHamPath :: Point -> ClosedPath -> ClosedPath
getHamPath currentPoint hamPath | hamPathCapacity initWalls == length (currentPoint:hamPath)
&& distBetweenPoints currentPoint (last hamPath) == 1
= currentPoint:hamPath
| otherwise = getHamPath newPoint (currentPoint:hamPath) where
newPoint = nextHamPathPoint (currentPoint:hamPath) clockwise
hamPathCapacity ((x1, y1),(x2, y2)) = (x2 - x1 - 1) * (y2 - y1 - 1)
nextHamPathPoint :: Path -> [StepDirection] -> Point
nextHamPathPoint _ [] = error "incorrect initWalls"
nextHamPathPoint hamPath (dir:dirs) | isPathContain hamPath virtualPoint
|| collisionWall virtualPoint initWalls =
nextHamPathPoint hamPath dirs
| otherwise = virtualPoint where
virtualPoint = pointStep dir (head hamPath)
```
Добавим найденный цикл Гамильтона в наш мир.
```
data World = World {
{-- … --}
, hamPath :: ClosedPath
}
initWorld timePoint = World {
{-- … --}
, hamPath = getHamPath wallsFirstPoint []
}
```
Внутри замкнутого пути наша змея может двигаться в 2х направлениях. Несмотря на то, что путь зациклен, он представляет из себя список с головой и хвостом. Будем считать движение от головы к хвосту DirFromHead и DirFromTail в обратном направлении.
```
data PathDirection = DirFromHead | DirFromTail deriving (Eq)
```
Добавим к контроллеру движения змеи управление ботом при помощи функции nextDirOnPath, которую опишем позже. Она возвращает пару (botStepDir, botPathDir) первый элемент дает нам предложенное ботом направление змеи на поле. Второй указывает на движение внутри цикла Гамильтона. Если вернулось DirFromHead, то есть обратное текущему, переворачиваем цикл.
```
moveController world
{-- … --}
| worldState world == Process = world {snake = snakeStep (direction world) (snake world)}
| otherwise = world { snake = snakeStep botStepDir (snake world)
, hamPath = if botPathDir == DirFromTail then hamPath world else reverse $ hamPath world
} where
(botStepDir, botPathDir) = nextDirOnPath (snake world) (hamPath world)
nextDirOnPath :: Snake -> ClosedPath -> (StepDirection, PathDirection)
nextDirOnPath = undefined
```
Добавим пару вспомогательных функций: dirBetweenPoints вернет нам направление между двумя точками по меньшему расстоянию по оси и pointNeighborsOnPath вернет пару соседей точки внутри замкнутого пути.
```
dirBetweenPoints :: Point -> Point -> StepDirection
dirBetweenPoints (x1, y1) (x2, y2) | x1 == x2 = if y1 > y2 then DirUp else DirDown
| y1 == y2 = if x1 > x2 then DirLeft else DirRight
| otherwise = if abs (x1 - x2) < abs (y1 - y2) then
dirBetweenPoints (x1, 0) (x2, 0) else
dirBetweenPoints (0, y1) (0, y2)
pointNeighborsOnPath :: Point -> ClosedPath -> (Point, Point)
pointNeighborsOnPath point path | not $ isPathContain path point || length path < 4 = error "incorrect initWalls"
| point == head path = (last path, head $ tail path)
| point == last path = (last $ init path, head path)
| otherwise = _pointNeighborsOnPath point path where
_pointNeighborsOnPath point (a:b:c:xs) = if point == b then (a,c) else _pointNeighborsOnPath point (b:c:xs)
```
Найдем на нашем замкнутом пути соседние точки для головы змеи, определим ту, которая является частью змеи и вернем направление к противоположному соседу.
```
nextDirOnPath :: Snake -> ClosedPath -> (StepDirection, PathDirection)
nextDirOnPath (snakeHead:snakeTail) path | snakeTail == [] = (dirBetweenPoints snakeHead point1, DirFromTail)
| point1 == head snakeTail = (dirBetweenPoints snakeHead point2, DirFromHead)
| otherwise = (dirBetweenPoints snakeHead point1, DirFromTail) where
(point1, point2) = pointNeighborsOnPath snakeHead path
```
Сейчас у нас есть бот, который проходит змейку по найденному пути, не сокращая его.
Ускоряем бота
-------------
Попробуем ускорить бота, добавив еще пару функций: collisionSnakeOnPath проверит, свободен ли замкнутый путь начиная с точки в заданном направлении от тела змеи и distBetweenPointsOnPath которая вернет пару расстояний от точки до точки на замкнутом пути. Первый элемент будет расстоянием для DirFromTail направления, второй для DirFromHead.
```
collisionSnakeOnPath :: Snake -> Point -> ClosedPath -> PathDirection -> Bool
collisionSnakeOnPath snake point path pathDir | null $ common snake pathPart = False
| otherwise = True where
pathPart = takePathPart point (if pathDir == DirFromHead then path else reverse path) (length snake)
common xs ys = [ x | x <- xs , y <- ys, x == y]
takePathPart point path len = _takePathPart point (path ++ (take len path)) len where
_takePathPart _ [] _ = []
_takePathPart point (x:xs) len | x == point = x:(take (len - 1) xs)
| otherwise = _takePathPart point xs len
distBetweenPointsOnPath :: Point -> Point -> ClosedPath -> (Int, Int)
distBetweenPointsOnPath point1 point2 path | point1 == point2 = (0, 0)
| id1 < id2 = (length path - id2 + id1,id2 - id1)
| otherwise = (id1 - id2, length path - id1 + id2) where
(id1,id2) = pointIndexOnPath (point1,point2) path 0 (0,0)
pointIndexOnPath _ [] _ ids = ids
pointIndexOnPath (point1,point2) (x:xs) acc (id1,id2) | x == point1 = pointIndexOnPath (point1,point2) xs (acc+1) (acc,id2)
| x == point2 = pointIndexOnPath (point1,point2) xs (acc+1) (id1,acc)
| otherwise = pointIndexOnPath (point1,point2) xs (acc+1) (id1,id2)
```
Сведем все в новую функцию управления змеей. Находим точку для сокращения цикла Гамильтона enterPointBypass в направлении фрукта, ищем самый короткий путь до фрукта в прямом и обратном направлении и проверяем ляжет ли туда змея. Если ничего не нашли, двигаемся дальше по циклу через nextDirOnPath.
```
nextDirBot :: Snake -> Point -> ClosedPath -> (StepDirection, PathDirection)
nextDirBot snake fruit path | distBypass1 < distBypass2 && distBypass1 < distToFruit1
&& not (collisionSnakeOnPath snake enterPointBypass path DirFromTail)
= (dirBetweenPoints (head snake) enterPointBypass, DirFromTail)
| distBypass2 < distToFruit1
&& not (collisionSnakeOnPath snake enterPointBypass path DirFromHead)
= (dirBetweenPoints (head snake) enterPointBypass, DirFromHead)
| otherwise = nextDirOnPath snake path where
dirBypass = dirBetweenPoints (head snake) fruit
enterPointBypass = pointStep dirBypass (head snake)
(distBypass1, distBypass2) = distBetweenPointsOnPath enterPointBypass fruit path
(distToFruit1, _) = distBetweenPointsOnPath (head snake) fruit path
```
Предложенный алгоритм сокращения пути не является оптимальным и имеет как минимум 2 явных проблемы. Мы рассматриваем точку входа для сокращения пути enterPointBypass только по направлению к фрукту, следовательно если цикл полностью заблокировал видимость фрукта, змея пойдет по полному пути. Также, если змея и фрукт расположены на достаточно большом расстоянии, как на картинке, бот выберет зеленое направление вместо белого, так как длину пути до фрукта мы сравниваем не по фактическому расстоянию на поле, а по длине цикла.
 Подключим наш nextDirBot к контроллеру движения змеей, добавим меню и смотрим на результат.
 | https://habr.com/ru/post/551504/ | null | ru | null |
# Введение в Spring, или что делать, если по всему проекту @Autowired и @Component, а вы не понимаете, что это
Приветствую тебя, Хабр!
Эта статья будет полезна тем, кто уже начал изучать Java и даже успел добиться некоторых успехов в понимании Java Core, и вот услышал слово Spring. И, возможно, даже не один раз: знание Spring Framework, как минимум, фигурирует в описаниях множества вакансий для джавистов. Эта статья поможет вам взобраться на самую первую ступеньку: понять общую идею столь популярного фреймворка.
Начнем издалека. Существует такое понятие как Inversion of Control, по-русски – Инверсия управления, сокращенно – IoC. IoC — один из принципов, приближающий наш код к слабосвязанности. IoC — это делегирование части наших обязанностей внешнему компоненту.
Существуют разные реализации IoC подхода, нас интересует одна из них — Dependency Injection, внедрение зависимостей. Что это такое, название говорит само за себя, так что раскрыть ее я постараюсь на примере. Мы пишем приложение, автоматизирующее работу сети магазинов. Есть классы Shop (магазин) и Seller (продавец). У класса Seller имеется поле типа Shop — магазин, в котором работает продавец. Вот мы и столкнулись с зависимостью: Seller зависит от Shop. Теперь задумаемся, как в объект Seller попадет объект Shop? Есть варианты:
* Внедрить его через конструктор и сразу, при создании продавца, указывать магазин, в котором он работает:
```
public class Seller {
private Shop shop;
public Seller(Shop shop) {
this.shop = shop;
}
}
```
* Создать сеттер и с помощью его вызова устанавливать продавцу магазин:
```
public class Seller {
private Shop shop;
public void setShop(Shop shop) {
this.shop = shop;
}
}
```
Перечисленные два способа — это реализация Dependency Injection (но пока еще это не IoC). И, наконец, мы подобрались к спрингу: он предоставляет еще один способ внедрять зависимости (а тут уже IoC).
Вообще говоря, Spring — это очень широкий набор библиотек на многие случаи жизни. Существует и Spring MVC для быстрого создания веб-приложений, и Spring Security для реализации авторизации в приложении, и Spring Data для работы с базами данных и еще куча всего. Но отдельно стоит Spring IoC — это базовый вид спринга, который реализует изучаемую нами тему — внедрение зависимостей. Spring IoC заслуживает внимания в самом начале изучения библиотек спринга по еще одной причине. Как вы увидите в процессе практической работы с другими видами спринга, для всех остальных спрингов Spring IoC используется как каркас.
Знакомство со Spring IoC начнем с главного термина: бин (англ. — bean). Самыми простыми словами,
> Бин — создаваемый Spring-ом объект класса, который можно внедрить в качестве значения поля в другой объект.
Хотите словами посложнее? А пожалуйста:
> Бин — объект класса, представляющий собой завершенный программный элемент с определенной бизнес-функцией либо внутренней функцией Spring'а, жизненным циклом которого управляет контейнер бинов.
>
>
Как вы уже поняли, для того, чтобы в Seller можно было внедрить Shop, Shop должен стать бином. Существует несколько способов рассказать приложению, какие объекты имеют гордое право называться бинами, все они приводят нас к понятию ApplicationContext. **ApplicationContext** — это сердце спринга. Как правило, он создается в самом начале работы приложения («поднимается») и управляет жизненным циклом бинов. Поэтому его еще называют контейнером бинов.
Подбираемся к главному. Каким образом нам необходимо переписать наши классы, чтобы Spring IoC и его слуга ApplicationContext подставили значение поля Shop объекту Seller? Вот таким:
```
@Component
public class Shop {
}
```
```
@Component
public class Seller {
@Autowired
private Shop shop;
}
```
Просто? Куда уж проще! Элегантно? Вполне. Здесь произошло следующее: аннотация Component сказала спрингу, что класс, который ей аннотируем, это бин. Аннотация Autowired попросила Spring в поле, которое она аннотирует, подставить значение. Эта операция называется «инжектнуть» (inject). Какое именно значение будет подставлено? Об этом чуть позже, сначала разберемся, как вообще классы становятся бинами.
Мы уже знаем, что в начале работы приложения должен подняться хранитель всех бинов ApplicationContext. Он-то и создает сразу все бины. Почти все. Дело в том, что по умолчанию любой бин имеет внутриспринговое свойство scope в значении singleton. Внутриспринговое, так как синглтоном в прямом смысле слова он не является. Он является синглтоном для спринга: при поднятии контекста Spring создаст ровно один объект-бин из указанного класса. Если вы хотите изменить такое поведение — пожалуйста, Spring разрешает управлять временем создания бина и их количеством для одного класса, но сейчас не об этом.
Итак, при поднятии ApplicationContext создаются все бины. Давайте выясним, а собственно где живет контекст и самое главное: как он определяет, из каких классов необходимо создавать бины. Вариантов несколько, для простоты изложения мы поговорим про один из них: конфигурирование с помощью файла xml. Вот его пример:
```
```
В этом файле продемонстрирован запуск создания бинов двумя путями. Первый, скажем так, ручной. Видите, здесь есть тег *bean* с указанием класса. Это и есть бин. Из всего, что прописано в этом файле с тегом *bean*, будут созданы бины.
Второй путь менее многословен. Помните, над классами мы поставили аннотацию Component. Из всех классов, аннотированных этой аннотацией, будут созданы бины. Благодаря этой строке из xml-файла:
Она говорит спрингу: просканируй весь пакет main и из всего, над чем будет стоять аннотация Component (или другие аннотации, являющиеся наследниками Component), создай бины. Компактно, не правда ли? Просто говорим, в каких пакетах содержатся классы, из которых нужно создавать бины, и аннотируем эти классы.
Поднять контекст с использованием xml-файла можно следующей строчкой кода:
```
ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
```
где beans.xml — путь к xml-нику, о котором шла речь выше.
С созданием бинов разобрались. Каким же образом Spring заполнит поле Shop при создании Seller’а? При поднятии контекста создается бин-объект класса Shop. Также создается бин-объект класса Seller, он же тоже аннотирован Component. У него есть поле типа Shop, аннотированное Autowired. Аннотация Autowired говорит спрингу: в это поле нужно инжектнуть бин. В нашем случае у нас есть всего один бин, подходящий на эту роль, то есть тип которого совпадает с типом поля: это бин — экземпляр класса Shop. Он и будет проинжектен в объект Seller, что и требовалось. Я понимаю, сейчас вопросики полезли как червячки: а что будет, если Spring не найдет нужный бин, или найдет несколько подходящих (особенно учитывая, что инжектить можно также по интерфейсу, а не по классу). Spring умен, но требует того же и от нас. Нам нужно либо иметь в системе ровно один бин, подходящий под каждый Autowired, либо обучать Spring действиям при таких конфликтах (об этом мы сейчас не будем, вы и так устали, крепитесь, статья подходит к концу).
Заметьте, что Seller – это тоже бин. Если бы он был не бином, а создавался через new, то автоматически бы ничего в него не проинжектнулось.
Возможно вы сейчас думаете, зачем все эти сложности. Но представьте, что у нас приложение не из 2 классов, а на несколько порядков больше и управление зависимостями уже становится не самой тривиальной задачей.
Возможно вы сейчас думаете, как красиво, просто и лаконично Spring позволяет внедрять зависимости. Но представьте, что что-то пошло не так и вам необходимо дебажить приложение. И все становится уже не так просто…
Парочка хинтов напоследок:
* Если вы реализовали проект и сейчас в недоумении, как же получить бин у спринга, чтобы посмотреть на него, сделайте вот так:
```
ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
Seller seller = (Seller) context.getBean(Seller.class);
```
Это легальный способ получить бин, хотя в современных реалиях так обычно не делают. Но для учебного примера можно.
* Поскольку Spring — это фреймворк, необходимо подключить его в свой проект. Я создаю приложение с помощью maven и добавляю в файл pom.xml зависимости spring-core и spring-context.
Spring IoC содержит в себе огромные возможности по созданию, настройке и инжекту бинов. Мы рассмотрели крохотную часть верхушки айсберга, один из способов работы со спрингом, но я надеюсь, что нам удалось окинуть его острым взором и получить общее представление о происходящем.
**UPD (20.04.2021).** Dependency Injection это не всегда IoC! В самом начале я как раз привожу примеры Dependency Injection, не являющиеся IoC. | https://habr.com/ru/post/455794/ | null | ru | null |
# Самые элитные IP-адреса
*N.B. Просьба не воспринимать написанное серьёзно.*
Есть в России любовь к «блатным номерам». Про госномера для автомобилей все знают. Золотые телефонные номера — торгуются во всю, и даже официально. Вот, некоторое время назад всплыла [новость](http://top.rbc.ru/politics/17/03/2015/55085b0f9a79479d844ad14d) даже про «красивый номер» паспорта с пятью нулями.
А как же IP-адреса?
*На иллюстрации кипрский Пиццехат хвастается блатным (увы, телефоном) 77.77.77.77. Хотя урл `77.77.77.77` выглядел бы куда как интереснее*.
Ну, допустим, нолик себе в конце IP кое-кто с небольшими усилиями может получить. Всего-то надо сетку больше /24 использовать.
А два нолика? /15 звучит уже серьёзно.
Но настоящие мажоры — это владельцы адресов с тремя нулями. И нет, я не говорю про гордых обладателей 10.0.0.0 и root-администраторов localhost, я про настоящие элитные белые IP. В первом приближении может показаться, что их всего 256, но с учётом всяких мультикастов, серых и экспериментальных сегментов, локалхостов и т.д., их совсем мало. Если верить IANA ([тут](http://www.iana.org/assignments/ipv4-address-space/ipv4-address-space.xhtml)), то у нас всего-навсего 221 /8 сетей. То есть всего может быть 221 блатных IPv4-адресов.
Вооружившись nmap'ом, nping'ом, whois'ом и прочими инструментами, изучаем, кто же эти счастливые люди, способные отвечать на адреса вида X.0.0.0?
Технологическая врезка
======================
На самом деле в современном интернете вполне можно получить себе .0 (и прочие .0.0, .0.0.0), даже если используется маленькая сеть — её достаточно порезать /32 и маршрутизировать через другие адреса. Всякого рода пулы NAT-адресов, unnumbered маршруты и прочие «нетрадиционные интернеты» в районе ISP'шного доступа для домашних пользователей позволяют вытворять всякие ~~ужасы~~ необычности.
Например, если у нас есть в хозяйстве сети 31.153.91.0/29, и 31.153.91.248/29 (вполне возможно получить такое на хостинге средней руки, .0 — по чистой случайности, а .248 — вполне распространённый адрес для /29), то мы можем (имея доступ к маршрутизации) сделать так:
`(на маршрутизаторе)
ip route 31.153.91.0/29 via 31.153.91.250`
И на хосте, мы просто вешаем адрес алиасом на наш основной интерфейс:
`ip address add 31.153.91.0/32 dev eth0`
После этого у нас адрес начинает отвечать на запросы. Почему? Потому что ip использует hop-by-hop маршрутизацию. Смотрим:
* маршрутизатор знает, что делать с пакетом на 31.153.91.0? Знает. Слать на 31.153.91.250, который, допустим, directly connected (то есть у маршрутизатора в этой сети есть свой адрес, например, 31.153.91.249/29).
* Наш сервер знает что делать? Конечно, у него этот адрес на интерфейсе прописан. Получаем ip-пакет с таким dst, обрабатываем. Если ещё остались сомнения относительно MAC'ов: при маршрутизации в mac-dst подставляется MAC-адрес маршрутизатора (а ip-dst не меняется), а в случае directly connected в mac-dst подставляется mac-адрес узла-получателя. То есть с точки зрения получателя он даже узнать не может, «маршрутизируют» на него трафик, или присылают как конечному узлу.
* После того, как ответ сформирован, адрес 31.153.91.0 попадает в ip-src. В ip-dst попадает адрес отправителя (кто-то из интернета).
* Пакет «в интернет» уходит через шлюз по умолчанию (default gateway). Который (мы предполагаем примитивную инсталляцию) выделен в сети 31.153.91.248/29, то есть, например, 31.153.91.249. Что у нас при этом «другой» ip-src никого не волнует — у нас dst-based hop-by-hop маршрутизация, то есть при маршрутизации смотрят только на dst.
* Маршрутизатор получает пакет «в интернеты» и обрабатывает его «как обычно»
Возвращаясь к позолоченным IP
=============================
Если .0 может перепасть кому-то случайно (в конце-концов, у нас больше 8 миллионов таких штук (129\*255\*255)), то с людей с двумя нулями в IP-адресе может быть существенно меньше — около 32 тысяч. Как уже было сказано раньше, с тремя нулями может быть всего 129 человек на всю планету (для сравнения — всего есть 71 яйцо Фаберже, а Пабло Пикассо создал около 20000 произведений). Другими словами, солидные IP для солидных людей. Если при этом учесть, что выдача x.0.0.0 для человечества и инфраструктуры значительно сложнее, чем штамповка номера вида `oOOOoo|78`, то количество реально доступных .0.0.0 значительно меньше. Почему? Потому что в классической маршрутизации, «все нули» в адресе хоста означают «номер сети» и узлам не назначаются. Любой провайдер с «классической маршрутизацией», получив себе X.0.0.0/21 с большой вероятностью потеряет этот адрес (даже если порежет сеть на подсети — получившийся X.0.0.0/29 будет всё равно иметь X.0.0.0 как номер сети).
Так сколько же у нас Реально Солидных Людей с Конкретно Солидными IP адресами? Так сказать элита элит, высшие сливки общества, люди, которые могут себе Позволить Скромное Обаяние Эксклюзивных IP-адресов?
(после нескольких минут с nmap'ом)
Собственно, у нас есть всего три представителя Элиты Элит, самых серьёзных и респектабельных узлов Интернета:
Назовём их по именам:
* [84.0.0.0](http://84.0.0.0/) — админка WD My Cloud Ex (Magyar Telecom, Венгрия, DSL-пул, если верить PTR'у).
* [117.0.0.0](http://117.0.0.0) — что-то странное, прикрытое http-auth, «TD-8840T». Вьетнамский телекомOnline Technologies LTD.
* [151.0.0.0](http://151.0.0.0) — странный http, возвращающий пустой ответ. Украинский телеком «Online Technologies LTD», Донбасс.
Видно, что все три — из явных ISP-диапазонов и потрачены на ~~домашних хомячков~~ ничего не подозревающих о собственной элитности пользователей домашнего интернета.
Ещё четыре узла отвечают на пинги, и ничего более.
* 75.0.0.0
* 92.0.0.0
* 109.0.0.0
* 112.0.0.0
Таким образом, можно констатировать, что самые блатные адреса тратятся совершенно бездарно. Среди остальных (серебрянные, вида X.Y.0.0, которых ожидается порядка 32 тысяч) на пинги ответили аж **2204** узла. Уже неплохо, да?
> Редакторская врезка: за время редактирования и форматирования статьи всё поменялось. Теперь у нас 19 IP-адресов, которые отвечают на пинги, и из них http(s) был только на: [117.0.0.0](http://117.0.0.0/), а хоть какая-то разумная сетевая активность (tcp) оказалась только только на ещё одном узле: 61.0.0.0
>
>
Замечание
=========
Казуальный пользователь может заметить, что красивым может быть не только адрес с нулями. 8.8.8.8 (один из двух публичных dns-серверов google'а) — чем не «красивый» адрес?
Но настоящий-то гик знает, что из-за особенности устройства маршрутизации в IP-сетях, именно многонулевые адреса самые сложно организуемые и добываемые. Остальные (ну, кроме «XXX.255.255.255», из которых, кстати, отвечает всего 10 шт) слишком тривиальны и могут заинтересовать только неискушенного пользователя. | https://habr.com/ru/post/253343/ | null | ru | null |
# FreeBSD Netgraph, считаем трафик
В продолжении темы о ядерной подсистеме графов Netgraph [FreeBSD Netgraph на примере Ethernet тоннеля](http://habrahabr.ru/blogs/bsdelniki/86553/) попробуем посчитать трафик используя протокол Сisco netflow.
В прошлом обзоре мы познакомились с модулями ng\_bridge, ng\_ether и ng\_ksocket и построили на их базе Ethernet тоннель через интернет, а сегодня я расскажу как, используя дополнительные модули netgraph, посчитать трафик, проходящий по этому тоннелю.
Для учета трафика будем использовать модуль ng\_netflow.
Википедия рассказывает
*Netflow — протокол, разработанный компанией Cisco и предназначенный для сбора информации об IP-трафике внутри сети.
Маршрутизаторы Cisco генерируют поток netflow, который передаётся на специальный узел, известный как netflow collector.*
Наш ng\_netflow прикинется маршрутизатором cisco и будет отдавать самый настоящий cisco netflow на коллектор. Коллектор собирает информацию, группирует трафик по потокам, IP адресам, рисует графики и т.п. Зависит от реализации. Я использовал триальный netflow analyzer 7.5.
### Опять про кубики
Нам потребуются:
**ng\_netflow** — Модуль ядерной подсистемы netgraph, реализующий протокол cisco netflow 5 версии. Ng\_netflow принимает входящий трафик, идентифицирует его, и создает счетчики активных потоков трафика. Потоки разбираются по протоколам, номерам портов, ToS, интерфейсам. Завершенные потоки отдаются в виде UDP дейтаграммы в Netflow коллектор. Поток считается завершенным: если был получен RST или TCP FIN пакет. Так же для потоков существуют таймауты, по которым поток будет завершен и передан в коллектор. Таймаут активного потока — по-умолчанию 1800 секунд. И таймаут не активного потока по-умолчанию 15 секунд.
Хуки Ng\_netflow имеют имена iface0, iface1, iface2, ifaceN. Также соответствующие им out0, out1, out2, outN. И хук экспорта статистики export.
Входящий трафик в ifaceN обрабатывается модулем учета. Если подключен соответственный хук outN, трафик без изменений уходит в него, если не подключен — никуда не уходит. Трафик вошедший в хук outN без изменений проходит к хуку ifaceN, без обработки модулем учета. Т.е фактически на счетчики попадает только входящий трафик в ifaceN. Для управления поведением учета трафика есть настройки, о которых будет рассказано ниже. В итоге через хук export будут выходить UDP дейтаграммы netflow, этот кух обычно подключают к хуку inet/dgram/udp модуля ng\_ksocket.
Принимаемые модулем контрольные сообщения, они же команды: info, ifinfo, setdlt, setifindex, settimeouts, setconfig, show. Опишу некоторые, об остальных читайте в man ng\_netflow.
Setdlt устанавливает тип интерфейса, подключенного к ifaceN. Из всех возможных вариантов (/usr/src/sys/net/bpf.h)
`/*
* Data-link level type codes.
*/
#define DLT_NULL 0 /* BSD loopback encapsulation */
#define DLT_EN10MB 1 /* Ethernet (10Mb) */
#define DLT_EN3MB 2 /* Experimental Ethernet (3Mb) */
#define DLT_AX25 3 /* Amateur Radio AX.25 */
#define DLT_PRONET 4 /* Proteon ProNET Token Ring */
#define DLT_CHAOS 5 /* Chaos */
#define DLT_IEEE802 6 /* IEEE 802 Networks */
#define DLT_ARCNET 7 /* ARCNET */
#define DLT_SLIP 8 /* Serial Line IP */
#define DLT_PPP 9 /* Point-to-point Protocol */
#define DLT_FDDI 10 /* FDDI */
#define DLT_ATM_RFC1483 11 /* LLC/SNAP encapsulated atm */
#define DLT_RAW 12 /* raw IP */`
поддерживаются только Ethernet и голый IP, соответственно варианты 1 и 12. Первый вариант установлен по-умолчанию. Синтаксис «setdlt { iface=0 dlt=12 }»
Settimeouts — устанавливает таймауты активных и не активных потоков, после которых статистика будет отправлена в коллектор. Синтаксис «settimeouts { inactive=15 active=1800 }»
**ng\_hub** — название идет из сетевой терминологии. Ethernet хабы уже давно нигде не используются и в отличии от современных умных Ethernet свитчей умели делать лишь два простых действия: принять пакет на любом интерфейсе, и отправить этот пакет на все интерфейсы.
Этот модуль работает совершенно так же. Принимает данные на любом подключенном хуке с произвольным именем, и отправляет эти данные без изменений на все подключенные хуки. Контрольных сообщений не принимает.
Мы не будем пропускать трафик через ng\_netgraph насквозь, пользуясь хуком outN, а используем модуль ng\_hub для копирования трафика проходящего по тоннелю в обе стороны.
### Составляем граф.
По сравнению со [старой](http://img.habreffect.ru/lmik/ethernet_over_udp_scheme.gif), схемой в новой видны изменения:
1. В разрыв между link2 модуля ng\_bridge и inet/dgram/udp модуля ng\_ksocket вставлен новый модуль ng\_hub.
2. К ng\_hub подключен новый ng\_netflow.
3. ng\_netflow подключено к новой копии модуля ng\_ksocket, который подключен к коллектору netflow.
### Собираем граф в системе.
Со стороны сервера bsd2 изменений никаких делать не придется.
На сервере bsd1 будем собирать всё с начала.
Создаем узел ng\_bridge и подключаем к его хуку «link0» хук сетевого интерфейса «em1» «lower».
**ngctl mkpeer em1: bridge lower link0**
Называем только что созданный узел именем «switch», его можно найти по пути «em1:lower».
**ngctl name em1:lower switch**
Подключаем к «link1» нашего «switch» upper сетевого интерфейса «em1».
**ngctl connect switch: em1: link1 upper**
Создаем узел ng\_hub и подключаем его к хуку «hublink0» хук «link2» нашего «switch»
**ngctl mkpeer switch: hub link2 hublink0**
Называем только что созданный узел именем «hub», его можно найти по пути «switch:link2»
**ngctl name switch:link2 hub**
Создаем узел ng\_ksocket и подключаем к его хуку «inet/dgram/udp» «hublink1» нашего «hub»
**ngctl mkpeer hub: ksocket hublink1 inet/dgram/udp**
Называем только что созданный узел именем «hub\_socket», его можно найти по пути «hub:hublink1»
**ngctl name hub:hublink1 hub\_socket**
Создаем узел ng\_netflow и подключаем к его хуку «iface0» «hublink2» нашего «hub»
**ngctl mkpeer hub: netflow hublink2 iface0**
Называем только что созданный узел именем «netflow», его можно найти по пути «hub:hublink2»
**ngctl name hub:hublink2 netflow**
Создаем ещё один узел ng\_ksocket и подключаем к его хуку «inet/dgram/udp» «export» созданного «netflow»
**ngctl mkpeer netflow: ksocket export inet/dgram/udp**
Называем только что созданный узел именем «netflow\_socket», его можно найти по пути «netflow:export»
**ngctl name netflow:export netflow\_socket**
Отправляем команду «bind» нашему «switch\_socket», с параметрами. ksocket займет порт 7777 на IP 1.1.1.1.
**ngctl msg switch\_socket: bind inet/1.1.1.1:7777**
Отправляем команду «connect» нашему «switch\_socket», с параметрами. ksocket подключится к порту 7777 по IP адресу 2.2.2.2.
**ngctl msg switch\_socket: connect inet/2.2.2.2:7777**
Отправляем команду «connect» нашему «netflow\_socket», с параметрами. ksocket подключится к порту 9996 по IP адресу 3.3.3.3. Там должен жить netflow collector.
**ngctl msg netflow\_socket: connect inet/3.3.3.3:9996**
Отправляем команду модулю ng\_ether сетевого интерфейса em1 перейти в режим прослушки пакетов, адресованных не ему. Нам ведь теперь необходимо принимать пакеты для устройств находящихся в нашей виртуальной сети.
**ngctl msg em1: setpromisc 1**
**ngctl msg em1: setautosrc 0**
Итоговый скрипт сборки графа:
`#!/bin/sh
self=1.1.1.1
peer=2.2.2.2
collector=3.3.3.3:9996
port=7777
if=em1
case "$1" in
start)
echo "Starting netgraph switch."
ngctl mkpeer ${if}: bridge lower link0
ngctl name ${if}:lower switch
ngctl connect switch: ${if}: link1 upper
ngctl mkpeer switch: hub link2 hublink0
ngctl name switch:link2 hub
ngctl mkpeer hub: ksocket hublink1 inet/dgram/udp
ngctl name hub:hublink1 hub_socket
ngctl mkpeer hub: netflow hublink2 iface0
ngctl name hub:hublink2 netflow
ngctl mkpeer netflow: ksocket export inet/dgram/udp
ngctl name netflow:export netflow_socket
ngctl msg hub_socket: bind inet/${self}:${port}
ngctl msg hub_socket: connect inet/${peer}:${port}
ngctl msg netflow_socket: connect inet/${collector}
ngctl msg ${if}: setpromisc 1
ngctl msg ${if}: setautosrc 0
echo "Ok."
exit 0
;;
stop)
echo "Stopping netgraph switch."
ngctl shutdown netflow_socket:
ngctl shutdown netflow:
ngctl shutdown hub_socket:
ngctl shutdown hub:
ngctl shutdown switch:
ngctl shutdown ${if}:
echo "Ok."
exit 0
;;
restart)
sh $0 stop
sh $0 start
;;
*)
echo "Usage: `basename $0` { start | stop | restart }"
exit 64
;;
esac`
Смотрим результат:
There are 8 total nodes:
`[root@bsd1] /root/> ngctl list
Name: em0 Type: ether ID: 00000001 Num hooks: 0
Name: em1 Type: ether ID: 00000002 Num hooks: 2
Name: switch Type: bridge ID: 000002c7 Num hooks: 3
Name: ngctl56729 Type: socket ID: 000002e1 Num hooks: 0
Name: hub_socket Type: ksocket ID: 000002ce Num hooks: 1
Name: hub Type: hub ID: 000002cb Num hooks: 3
Name: netflow_socket Type: ksocket ID: 000002d4 Num hooks: 1
Name: netflow Type: netflow ID: 000002d1 Num hooks: 2`
Погоняв немного трафика по тоннелю смотрим:
`[root@bsd1] /root/> ngctl msg netflow: info
Rec'd response "info" (805306369) from "[2d1]:":
Args: { Bytes=1722435 Packets=13683 Records used=27 Active expiries=203 Inactive expiries=5566 Inactive timeout=15 Active timeout=1800 }`
Так же посмотрев на статистику коллектора, можно увидеть прошедший по тоннелю трафик.
### Конец
Практическое использование учета трафика в тоннеле сомнительно, так что сбор такого графа можно рассматривать как пример для дальнейшего понимания работы подсистемы и модернизации готовых схем под свои нужды.
В следующих статьях опишу взаимодействие подсистемы netgraph с ipfw, с более практичным способом учета трафика через ng\_netflow.
До новых встреч. | https://habr.com/ru/post/87407/ | null | ru | null |
# NVMe Namespaces: возможности и подводные камни
Уверен, многие слышали про *NVM Express*, или просто *NVMe*. Изначально для меня это были просто быстрые диски. Потом я осознал, что это интерфейс для подключения этих дисков. Затем стал понимать NVMe как протокол для передачи данных по PCIe-шине. И не просто протокол, а протокол, разработанный специально для *твердотельных* накопителей!
Мало-помалу я пришел к пониманию, что это целая *спецификация*. И понеслось… Сколько интересных особенностей использования, оказывается, существует у NVMe. Сколько всего придумано… Было даже немного обидно, что мимо меня прошел такой пласт информации.
Так что же такое NVMe? Рассмотрим подробнее.
Началось все с *SATA-интерфейса*. На самом деле до него существовала масса других интерфейсов — SCSI, UltraSCSI, ATA, PATA и прочие, но это уже дела давно минувших дней. В этой статье мы рассмотрим только актуальные сейчас интерфейсы.
Скорость передачи данных по SATA-интерфейсу достигает 560 Мбайт/с, чего с лихвой хватает для HDD-дисков, производительность которых варьируется от 90 до 235 Мбайт/с (есть отдельные прототипы, скорость которых достигает 480 Мбайт/с). Но вот для SSD-дисков этого недостаточно, уже сейчас их производительность достигает от 3000 до 3500 Мбайт/с. SAS-интерфейс также не подойдет, его максимальная скорость всего лишь 1200 Мбайт/c.
Для того, чтобы реализовать весь потенциал твердотельных накопителей, великие умы решили использовать *PCIe-интерфейс*. Сейчас он позволяет передавать данные со скоростью от 8 до 32 Гбайт/c. Чтобы унифицировать подключение SSD к PCIe-интерфейсу, была разработана спецификация NVMe. Точно так же, как в свое время была создана спецификация для подключения USB-Flash-накопителей.
Полностью разбирать NVMe мы не будем. В этой статье я хочу поделиться с вами сильно заинтересовавшей меня особенностью — *NVMe Namespaces*, или *Пространства имен*.
Надеюсь, среди читателей есть те, кто интересуется изучением этой технологии. Буду рад комментариям опытных пользователей. А если вы, как и я, только начинаете разбираться в теме, рекомендую ознакомиться [с циклом статей](https://habr.com/ru/company/selectel/blog/475304/) об истории SSD. В свое время она помогла мне утрамбовать и разложить по полочкам много хлама в моей голове.
Ближе к NVMe
------------
### NVMe в Linux
Начну издалека. К изучению и поиску информации о пространствах имен меня побудил вопрос: «Почему NVMe-диски в Linux называются именно так?»
Все привыкли к обозначению дисков в Linux в виде блочных устройств. Они представляют собой *файловые дескрипторы*, которые обеспечивают интерфейс для взаимодействия с физическими или виртуальными устройствами. И такие устройства имеют не случайное, а вполне строгое название, содержащее некоторую информацию. Обратимся к следующему выводу из *devfs*:
```
root@thinkpad-e14:~$ ls -l /dev/ | grep -E "nvme"
crw------- 1 root root 241, 0 окт 25 22:04 nvme0
brw-rw---- 1 root disk 259, 0 окт 25 22:04 nvme0n1
brw-rw---- 1 root disk 259, 1 окт 25 22:04 nvme0n1p1
brw-rw---- 1 root disk 259, 2 окт 25 22:04 nvme0n1p2
brw-rw---- 1 root disk 259, 3 окт 25 22:04 nvme0n1p3
```
Здесь перечислены все NVMe-устройства, подключенные к рабочей машине. Рассмотрим блочное устройства */dev/nvme0n1p1*. Часть *nvme*, как ни странно, применяется для NVMe-устройств. Число, идущее следом, обозначает *порядковый номер контроллера диска*, который отвечает за все операции, производимые с накопителем. Заключительная часть *p1* указывает на *номер раздела* на диске. И наконец, часть, которая заслуживает нашего внимания, — n1. Это и есть номер пространства.
Для простоты можно также провести некоторую аналогию с обыкновенными SSD:
/dev/sda — аналог /dev/nvme0n1
/dev/sda1 — аналог /dev/nvme0n1p1
> **Обратите внимание на устройство /dev/nvme0. Это NVMe-контроллер. Он является символьным устройством. Таким образом, мы можем обращаться к нему, отправляя определенные команды, чем мы и воспользуемся далее.**
### Namespace vs Partition
У вас может возникнуть вопрос: чем namespace отличается от partition? Отбросим все возможности и преимущества NVMe Namespace. Partition — это раздел диска *на уровне хоста*. Namespace же является разделом *на уровне контроллера*. То есть Namespace является неким *логическим* пространством, с которым хост работает как с блочным устройством.
Еще один уровень разделов добавляет гибкости в организации системы хранения, что позволяет использовать различные технологии, направленные на увеличение надежности, производительности и безопасности данных. Мы рассмотрим их позже.
### Параметры NVMe-контроллера
Всеми операциями с данными занимается специальный NVMe-контроллер. Помимо этого, в своей памяти он хранит метаданные о себе и внутреннем устройстве информации: серийный номер, модель, всевозможные настройки диска, пространств, закрепленных за ним, формат данных и так далее.
Предлагаю рассмотреть их под микроскопом. Для этого я отправил контроллеру специальную команду, в ответ на которую он вернул метаданные. Позже я объясню, как это сделать, а сейчас взгляните на них. Так как данных достаточно много, я не стал вставлять их целиком, но вы обязаны знать, что те параметры, о которых я буду говорить далее, *на самом деле существуют*:
```
{
"vid" : 5197,
"ssvid" : 5197,
"sn" : "00000000000000",
"mn" : "00000000000000000000000000",
"fr" : "7L1QFXV7",
"rab" : 2,
"ieee" : 9528,
"cmic" : 0,
"mdts" : 9,
"cntlid" : 5,
"ver" : 66304,
"rtd3r" : 100000,
"rtd3e" : 8000000,
"oaes" : 512,
"ctratt" : 0,
"rrls" : 0,
"crdt1" : 0,
"crdt2" : 0,
"crdt3" : 0,
"oacs" : 23,
"tnvmcap" : 256060514304,
"unvmcap" : 0,
...
}
```
Метаданные хранятся в контроллере в виде последовательности байтов в порядке от старшего к младшему, поэтому далее я буду придерживаться следующего формата записи:
*[интервал в байтах (формата Big-Endian)] / название параметра / расшифровка.*
Пример для лучшего понимания. Следующая запись означает, что с 71 по 64 байт хранится значение параметра *fr*, который расшифровывается как *firmware revision*:
*[71:64] / fr / firmware revision.*
*[23:4] / sn / serial number.* Содержит серийный номер контроллера.
*[63:24] / mn / model number.* Содержит номер модели, или part number.
*[71:64] / fr / firmware revision.* Содержит номер ревизии прошивки контроллера.
*[257:256] / oacs / optional admin command support.* Указывает на наличие дополнительных команд и функций контроллера. Состоит он из 16 бит, каждый из которых отвечает за определенную команду. Если бит равен 1, то контроллер дает возможность:
* [15:10] — зарезервированы;
* [9] — получить статус LBA;
* [8] — получить доступ к *дорбелл буферу («Doorbell Buffer Config»)*;
* [7] — управлять *виртуализацией («Virtualization Management»)*;
* [6] — использовать команды *NVMe-Mi Recieve и NVMe-Mi Send («NVMe Management Interface»*);
* [5] — использовать *директивы («Directives»)*;
* [4] — использовать *команды для самопроверки («Self-Test Commands»)*;
* [3] — управлять *пространствами имен («Namespace Management»)*;
* [2] — обновлять *прошивку контроллера* (команды *«Firmware Commit»* и *«Firmware Download»*);
* [1] — форматировать *пространства имен («NVM Format»)*;
* [0] — поддержка *команд протокола безопасности («Security Send», «Security Receive»)*.
В данной статье мы затронем только те функции, которые относятся к пространствам имен, а именно *«Namespace Management»* и *«NVM Format»*. Если вас интересуют подробности о других функциях, можно обратиться к спецификации [NVM Express Revision 1.4](https://nvmexpress.org/wp-content/uploads/NVM-Express-1_4-2019.06.10-Ratified.pdf).
### Параметры NVMe-пространств
Теперь рассмотрим метаданные NVMe-пространств:
```
{
"nsze" : 500118192,
"ncap" : 500118192,
"nuse" : 233042000,
"nsfeat" : 0,
"nlbaf" : 0,
"flbas" : 0,
"mc" : 0,
"dpc" : 0,
"dps" : 0,
"nmic" : 0,
"rescap" : 0,
...
]
}
```
*[7:0] / nsze / namespace size.* Это максимальный размер пространства в логических блоках. В данном случае — 500118192 512-байтных блоков, что, кстати, и указано в выводе *blockdev*:
```
root@thinkpad-e14:~$ sudo blockdev --getsz /dev/nvme0n1
500118192
```
*[15:8] / ncap / namespace capacity*. Это количество логических блоков, выделенных пространству для хранения данных в текущий момент.
*[23:17] / nuse / namespace use.* Это количество логических блоков, занятых данными в текущий момент.
Обратите внимание, что параметры nsze и ncap равны. Какой смысл указывать максимальный объем и объем, который выделен в текущий момент? Значит ли это, что в текущий момент может быть выделено меньше, чем доступно? Да!
Дело в том, что пространства имен поддерживают технологию *Thin Provisioning*. Это означает, что пространству выделяется только часть от указанного объема. Другая часть будет оставаться в общем пуле и выделяться этому или другим пространствам по требованию: при заполнении выделенного объема или при достижении критического порога. В общем, эта технология позволяет эффективнее использовать ресурсы для хранения данных. Подробнее и нагляднее с этой технологией можно ознакомиться [в этой статье](http://pyatilistnik.org/kak-rabotaet-i-zachem-nuzhen-thin-provisioning/).
В нашей же ситуации *nsze* и *ncap* равны, так как пространство было создано без поддержки тонкого распределения. Выглядеть такое пространство на диске будет так:
*ncap* и *nsize* будут указывать на одно 一 *общий объем пространства*. В случае с использованием тонкого распределения на диске пространство будет выглядеть так:
Здесь *nsze* указывает на максимальный объем, *nca*p — на выделенный, а *nuse* в обоих случая показывает только то, что занято. Когда значение *nuse* достигнет значения *ncap*, то *ncap* увеличится, но не больше, чем *nsze*.
Стоит отметить, что для поддержки этой технологии необходима соответствующая настройка пространства имен, а также поддержка тонкого распределения со стороны контроллера.
*[24:24] / nsfeat / namespace features.* Этот параметр особенно интересен. Он указывает на наличие дополнительных особенностей пространства. Состоит он из 8 бит (перечислены они тоже в Big Endian), каждый из которых отвечает за определенную функцию. Если значение бита равно 1, то функция активна, 0 — нет:
* [7:5] — зарезервированы;
* [4:4] — поддержка дополнительных полей для *оптимизации ввода-вывода*;
* [3:3] — отключение переиспользования поля *NGUID*;
* [2:2] — поддержка *делоцированных и незаписанных блоков («Context Attributes»)*;
* [1:1] — поддержка *дополнительных полей для атомарной записи («Atomic Operations»)*;
* [0:0] — поддержка *тонкого распределения*.
*[26:26] / flbas / formatted lba size*. Этот параметр указывает на структуру LBA. Также состоит из 8 бит:
* *[7:5]* — зарезервированы;
* *[4:4]* — при значении 1: указывает, что метаданные будут храниться в *конце блока;* при значении 0: метаданные передаются *отдельным буфером*;
* *[3:0]* — позволяет выбрать один из 16 возможных форматов LBA.
*[29:29] / dps / end-to-end data protection type settings*. Указывает на тип сквозной защиты данных. Состоит из 8 бит:
* *[7:4*] — зарезервированы;
* *[3:3]* — указывает на *тип передачи* метаданных;
* *[2:0]* — указывает на *наличие защиты данных* и ее *тип.*
*[30:30] / nmic / namespace multi-path and Namespace Sharing Capabilities*. Это поле указывает на поддержку функций, связанных с мультидоступом к пространствам имен:
* *[7:1]*— зарезервированы;
* *[0:0]*— значение 1 указывает на то, что данное пространство является *публичным (public namespace)* и может связываться с *несколькими контроллерами*, а значение 0 — на то, что пространство является *приватным (private namespace)* и привязывается только к *одному*.
На этом можно завершить краткий обзор параметров. Их количество огромно, что позволяет очень тонко настроить пространства имен под различные задачи, которые мы рассмотрим в конце статьи. Подробное описание каждого параметра можно изучить в спецификации [NVM Express Revision 1.4](https://nvmexpress.org/wp-content/uploads/NVM-Express-1_4-2019.06.10-Ratified.pdf).
### Публичные и приватные пространства
В статье уже упоминались такие термины, как *публичные пространства* и *приватные пространства*. Но я не вносил ясности в их значение, поэтому считаю нужным уделить им немного времени.
Одним из этапов создания пространства является его закрепление за NVMe-контроллером. Доступ к пространству и будет осуществляться через тот контроллер, за которым оно закреплено. Но пространство может быть закреплено не только за одним контроллером — приватное, но и за несколькими контроллерами — публичное.
Если приватное пространство можно назвать обычным, так как из него ничего интересного слепить нельзя, то публичное пространство позволяет использовать такую возможность, как *namespace multi-path*.
Взаимодействие с NVMe
---------------------
Приступим к вопросу взаимодействия с NVMe-устройствами: как посылать различные команды контроллеру, создавать пространства имен, форматировать их и т. д. Для этого в мире Linux существует утилита — nvme-cli. С ее помощью и можно выполнять данные операции.
### nvme list
Чтобы вывести список NVMe-устройств, не обязательно обращаться к devfs подобным образом:
```
root@thinkpad-e14:~$ ls /dev/ | grep "nvme"
nvme0
nvme0n1
nvme0n1p1
nvme0n1p2
nvme0n1p3
```
Или использовать lspci, чтобы узнать что же такое подключено к машине:
```
root@thinkpad-e14:~$ lspci | grep -E "NVMe|Non-Volatile"
07:00.0 Non-Volatile memory controller: Samsung Electronics Co Ltd Device a809
```
Достаточно использовать команду *nvme list*:
```
root@thinkpad-e14:~$ nvme list -o json
{
"Devices" : [
{
"NameSpace" : 1,
"DevicePath" : "/dev/nvme0n1",
"Firmware" : "9L1QFXV7",
"Index" : 0,
"ModelNumber" : "SAMSUNG MZALQ256HAJD-000L1",
"ProductName" : "Non-Volatile memory controller: Samsung Electronics Co Ltd Device 0xa809",
"SerialNumber" : "00000000000000",
"UsedBytes" : 38470483968,
"MaximumLBA" : 500118192,
"PhysicalSize" : 256060514304,
"SectorSize" : 512
}
]
}
```
В качестве примера я вывел информацию в формате *JSON*. Как вы можете наблюдать, здесь выводится не просто список устройств, а еще и различная информация о них. Думаю, что часть атрибутов (например, *DevicePath* или *ModelNumbe*r) в комментариях не нуждаются, поэтому обращаю внимание только на некоторые:
* *Index* — номер контроллера;
* *UsedBytes* — используемый объем пространства в байтах;
* *PhysicalSize* — максимальный объем пространства в байтах;
* *SectorSize* — формат *LBA*, или *логического блока*, — минимального адресуемого блока данных;
* *MaximumLBA* — максимальное количество логических блоков.
### nvme id-ctrl, nvme id-ns
Ранее в статье, чтобы получить метаданные об устройстве, я отправлял контроллеру команду *Identify*. Для этого я использовал команду *nvme id-ctrl* для идентификации контроллера:
```
root@thinkpad-e14:~$ nvme id-ctrl /dev/nvme0
```
И *nvme id-ns* для идентификации пространства:
```
root@thinkpad-e14:~$ nvme id-ns /dev/nvme0n1
```
Обратите внимание, что необходимо указать устройство — контроллер или пространство имен.
### nvme create-ns, nvme delete-ns
Создание пространств имен проходит в несколько этапов. Сначала его нужно сформировать. Для этого используется команда *nvme create-ns*:
```
root@thinkpad-e14:~$ nvme create-ns /dev/nvme0 --nsze 1875385008 --ncap 1875385008 --flbas 0 --nmic 1 --dps 0
create-ns: Success, created nsid:1
```
Аргументы, которые указываются этой команде, вам уже знакомы. Мы их рассмотрели в разделе «Параметры NVMe-пространств».
Для удаления пространства используется команда *nvme delete-ns*:
```
root@thinkpad-e14:~$ nvme delete-ns /dev/nvme0n1
delete-ns: Success, deleted nsid:1
```
### nvme attach-ns, nvme detach-ns
Второй этап создания NVMe-пространств — привязка к контроллеру сформированного пространства. Для этого необходимо использовать команду *nvme attach-ns*:
```
root@thinkpad-e14:~$ nvme attach-ns /dev/nvme0 --namespace-id 1 --controllers 1
attach-ns: Success, nsid:1
```
Данной командой мы привязываем пространство с идентификатором 1 к контроллеру */dev/nvme0*. Также обратите внимание на аргумент *--controllers*. Здесь перечисляются идентификаторы NVMe-контроллеров, к которым можно привязать пространство. Этот аргумент опционален и используется при создании публичных пространств.
> По какой-то причине нумерация контроллеров начинается с 1, то есть контроллер /dev/nvme0 имеет идентификатор 1, который и указывается в аргументе --controllers. Надеюсь, это поможет вам избежать потерю времени на изучении следующей ошибки:
>
>
>
>
> ```
> root@thinkpad-e14:~$ nvme attach-ns /dev/nvme0 --namespace-id 1 --controllers 0
> NVMe Status:CONTROLLER_LIST_INVALID: The controller list provided is invalid(211c)
> ```
>
Чтобы отвязать пространство, используется команда *nvme detach-ns*:
```
root@thinkpad-e14:~$ nvme detach-ns /dev/nvme0n1 --namespace-id 1 --controllers 1
detach-ns: Success, nsid:1
```
После этого пространство исчезает из списка блочных устройств и его становится невозможно использовать. В аргументе --controllers также необходимо указывать только те контроллеры, от которых вы хотите отвязать пространство.
### nvme reset
После привязки пространства к контроллеру, как правило, его можно использовать для работы. Однако случается так, что контроллер не может увидеть пространства. В таком случае его необходимо перезапустить — использовать команду *nvme reset*.
### nvme format
В случае если необходимо изменить формат LBA у пространства, на помощь приходит команда *nvme format*:
```
root@thinkpad-e14:~$ nvme format /dev/nvme0n1 --lbaf 0
Success formatting namespace:1
```
Аргумент --lbaf указывает на формат LBA.
Однако эту команду также можно использовать и для безопасной затирки данных на NVMe-накопителе:
```
root@thinkpad-e14:~$ nvme format /dev/nvme0n1 --ses 1 -r
Success formatting namespace:1
```
Аргумент --ses указывает на уровень затирки:
* 1 — удалить все данные;
* 2 — удалить зашифрованные данные.
Аргумент -r указывает на то, что контроллер будет перезапущен после безопасной затирки.
Применение
----------
Возможных вариантов использования пространств много. В основном они используются для увеличения производительности, резервирования и применяются в СХД, однако есть и более приземленные варианты использования.
### Spare Area
Начнем с довольно обычной практикой использования. Spare Area, или Резервная область, была придумана еще до NVMe. Это специальное пространство на твердотельном накопителе, которое используется самим контроллером для внутренних операций и недоступно хосту.
Изменяя размер пространств, мы можем изменить и размер резервной области. Дело в том, что весь объем диска равен сумме объемов всех пространств и объема резервной области:
Соответственно, если мы уменьшим общий объем пространств, то оставшийся объем уйдет в пользу резервной области.
Если вы хотите узнать больше про резервную область, можете обратиться [к этой статье](https://habr.com/ru/company/ocz/blog/393131/).
### Шифрование и изоляция
NVMe-диски поддерживают самошифрование по [спецификации OPAL](https://nvmexpress.org/joint-white-paper-on-self-encrypting-drives-from-nvm-express-inc-and-the-tcg/). Более того, для каждого пространства имен используются различные ключи шифрования.
Также контроллер предоставляет возможность защиты от записи. Существует три уровня:
* только для чтения до следующей перезагрузки;
* только для чтения до следующей перезагрузки после отключения функции защиты от записи;
* только для чтения на протяжении всей работы.
Это часто применяется в стационарных и мобильных ПК. В пространство, доступное только для чтения, можно поместить, например, загрузчик, чтобы избежать его повреждения. Таким же образом можно защитить другие важные данные.
### Multiple Using
Как упоминалось ранее, пространства являются разделами на уровне контроллера, которые видны конечному хосту как отдельное устройство. А можно ли разделить NVMe-накопитель большого объема не несколько приватных пространств, каждое из которых затем выделить разным хостам? Можно! А с использованием сетевого протокола *NVMe-oF (NVMe Over Fabrics)* выделить эти пространства можно не только виртуальным хостам, но и физическим.
При таком использовании накопителя схема разделения будет выглядеть следующим образом:
NVMe-контроллер позаботится о том, чтобы пространства были изолированы друга от друга: данные будут храниться в отделенных друг от друга областях накопителя, у каждого хоста будет собственная очередь для ввода-вывода. Тем не менее, *spare area*, или *резервные области*, по-прежнему будут общими.
### Namespace Multi-path и Namespace Sharing
Namespace Sharing, или Public Namespaces, подразумевает под собой возможность совместного доступа одного или нескольких хостов к пространству через два и более контроллеров.
Для чего это необходимо? На рисунке показана схема использования публичных пространств. Да, интересно: мы можем обратиться к пространству NS B через контроллер NVMe Controller 1 и NVMe Controller 2. Но я не вижу в этом какой-то полезности… пока схема не будет выглядеть следующим образом:
Здесь мы видим, что контроллеры находятся на совершенно разных хостах и у нас есть несколько независимых путей к данным: через хост-контроллеры Host A (синие контроллеры) и Host B (фиолетовые контроллеры). Теперь это можно использовать для резервирования или для наращивания производительности: если синий путь будет сильно нагружен, то мы пойдем по фиолетовому.
Такой подход позволяет организовать высокопроизводительные и высоконадежные гибкие программно-определяемые СХД из обычных серверных платформ с использованием NVMe-oF.
Итог
----
NVMe Namespaces — это ~~не только ценный мех~~ не просто логическое разделение диска. Это очень интересная и важная технология, которая позволяет строить удобные инфраструктурные решения по хранению данных. Возможности для резервирования, шифрования, увеличения срока службы диска позволяют поддерживать стабильную работу высоконагруженных сервисов.
В данной статье мы рассмотрели далеко не все аспекты и тонкости использования пространств имен. Получился, скорее, обзор или знакомство. Однако я надеюсь, что это поможет вам при желании начать более глубокое изучение технологии.
Послесловие
-----------
При написании статьи я столкнулся с ~~попаболью~~ рядом проблем, мешавших мне завершить работу. Будьте внимательны при выборе дисков для тестирования различных возможностей NVMe. Мне далеко не с первого раза удалось разобраться в проблемах и подобрать себе диск, который бы минимально удовлетворял моим требованиям. Да и производители дисков неохотно делятся такой информацией, а некоторые даже вводят в заблуждение, поэтому пришлось действовать наобум. В частности, я столкнулся с такими проблемами:
* Диски Samsung 970 EVO/970 EVO Plus с прошивками 2b2qexe7/2b2qexm7 не реализуют команды reset и format;
* Диски Samsung 970 EVO/970 EVO Plus с прошивками 2b2qexe7/2b2qexm7 не реализуют управление пространствами при помощи команд create-ns, delete-ns, detach-ns, atach-ns;
* Диски Samsung PM991 с прошивкой 9L1QFXV7 имеют баг, из-за которого перезагрузка контроллера при помощи команды reset приводит к ошибке;
* Диски Samsung PM991 с прошивкой 9L1QFXV7 имеют баг, из-за которого форматирование пространства при помощи команды format приводит к ошибке;
* Диски Samsung PM991 с прошивкой 9L1QFXV7 не реализуют управление пространствами при помощи команд create-ns, delete-ns, detach-ns, atach-ns.
Я уверен, что диски из корпоративного сегмента лишены этих проблем, однако не всем по силам приобрести такие железки, поэтому подробно изучайте диски и мануалы по ним при покупке. А если есть возможность изучить диски до покупки и посмотреть параметры NVMe-контроллера, обязательно воспользуйтесь ею.
Полезные источники
------------------
1. [SSD: устройство, компоненты и принципы работы](https://dtf.ru/hard/46510-ssd-ustroystvo-komponenty-i-principy-raboty)
2. [A Quick Tour of NVM Express](https://metebalci.com/blog/a-quick-tour-of-nvm-express-nvme/)
3. [NVMe 1.4 Specification](https://nvmexpress.org/wp-content/uploads/NVM-Express-1_4-2019.06.10-Ratified.pdf)
4. [NVMe Namespaces](https://nvmexpress.org/resources/nvm-express-technology-features/nvme-namespaces/)
5. [Base NVM Express — Part One](https://nvmexpress.org/base-nvm-express-part-one/)
6. [NVMe Command Line Interface (NVMe-CLI)](https://nvmexpress.org/open-source-nvme-management-utility-nvme-command-line-interface-nvme-cli/)
7. [NVMe Over Fabrics](https://nvmexpress.org/nvme-over-fabrics-part-two/#:~:text=Namespace%20sharing%20refers%20to%20the,contain%20two%20or%20more%20controllers)
8. [Также по теме](https://www.youtube.com/watch?v=7MYw-0qfpH8)
[](https://slc.tl/RyYt5) | https://habr.com/ru/post/545078/ | null | ru | null |
# Готовить Kubernetes-кластер просто и удобно? Анонсируем addon-operator
Вслед за [shell-operator](https://habr.com/ru/company/flant/blog/447442/) мы представляем его старшего брата — [addon-operator](https://github.com/flant/addon-operator). Это Open Source-проект, который используется для установки в кластер Kubernetes системных компонентов, которые можно назвать общим словом — дополнения.
Зачем вообще какие-то дополнения?
---------------------------------
Не секрет, что Kubernetes это не готовый продукт всё-в-одном, и для построения «взрослого» кластера понадобятся различные дополнения. Addon-operator поможет установить, настроить и поддерживать эти дополнения в актуальном состоянии.
Необходимость дополнительных компонентов в кластере раскрыта в [докладе](https://habr.com/ru/company/flant/blog/449096/) коллеги [driusha](https://habr.com/ru/users/driusha/). Вкратце, ситуация с Kubernetes на данный момент такова, что для простой установки «поиграться» можно обойтись компонентами из коробки, для разработчиков и тестирования можно добавить Ingress, а вот для полноценной установки, о которой можно сказать «ваш production готов», необходимо добавить с десяток различных дополнений: что-то для мониторинга, что-то для логов, не забыть ingress и cert-manager, выделить группы узлов, добавить сетевые политики, приправить настройками sysctl и pod autoscaler’ом…
В чем специфика работы с ними?
------------------------------
Как показывает практика, одной установкой дело не ограничивается. Для комфортной работы с кластером дополнения нужно будет обновлять, отключать (удалять из кластера), а что-то захочется протестировать перед установкой в production-кластер.
Так, может, тут и Ansible хватит? Возможно. Но **полноценные дополнения в общем случае не живут без настроек**. Эти настройки могут отличаться в зависимости от варианта кластера (aws, gce, azure, bare-metal, do, ...). Некоторые настройки нельзя задать заранее — их нужно получать из кластера. А кластер не статичен: для некоторых настроек придётся следить за изменениями. И тут уже Ansible не хватает: нужна программа, которая живёт в кластере, т.е. Kubernetes Operator.
Те, кто попробовал в работе [shell-operator](https://github.com/flant/shell-operator), скажут, что задачи установки и обновления дополнений и слежения за настройками вполне можно решить с помощью [хуков](https://github.com/flant/shell-operator/blob/master/HOOKS.md) для shell-operator. Можно написать скрипт, который будет делать условный `kubectl apply` и следить, например, за ConfigMap, где будут храниться настройки. Примерно это и реализовано в addon-operator.
Как это организовано в addon-operator?
--------------------------------------
Создавая новое решение, мы исходили из следующих принципов:
* Установщик дополнений должен поддерживать **шаблонизацию и декларативную конфигурацию**. Не делаем магических скриптов, которые устанавливают дополнения. Addon-operator использует Helm для установки дополнений. Для установки нужно создать чарт и выделить values, которые будут использованы для настройки.
* Настройки можно **генерировать при установке**, их можно **получить из кластера**, либо **получать обновления**, следя за ресурсами кластера. Эти операции можно реализовать с помощью хуков.
* Настройки можно **хранить в кластере**. Для хранения настроек в кластере создаётся ConfigMap/addon-operator и Addon-operator следит за изменениями этого ConfigMap. Addon-operator даёт хукам доступ к настройкам с помощью простых соглашений.
* **Дополнение зависит от настроек**. Если настройки изменились, то Addon-operator выкатывает Helm-чарт с новыми values. Объединение Helm-чарта, values для него и хуков мы назвали модулем (подробнее см. ниже).
* **Стейджирование**. Нет магических релиз-скриптов. Механизм обновлений аналогичен обычному приложению — собрать дополнения и addon-operator в образ, протегировать и выкатить.
* **Контроль результата**. Addon-operator умеет отдавать метрики для Prometheus.
Что такое дополнение в addon-operator?
--------------------------------------
Дополнением можно считать всё, что добавляет в кластер новые функции. Например, установка Ingress — отличный пример дополнения. Это может быть любой оператор или контроллер со своим CRD: prometheus-operator, cert-manager, kube-controller-manager, и т.д. Или что-то небольшое, но упрощающее эксплуатацию — например, secret copier, копирующий registry-секреты в новые пространства имён, или sysctl tuner, настраивающий параметры sysctl на новых узлах.
Для реализации дополнений Addon-operator предоставляет несколько концепций:
* **Helm-чарт** используется, чтобы устанавливать в кластер различное ПО — например, Prometheus, Grafana, nginx-ingress. Если у нужного компонента есть Helm-чарт, то установить его с помощью Addon-operator будет очень просто.
* **Хранилище values**. У Helm-чартов обычно есть много разных настроек, которые могут меняться со временем. Addon-operator поддерживает хранение этих настроек и умеет следить за их изменениями, чтобы переустановить Helm-чарт с новыми значениями.
* **Хуки** — это исполняемые файлы, которые Addon-operator запускает по событиям и которые получают доступ к хранилищу values. Хук может следить за изменениями в кластере и обновлять значения в хранилище values. Т.е. с помощью хуков можно сделать discovery, чтобы собирать значения из кластера при старте или по расписанию, а можно и continuous discovery, собирая значения из кластера по изменениям в кластере.
* **Модуль** — это объединение Helm-чарта, хранилища values и хуков. Модули можно включать и отключать. Отключение модуля — это удаление всех релизов Helm-чарта. Модули могут включать сами себя динамически, например, если включены все необходимые ему модули или если discovery в хуках нашёл нужные параметры — это делается с помощью вспомогательного enabled-скрипта.
* **Глобальные хуки**. Это хуки «сами по себе», они не включены в модули и имеют доступ к глобальному хранилищу values, значения из которого доступно всем хукам в модулях.
Как эти части работают вместе? Рассмотрим картинку из документации:
Сценария работы два:
1. Глобальный хук запускается по событию — например, при изменении ресурса в кластере. Этот хук обрабатывает изменения и записывает новые значения в глобальное хранилище values. Addon-operator замечает, что глобальное хранилище изменилось и запускает все модули. Каждый модуль с помощью своих хуков определяет, нужно ли ему включаться, и обновляет своё хранилище values. Если модуль включен, то Addon-operator запускает установку Helm-чарта. Helm-чарту при этом доступны values из хранилища модуля и из глобального хранилища.
2. Второй сценарий проще: модульный хук запускается по событию, изменяет значения в хранилище values модуля. Addon-operator это замечает и запускает Helm-чарт с обновлёнными values.
Дополнение может быть реализовано виде одного единственного хука или как один Helm-чарт, или **даже как несколько зависимых модулей** — это зависит от сложности устанавливаемого в кластер компонента и от нужного уровня гибкости настроек. Например, в репозитории ([/examples](https://github.com/flant/addon-operator/tree/master/examples)) есть дополнение sysctl-tuner, которое реализовано как в виде простого модуля с хуком и Helm-чартом, так и с использованием хранилища values, что даёт возможность добавлять настройки через редактирование ConfigMap.
Доставка обновлений
-------------------
Несколько слов про организацию обновлений компонентов, которые устанавливает Addon-operator.
Чтобы запустить Addon-operator в кластере, нужно **собрать образ с дополнениями** в виде файлов хуков и Helm-чартов, добавить бинарный файл `addon-operator` и всё, что понадобится для хуков: `bash`, `kubectl`, `jq`, `python` и т.д. Дальше этот образ можно выкатывать в кластер как обычное приложение и скорее всего вы захотите организовать ту или иную схему тегирования. Если кластеров немного, может подойти тот же подход, что и с приложениями: новый релиз, новая версия, пойти по всем кластерам и поправить image у Pod’ов. Однако, в случае выката на ощутимое количество кластеров, нам больше подошла концепция самообновления из канала.
У нас это устроено так:
* Канал — это по сути идентификатор, который можно задавать любым (например, dev/stage/ea/stable).
* Имя канала — это тег образа. Когда нужно выкатить обновления в канал, то собирается новый образ и тегируется именем канала.
* Когда в registry появляется новый образ, Addon-operator рестартуется и запускается с новым образом.
Это не best practice, о чем написано в [документации Kubernetes](https://kubernetes.io/docs/concepts/containers/images/#updating-images). Так делать не рекомендуется, но речь идёт про *обычное приложение, которое живёт в одном кластере*. В случае Addon-operator приложение — это множество Deployments, разбросанных по кластерам, и самообновление очень сильно помогает и упрощает жизнь.
Каналы помогают и **в тестировании**: если есть вспомогательный кластер, можно настроить его на канал `stage` и катать обновления в него перед выкатом в каналы `ea` и `stable`. Если c кластером на канале `ea` произошла ошибка, можно его переключить на `stable`, пока идёт расследование проблемы с этим кластером. Если кластер выведен из активной поддержки, он переключается на свой «застывший» канал — например, `freeze-2019-03-20`.
Помимо обновлений хуков и Helm-чартов может понадобиться **обновить и сторонний компонент**. Например, вы заметили ошибку в условном node-exporter и даже придумали, как его пропатчить. Далее открыли PR и ждёте нового релиза, чтобы пройтись по всем кластерам и увеличить версию образа. Чтобы не ждать неопределённое время, можно собрать свой node-exporter и переключиться на него до принятия PR.
В общем-то, это можно и без Addon-operator сделать, но с Addon-operator модуль для установки node-exporter будет на виду в одном репозитории, Dockerfile для сборки своего образа можно держать тут же, всем участникам процесса становится проще понимать, что происходит… А если кластеров несколько, то становится проще как тестировать свой PR, так и накатывать новую версию!
Эта организация обновления компонентов работает успешно у нас, но можно реализовать и любую другую подходящую схему — ведь **в данном случае Addon-operator является простым бинарным файлом**.
Заключение
----------
Принципы, реализованные в Addon-operator, позволяют выстроить прозрачный процесс создания, тестирования, установки и обновления дополнений в кластере, аналогичный процессам разработки обычных приложений.
Дополнения для Addon-operator в формате модулей (Helm-чарт + хуки) можно выкладывать в широкий доступ. Мы, компания Флант, планируем выложить в течение лета наши наработки в виде таких дополнений. Присоединяйтесь к разработке на GitHub ([shell-operator](https://github.com/flant/shell-operator), [**addon-operator**](https://github.com/flant/addon-operator)), пробуйте сделать своё дополнение на основе [примеров](https://github.com/flant/addon-operator/tree/master/examples) и [документации](https://github.com/flant/addon-operator/blob/master/README.md), ждите новостей на Хабре и на нашем [канале в YouTube](https://www.youtube.com/c/%D0%A4%D0%BB%D0%B0%D0%BD%D1%82)!
***ОБНОВЛЕНО (14 июня)**: Если у вас есть англоязычные коллеги, которые могут заинтересоваться addon-operator'ом, то соответствующий анонс для них доступен в [нашем блоге на Medium](https://medium.com/flant-com/kubernetes-addon-operator-89f7bae4f3f9).*
P.S.
----
Читайте также в нашем блоге:
* «[Расширяем и дополняем Kubernetes (обзор и видео доклада)](https://habr.com/ru/company/flant/blog/449096/)»;
* «[Представляем shell-operator: создавать операторы для Kubernetes стало ещё проще](https://habr.com/ru/company/flant/blog/447442/)». | https://habr.com/ru/post/455543/ | null | ru | null |
# Рисуем мерцающий текст системой частиц
 В позапрошлой своей [статье](http://habrahabr.ru/post/144831/), посвящённой созданию открытки средствами OpenGL под Android, я оставил фразу «текст поздравления добавим позже». Так вот, время пришло.
Текст будет выглядеть примерно так, как на картинке, за исключением того, что он слегка мерцает, каждая «звёздочка» плавно исчезает и появляется (кроме того, в финальном варианте и сам текст другой, и цвет не тот, и размеры шрифта и частиц тоже). Нарисован он с помощью анимированной системы частиц, причём в массиве вершин задаются лишь координаты центра каждой точки и некий «сдвиг по фазе» для анимации, ну а сама анимация сделана через шейдеры.
Отрисовка частиц осуществляется механизмом Point Sprites, который как раз и создан для таких случаев. Основная его особенность в том, что мы задаём лишь координаты центра точки и её размер, а OpenGL сам генерит нам по четыре угловых вершины и два треугольника, включая их пространственные и текстурные координаты, для отрисовки множества одинаковых (в смысле, имеющих одну и ту же текстуру) квадратных картинок. Итак, заглянем под ка[по]т.
#### Собственно текст
Первое, что нам надо сделать — это определить координаты точек. Для этого мы сделаем Bitmap, в котором выведем произвольный текст в удобном нам месте, после чего найдём в результирующей картинке точки нужного цвета и случайно выберем из них те, к которым привяжем наши частицы.
Генерим Bitmap:
```
int width = screenWidth, height = screenHeight, fontSize = (int) (screenHeight / 8);
// Create an empty, mutable bitmap
Bitmap bitmap = Bitmap.createBitmap(width, height, Bitmap.Config.ARGB_4444);
// get a canvas to paint over the bitmap
Canvas canvas = new Canvas(bitmap);
bitmap.eraseColor(Color.BLACK);
// Draw the text
Paint textPaint = new Paint();
textPaint.setTextSize(fontSize);
textPaint.setAntiAlias(false);
textPaint.setARGB(0xff, 0xff, 0xff, 0xff);
textPaint.setTextAlign(Paint.Align.CENTER);
textPaint.setTypeface(Typeface.SANS_SERIF);
// draw the text centered
canvas.drawText("Привет,", width / 2, height / 4, textPaint);
canvas.drawText("Хабр!", width / 2, height / 2, textPaint);
int[] pixels = new int[width * height];
bitmap.getPixels(pixels, 0, width, 0, 0, width, height);
bitmap.recycle();
```
Здесь, screenWidth и screenHeight получены из аргументов к функции onSurfaceChanged наследника класса Renderer. Предпоследняя строчка в этом куске кода получила массив пикселей в виде упакованных целых чисел. Чёрные точки (фон) имеют в нём цвет 0xff000000, белые — 0xffffffff (старший байт — это альфа-канал).
Кстати, если бы мы захотели натянуть этот текст на текстуру, мы сделали бы это добавлением, например, таких строчек *перед* вызовом bitmap.recycle():
```
GLES20.glGenTextures(1, textures, 0);
GLES20.glBindTexture(GLES20.GL_TEXTURE_2D, textures[0]);
GLES20.glTexParameterf(GLES20.GL_TEXTURE_2D, GLES20.GL_TEXTURE_MIN_FILTER, GLES20.GL_NEAREST);
GLES20.glTexParameterf(GLES20.GL_TEXTURE_2D, GLES20.GL_TEXTURE_MAG_FILTER, GLES20.GL_LINEAR);
GLES20.glTexParameterf(GLES20.GL_TEXTURE_2D, GLES20.GL_TEXTURE_WRAP_S, GLES20.GL_REPEAT);
GLES20.glTexParameterf(GLES20.GL_TEXTURE_2D, GLES20.GL_TEXTURE_WRAP_T, GLES20.GL_REPEAT);
// Use the Android GLUtils to specify a two-dimensional texture image from our bitmap
GLUtils.texImage2D(GLES20.GL_TEXTURE_2D, 0, bitmap, 0);
```
Однако, нам нужно нечто совершенно иное. Находим белые точки на чёрном фоне, выбираем из них случайные, создаём массив частиц и сразу конвертируем его в вершинный буфер (функцию конвертации см. в позапрошлом посте):
```
private final int mParticles = 1200;
private int glParticleVB;
...
int colored = 0;
float[] cx = new float[width * height];
float[] cy = new float[width * height];
for (int y = 0, idx = 0; y < height; y++)
for (int x = 0; x < width; x++)
if ((pixels[idx++] & 0xffffff) != 0) {
cx[colored] = x / (float)width;
cy[colored] = y / (float)height;
colored++;
}
float[] particleBuf = new float[3 * mParticles];
for (int i = 0, idx = 0; i < mParticles; i++, idx += 3) {
int n = (int) (Math.random() * colored);
particleBuf[idx + 0] = cx[n] * 2 - 1;
particleBuf[idx + 1] = 1 - cy[n] * 2;
particleBuf[idx + 2] = (float) Math.random();
}
glParticleVB = createBuffer(particleBuf);
```
Количество частиц подбирается на глаз. Как было сказано выше, каждая частица содержит лишь пару координат и «сдвиг по фазе» для анимации. Стоит заметить, что Y-координата инвертируется, так как в OpenGL низ экрана имеет координату "-1", а верх — "+1", тогда как в bitmap'е верх картинки — это «0», а низ — «height».
 #### Текстура частицы
Теперь загрузим текстуру частицы. Я воспользовался вот такой картинкой (сгенерировал её отдельно), хотя можно использовать любую другую, лишь бы устраивал конечный результат. Файл с картинкой (допустим, он называется particle.png) кладём в папку res/drawable проекта, после чего пишем код загрузки текстуры из ресурса:
```
private int particleTex;
...
public static int loadTexture(final Context context, final int resourceId)
{
final int[] textureHandle = new int[1];
GLES20.glGenTextures(1, textureHandle, 0);
if (textureHandle[0] != 0)
{
final BitmapFactory.Options options = new BitmapFactory.Options();
options.inScaled = false; // No pre-scaling
// Read in the resource
final Bitmap bitmap = BitmapFactory.decodeResource(context.getResources(), resourceId, options);
// Bind to the texture in OpenGL
GLES20.glBindTexture(GLES20.GL_TEXTURE_2D, textureHandle[0]);
// Set filtering
GLES20.glTexParameteri(GLES20.GL_TEXTURE_2D, GLES20.GL_TEXTURE_MIN_FILTER, GLES20.GL_NEAREST);
GLES20.glTexParameteri(GLES20.GL_TEXTURE_2D, GLES20.GL_TEXTURE_MAG_FILTER, GLES20.GL_NEAREST);
// Load the bitmap into the bound texture.
GLUtils.texImage2D(GLES20.GL_TEXTURE_2D, 0, bitmap, 0);
// Recycle the bitmap, since its data has been loaded into OpenGL.
bitmap.recycle();
}
return textureHandle[0];
}
...
particleTex = loadTexture(mContext, R.drawable.particle);
```
Здесь предполагается, что mContext мы сохранили в момент создания экземпляра класса Renderer.
#### Шейдеры
Мне хотелось создать следующий эффект: каждая частица должна «пульсировать», т.е. циклически увеличиваться и сжиматься, причём каждая должна двигаться независимо. Посмотрев на результат, я добавил ещё одно улучшение: когда размер частицы достигает 3/4 от максимального, её цвет начинает становиться белым (и становится таким в максимальной точке).
```
private final String particleVS =
"precision mediump float;\n" +
"attribute vec4 vPosition;\n" +
"attribute float vSizeShift;\n" +
"uniform float uPointSize;\n" +
"uniform float uTime;\n" +
"uniform vec4 uColor;\n" +
"varying vec4 Color;\n" +
"void main() {\n" +
" float Phase = abs(fract(uTime + vSizeShift) * 2.0 - 1.0);\n" +
" vec4 pColor = uColor;\n" +
" if (Phase > 0.75) {\n" +
" pColor.y = (Phase - 0.75) * 4.0;\n" +
" };\n" +
" Color = pColor;\n" +
" gl_PointSize = uPointSize * Phase;\n" +
" gl_Position = vPosition;\n" +
"}\n";
private final String particleFS =
"precision mediump float;\n" +
"uniform sampler2D uTexture0;\n" +
"varying vec4 Color;\n" +
"void main()\n" +
"{\n" +
" gl_FragColor = texture2D(uTexture0, gl_PointCoord) * Color;\n" +
"}\n";
```
Легко видеть, что вершинный шейдер здесь отвечает за анимацию размера частицы и цвета, а фрагментный — только применяет текстуру с помощью системной переменной gl\_PointCoord. Аттрибут vSizeShift имеет здесь диапазон от 0 до 1, при сложении с uTime и выделении дробной части получаем своё значение фазы анимации для каждой частицы. Кстати, поскольку исходный цвет будет задан фиолетовым, то переход к белому цвету делается только за счёт зелёной компоненты. Копируем позицию, определяем цвет частицы и её размер — и готово.
Осталось только загрузить шейдеры (опять же, функцию Compile см. в исходном посте):
```
private int mPProgram;
private int maPPosition;
private int maPSizeShift;
private int muPPointSize;
private int muPTime;
private int muPTexture;
private int muPColor;
...
mPProgram = Compile(particleVS, particleFS);
maPPosition = GLES20.glGetAttribLocation(mPProgram, "vPosition");
maPSizeShift = GLES20.glGetAttribLocation(mPProgram, "vSizeShift");
muPPointSize = GLES20.glGetUniformLocation(mPProgram, "uPointSize");
muPTime = GLES20.glGetUniformLocation(mPProgram, "uTime");
muPTexture = GLES20.glGetUniformLocation(mPProgram, "uTexture0");
muPColor = GLES20.glGetUniformLocation(mPProgram, "uColor");
```
и отрисовать всё.
#### Рендер
У нас всё готово, осталось лишь задать константы и вызвать функцию отрисовки.
```
private void DrawText()
{
GLES20.glUseProgram(mPProgram);
GLES20.glDisable(GLES20.GL_DEPTH_TEST);
GLES20.glActiveTexture(GLES20.GL_TEXTURE0);
GLES20.glBindTexture(GLES20.GL_TEXTURE_2D, particleTex);
GLES20.glBindBuffer(GLES20.GL_ARRAY_BUFFER, glParticleVB);
GLES20.glEnableVertexAttribArray(maPPosition);
GLES20.glVertexAttribPointer(maPPosition, 2, GLES20.GL_FLOAT, false, 12, 0);
GLES20.glEnableVertexAttribArray(maPSizeShift);
GLES20.glVertexAttribPointer(maPSizeShift, 1, GLES20.GL_FLOAT, false, 12, 8);
GLES20.glBindBuffer(GLES20.GL_ARRAY_BUFFER, 0);
GLES20.glUniform1f(muPPointSize, 12);
GLES20.glUniform4f(muPColor, 1, 0, 1, 1);
GLES20.glUniform1i(muPTexture, 0);
GLES20.glUniform1f(muPTime, (SystemClock.uptimeMillis() % 1000) / 1000.0f);
GLES20.glDrawArrays(GLES20.GL_POINTS, 0, mParticles);
GLES20.glDisableVertexAttribArray(maPPosition);
GLES20.glDisableVertexAttribArray(maPSizeShift);
}
```
#### Результат
#### Заключение
На этом моя серия tutorial'ов по OpenGL ES 2.0 на Android пока заканчивается, и я объявляю недельный перерыв, по истечении которого смогу выложить .apk-файл, который позволит оценить результат на своём устройстве, а также сравнить производительность. Впрочем, в течение этого времени не исключено появление новых статей в случае, если я захочу добавить к открытке ещё какие-нибудь спецэффекты. | https://habr.com/ru/post/145231/ | null | ru | null |
# Модуляция звука
Немного теории, что мне известно о звуке — звук это:
волна, колебания, затухающие колебания, волна может быть описана с точки зрения физики, волна может быть описана с точки зрения математики.
[Скачать и протестировать программу](https://djdnkey.blogspot.com/2018/12/sound-lab-sinus-synthesizer-mixed.html)
Поскольку моделируем мы на компьютере, то наша волна описывается при помощи последовательности (ряда Фурье) из байт (чисел от -128 до 127 и ноля), тоесть массивом байт.
Уравнение колебательных движений лучше всего описывает функция SIN.
Согласитесь было бы слишком просто, если бы мы просто прогнали по массиву функцию SIN.
Поэтому руководствуясь статьями об описании устройства синтезатора Yamaha, я написал следующий алгоритм:
1. При помощи функции SIN создается основная или моделирующая волна, вот формула которая может пригодиться другим разработчика:
```
for(int k = 0; k < SoundLabVisual.player.data.length;k++){
double sinusoid = amplitude1 * Math.sin(2 * (3.14/1 ) * k * frequency1 + faza);
}
```
Где:
**amplitude1** — амплитуда
**frequency1** — частота колебаний
**faza** — начальная фаза колебаний
2. При помощи второй функци SIN, создается основная волна, амплитудой в которой выступают значения первой волны:
```
//cдвиг по оси
double a1 = 0.1f;
//cдвиг по оси
double c1 = 0.1f;
//cдвиг по оси
double d1 = 0.1f;
sinusoid = a1 + (sinusoid * Math.sin( (c1 * (double)k) * frequency2Double + d1 ));
```
Скриншот программы
Тестовые звуки я загрузил в программу lmms.
[Послушать mp3](https://yadi.sk/d/O3yPyVzneQiWcA)
Будет реализован другой алгоритм, который будет работать по каналам, если получится напишу о нем во второй статье.
Update:
По замечаниям комментаторов алгоритмы теперь можно перемножать сами на себя и между собой.
```
if(jCheckBox8.isSelected()){
sinusoid = (a1 + (sinusoid * Math.sin( (c1 * (double)k) * frequency2Double + d1 ))) * (a1 + (sinusoid * Math.sin( (c1 * (double)k) * frequency2Double + d1 )));
}else{
sinusoid = a1 + (sinusoid * Math.sin( (c1 * (double)k) * frequency2Double + d1 ));
}
```
Update 2: Программа обновлена, теперь к звуку волну можно примешать. | https://habr.com/ru/post/431488/ | null | ru | null |
# Разработка черного списка sms для Android
Здравствуй, уважаемое хабрасообщество!
Основываясь на ответах на мой [вопрос](http://habrahabr.ru/qa/19750/), публикую данный топик. «Антиспам» — несколько громкое название для сделанного приложения, так как на данном этапе оно представляет собой лишь черный список отправителей. Однако в будущем я планирую сделать действительно антиспам с автоматической фильтрацией. Материал, расположенный ниже, рассчитан на тех, кто хоть чуточку знаком с разработкой под Android и делал хоть какие-то шаги для разработки своего собственного приложения, так как я не буду рассказывать про создание всего приложения с нуля, а расскажу только о наиболее интересных и важных моментах. Кому интересно, добро пожаловать под кат.
#### Ты помнишь, как все начиналось?
Небольшое лирическое отступление. Началось все с того, что я где-то слил номер своего мобильного телефона. Я даже подозреваю где именно, так как моим друзьям, которые регистрировались на том же сайте, что и я, приходят те же спам сообщения в одно и то же время. Но сейчас не об этом. По пятницам мне стали приходит рекламы различных клубов и с каждой неделей поток сообщений только увеличивался. Поскольку я стал обладателем телефона на базе ОС Android, то я решил сделать приложение, которое будет бороться с этим безобразием. Программисты никогда не ищут легких путей – к мобильному оператору я обращаться не хотел, да и к тому же я давно хотел начать разрабатывать под Android.
#### Архитектура и схема работы приложения
Приложение состоит из трех частей:
1. Собственно фильтр, принимающий и фильтрующий смс сообщения;
2. База данных, которая хранит черный список отправителей и сообщения, полученные от них;
3. Пользовательский интерфейс.
Как все это работает? Пользователь добавляет в черный список отправителей либо из «Входящих», либо из «Контактов». Включает фильтр и закрывает приложение. При получении сообщения приложение анализирует его отправителя, и если он находится в черном списке, то помещает сообщение в так называемое хранилище, чтобы пользователь впоследствии мог посмотреть отфильтрованные сообщения. Если же отправитель «чист», то СМС попадает в папку «Входящие».
#### Первый прототип
Сказано сделано. Однако реализация первого прототипа не прожила и дня. Дело в том, что я пытался ловить событие о получении текстового сообщения, и в обработчике этого события удалять из папки «Входящие» все сообщения, отправители которых находились в черном списке. Проблема заключается в том, что владелец телефона все равно слышал бы сигнал, информирующий о получении СМС, а при открытии папки с входящими ничего нового бы там не видел! И это как-то не хорошо. Поэтому я начал искать способ перехватить сообщение, еще до того, как оно попадет в папку «Входящие».
#### Перехват сообщений
ОС Android устроена так, что о таких событиях как получение СМС, включение WI-FI, подключение зарядки и тому подобное, система информирует приложения с помощью широковещательной рассылки. Подробнее об этом механизме и об архитектуре в целом Android можно почитать [здесь (4 перевода)](http://habrahabr.ru/post/141504/). Для создания получателя (слушателя) такой системной широковещательной рассылки необходимо:
1. Создать свой класс, унаследованный от BroadcastReceiver и перегрузить метод onReceive;
2. Зарегистрировать его в системе и указать, какие типы рассылок мы хотим получать.
#### Создание слушателя
```
public class SMSReceiver extends BroadcastReceiver
{
@Override
public void onReceive(Context context, Intent intent)
{
Bundle bundle = intent.getExtras();
Object[] pdus = (Object[]) bundle.get("pdus");
if (pdus.length == 0)
{
return;
}
Sms sms = Sms.fromPdus(pdus, context);
SmsDatabase db = null;
try
{
db = SmsDatabase.open(context);
if (Filter.filter(context).isSpam(sms, db))
{
abortBroadcast();
db.messages().save(sms);
}
}
finally
{
if (db != null) db.close();
}
}
}
```
Метод onReceive срабатывает каждый раз, когда на телефон приходит СМС сообщение. Из параметра intent можно извлечь всю необходимую информацию. **Внимание**, согласно документации, класс, унаследованный от BroadcastReceiver, актуален только во время выполнения метода onReceive. Это значит, что система может уничтожить экземпляр класса как только закончиться выполнение указанного метода. Также это значит, что не стоит хранить какую либо информацию в нестатических полях класса.
В первых двух строках мы извлекаем информацию о [PDU](http://en.wikipedia.org/wiki/Protocol_data_unit). Грубо говоря, это СМС в «сыром» виде. После проверки на пустоту мы пытаемся извлечь информацию о сообщении с помощью статического метода fromPdus() в самописном классе Sms, который будет описан позднее.
Затем мы с помощью класса Filter проверяем, не находится ли отправитель только что полученного СМС сообщения в черном списке. Если находится, что мы сохраняем сообщение в БД и с помощью метода abortBroadcast() прерываем рассылку. Это значит, что все получатели с более низким приоритетом, зарегистрированные на получение уведомления о СМС, даже не узнают, что такое событие имело место быть. Нашему получателю мы установим самый высокий приоритет (даже выше получателя, который издает звуки и вибрирует устройством), чтобы не беспокоить пользователя в случае получения спам-сообщения. О приоритетах читайте чуть ниже.
В предыдущей версии приложения, в методе onReceive соединение с БД открывалось дважды: первый раз в классе Filter при проверке сообщения, а второй раз непосредственно при записи смс в БД. Однако я отказался от такого подхода и сделал код «чуть более неправильным» с точки зрения «красивости» кода, так как время выполнения метода onReceive ограничено 10ю секундами и открывать два соединения подряд не имеет смысла. Ведь если наш метод не уложиться в отведенное время, то Android вызовет метод следующего получателя и тогда пользователь будет проинформирован о получении смс.
#### Регистрация слушателя
Слушателя мы написали. Осталось зарегистрировать его системе. Сделать это можно двумя способами:
1. Программно при помощи метода registerReceiver(). В этом случае получатель будет жить только пока жив компонент, который его зарегистрировал (как правило, это Activity);
2. При помощи AndroidManifest. В этом случае получатель будет жить, даже если приложение будет закрыто, и более того, даже если телефон будет перезагружен!
Очевидно, что 2й вариант является более приемлемым. Давайте посмотрим, как его можно реализовать:
```
……………. Здесь прочие теги …………………..
```
Здесь все предельно просто. Указываем имя класса получателя (android:name), а затем с помощью тега intent-filter указываем приоритет (android:priority, 1000 – максимальное значение; у стандартного получателя, который вибрирует и издает звуки, приоритет 999) и на какие события мы подписываемся (android.provider.Telephony.SMS\_RECEIVED).
#### Включение и выключение слушателя
Следует сказать, что получатель по умолчанию выключен. Отсюда вытекает то, что пользователь имеет возможность включать и выключать фильтр, путем активации и деактивации получателя СМС. В классе Filter для этого имеются соответствующие методы on(), off() и enabled().
Класс Filter, кстати говоря, является классом одиночкой (singleton), так как у нас должен быть один фильтр на все приложение, несмотря на то, что он зависит от контекста (Context). В классе SMSReceiver вы могли видеть как происходит доступ к экземпляру фильтра через статический метод filter(), который принимает экземпляр класса Context в качестве параметра.
```
private static Filter _filter;
public static Filter filter(Context context)
{
if (_filter == null || !_filter._context.equals(context))
{
_filter = new Filter(context);
}
return _filter;
}
```
Я ни в коем случае не утверждаю, что такая реализация единственно верная. Если вы можете предложить более удачное решение, то я с удовольствием его рассмотрю.
В конструкторе класса Filter следует инициализировать необходимые для работы данные:
```
private final ComponentName componentName;
private final PackageManager packageManager;
private Context _context;
private Filter(Context context)
{
_context = context;
String packageName = context.getPackageName();
String receiverComponent = packageName + ".SMSReceiver";
componentName = new ComponentName(packageName, receiverComponent);
packageManager = context.getPackageManager();
}
```
componentName – это полное имя компонента приложения, в данном случае получателя, которое включает в себя название пакета и имя класса (SMSReceiver).
packageManager – из названия ясно, что это класс для управления компонентами приложения.
Рассмотрим метод, который включает фильтр:
```
public void on()
{
if (!enabled())
{
packageManager.setComponentEnabledSetting(componentName,
PackageManager.COMPONENT_ENABLED_STATE_ENABLED,
PackageManager.DONT_KILL_APP);
}
else
{
Util.showMessage(_context.getString(R.string.alreadyStarted), _context);
}
}
```
Тут все просто. Если компонент уже включен (enabled() – самописный метод, рассмотрим его чуть позже), то сообщаем пользователю об этом, если же выключен – включаем. Статический класс Util является самописным и включает в себя различные вспомогательные функции. В данном случае метод showMessage использует стандартный класс Toast для отображения сообщений на экран.
Метод off(), отключающий фильтр, полностью аналогичен методу on() за исключением того, что используется флаг PackageManager.COMPONENT\_ENABLED\_STATE\_DISABLED, а в случае, если фильтр уже выключен, выводится соответствующее сообщение.
Метод, проверяющий состояние фильтра, выглядит еще проще:
```
public boolean enabled()
{
int enabled = packageManager.getComponentEnabledSetting(componentName);
return (enabled == PackageManager.COMPONENT_ENABLED_STATE_ENABLED);
}
```
#### Проверка на вшивость
В классе Filter остался еще один метод, который не был описан. Это метод isSpam(), который, собственно, и выполняет основную задачу приложения. Метод крайне прост. Он извлекает из смс сообщения его отправителя и пытается найти его в БД. Если таковой имеется, то сообщение считается спамом.
```
public boolean isSpam(Sms sms, SmsDatabase db)
{
Sender sender = sms.sender();
return db.senders().exists(sender);
}
```
#### Класс Sms
Класс Sms упоминался уже дважды. Надо бы рассказать про него несколько подробнее. Этот класс служит представлением СМС сообщений в приложении. Он содержит следующие поля:
```
private String _body;
private Sender _sender;
private long _timestamp;
```
где \_body – тело сообщения, \_sender – отправитель сообщения \_timestamp – время получения сообщения в виде UNIX’ового timestamp’а.
Класс Sender не является стандартным для Android. Он написан руками и умеет хранить телефон отправителя, а также по необходимости извлекать имя отправителя из телефонной книги. Подробно мы не будем его рассматривать.
Мы уже знаем, что у класса Sms есть статический метод fromPdus(), извлекающий информацию о сообщении из PDU. Посмотрим на его код:
```
public static Sms fromPdus(Object[] pdus, Context context)
{
Sms result = new Sms();
for (int i = 0; i < pdus.length; i++)
{
SmsMessage sms = SmsMessage.createFromPdu((byte[]) pdus[i]);
result._body += sms.getMessageBody();
}
SmsMessage first = SmsMessage.createFromPdu((byte[]) pdus[0]);
result._sender = new Sender(first.getOriginatingAddress(), context);
result._timestamp = first.getTimestampMillis();
return result;
}
```
На первый взгляд метод может показаться сложным. Однако это не так. Единственная сложность заключается в том, что одно логическое СМС сообщение, может быть разбито на несколько физических. Думаю, что в этом плане Америку я для Вас не открыл. Этот спецэффект знаком всем, кто всегда пишем без пробелов, чтобы впихнуть как можно больше информации в одну СМС и сэкономить свои кровные.
Таким образом, мы в цикле собираем тело сообщения по кусочкам, а потом из самого первого СМС сообщения извлекаем необходимую информацию. В общем-то, с классом Sms на это можно закончить.
#### Немного о базе данных
Черный список наглых спамеров, а также результаты их непризнанного творчества хранятся в базе данных. Это необходимо для того, чтобы пользователь мог посмотреть, что ему там понаприходило. Ведь теоретически пользователь может добавить в черный список и телефонный номер из своих контактов, а после того как помирится с его обладателем, может захотеть почитать полученные от него СМС.
Нам повезло, ведь в Android’е прямо из коробки идет СУБД SQLite. Всю логику работы с БД я реализовал с использованием стандартных JAVA классов и запросов на SQL. По закону подлости, после такого, как я закончил эту часть приложения, я прочитал на Хабре [статью](http://habrahabr.ru/post/143431/) про ORM для Android.
Работа с БД у меня построена по принципу: открыл соединение – поработал с данными – закрыл соединение. Эта практика особенно хороша для SQLite, так как эта СУБД является файловой и может возникнуть блокировка при операции чтения или записи. Поэтому я стараюсь не держать долгоживущих соединений.
Очень не хотелось бы рассматривать все методы–обертки для БД, так как их достаточно много, а статья не резиновая. К тому же все они однотипны, поэтому для понимания сути рассмотрим только метод, использование которого мы видели в методе onReceive класса SMSReceiver.
Запись «db.messages().save(sms)» говорит нам о том, что в рамках соединения db мы обращаемся к таблице Messages, которая хранит отфильтрованные сообщения, и добавляем в нее новое сообщение sms при помощи метода save(). Повторюсь, что все классы и методы самописны.
```
public void save(Sms sms)
{
if (!Preferences.get(_context).storeSms()) return;
int maxCount = Preferences.get(_context).storedSmsAmount();
if (count() >= maxCount) trim(maxCount - 1);
SQLiteStatement insert = _db.compileStatement(
"INSERT INTO Messages(Phone, Timestamp, Body)" +
"VALUES (?, ?, ?)");
insert.bindString(1, sms.sender().phone());
insert.bindLong(2, sms.timestamp());
insert.bindString(3, sms.body());
insert.execute();
}
```
Первой строкой кода мы получаем доступ к настройкам приложения и проверяем флаг, отвечающий за желание пользователя хранить отфильтрованные сообщения. Если пользователь отказался от хранения, то просто выходим.
Затем, опять же из настроек, извлекаем установленный пользователем размер хранилища отфильтрованных СМС. И если текущее количество сообщений больше этого размера, удаляем из хранилища старые сообщения с учетом порядка их получения. То есть первыми будут удалены сообщения, которые первыми и были получены. Классическая очередь.
После этих телодвижений формируем запрос на вставку данных в таблицу Messages и с помощью типизированных методов bind() привязываем данные к сформированному запросу. В конце исполняем запрос.
#### Тестирование и отладка
Вроде все готово. Остается маленький шажок. Вопрос в том, как нам убедится, что приложение правильно функционирует? Что получатель вообще хоть что-то получает, а БД это что-то сохраняет? Про возможности Unit-тестирования приложений под Android я рассказывать не буду, так как это тема отдельного большого топика. Расскажу лишь про то, как сымитировать получение СМС на эмуляторе.
Для этого откроем любой telnet-клиент. В зависимости от настроения, я использую либо Putty, либо стандартный клиент в Windows 7 (который сначала необходимо включить). Подключаемся к localhost, а в качестве порта указываем порт, отображаемый в заголовке окна с эмулятором. Как правило, это 5554. Само собой разумеется, что при этом эмулятор должен быть запущен. После прочтения приветствия можно начинать вводить команды.
Команд достаточно много. Их список можно получить, набрав команду «help». С помощью этих команд можно имитировать многие события, которые могут происходить с телефоном. Однако нас интересует только имитация получения СМС сообщения.
Чтобы это сымитировать, достаточно набрать команду
```
sms send номер_телефона текст_сообщения
```
где номер\_телефона — любая последовательность цифр, которая может начинаться со знака «+», а текст\_сообщения – содержимое сообщения, включая пробелы и другие символы, которые мы обычно пишем в СМС.
В случае успешной имитации мы увидим сообщение “OK” в терминале telnet-клиента.
#### Заключение
В данном топике я постарался раскрыть основные технические подробности моего приложения, обратить внимание на подводные камни и некоторые возможности Android платформы. Последнюю версию приложения можно бесплатно [скачать](https://play.google.com/store/apps/details?id=com.dpforge.spamkiller) с Google Play.
Если возникли какие-то вопросы или у Вас есть какие-то предложения, то я буду благодарен, если Вы напишите об этом в комментариях или в личные сообщения. Конструктивная критика только приветствуется. Спасибо за внимание!
PS: Прошу прощения, что не вставил скриншоты. И так получилось достаточно много материала, да и не знаю, что из описанного требует графического пояснения. Если Вы не согласны со мной, то я обязательно поправлю топик. | https://habr.com/ru/post/146453/ | null | ru | null |
# Процесс загрузки Windows или что спрятано под стартовым логотипом
А вы никогда не задумывались над тем, что же происходит с операционной системой в тот момент, когда она рисует свой логотип и говорит «Starting Windows»? И вообще, почему она долго загружается? Ведь при старте системы уж точно не решаются никакие задачи, сложные с вычислительной точки зрения!
Что тогда подразумевает под собой загрузка операционной системы? По большей части это проецирование в память исполняемых модулей и инициализация служебных структур данных. Структуры данных живут в памяти, поэтому операции с ними по идее должны быть быстрыми. Все наталкивает на мысль о том, что время съедается именно процессом загрузки исполняемых модулей в память.
Давайте интереса ради разберемся, какие модули, в каком количестве и в каком порядке загружаются при старте ОС. Чтобы выяснить это, можно, например, получить лог загрузки системы. Подопытная ОС в моем случае — Windows 7 Enterprise x64. Логировать процесс загрузки будем при помощи отладчика ядра. Существует несколько вариантов отладчиков ядра, лично я предпочитаю WinDbg. Также нам понадобятся некоторые вспомогательные средства для волшебного превращения лога в нечто более приятное глазу.
#### Mining and crafting
Настройка отладки хорошо гуглится, поэтому описывать подробно этот процесс я не буду. Поскольку нас интересует все происходящее с момента старта системы, нам нужно отметить пункт «Cycle Initial Break», с помощью чего отладчик остановится, как только в отлаживаемой системе будет загружена подсистема отладки ядра. Дублирование вывода в файл можно осуществить при помощи команд ".logopen" и ".logclose", это просто. Другая полезная команда — ".cls". Она очищает экран команд, и да, только экран команд.
Интересующая нас функция — «MiCreateImageFileMap». Это внутренняя функция менеджера памяти, проецирующая исполняемый файл в память. Проецирование в память происходит при создании секции, например, при запуске исполняемого файла. Однако учтите, что если исполняемый файл проецируется в память, это не гарантия того, что будет выполнен его код! Эта функция просто создает проекцию, чаще всего «про запас», чтобы, если кто-то надумает запустить модуль на исполнение, можно было сэкономить время его загрузки. На эту функцию поставим логирующую точку останова.
Если у вас достаточно маны, вводите следующую команду:
```
bu nt!MiCreateImageFileMap "dt nt!_EPROCESS -d ImageFileName @$proc; dt nt!_FILE_OBJECT -d FileName @rcx; g"
```
Магическая строчка буквально означает следующее:
* bu (Set Unresolved Breakpoint) — установить неразрешенную точку останова. Не то чтобы кто-то или что-то не разрешал, просто для ее установки необходимо определиться, по какому адресу ее ставить. Дело в том, что заранее не известно, по какому адресу она должна располагаться. При загрузке любого модуля проверяется присутствие в нем необходимой функции, и если такая функция найдена, точка останова устанавливается автоматически. Такой способ установки незаменим при включенном ASLR — рандомизации адресного пространства, поскольку модули будут загружаться каждый раз по разным адресам, и точка останова, установленная по фиксированному адресу, с большой вероятностью окажется не у дел.
* nt!MiCreateImageFileMap — символ, на котором нужно останавливаться. В WinDbg принята запись в форме 'module\_name!function\_name'. В данном случае nt является предопределенным псевдонимом для ntoskrnl.exe.
* далее следует часть WinDbg-скрипта, которая будет выполняться каждый раз при остановке на этой функции. «dt nt!\_EPROCESS -d ImageFileName @$proc» по-русски означает «отобразить поле ImageFileName структуры \_EPROCESS из модуля nt при условии ее отображения по адресу, определенному в псевдорегистре «текущий процесс»». Следующая после разделителя ";" команда означает примерно то же самое, только адрес структуры берется из регистра rcx, в котором в Microsoft x64 ABI передается первый параметр функции. «g» означает «go», т.е. продолжить исполнение.
Небольшая рекомендация по использованию логирующих точек останова: старайтесь не использовать расширения отладчика (команды, начинающиеся с "!"), поскольку в таком случае логирование будет выполняться на порядок медленнее.
Поехали! Отжимаем тормоз точки останова и ждем. Я ждал, пока не прогрузится рабочий стол, т.е. я залогинился. Полученный «урожай» немного редактируется, обрезается все лишнее для удобства дальнейшей обработки и скармливается дружище питону. Не будем заострять внимание на парсинге лога. Отметим только, что граф укладывался в форму спирали Архимеда с дальнейшей коррекцией вручную, поскольку происходило наложение узлов друг на друга. В полученном графе учитывается порядок загрузки библиотек. К сожалению, пришлось пожертвовать учетом порядка загрузки исполняемых файлов относительно библиотек в угоду удобочитаемости графа.
#### Карта звездного неба
Условно выделим несколько групп загрузки.
Начинается работа OC в модуле ntoskrnl.exe, являющимся ядром ОС. А если еще конкретнее — с функции KiSystemStartup(). Вместе с загружаемыми системными компонентами она формирует фундамент ОС: разделение режимов работы, базовые сервисы для пользовательских приложений и т.п. В эту же группу входят драйверы, отмеченные для загрузки во время старта системы. В двух словах, в этой ракушке зарождается ОС Windows.
Следующий узел — менеджер сессий (session manager). Его представляет первый после системного процесс, стартующий в Windows — smss.exe. Процесс примечателен тем, что является родным (native) процессом Windows, то есть он не использует подсистему Win32, которая в общем-то еще не загружена. Этот процесс использует только нативные сервисы операционной системы посредством ntdll.dll, представляющей собой интерфейс режима пользователя для сервисов ОС. Также этот процесс является доверенным компонентом операционной системы и обладает исключительными правами, например, он может создавать маркеры безопасности (security tokens). Но главное его предназначение — создание сеансов и инициализация подсистем, как графической, так и различных исполняемых (Windows, POSIX). Эта ракушка воздает каждому по потребностям.
Группа входа в систему (logon) состоит из нескольких процессов. В целом они отвечают за инициализацию сеансов. Это включает в себя отображение экрана приветствия, создание рабочих столов, запуск процессов автозагрузки и инициализацию подсистемы безопасности и т.п. Этот веник отметает всех посторонних.
Самой массивной оказалась группа сервисов. Во многом она обязана своим объемом службе SuperFetch. Эта та самая, про которую говорят, что она по выходным заранее прогружает офисный пакет, а в начале рабочей недели — Steam с игрушками. Superfetch прогружает огромное количество модулей при старте системы, чтобы потом «все быстрее работало». Да и кроме него в системе хватает сервисных приложений и автозапускающихся драйверов. Думаю, все видели оснастку «Службы и приложения». Эта звезда жизни заводит в системе все, что нужно и не очень.
Последним отмечу любимый всеми explorer.exe. Примечательно, что к моменту его запуска все используемые им модули уже загружены в память. В скриншот также попал некий vcredist\_x64.exe — бедолага лежал на рабочем столе подопытной виртуальной машины и был прогружен в память проводником.
Вообще способов оказаться загруженным в память у модуля много. Например, достаточно запросить информацию из ресурсов исполняемого файла, в том числе его иконку. Конкретно в данном примере проводник проверял, является ли эта программа требующей повышенных привилегий, т.е. стоит ли дорисовывать к иконке соответствующий рисуночек с желто-голубым щитом. Еще раз отмечу, что загрузка модуля в память не означает выполнение его кода!
Лично я держу получившуюся картинку под боком. По ней хорошо прослеживаются зависимости, например, драйверов. Также в паре с утилитой Sysinternals Autoruns можно увидеть, на каком этапе загрузки подтягиваются те или иные модули.
Граф загрузки был построен для ОС Windows 7 Enterprise x64, установленной на виртуальной машине VMware. Ниже приведены векторное изображение графа и непосредственно файл в формате gml, с которым можно поиграться в любом редакторе графов.
[Граф в формате GML](http://www.ptsecurity.ru/download/boot_graph_win7_ent_x64.gml)
[Векторное изображение графа](http://www.ptsecurity.ru/download/boot_svg_win7_ent_x64.svg)
Внимание! Бонус!
Граф загрузки для чистой ОС Windows 8 Enterprise x64 на живой машине ;)
[Граф в формате GML](http://www.ptsecurity.ru/download/boot_graph_win8_ent_x64.gml)
[Векторное изображение графа](http://www.ptsecurity.ru/download/boot_svg_win8_ent_x64.svg)
Ингредиенты:
WinDbg @ [msdn.microsoft.com/en-us/windows/hardware/gg463009.aspx](http://msdn.microsoft.com/en-us/windows/hardware/gg463009.aspx)
Python @ [www.python.org](http://www.python.org/)
NetworkX @ [networkx.lanl.gov](http://networkx.lanl.gov/)
yEd Graph Editor @ [www.yworks.com/en/products\_yed\_about.html](http://www.yworks.com/en/products_yed_about.html)
Руки @ Плечи | https://habr.com/ru/post/164121/ | null | ru | null |
# Архитектура Cisco DNA – ИТ в условиях цифрового бизнеса
Базовые задачи ИТ практически не менялись на протяжении последних десятилетий. Изменения, как правило, касались используемых технологий, а не процессов или требований, используемых или предъявляемых к ИТ. Такое положение вещей продолжалось до тех пор, пока ИТ оставалось исключительно сервисной службой, а участие ИТ в основном бизнесе предприятия было крайне ограниченным.
Сегодня мы наблюдаем стремительные изменения, источником которых стала повсеместная цифровизация современного бизнеса – компании активно используют современные технологии для получения конкурентных преимуществ.
В марте 2016 года компания Cisco представила новую архитектуру для корпоративных сетей – **Cisco Digital Network Architecture** или Архитектура цифровых сетей Cisco. Что представляет собой новая архитектура? Какие ее основные особенности и отличия? Какие задачи решает и какими преимуществами обладает? На эти и многие другие вопросы будут даны ответы в этой статье.
Рис 1. – Архитектура Cisco Digital Network Architecture — Cisco DNA
В условиях цифровизации ИТ становится ключевым участником бизнес-процесса. Качественное изменение роли повышает значимость ИТ в структуре предприятия, но не дается бесплатно – к ИТ предъявляются новые требования, которые зачастую невозможно реализовать в рамках привычных процессов и технологий.
```
Говоря о новых требованиях, в первую очередь следует упомянуть **скорость ИТ-процессов**. Основная проблема сегодня – ИТ не успевают за изменениями в основном бизнесе. Необходимые изменения осуществляются слишком медленно, а результат изменений уже неактуален на момент ввода в эксплуатацию. Среди причин можно назвать низкий уровень автоматизации и эффективности использования существующих ресурсов, а также высокая степень сложности, как самой инфраструктуры, так и процессов с ней связанных.
```
Другой задачей, которую призван решать современный ИТ, является **прозрачность процессов**, происходящих в инфраструктуре и приложениях предприятия. Несмотря на длительное существование различных технологий оценки состояния сети, таких, например, как SNMP или Netflow, эти технологии, являясь очень эффективным способом получения статистики, не обладают встроенными средствами по формированию аналитики. И даже с внешними системами анализа эти технологии не способны представить картину происходящего с точки зрения бизнес-приложений.
Не следует забывать о требованиях, которые возникают на стыке между ИТ и основным бизнесом. Наиболее наглядно такое взаимодействие продемонстрировала компания Gartner в виде концепции Би-модального (Bi-modal) ИТ. Одной из ключевых особенностей такого подхода стала уже упомянутая автоматизация. В случае би-модального подхода речь идет об автоматизации процессов не только в пределах самого ИТ-отдела, но в даже в большей степени при взаимодействии ИТ с бизнесом.
Наконец, бюджет ИТ из года в год слабо меняется, а CIO вынуждены распределять финансирование между несколькими зачастую конкурирующими инициативами, стараясь совместить поддержку существующей инфраструктуры с развитием и внедрением новых технологий, необходимых бизнесу, не забывая при этом об обеспечении информационной и сетевой безопасности и соблюдении различных регуляторных требований.
И здесь перед ИТ возникает крайне сложная задача поиска эффективного баланса для обеспечения всех указанных требований.
Архитектура Cisco DNA
=====================
```
Чтобы помочь корпоративным заказчикам ответить на вызовы современного мира, компания Cisco в марте 2016 года представила инновационную Архитектуру цифровых сетей **Cisco Digital Network Architecture**. Cisco DNA – это открытая, расширяемая и программно-определяемая архитектура для современного цифрового предприятия.
```
В первую очередь Cisco DNA объединяет в себе, как уже существующие и зарекомендовавшие себя решения Cisco, так и технологии, которые ранее не использовались в корпоративном сегменте – например такие, как SDN и NFV. Во-вторых, Cisco DNA определяет и описывает рекомендованное взаимодействие для всех используемых в рамках архитектуры продуктов и решений с помощью открытых программных интерфейсов API. В-третьих, Cisco DNA объединяет такие решения в логические блоки, которые в свою очередь адресуют все рассмотренные ранее задачи ИТ современного цифрового предприятия – упрощение и автоматизация ИТ-процессов, ускорение внедрения инноваций, получение всеобъемлющей аналитики о сети, приложениях и пользователях, снижение рисков, издержек и расходов и, конечно, эффективное и автоматизированное взаимодействие с основным бизнесом.
DNA Виртуализация
-----------------
В основе любых ИТ-технологий лежит инфраструктура. Одним из базовых принципов Cisco DNA является повсеместное использование **виртуализации**, как способа значительно повысить эффективность использования доступных ресурсов ИТ. В рамках Cisco DNA виртуализация впервые затронула сетевую инфраструктуру. Во многом это стало возможным благодаря бурному развитию технологий виртуализации сетевых функций NFV, которые в последние несколько лет завоевали значительную популярность среди операторов связи. Cisco DNA сделала доступными технологии NFV для корпоративных заказчиков. Что это означает с практической точки зрения? Многие из сетевых функций, которые ранее были доступны только в виде специализированного оборудования, теперь доступны в виртуализированном виде, при этом полностью сохраняя все функциональные возможности аппаратных аналогов. Большинство аппаратных решений Cisco уже имеют виртуализированную версию. Это и Cisco CSR1000v – программный аналог флагманской платформы маршрутизатора Cisco ASR 1000, и Cisco ASAv – аналог сетевого экрана Cisco ASA, и виртуализированные версии системы контроля и фильтрации Web-трафика Cisco Web Security Appliance и многие другие.
Использование NFV для ИТ означает гораздо более эффективное управление ресурсами. Те проекты, которые раньше требовали специализированных аппаратных платформ, а время исполнение таких проектов занимало от недель до месяцев, теперь могут быть развернуты за часы или даже минуты. При этом зачастую не требуется проведение стендовых испытаний или монтажных работ – все изменения производятся в рамках доступного пула x86 ресурсов, размещенных в центральном или удаленном офисе предприятия.
Рис 2. – Решение Cisco Enterprise NFV
С точки зрения Cisco DNA в первую очередь наиболее целесообразно использовать NFV-технологии для решения сетевых задач удаленного офиса. Во многих случаях такие офисы используют стандартный набор аппаратных решений – маршрутизатор, коммутатор, сетевой экран, оптимизация WAN каналов, фильтрация трафика. В рамках Cisco DNA анонсировано уникальное решение **Cisco Enterprise NFV**, которое обеспечивает весь жизненный цикл виртуализированной сетевой инфраструктуры удаленного офиса предприятия. Помимо уже упомянутых виртуализированных версий классических аппаратных решений, Cisco Enterpise NFV включает в себя совершенно новые разработки – **Cisco Enterprise Service Automation** (Cisco ESA) – программный комплекс для автоматизации внедрения и эксплуатации Cisco Enterprise NFV, а также специальные гибридные аппаратные платформы, которые поддерживают запуск нескольких VNF на одной аппаратной платформе и обеспечивают объединения таких VNF в логические цепочки (service-chaining), при этом поддерживают управление через открытые программные интерфейсы Netconf API, RESTconf API.
Cisco DNA, не ограничивает заказчиков использованием только NFV технологий для обеспечения сетевых сервисов. Современные аппаратные решения Cisco в области маршрутизации и коммутации, продолжают оставаться эффективными решениями для множества инфраструктурных задач. Однако, чтобы такие решения соответствовали требованиям и задачам Cisco DNA, компания Cisco внесла существенные дополнения в ПО своих аппаратных платформ. В первую очередь речь идет о доступности открытых API управления на всех рекомендованных аппаратных платформах – Cisco Catalyst 3650/3850, Cisco ISR 4000, Cisco ASR 1000 и других популярных моделях. Во-вторых, для большинства аппаратных маршрутизаторов появилась возможность хостинга любых бизнес-приложений непосредственно на платформе маршрутизатора или на основе специального модуля. Здесь речь может идти о практически любых приложениях, в том числе выполняющих задачи сбора телеметрии для Аналитики или, например, обеспечение специализированных алгоритмов шифрования для связи различных офисов предприятия в соответствии корпоративными требованиями и стандартами и множество других приложений.
DNA Автоматизация
-----------------
Следующим ключевым принципом Cisco DNA является Автоматизация и Надежность. Сама по себе задача автоматизации не является революционной. Многие годы производители оборудования и решений для корпоративного сегмента предлагают специализированные системы управления (NMS), которые призваны автоматизировать часть процессов взаимодействия с инфраструктурой. К преимуществам таких решений однозначно можно отнести глубокую интеграцию с обслуживаемым решением и, как следствие, богатые возможности настройки и кастомизации таких систем. Недостатки таких систем являются продолжением их достоинств. Они остаются сложными в освоении и эксплуатации, сфера их применения ограничена соответствующей частью инфраструктуры и не учитывает специфику бизнес-приложений предприятия, возможности интеграции на основе открытых API не всегда отвечает требованиям цифрового предприятия.
Рис 3. – Одна сеть — одна политика
Автоматизация в рамках Cisco DNA направлена на упрощение и ускорение всех основных ИТ-процессов как для управления сетевой инфраструктурой, так и при взаимодействии с бизнесом-приложениями через открытые API. С точки зрения Cisco DNA приоритетом является быстрое, простое и надежное внедрение требуемой ИТ-услуги и обеспечение гарантии качества такой услуги при последующей эксплуатации, а не процесс выбора той или иной технологии для реализации этой услуги. С таким подходом Cisco DNA позволяет предприятию найти уникальный баланс между инфраструктурной сложностью, зачастую необходимой для реализации любых потенциальных ИТ-услуг, и простотой эксплуатации. Для реализации этого подхода Cisco разработала и выпустила в ноябре 2015 года инновационное решение для автоматизации всех процессов в корпоративной сетевой инфраструктуре **Cisco Application Policy Infrastructure Controller – Enterprise Module** или **Cisco APIC-EM**.
Cisco APIC-EM — это первый коммерчески доступный SDN-контроллер Cisco для корпоративной кампусной и распределенной проводной и беспроводной сети. Это решение органично дополняет получившую мировое признание архитектуру Cisco ACI для центров обработки данных (ЦОД). В рамках ACI функцию SDN-контроллера выполняет Cisco APIC. Таким образом с выпуском Cisco APIC и затем Cisco APIC-EM, SDN-решение Cisco полностью обеспечивает автоматизацию ИТ-процессов и услуг, охватывающих все домены корпоративной сети. Cisco APIC-EM, в отличие от классических концептов SDN-контроллеров, обладает рядом существенных преимуществ. Во-первых, наряду с возможностью использования REST API для программирования услуг в сети, APIC-EM обладает интуитивно понятным графическим интерфейсом управления – любая функция доступная через API, также доступна и через графический интерфейс и наоборот. Это позволяет эффективно использовать APIC-EM в рамках би-модального ИТ, когда традиционный ИТ взаимодействует с инфраструктурой в основном через графический интерфейс, а подразделения DevOps – через API. Во-вторых, APIC-EM можно начать использовать в сети, уже находящейся в эксплуатации – в отличие от классических SDN-решений не требуется мигрировать плоскость управления (Control Plane) на централизованный SDN-контроллер, что позволяет одновременно сохранить автономность каждого устройства, а с другой скрыть сложность инфраструктуры. Это особенно важно с учетом распределенной природы корпоративной сети, для которой классические SDN-решения с централизацией плоскости управления ограничено применимы. В-третьих, уже сейчас Cisco APIC-EM поддерживает все современные модели оборудования Cisco для корпоративной сети. Наконец, APIC-EM сразу поставляется с набором готовых приложений, призванных автоматизировать наиболее часто встречающиеся операции в корпоративной сети – внедрение нового оборудования (приложение Network PnP), применение Cisco CVD (www.cisco.com/go/cvd) дизайнов и политик (приложения IWAN App и EasyQoS App), поиск неисправностей и сбоев в сети (приложение Path Tracer) и другие.
Рис 4. – Cisco APIC-EM в би-модальном ИТ
И самое главное — чтобы начать знакомство с Cisco APIC-EM, достаточно зарегистрироваться на портале для разработчиков [Cisco DevNet](http://developer.cisco.com) и получить доступ к "песочнице" (sandbox) APIC-EM, доступной всем желающим.
DNA Аналитика
-------------
Внедрение Автоматизации Cisco DNA позволяет заказчикам значительно упростить и ускорить процессы внедрения и эксплуатации ИТ инфраструктуры с учетом требований бизнес-приложений или даже с их непосредственным участием (модель DevOps), но не подразумевает в общем случае контроля качества предоставляемых услуг. Для решения этой задачи Cisco DNA предлагает группу решений DNA Аналитика. Средства Аналитики, получая «телеметрию» с корпоративной инфраструктуры и приложений, способны в режиме реального времени осуществлять различные виды анализа о состоянии, поведении и тенденциях, как для самих ИТ-услуг, так и для пользователей, потребляющих эти услуги, а также оценить насколько результат соответствует согласованному качеству предоставления сервиса. Для формирования такой телеметрии могут использоваться специальные легковесные приложения, которые размещаются непосредственно на устройствах и/или виртуальных машинах.
Наглядными примерами систем аналитики для Cisco DNA являются **Cisco Tetration Analytics** и **Cisco Connected Mobile Experience (CMX)**. Cisco CMX – это инновационная технология, разработанная специально для беспроводных сетей, позволяет собрать, проанализировать и выдать в удобной форме информацию о местоположении беспроводных клиентов, сформировать профили их поведения и присутствия в беспроводной сети – эта и другая информация может быть использована основными бизнес-подразделениями компании для создания уникальных персонифицированных услуг для коммерческих клиентов. В свою очередь Tetration Analytics – это новейшая платформа Cisco для формирования аналитики в рамках ЦОД. Tetration Analytics использует программные и аппаратные сенсоры для анализа поведения пользователей и приложений в ЦОД, радикально повышая прозрачность происходящих в ЦОД процессов.
DNA Безопасность
----------------
Скорость и качество предоставляемых услуг имеет значение только при обеспечении достаточного уровня защиты, как самой инфраструктуры, так и потребителей ИТ-услуг – пользователей и приложений. В этих условиях обеспечение и контроль безопасности играет критически важную роль.
В Cisco DNA интегрированы современные решения Cisco для обеспечения информационной и сетевой безопасности – в качестве примера следует упомянуть **Cisco ISE, Cisco Stealthwatch**. Программные и аппаратные компоненты на всех уровнях архитектуры оснащены специализированными средствами контроля доступа и обнаружения угроз. Особый акцент сделан на использовании технологий TrustSec и MacSec. В Cisco DNA использованы решения на базе этих технологий – **Сеть как сенсор (Network-as-a-Sensor)** и **Сеть как средство контроля (Network-as-Enforcer)**. Эти технологии прозрачно поддерживаются, как на уровне инфраструктуры, так и средствами Автоматизации и Аналитики Cisco DNA.
DNA Облачные сервисы
--------------------
Еще одной особенностью современного мира ИТ стало активное использование публичных или частных облачных сервисов для решения корпоративных задач. Cisco DNA уже сейчас предлагает ряд решений на базе облачных технологий, позволяющих заказчикам получать услуги из облака Cisco или предоставлять соответствующие услуги на базе собственных центров обработки данных. Среди таких решений следует, конечно, упомянуть Cisco CMX Cloud – облачный вариант реализации средств аналитики Cisco Connected Mobile Experience.
Cisco DNA – это набор разнообразных технологий и решений, как программных, так и аппаратных. Чтобы упростить процесс выбора и заказа решений, обеспечивающих преимущества Cisco DNA, компания Cisco включила лицензии для большинства программных DNA компонентов в новую модель лицензирования оборудования **Cisco ONE Software.** Приобретая инфраструктурное оборудование в рамках этой модели лицензирования, заказчик может быть уверен, что он также приобретает право на использование уникальных программных продуктов Cisco, реализующих задачи Автоматизации, Аналитики и Виртуализации Cisco DNA.
Выводы
======
Подводя итог, **Cisco Digital Network Architecture** – это революционная архитектура ИТ для любого современного предприятия. Cisco DNA позволяет заказчикам радикально снизить издержки при внедрении и эксплуатации ИТ-инфраструктуры и услуг, ускорить процесс инноваций в ИТ, при этом обеспечить защиту существующих и будущих инвестиций и, что немаловажно, ИТ стать частью основного бизнеса и обеспечивать его рост и предсказуемость.
Полезные ссылки:
[Материалы по Cisco DNA](http://www.cisco.com/c/ru_ru/solutions/enterprise-networks/digital-network-architecture/index.html?CAMPAIGN=ciscodna_17&COUNTRY_SITE=ru&POSITION=dnaarticle&REFERRING_SITE=habrahabr)
[](http://www.cisco.com/c/ru_ru/solutions/enterprise-networks/index.html?CAMPAIGN=ciscodna_17&COUNTRY_SITE=ru&POSITION=dnaarticle&REFERRING_SITE=habrahabr) | https://habr.com/ru/post/309314/ | null | ru | null |
# Selenium для Python. Глава 2. Первые Шаги
Продолжение перевода неофициальной документации Selenium для Python.
Перевод сделан с разрешения автора Baiju Muthukadan.
Оригинал можно найти [здесь](http://selenium-python.readthedocs.org/index.html).
Содержание:
-----------
1. [Установка](https://habr.com/ru/post/248559/)
2. Первые Шаги
3. [Навигация](https://habr.com/ru/post/250947/)
4. [Поиск Элементов](https://habr.com/ru/post/250975/)
5. [Ожидания](https://habr.com/ru/post/273089/)
6. [Объекты Страницы](https://habr.com/ru/post/273115/)
7. WebDriver API
8. Приложение: Часто Задаваемые Вопросы
2. Первые шаги
==============
2.1. Простое использование
--------------------------
Если вы установили привязку Selenium к Python, вы можете начать использовать ее с помощью интерпретатора Python.
```
from selenium import webdriver
from selenium.webdriver.common.keys import Keys
driver = webdriver.Firefox()
driver.get("http://www.python.org")
assert "Python" in driver.title
elem = driver.find_element_by_name("q")
elem.send_keys("pycon")
elem.send_keys(Keys.RETURN)
assert "No results found." not in driver.page_source
driver.close()
```
Код выше может быть сохранен в файл (к примеру, python\_org\_search.py), и запущен:
>
> ```
> python python_org_search.py
> ```
>
Запускаемый вами Python должен содержать установленный модуль selenium.
2.2. Пошаговый разбор примера
-----------------------------
Модуль selenium.webdriver предоставляет весь функционал WebDriver'а. На данный момент WebDriver поддерживает реализации Firefox, Chrome, Ie и Remote. Класс Keys обеспечивает взаимодействие с командами клавиатуры, такими как RETURN, F1, ALT и т.д…
```
from selenium import webdriver
from selenium.webdriver.common.keys import Keys
```
Далее создается элемент класса Firefox WebDriver.
```
driver = webdriver.Firefox()
```
Метод driver.get перенаправляет к странице URL в параметре. WebDriver будет ждать пока страница не загрузится полностью (то есть, событие “onload” игнорируется), прежде чем передать контроль вашему тесту или скрипту. Стоит отметить, что если страница использует много AJAX-кода при загрузке, то WebDriver может не распознать, загрузилась ли она полностью:
```
driver.get("http://www.python.org")
```
Следующая строка — это утверждение (англ. assertion), что заголовок содержит слово “Python” [assert позволяет проверять предположения о значениях произвольных данных в произвольном месте программы. По своей сути assert напоминает констатацию факта, расположенную посреди кода программы. В случаях, когда произнесенное утверждение не верно, assert возбуждает исключение. Такое поведение позволяет контролировать выполнение программы в строго определенном русле. Отличие assert от условий заключается в том, что программа с assert не приемлет иного хода событий, считая дальнейшее выполнение программы или функции бессмысленным — Прим. пер.]:
```
assert "Python" in driver.title
```
WebDriver предоставляет ряд способов получения элементов с помощью методов find\_element\_by\_\*. Для примера, элемент ввода текста input может быть найден по его атрибуту name методом find\_element\_by\_name. Подробное описание методов поиска элементов можно найти в главе Поиск Элементов:
```
elem = driver.find_element_by_name("q")
```
После этого мы посылаем нажатия клавиш (аналогично введению клавиш с клавиатуры). Специальные команды могут быть переданы с помощью класса Keys импортированного из selenium.webdriver.common.keys:
```
elem.send_keys("pycon")
elem.send_keys(Keys.RETURN)
```
После ответа страницы, вы получите результат, если таковой ожидается. Чтобы удостовериться, что мы получили какой-либо результат, добавим утверждение:
```
assert "No results found." not in driver.page_source
```
В завершение, окно браузера закрывается. Вы можете также вызывать метод quit вместо close. Метод quit закроет браузер полностью, в то время как close закроет одну вкладку. Однако, в случае, когда открыта только одна вкладка, по умолчанию большинство браузеров закрывается полностью:
```
driver.close()
```
2.3. Использование Selenium для написания тестов
------------------------------------------------
Selenium чаще всего используется для написания тестовых ситуаций. Сам пакет selenium не предоставляет никаких тестовых утилит или инструментов разработки. Вы можете писать тесты с помощью модуля Python unittest. Другим вашим выбором в качестве тестовых утилит/инструментов разработки могут стать py.test и nose.
В этой главе, в качестве выбранной утилиты будет использоваться unittest. Ниже приводится видоизмененный пример с использованием этого модуля. Данный скрипт тестирует функциональность поиска на сайте python.org:
```
import unittest
from selenium import webdriver
from selenium.webdriver.common.keys import Keys
class PythonOrgSearch(unittest.TestCase):
def setUp(self):
self.driver = webdriver.Firefox()
def test_search_in_python_org(self):
driver = self.driver
driver.get("http://www.python.org")
self.assertIn("Python", driver.title)
elem = driver.find_element_by_name("q")
elem.send_keys("pycon")
assert "No results found." not in driver.page_source
elem.send_keys(Keys.RETURN)
def tearDown(self):
self.driver.close()
if __name__ == "__main__":
unittest.main()
```
Вы можете запустить тест выше из командной строки следующей командой:
>
> ```
> python test_python_org_search.py
> .
> ----------------------------------------------------------------------
> Ran 1 test in 15.566s
>
> OK
> ```
>
Результат сверху показывает, что тест завершился успешно.
2.4. Пошаговый разбор примера
-----------------------------
Сначала были импортированы все основные необходимые модули. Модуль [unittest](http://docs.python.org/library/unittest.html) встроен в Python и реализован на Java’s JUnit. Этот модуль предоставляет собой утилиту для организации тестов.
Модуль selenium.webdriver предоставляет весь функционал WebDriver'а. На данный момент WebDriver поддерживает реализации Firefox, Chrome, Ie и Remote. Класс Keys обеспечивает взаимодействие с командами клавиатуры, такими как RETURN, F1, ALT и т.д…
```
import unittest
from selenium import webdriver
from selenium.webdriver.common.keys import Keys
```
Класс теста унаследован от unittest.TestCase. Наследование класса TestCase является способом сообщения модулю unittest, что это тест:
```
class PythonOrgSearch(unittest.TestCase):
```
setUp — это часть инициализации, этот метод будет вызываться перед каждым методом теста, который вы собираетесь написать внутри класса теста. Здесь мы создаем элемент класса Firefox WebDriver.
```
def setUp(self):
self.driver = webdriver.Firefox()
```
Далее описан метод нашего теста. Метод теста всегда должен начинаться с фразы test. Первая строка метода создает локальную ссылку на объект драйвера, созданный методом setUp.
```
def test_search_in_python_org(self):
driver = self.driver
```
Метод driver.get перенаправляет к странице URL в параметре. WebDriver будет ждать пока страница не загрузится полностью (то есть, событие “onload” игнорируется), прежде чем передать контроль вашему тесту или скрипту. Стоит отметить, что если страница использует много AJAX-кода при загрузке, то WebDriver может не распознать, загрузилась ли она полностью:
```
driver.get("http://www.python.org")
```
Следующая строка — это утверждение, что заголовок содержит слово “Python”:
```
self.assertIn("Python", driver.title)
```
WebDriver предоставляет ряд способов получения элементов с помощью методов find\_element\_by\_\*. Для примера, элемент ввода текста input может быть найден по его атрибуту name методом find\_element\_by\_name. Подробное описание методов поиска элементов можно найти в главе Поиск Элементов:
```
elem = driver.find_element_by_name("q")
```
После этого мы посылаем нажатия клавиш (аналогично введению клавиш с клавиатуры). Специальные команды могут быть переданы с помощью класса Keys импортированного из selenium.webdriver.common.keys:
```
elem.send_keys("pycon")
elem.send_keys(Keys.RETURN)
```
После ответа страницы, вы получите результат, если таковой ожидается. Чтобы удостовериться, что мы получили какой-либо результат, добавим утверждение:
```
assert "No results found." not in driver.page_source
```
Метод tearDown будет вызван после каждого метода теста. Это метод для действий чистки. В текущем методе реализовано закрытие окна браузера. Вы можете также вызывать метод quit вместо close. Метод quit закроет браузер полностью, в то время как close закроет одну вкладку. Однако, в случае, когда открыта только одна вкладка, по умолчанию большинство браузеров закрывается полностью.:
```
def tearDown(self):
self.driver.close()
```
Завершающий код — это стандартная вставка кода для запуска набора тестов [Сравнение \_\_name\_\_ с "\_\_main\_\_" означает, что модуль (файл программы) запущен как отдельная программа («main» (англ.) — «основная», «главная») (а не импортирован из другого модуля). Если вы импортируете модуль, атрибут модуля \_\_name\_\_ будет равен имени файла без каталога и расширения — Прим. пер.]:
```
if __name__ == "__main__":
unittest.main()
```
2.5. Использование Selenium с remote WebDriver
----------------------------------------------
Для использования remote WebDriver (удаленного веб-драйвера) необходимо запустить Selenium server. Для запуска сервера используйте команду:
>
> ```
> java -jar selenium-server-standalone-2.x.x.jar
> ```
>
Пока Selenium server запускается, вы можете видеть сообщения вида:
>
> ```
> 15:43:07.541 INFO - RemoteWebDriver instances should connect to: http://127.0.0.1:4444/wd/hub
> ```
>
Строка выше сообщает о том, что вы можете использовать указанный URL для подключения remote WebDriver. Ниже приводится несколько примеров:
```
from selenium.webdriver.common.desired_capabilities import DesiredCapabilities
driver = webdriver.Remote(
command_executor='http://127.0.0.1:4444/wd/hub',
desired_capabilities=DesiredCapabilities.CHROME)
driver = webdriver.Remote(
command_executor='http://127.0.0.1:4444/wd/hub',
desired_capabilities=DesiredCapabilities.OPERA)
driver = webdriver.Remote(
command_executor='http://127.0.0.1:4444/wd/hub',
desired_capabilities=DesiredCapabilities.HTMLUNITWITHJS)
```
Переменная desired\_capabilities — это словарь. Вместо того, чтобы использовать словари по умолчанию, вы можете явно прописать значения:
```
driver = webdriver.Remote(
command_executor='http://127.0.0.1:4444/wd/hub',
desired_capabilities={'browserName': 'htmlunit',
'version': '2',
'javascriptEnabled': True})
```
[Перейти к следующей главе](https://habr.com/ru/post/250947/) | https://habr.com/ru/post/250921/ | null | ru | null |
# Интеграция WordPress и Zend FrameWork
Да-да, случается и такое.
Допустим, Вы работаете в распределённой команде. Дизайнер сидит где-то в далёкой загадочной стране, и всё что от него можно получить — шаблоны, сделанные для WordPress. А Вам нужно добавить на сайт далеко не тривиальный функционал. Трогать ядро WordPress Вам нельзя, а возможности плагинов Вас совершенно не устраивают (может вам не хватает стандартного набора хуков, а может просто не любите этот движок, всякое бывает).
Первый порыв — взять подходящий движок или фреймворк (например ZF), перенести на него дизайн и спокойно работать. Но вот загвоздка, вы сделаете новый функционал и уйдёте с проекта, а дизайнер и саппорт останутся. И они не умеют и не хотят уметь делать что либо на ZF.
Если вам интересно как выкручиваться в подобной ситуации, приглашаю под кат
Концепт такой. Весь нестандартный функционал выполняет ZF, а WP только выводит результат, так же, как например содержимое отдельной страницы или поста. Т.о. дизайнер может как угодно изменять рамку (хедер, футер, и т.п) для любых страниц, новая рамка применится и к страницам от ZF. Саппорт будет как ни в чём ни бывало, редактировать статические странички и новости, вставляя где надо ссылки на функционал ZF,
Первым делом требуется заставить WP спрашивать содержимое у ZF для запросов определённого вида, например /do/account/signup/
Конечно, используем систему плагинов. Только вот нету хука, который даст возможность не тянуть пост из wordPressa, а вызвать содержимое через какую либо функцию. Если кто то найдёт, то расскажите мне, будьте добры :) Поэтому будем вероломно использовать хук, который есть и вызывается до подготовки контента.
На наше счастье, http запросы парсятся классом WP\_Query и этим же классом готовится содержимое страницы. WP использует один глобальный объект этого класса. Без всяких угрызений совести, заменяем этот объект на наш подставной экземпляр наследника класса WP\_Query. Чувствуете к чему я веду? Правильно, функция get\_posts() будет переопределена.
Лично я сперва вызываю стандартный метод, он заполнит все глобальные объекты стандартными данными, вытянет из базы дефолтную страницу для отображения, вобщем он молодец, мне без него было бы трудно.
Затем я заменяю контент дефолтной страницы, результатом пришедшим от ZF.
**`define('ZF_MARKER', 'do');
add_action('parse_request', 'zf_query_controller');
function zf_query_controller() {
parse_str($_SERVER['QUERY_STRING'], $params);
if(isset($params[ZF_MARKER])) {
global $wp_the_query;
$q = new ZF_Query();
$q->copyFrom($wp_the_query);
$zf_uri = trim($params[ ZF_MARKER ], "/ ");
$q->req_uri_zf = empty($zf_uri)? '/' : '/' . $zf_uri . '/';
$wp_the_query = $q;
}
}
class ZF_Query extends WP_Query
{
public $req_uri_original = '';
public $req_uri_zf = '';
function copyFrom(WP_Query $wp_query) {
$vars = get_object_vars($wp_query);
foreach($vars as $name => $value) {
$this->$name = $value;
}
}
function &get_posts() {
parent::get_posts();
$post_zf = array(
"ID" => 1,
"post_author" => 1,
"post_date" => '',
"post_date_gmt" => '',
"post_content" => '',
"post_title" => '',
"post_excerpt" => "",
"post_status" => "publish",
"comment_status"=> "open",
"ping_status" => "open",
"post_password" => "",
"post_name" => "",
"to_ping" => "",
"pinged" => "",
"post_modified" => "",
"post_modified_gmt"=> "",
"post_content_filtered"=> "",
"post_parent" => 0,
"guid" => "",
"menu_order" => 1,
"post_type" => ZF_MARKER,
"post_mime_type"=> "",
"comment_count" => "0",
"ancestors" => array(),
"filter" => "",
);
$tmp = $_SERVER['REQUEST_URI'];
$_SERVER['REQUEST_URI'] = $this->req_uri_zf;
$post_zf['post_content'] = require_once ABSPATH . 'zf-app/public/index.php';
$_SERVER['REQUEST_URI'] = $tmp;
global $post;
$post = (object)$post_zf;
$this->posts = array($post);
$this->post = $post;
$this->post_count = count($this->posts);
$this->current_post = 0;
$this->is_single = 1;
$this->is_page = 0;
$this->is_404 = 0;
$this->is_archive = 0;
$this->is_home = 0;
// эти 2 строки нужны, чтобы wordPress (особеннно в версии 3.x) не думал, что у него запросили нечто некорректное.
global $wp_filter;
unset($wp_filter['template_redirect']);
return $this->posts;
}
}`**
И конечно правило для .haccess:
**`RewriteRule /?do/(.*) /index.php?do=$1 [L]`**
Можно и без него, тогда урлы для функционала ZF будут вида /?do=account/signup/
Также, необходимо изменить ZF, он должен не выводить свой респонс, а возвращать его.
**`$controller->returnResponse(true);
$resp = $application->bootstrap()->getBootstrap()->run();
return $resp->getBody();`**
Возвращаемый HTML нужен без тегов и Так что отключите лэйаут или сделайте его примитивным, типа
**`php echo $this-layout()->content ?>`**
Вот вобщем-то и всё.
---
PS: Ещё один момент. если Вам нужно научить WP как-то особенно обращаться с содержимым от ZF, то можно зайти в шаблон Single.php используемой темы и прописать в нужном месте
**`php the_post(); if (ZF_MARKER == $post-post_type) : ?>
php echo $post-post_content;?>
php else:?
...
php endif; ?`**
Для этого и были нужны строчки:
`$this->is_single = 1;
$this->is_page = 0;
$this->is_404 = 0;
$this->is_archive = 0;
$this->is_home = 0;` | https://habr.com/ru/post/96782/ | null | ru | null |
# Введение в анализ сложности алгоритмов (часть 4)
*От переводчика: данный текст даётся с незначительными сокращениями по причине местами излишней «разжёванности» материала. Автор абсолютно справедливо предупреждает, что отдельные темы могут показаться читателю чересчур простыми или общеизвестными. Тем не менее, лично мне этот текст помог упорядочить имеющиеся знания по анализу сложности алгоритмов. Надеюсь, что он окажется полезен и кому-то ещё.
Из-за большого объёма оригинальной статьи я разбила её на части, которых в общей сложности будет четыре.
Я (как всегда) буду крайне признательна за любые замечания в личку по улучшению качества перевода.*
Опубликовано ранее:
[Часть 1](http://habrahabr.ru/post/196560/)
[Часть 2](http://habrahabr.ru/post/195482/)
[Часть 3](http://habrahabr.ru/post/195996/)
#### Оптимальная сортировка
**Поздравляю!** Теперь вы знаете о том, как анализировать сложность алгоритмов, что такое асимптотическая оценка и нотация «большое-О». Вы также в курсе, как интуитивно выяснить является ли сложностью алгоритма `O( 1 )`, `O( log( n ) )`, `O( n )`, `O( n`2 `)` и так далее. Вы знакомы с символами `o`, `O`, `ω`, `Ω`, `Θ` и понятием «наихудшего случая». Если вы добрались до этого места, то моя статья уже выполнила свою задачу.
Этот финальный раздел — опциональный. Он несколько сложнее, так что можете не стесняясь пропустить его, если хотите.От вас потребуется сфокусироваться и потратить некоторое время на решение упражнений. Однако, так же здесь будет продемонстрирован очень полезный и мощный способ анализа сложности алгоритмов, что, безусловно, ст**о**ит внимания.
Мы рассматривали реализацию сортировки, называемую сортировкой выбором, и упоминали, что она не является оптимальной. *Оптимальный алгоритм* — это тот, который решает задачу наилучшим образом, подразумевая, что не существует алгоритма, делающего это лучше. Т.е. все прочие алгоритмы для решения данной проблемы имеют такую же или б**о**льшую сложность. Может существовать масса оптимальных алгоритмов, имеющих одинаковую сложность. Та же проблема сортировки может быть решена оптимально многими способами. Например, мы можем использовать для быстрой сортировки ту же идею, что и при бинарном поиске. Такой способ называется *сортировкой слиянием*.
Прежде, чем реализовать собственно сортировку слиянием, нам надо написать вспомогательную функцию. Назовём её `merge`, и пусть она принимает два уже отсортированных массива и соединяет их в один (тоже отсортированный). Это легко сделать:
```
def merge( A, B ):
if empty( A ):
return B
if empty( B ):
return A
if A[ 0 ] < B[ 0 ]:
return concat( A[ 0 ], merge( A[ 1...A_n ], B ) )
else:
return concat( B[ 0 ], merge( A, B[ 1...B_n ] ) )
```
Функция `concat` принимает элемент («голову») и массив («хвост») и соединяет их, возвращая новый массив с «головой» в качестве первого элемента и «хвостом» в качестве оставшихся элементов. Например, `concat( 3, [ 4, 5, 6 ] )` вернёт `[ 3, 4, 5, 6 ]`. Мы используем `A_n` и `B_n`, чтобы обозначить размеры массивов `A` и `B` соответственно.
**Упражнение 8**Убедитесь, что функция выше действительно осуществляет слияние. Перепишите её на вашем любимом языке программирования, используя итерации (цикл for) вместо рекурсии.
Анализ этого алгоритма показывает, что его время выполнения — `Θ( n )`, где `n` — длина результирующего массива (`n = A_n + B_n`).
**Упражнение 9**Проверьте, что временем выполнения `merge` является `Θ( n )`.
Используя эту функцию, мы можем построить лучший алгоритм сортировки. Идея следующая: мы разбиваем массив на две части, рекурсивно сортируем каждую из них и объединяем два отсортированных массива в один. Псевдокод:
```
def mergeSort( A, n ):
if n = 1:
return A # it is already sorted
middle = floor( n / 2 )
leftHalf = A[ 1...middle ]
rightHalf = A[ ( middle + 1 )...n ]
return merge( mergeSort( leftHalf, middle ), mergeSort( rightHalf, n - middle ) )
```
Эта функция сложнее предыдущих для понимания, поэтому выполнение следующего упражнения может потребовать у вас больше времени.
**Упражнение 10**Убедитесь в правильности `mergeSort` (т.е. проверьте, что она верно сортирует переданный ей массив). Если вы не можете понять, почему она в принципе работает, то прорешайте вручную небольшой пример. При этом не забудьте убедиться, что `leftHalf` и `rightHalf` получаются при разбиении массива примерно пополам. Разбиение не обязательно должно приходиться точно на середину, если, например, массив содержит нечётное количество элементов (вот для чего нам нужна функция `floor`).
В качестве финального упражнения давайте проанализируем сложность `mergeSort`. На каждом шаге мы разбиваем исходный массив на две равные части (аналогично `binarySearch`). Однако, в этом случае дальнейшие вычисления происходят на обеих частях. После возврата рекурсии мы применяем к результатам операцию `merge`, что занимает `Θ( n )` времени.
Итак, мы разбили оригинальный массив на две части, размером `n / 2` каждая. Когда мы будем их соединять, в операции будут участвовать `n` элементов, следовательно, время выполнения будет `Θ( n )`. Рисунок ниже поясняет эту рекурсию:
Давайте посмотрим, что здесь происходит. Каждый кружок представляет собой вызов функции `mergeSort`. Число в кружке показывает количество элементов в массиве, который будет отсортирован. Верхний синий кружок — первоначальный вызов `mergeSort` для массива, размером `n`. Стрелочки показывают рекурсивные вызовы между функциями. Оригинальный вызов `mergeSort` порождает два новых для массивов, размером `n / 2` каждый. В свою очередь, каждый из них порождает ещё два вызова с массивами в `n / 4` элементов, и так далее до тех пор, пока мы не получим массив размера 1. Эта диаграмма называется *рекурсивным деревом*, потому что иллюстрирует работу рекурсии и выглядит как дерево (точнее, как инверсия дерева с корнем вверху и листьями внизу).
Заметьте, что количество элементов в каждой строке остаётся равным `n`. Так же обратите внимание, что каждый вызывающий узел использует для операции `merge` результаты, полученные от вызываемых узлов. Например, красный узел сортирует `n / 2` элементов. Чтобы сделать это, он разбивает `n / 2` массив на два по `n / 4`, рекурсивно вызывает с каждым из них `mergeSort` (зелёные узлы) и объединяет результаты в единое целое размером `n / 2`.
В результате сложностью каждой строки является `Θ( n )`. Мы знаем, что количество таких строк, называемое *глубиной* рекурсивного дерева, будет `log( n )`. Основанием для этого являются те же аргументы, которые мы использовали для бинарного поиска. Итак, у нас `log( n )` строк со сложностью `Θ( n )`, следовательно, общая сложность `mergeSort`: `Θ( n * log( n ) )`. Это намного лучше, чем `Θ( n`2 `)`, которую нам даёт сортировка выбором (помните, `log( n )` намного меньше `n`, поэтому `n * log( n )` так же намного меньше `n * n = n`2).
Как вы видели в последнем примере, анализ сложности позволяет нам сравнивать алгоритмы, чтобы понять, который из них лучше. Исходя из этих соображений, теперь мы можем быть уверены, что для массивов больших размеров сортировка слиянием намного опередит сортировку выбором. Такое заключение было бы проблематично сделать, если бы мы не имели теоретического базиса анализа разработанных нами алгоритмов. Несомненно, алгоритмы сортировки с временем выполнения `Θ( n * log( n ) )` широко используются на практике. Например, [ядро Linux использует алгоритм, называемый «сортировкой кучей»](http://lxr.free-electrons.com/source/lib/sort.c), который имеет такое же время выполнения, как и сортировка слиянием. Заметим, что мы не будем доказывать оптимальность данных алгоритмов сортировки. Это потребовало бы гораздо более громоздких математических аргументов, но будьте уверены: с точки зрения сложности нельзя найти вариант лучше.
После изучения данной статьи, приобретённая вами интуиция относительно анализа сложности алгоритмов должна будет помогать вам создавать быстрые программы и сосредотачивать усилия по оптимизации на тех вещах, которые действительно имеют большое влияние на скорость выполнения. Всё вместе позволит вам работать более продуктивно. К тому же математический язык и нотации (например, «большое О»), рассмотренные в данной статье, будут вам полезны при общении с другими разработчиками программного обеспечения, когда речь зайдёт о времени выполнения алгоритмов, и, надеюсь, вы сможете применить на практике приобретённые знания.
#### Вместо заключения
Статья публикуется под [Creative Commons 3.0 Attribution](http://creativecommons.org/licenses/by/3.0/). Это означает, что вы можете копировать её, публиковать на своих веб-сайтах, вносить в текст изменения и вообще делать с ней всё, что заблагорассудится. Только не забывайте упоминать при этом моё имя. Единственное но: если вы основываете свою работу на данном тексте, то я настоятельно призываю вас публиковать её под Creative Commons, чтобы облегчить совместную работу и распространение информации.
**Спасибо за то, что дочитали до конца!**
#### Ссылки
1. Cormen, Leiserson, Rivest, Stein. [Introduction to Algorithms](http://www.amazon.co.uk/Introduction-Algorithms-T-Cormen/dp/0262533057/ref=sr_1_1?ie=UTF8&qid=1341414466&sr=8-1), MIT Press
2. Dasgupta, Papadimitriou, Vazirani. [Algorithms](http://www.amazon.co.uk/Algorithms-Sanjoy-Dasgupta/dp/0073523402/ref=sr_1_1?s=books&ie=UTF8&qid=1341414505&sr=1-1), McGraw-Hill Press
3. Fotakis. Course of [Discrete Mathematics](http://discrete.gr/) at the National Technical University of Athens
4. Fotakis. Course of [Algorithms and Complexity](http://www.corelab.ece.ntua.gr/courses/algorithms/) at the National Technical University of Athens | https://habr.com/ru/post/196226/ | null | ru | null |
# Блокчейн + распределённое хранилище = Sia
Всем привет! У всех нас есть данные, которые хочется держать под контролем. Мы не хотим потерять к ним доступ и не хотим, чтобы доступ был у кого-то ещё. Где хранить такие данные? Я считаю, что [Sia](https://sia.tech) может стать идеальным местом для этого и расскажу, почему.
*Disclaimer: Sia активно развивается и, по словам разработчиков, всё ещё не подходит для того, чтобы быть единственным местом для бекапа.*
[Sia](https://sia.tech) (произносится "Сая") — это распределённая система на основе блокчейна, участники которой хранят информацию на жестких дисках друг друга за плату. Участник системы может решить быть только пользователем, загружающим данные (в терминологии Sia — renter), или же сервером, принимающим данные (в терминологии Sia — host), или совмещать эти две роли. Хосты заинтересованы в хранении данных, так как они уходят в убыток, если теряют данные. Это обеспечивается следующим образом: при заключении контракта на хранение данных хост вносит депозит и ежедневно подтверждает факт хранения загруженных данных; если он этого не делает, то лишается части депозита. Подробности процесса оставим на десерт :-)
Чтобы данные уцелели даже в случае отказа нескольких хостов, используются [коды Рида — Соломона](https://ru.wikipedia.org/wiki/%D0%9A%D0%BE%D0%B4_%D0%A0%D0%B8%D0%B4%D0%B0_%E2%80%94_%D0%A1%D0%BE%D0%BB%D0%BE%D0%BC%D0%BE%D0%BD%D0%B0). Данные загружаются на 40 хостов и остаются доступными, если хотя бы 10 из этих хостов доступны. Избыточность хранения составляет 3x. В будущем ожидается рост uptime хостов, после чего избыточность можно будет снизить.
В Sia используется свой альткоин — Siacoin. Есть свой блокчейн, в котором хранятся как обычные транзакции, так и контракты на хранение файлов. (Блокчейн биткоина не подошёл бы для Sia, так как в нём нет возможности заключать такие контракты.) Есть и свой [explorer](https://explore.sia.tech/), и майнеры, и биржи для обмена — одним словом, всё, что прилагается к альткоину.
*Страница Siacoin на бирже Poloniex.*
Так почему мне нравится хранить данные в такой системе? А вы не задумывались, какие ещё способы есть в нашем распоряжении? Есть огромное количество способов, имещих [единую точку отказа](https://en.wikipedia.org/wiki/Single_point_of_failure). А единая точка отказа оправдывает своё название и [рано или поздно отказывает](https://habrahabr.ru/post/322932/). Кроме того, такие системы тяготеют к централизации и отказу от анонимности и становятся удобным местом для насаждения государственного контроля за данными пользователя. Мне претит мысль о том, что кто-то может лишить меня доступа к моим же данным. Какой же выбор остаётся у людей, желающих децентрализованно хранить данные? Например, покупать место или серверы в нескольких централизованных системах. Для большинства людей это означает огромные накладные расходы в виде потраченного времени и денег, особенно если делать это анонимно.
Пара слов о том, почему так важна анонимность при хранении данных. Если государство знает о твоей собственности, то на самом деле она тебе не принадлежит, так как государство определяет правила игры и завтра может решить забрать её у тебя (или частично забрать, обложив налогом). Например, в США [изымали золото у людей](https://ru.wikipedia.org/wiki/%D0%9A%D0%BE%D0%BD%D1%84%D0%B8%D1%81%D0%BA%D0%B0%D1%86%D0%B8%D1%8F_%D0%B7%D0%BE%D0%BB%D0%BE%D1%82%D0%B0_%D1%83_%D0%BD%D0%B0%D1%81%D0%B5%D0%BB%D0%B5%D0%BD%D0%B8%D1%8F_%D0%A1%D0%A8%D0%90_%D0%B2_1933_%D0%B3%D0%BE%D0%B4%D1%83) во времена Великой депрессии. Единственный надёжный способ обезопасить собственность — это отвязать её от любой информации, которой располагает государство.
Когда я осознал это, я решил было сделать систему, лишённую этих недостатков: децентрализованную, анонимную и надёжную. Сначала я решил проверить, нет ли чего готового на гитхабе. И нашёл Sia — именно то, что нужно! С точки зрения пользователя, Sia — это готовый аналог покупки кучи серверов для ручной загрузки данных. И аналог более эффективный, так как один сервер хранит данные тысяч пользователей. Калькулятор стоимости хранения на [сайте Sia](https://sia.tech) показывает, что хранение 5Тб в течение месяца обойдётся в 10 долларов. (Disclaimer: реальная цена будет выше из-за комиссий на создание контрактов и тройной избыточности хранения, но всё равно остаётся очень и очень привлекательной.)
Как загрузить файлы в Sia
-------------------------
См. также [руководство на официальном сайте](https://sia.tech/ru/get-started/).
1. Скачать и запустить [Sia-UI](https://sia.tech/ru/apps/#ui).
2. [Купить сиакоины](https://sia.tech/ru/get-siacoin).
3. Загрузить файлы, [используя интерфейс Sia-UI](https://blog.sia.tech/getting-started-with-private-decentralized-cloud-storage-c9565dc8c854).
Все приватные ключи, использующиеся в кошельке, получаются из seed, который программа выдаёт в начале работы. Для восстановления доступа к сиакоинам кошелька (но пока, к сожалению, не к файлам) достаточно знать этот seed.
Если честно, Sia-UI я ни разу не запускал, так как я живу в командной строке, а Sia предоставляет отличные инструменты для этого: [siad](https://github.com/NebulousLabs/Sia/tree/master/siad) и [siac](https://github.com/NebulousLabs/Sia/tree/master/siac). (Кстати, весь код Sia написан на Go, что не может не радовать.) Основы работы с `siad` и `siac` можно почерпнуть из [статьи про запуск хоста](https://blog.sia.tech/how-to-run-a-host-on-sia-2159ebc4725) и из хеплов этих программ. Программу `siad` обычно достаточно просто запустить, а взаимодействовать с ним уже через `siac`.
Примеры команд:
* `siac wallet unlock` — разблокировать кошелёк (требуется ввод seed),
* `siac wallet balance` — показать текущий баланс кошелька,
* `siac renter setallowance money time_period` — заключить контракты с хостами,
* `siac renter upload /path/to/source/file path/in/sia` — загрузить файл в Sia,
* `siac renter contracts` — вывести все заключённые контракты с хостами.
`siac` взаимодействует с `siad` через [HTTP API](https://github.com/NebulousLabs/Sia/blob/master/doc/API.md). С помощью него можно строить свои системы, использующие Sia в качестве хранилища. Команда Sia делает ставку на то, что в будущем компании будут хранить свои данные в Sia.
Для хранения данных необходима информация, находящаяся в папке `renter/`. Есть планы о восстановлении данных исключительно из seed (см. в разделе "планы").
По желанию можно сохранить информацию об объёме загруженного с помощью `siac renter export` и загрузить её в "пузомерку": [rankings.sia.tech](https://rankings.sia.tech/).
Как запустить свой хост Sia
---------------------------
Хост Sia будет приносить доход в сиакоинах своему владельцу. Это неплохой способ монетизировать неиспользуемые части жестких дисков. Оплачивается не только хранение, но и трафик.
Про запуск своего сервера есть [целая статья](https://blog.sia.tech/how-to-run-a-host-on-sia-2159ebc4725). Я тут опять пробегусь по верхам.
1. Нужны программы `siad` и `siac`. Программа `siad` запускается, а все действия осуществляются через `siac`. Надо подождать, пока `siad` скачает блокчейн. Это занимает несколько часов, есть планы по значительному ускорению.
2. Завести адрес (`siac wallet address`), закинуть на него сиакоинов, купленных [любым способом](https://sia.tech/ru/get-siacoin).
3. Добавить папку: `siac host folder add /path/to/dir size`
4. Назначить цену за хранение, загрузку и выгрузку данных: `siac config`.
5. Опубликовать информацию о хосте: `siac host announce`.
Через некоторое время хост начнёт получать контракты и на него будут загружать данные.
Доходы хостеров можно посмотреть на сайте [siahub.info](http://siahub.info/). Пример графика доходов [хоста](http://siahub.info/host/762), на который загружено 585 из доступных 999 Гб:
Данный хост получает 57 сиакоинов каждый день. 1 сиакоин сегодня стоит примерно 1.5 цента, а значит этот хост ежедневно получает примерно 50 рублей. Пусть есть NAS на 4Тб за 20к рублей. При аналогичном проценте заполнения он выдавал бы примерно 200 рублей в день, то есть 6к рублей в месяц — неплохая окупаемость.
Доказательство хранения
-----------------------
В Sia хосты регулярно доказывают, что хранят загруженные данные. Это важный момент, так как иначе недобросовестные хосты могли бы сбрасывать все данные в /dev/null, продолжая получать плату. Выше я обещал рассказать, как устроено доказательство хранения. Это подробно описано в [статье](https://www.sia.tech/whitepaper.pdf) от создателя Sia. Ниже моё объяснение на пальцах.
Данные контракта можно представить как массив из фрагментов одинакового размера. Устроим [древовидное хеширование](https://ru.wikipedia.org/wiki/TTH) этих фрагментов. Для этого рассчитаем сильные криптографические хеши этих фрагментов. Потом разобъем полученные хеши на пары и рассчитаем хеши от соединённых хешей каждой пары. Полученные хеши снова разобьём на пары и так, пока не получим один хеш. Он-то и хранится в контракте и обновляется, когда пользователь загружает новые данные по этому контракту. Теперь вернёмся к отдельному фрагменту файла и проследим его "путь" до корня дерева. На каждом шагу в хеширование будет "примешиваться" хеш, приходящий от другой группы фрагментов. Если мы предоставим данный фрагмент и эти дополнительные хеши, находящиеся на пути от фрагмента до корня, то сможем доказать, что данный фрагмент присутствует на данной позиции в данных. Подделка такого доказательства равносильна нахождению коллизии хеш-функции.
Как же это применяется в Sia? Номер фрагмента, хранение которого хост должен доказать, определяется в зависимости от хешей предыдущих блоков, поэтому его сложно предсказать заранее. В определённый промежуток времени (по блокам, а не по часам) хост должен загрузить доказательство хранения выбранного фрагмента, иначе он теряет деньги.
У внимательного читателя мог возникнуть вопрос — а что, если зловредный хост будет хранить данные, но не будет давать их скачивать пользователю? Или просто иметь низкий uptime, из-за чего пользоваться им будет невозможно. Для борьбы с этим в Sia придумали систему рейтинга хостов. Каждый запущенный клиент вычисляет этот рейтинг независимо, в том числе измеряет uptime, поэтому лучше дать программе поработать вхолостую перед заключением контрактов, чтобы набралась статистика по хостам. Все факторы, влияющие на рейтинг, разбираются в [статье про рейтинг](https://forum.sia.tech/topic/1037/the-hosting-handbook). Рейтинги хостов можно смотреть командой `siac hostdb -v` и на сайте [siahub.info](http://siahub.info/).
Siafund
-------
В Siacoin есть одна особенность, которую я не встречал раньше в альткоинах. [Siafund](https://siawiki.tech/wallet/siafund) — это особый вид ресурсов, который может храниться в том же блокчейне и на таких же адресах, как и Siacoin. Адреса, на которых хранится Siafund, получают часть доходов хостов. Отчисления в размере 3.9% от выплат по успешным контрактам распределяются пропорционально между держателями Siafund. В природе существует ровно 10к Siafund. Большая их часть находится у разработчиков (Nebulous Inc.), но немногим больше 1000 были в своё время распроданы. Siafund продаются на бирже [bitsquare.io](https://bitsquare.io/) и на канале #siafunds [Slack-чата](https://slackin.sia.tech/). В настоящее время цена одного Siafund составлет примерно 2 биткоина. Siafund'ы неделимы.
Siafund — это альтернатива предмайнингу собственной криптовалюты разработчиками альткоина. По задумке создателей, из-за высокой цены обладателями Siafund будут только люди, приверженные идеям проекта, включая разработчиков. Чем больше Sia будет использоваться для хранения файлов, тем больший доход будeт приносить Siafund.
Обозреватели сети
-----------------
На [siapulse.com](http://siapulse.com/) и [siahub.info](http://siahub.info/) есть красивые карты хостов.
Хосты уже есть на всех материках, кроме Африки. Общее количество активных — 275. В том числе хосты есть в нескольких городах России и Украины. Приглашаю всех, кому нужна помощь с запуском хоста и вообще с Sia, на каналы [Slack-чата](https://slackin.sia.tech/), включая #help, #russian и #farming.
Планы
-----
Некоторые планы из [официального roadmap](https://trello.com/b/Io1dDyuI/sia-public-roadmap):
* возможность поделиться загруженным файлом с другим пользователем Sia (в следующем релизе) и с кем угодно (через 2 года).
* Загрузка частей файла.
* Эффективное хранение маленьких файлов.
* Стримминг видео.
* Автоматическое назначение цены хостом.
* Восстановление файлов из seed.
* Поддержка мобильных и других легковесных клиентов.
Сообщество
----------
* [Slack-чат](https://slackin.sia.tech/) — очень интересное место, среди каналов есть #russian.
* [Блог](https://blog.sia.tech/), [форум](https://forum.sia.tech/) и [Twitter](https://twitter.com/siatechhq).
* [Github](https://github.com/NebulousLabs/Sia) — код, баг-репорты и пул-реквесты.
Спасибо всем, кто дочитал до конца! | https://habr.com/ru/post/330140/ | null | ru | null |
# F# Хвостовая рекурсия. Подводные грабли. Часть 1
*Винни Пух: Ой, что это случилось с твоим хвостом?
Иа: А что с ним могло случится?
Винни Пух: Его нет.
Иа: Ты не ошибся?
Винни Пух: Хвост или есть или нет совсем! Тут нельзя ошибиться.
Иа: А что же тогда там есть?
Винни Пух: Ничего!*
У нас в проекте, в одном из серверных компонентов, после очередного рефакторинга начала течь память. Казалось бы .NET, F#, менеджед код, сборка мусора, все дела, но память, куда-то утекала. Ценой бессонных ночей и попорченных нервов, источник утечки был найден. Оказалось что проблема вызвана куском кода, который был, чуть ли не один к одному скопирован из учебника по F#.
Все дело было в хвостовой рекурсии, вернее, как оказалось в ее отсутствии в неожиданных местах.
Хвостовая рекурсия
------------------
Рекурсия, это наверно один из самых важных инструментов в арсенале функционального программирования. А так как при рекурсивных вызовах используется стек, который, как известно, не безграничен, то может показаться, что применение рекурсии ограничено, и глубина рекурсии конечна.
Однако, все не так мрачно, практически все компиляторы функциональных языков, имеют такую полезную штуку как оптимизация хвостовой рекурсии, с помощью которой можно использовать рекурсию без использования стека, что в свою очередь снимает ограничение на вложенность рекурсии.
*Хвостовая рекурсия это частный случай рекурсии, когда рекурсивный вызов может быть заменен итерацией.* С одной стороны на совести программиста остается написание логики в «хвостовом» стиле, с другой стороны компилятор тоже должен «обнаружить» хвостовую рекурсию и раскрутить рекурсию в итерацию.
Обычно начинающий «функциональщик» быстро набивает глаз и руку и использует везде хвостовую рекурсию. **Но есть несколько особых случаев, когда функция, которая, казалось бы, является железно «хвостовой» на самом деле не является таковой.** Эти особые случаи могут привести к очень неприятным последствиям, и могут убить массу времени и нервов.
Давайте рассмотрим первый такой случай и сформулируем правило, с помощью которого можно избежать «неприятностей».
Давайте, для начала возьмем простую функцию, которая суммирует числа все числа от одного до N:
```
let rec sum i =
if i <= 0L then 0L
else i + sum (i - 1L)
> sum 10L;;
val it : int64 = 55L
```
Все хорошо, за исключением одной момента. Если мы попробуем посчитать сумму хотя бы для 100000, то получим в лоб StackOverflowException. Т.е. у нас банально не хватило стека для вычислений:
```
> sum 100000L;;
Process is terminated due to StackOverflowException.
```
Ответ на эту проблему, использование аккумулятора, как аргумента рекурсивной функции:
```
let sumTailRec i =
let rec loop acc i =
if i <= 0L then acc
else loop (acc + i) (i - 1L)
loop 0L i
```
Мы переписали нашу функцию таким образом, что стек ей оказывается не нужен, вместо того чтобы возвращаться назад для суммирования, мы пробрасываем аккумулятор в качестве аргумента.
Проиллюстрировать порядок вычисления (для аргумента 5) можно так. Без хвостовой рекурсии:
```
sum: 5 + (4 + (3 + (2 + (1 + (0))))) – тут мы идем сначала в одну сторону, а потом, дойдя до нуля возвращаемся и суммируем. Как раз для того чтобы возвращаться и нужен стек.
```
С хвостовой рекурсией:
```
sumTailRec: (((0 + 5) + 4) + 3) + 2) + 1) – здесь, мы идем только в одну сторону, и ответ у нас накапливается в аккумуляторе, поэтому собственно стек нам и не нужен.
```
Новая функция уже может переварить сколь угодно большое число (пока хватит разрядности int64).
```
> sumTailRec 10000000L;;
val it : int64 = 50000005000000L
```
Теперь, давайте немного напишем более обобщенную функцию, которая суммирует не сами числа, а результат некоторой заданной функции от текущего числа.
```
let sumFTailRec f i =
let rec loop acc i =
if i <= 0L then acc
else loop (acc + f i) (i - 1L)
loop 0L i
```
В новой версии у нас появился еще один параметр – функция, результат вычисления которой нужно суммировать. Вот вариант, который суммирует сами числа:
```
> sumFTailRec (fun i -> i) 10000000L
val it : int64 = 50000005000000L
```
А вот, который суммирует квадраты:
```
> sumFTailRec (fun i -> i*i) 10000000L
val it : int64 = 1291990006563070912L
```
Пока все хорошо. Но есть небольшой нюанс, функция которая передается, может «кинуть» исключение. Вот пример:
```
> let someProblemFun i = i/((i+1L) % 1000L)
> sumFTailRec someProblemFun 10000000L
System.DivideByZeroException: Attempted to divide by zero.
Stopped due to error
```
Проблема
--------
При значении i = 999, у нас возникает деление на ноль. Предположим, что мы хотим при исключении, не аварийно завершать вычисление, а просто игнорировать проблемный элемент. Нам понадобится обработка исключения. Само собой напрашивается вполне логичное и ожидаемое решение:
```
let sumFTailRecWithTry f i =
let rec loop acc i =
if i <= 0L then acc
else
try
loop (acc + f i) (i - 1L)
with
exc ->
printfn "exn raised:%s" exc.Message
loop acc (i - 1L)
loop 0L i
```
Итак пробуем:
```
> sumFTailRecWithTry someProblemFun 10000L
exn raised:Attempted to divide by zero.
...
exn raised:Attempted to divide by zero.
val it : int64 = 351405L
```
Результат получили, исключения отловили, вроде все нормально. Теперь пробуем скормить более серьезное число:
```
> sumFTailRecWithTry someProblemFun 10000000L
exn raised:Attempted to divide by zero.
...
exn raised:Attempted to divide by zero.
Process is terminated due to StackOverflowException.
```
Упс… В чем же дело? На первый взгляд у нас функция с хвостовой рекурсией, почему вдруг закончился стек?
Как можно догадаться, проблема в конструкции try … with. Дело в том, что если рекурсивный вызов выполняется в блоке try, то у хвостовой рекурсии «отваливается» хвост, и она становится обычной рекурсией. Почему? Потому что в любом из последующих рекурсивных вызовов loop, теоретически может выпасть исключение, а т.к. нам надо его будет обработать, то нужно запомнить в стеке место, куда нужно вернуться при «выпадении» исключения.
Решение
-------
Какой из такой неприятной ситуации выход? Очень простой, *не нужно оборачивать рекурсивный вызов блоком try… with*, ведь исключение мы ожидаем только при вызове «внешней» функции f, значит оборачивать нужно только этот вызов:
```
let sumFReallyTailRecWithTry f i =
let rec loop acc i =
if i <= 0L then acc
else
let fRes =
try f i
with exc ->
//printfn "exn raised:%s" exc.Message
0L
loop (acc + fRes) (i - 1L)
loop 0L i
```
Пробуем:
```
> sumFReallyTailRecWithTry someProblemFun 10000000L
val it : int64 = 374200932236L
```
Вуаля! Стека на этот раз хватило, вернее он остался не тронутый.
**Итак, правило: никогда не помещайте хвостовой вызов в блок try… with.**
*Во второй серии будут шокирующие разоблачения касающиеся хвостовой рекурсии для async { … } и MailboxProcessor.* | https://habr.com/ru/post/143690/ | null | ru | null |
# Как считать сигнал с аналоговых входов Teensy++ и вывести их на экран
Недавно обзавелся [вот этой штукой](http://www.pjrc.com/store/teensypp_pins.html) и захотел попробовать поиграться с ней. Стандартных примеров со светодиодом хватило ненадолго, поэтому я решил попробовать считать значения с аналоговых входов Teensy (которых, к слову, 8 штук) и как-то визуализировать их.
Создатели предлагают две альтернативы для программирования Teensy — С с AVR-GCC или Arduino IDE с установленным плагином для Teensy. Возможно, программирование через AVR-GCC предоставляет большие возможности — но я все равно остановился на Arduino IDE, так как для новичка она ощутимо проще.
Итак, для начала нужно скачать Arduino [отсюда](http://www.arduino.cc/en/Main/Software).
Если вы работаете под Linux — в udev нужно добавить правило для Teensy — его можно найти [тут](http://www.pjrc.com/teensy/49-teensy.rules). Выглядит это примерно так:
`sudo cp 49-teensy.rules /etc/udev/rules.d/`
Затем необходимо скачать устанощик плагина Teensyduino [отсюда](http://www.pjrc.com/teensy/td_download.html). При установке можно выбрать, какие модули устанавливать (я установил все — в хозяйстве пригодится :).
После этого в Arduino IDE появится поддержка Teensy.
Теперь нужно написать код, который будт считывать значения с аналоговых входов и отправлять их в USB serial.
```
void setup() {
Serial.begin(9600);
}
int pins[] = {0, 1, 2, 3, 4, 5, 6, 7};
int val;
int i;
void loop() {
for (i = 0 ; i < 8 ; i++) {
val = analogRead(pins[i]);
Serial.print("p");
Serial.print(i);
Serial.print(":");
Serial.print(val);
Serial.print("\n");
}
delay(100);
}
```
Код достаточно банален — в методе setup инициализируем наш последовательный порт, в цикле проверяем значения на входах и записываем их в порт.
Перед разверткой программы на вашу плату в меню Tools необходимо выбрать модель вашей платы (в моем случае это Teensy++ 2.0) и последовательный порт (у меня это был /dev/ttyACM0). **Для того, чтобы программа корректно использовала последовательный порт, мне пришлось запустить IDE от sudo**.
Компиляция и запуск программы осуществляются при помощи нажатия кнопки Verify (галочка в левом верхнем углу). После этого вылезет диалог Teensy Loader, показывающий, что нужно нажать на кнопку на плате. Нажмите ее — в окне появится надпись Reboot, и прошивка будет развернута.
После перезагрузки устройство начнет спамить вам прямо в последовательный порт :)
Вывод можно посмотреть довольно банально:
`sudo cat /dev/ttyACM0`
Там должно быть что-то вроде
```
p0:294
p1:290
p2:286
p3:275
p4:272
p5:274
p6:273
p7:270
```
Теперь можно приступить к визуализации пересылаемых данных.
В качестве визуализатора я использовал связку Python + PyQt + pySerial.
```
import serial as Serial
import re
import random
import thread
import time
import sys
from PyQt4.QtCore import *
from PyQt4.QtGui import *
class Fetcher(QThread):
def __init__(self, parent = None):
QThread.__init__(self, parent)
def run(self):
pinRe = re.compile("\d+")
pinValues = [0, 0, 0, 0, 0, 0, 0, 0]
serial = Serial.Serial('/dev/ttyACM0', 9600, timeout = 0.1)
while True:
pinString = serial.readline()
pinParseResult = pinRe.findall(pinString)
if (len(pinParseResult) == 2):
pinValues[int(pinParseResult[0])] = int(pinParseResult[1])
self.emit(SIGNAL("pinupdate"), pinValues)
serial.close()
class Form(QDialog):
MAX_VALUE = 1200
pins = [0, 0, 0, 0, 0, 0, 0, 0]
pinInfos = [0, 0, 0, 0, 0, 0, 0, 0]
def __init__(self, parent=None):
super(Form, self).__init__(parent)
for key in range(8):
self.pins[key] = QProgressBar()
self.pins[key].setOrientation(Qt.Vertical)
self.pins[key].setValue(35)
self.pinInfos[key] = QLabel()
mainLayout = QVBoxLayout()
topLayout = QHBoxLayout()
bottomLayout = QHBoxLayout()
for key in range(len(self.pins)):
if key % 4 == 0 and key / 4 == 1:
topLayout.addItem(QSpacerItem(100, 10))
if key % 4 == 2 and key / 4 == 1:
bottomLayout.addItem(QSpacerItem(100, 10))
if key % 4 == 0 or key % 4 == 1:
topLayout.addWidget(self.pinInfos[key])
topLayout.addWidget(self.pins[key])
topLayout.addItem(QSpacerItem(40, 10))
else:
bottomLayout.addWidget(self.pinInfos[key])
bottomLayout.addWidget(self.pins[key])
bottomLayout.addItem(QSpacerItem(40, 10))
mainLayout.addLayout(topLayout)
mainLayout.addLayout(bottomLayout)
self.setLayout(mainLayout)
self.setWindowTitle("Pin display")
def connectSlots(self, fetcher):
self.connect(fetcher, SIGNAL('pinupdate'), self.updateBars)
def updateBars(self, values):
valuesNormalised = map(lambda x: (float(x) / self.MAX_VALUE) * 100, values)
for key in range(len(values)):
self.pins[key].setValue(valuesNormalised[key])
self.pinInfos[key].setText("Pin %i, Value: %4i" % (key, values[key]))
app = QApplication(sys.argv)
form = Form()
form.show()
fetcher = Fetcher()
fetcher.start()
form.connectSlots(fetcher)
app.exec_()
```
Вкратце — создается форма с восемью прогрессбарами, обозначается слот для обновления значения на пинах, запускается поток, непрерывно получающий данные из последовательного порта и оповещающий об этом форму.
Что из этого получилось — можно увидеть в самом начале статьи. | https://habr.com/ru/post/146164/ | null | ru | null |
# Cкринкастинг на сайте по WebRTC из браузера Chrome
Cкринкастинг в Chrome
---------------------
Cкринкастинг (демонстрация экрана, скриншаринг) уже работает в браузере Google Chrome и позволяет захватывать как окно самого браузера, так и окно любого другого приложения. Например можно захватить Firefox, запущенный в соседнем окне.
Все бы замечательно, но есть проблема с безопасностью. В браузере Chrome скринкастинг выключен.
Для его включения необходимо воспользоваться **Chrome Desktop Capture API** и мы покажем в этой статье как это сделать.
Расширение для скринкастинга
----------------------------
Чтобы скринкастинг заработал, юзер должен установить ваше расширение (Chrome Extension), которое создано специально для вашего сайта (домена).
Самый первый запуск скринкастинга потребует от пользователя нескольких действий:
1. Юзер заходит на сайт и нажимает кнопку **Начать демонстрацию экрана**.
2. Юзеру предлагается добавить расширение для этого действия.
Добавление расширения происходит в аккуратном блоке, который выводится самим Chrome — браузером и предлагает добавить расширение в 1 клик. В блоке обозначено, что расширение сможет захватывать экран.
Собственное расширение
----------------------
Следующим шагом будет создание расширения для своего домена. Например ваш тестовый домен — **mysupercat.com**. В этом случае, при создании расширения, вам нужно будет прописать ваш домен в коде расширения.
Кроме этого, ваш домен (сайт на этом домене) обязательно должен работать по HTTPS. Соответственно ваша страница скринкастинга должна открываться как-то так: **[mysupercat.com/screen-sharing.php](https://mysupercat.com/screen-sharing.php)**
Домен и HTTPS — это пожалуй все, что потребуется для создания собственного расширения для скринкастинга. При этом покупать SSL-сертификаты не обязательно. Self-signed сертификаты также подойдут. Главное чтобы ваша страница открывалась по HTTPS, пусть даже с красной строчкой:
Хотя, потребуется еще кое-что — пять американских долларов. Ровно столько придется заплатить за членство в клубе разработчиков под Chrome.
Подведем итоги. Чтобы приступить к созданию и тестированию собственного расширения, нам потребуется:
* доменное имя
* хостинг с HTTPS
* 5 долларов на карте
Публикация расширения
---------------------
1. Переходим в Chrome Developer Dashboard и оплачиваем заготовленные 5 баксов.
2. Готовим ZIP-архив с файлами расширения.
Для этого скачиваем 2 файла [здесь](https://github.com/flashphoner/flashphoner_client/tree/wcs_api-2.0/examples/demo/dependencies/screen-sharing/chrome-extension).
Меняем файл **manifest.json** и проставляем свои:
* name
* author
* description
* homepage\_url
Например
```
"Name" : "My cool screen sharing extension",
"Author" : "I am",
"Description" : "The extensions shares screens from my website",
"Homepage_url" : "https://mysupercat.com",
```
```
{
"name" : "Flashphoner Screen Sharing",
"author": "Flashphoner",
"version" : "1.4",
"manifest_version" : 2,
"minimum_chrome_version": "34",
"description" : "This Chrome extension is developed for http://flashphoner.com WCS Api to enable screen capture.",
"homepage_url": "http://flashphoner.com",
"background": {
"scripts": ["background-script.js"],
"persistent": false
},
"externally_connectable": {
"matches": [
"https://flashphoner.com/*",
"https://*.flashphoner.com/*",
"*://localhost/*",
"*://127.0.0.1/*"
]
},
"icons": {
"16": "logo16.png",
"48": "logo48.png",
"128": "logo128.png"
},
"permissions": [
"desktopCapture"
],
"web_accessible_resources": [
"logo48.png"
]
}
```
Кроме этого меняем иконки и подставляем свой домен в коде **externally\_connectable**
```
"externally_connectable": {
"matches": [
"https://mysupercat.com/*",
"https://*.mysupercat.com/*",
"*://localhost/*",
"*://127.0.0.1/*"
]
}
```
В итоге получается такой **manifest.json**:
```
{
"name" : "My cool screen sharing extension",
"author": "I am",
"version" : "1.0",
"manifest_version" : 2,
"minimum_chrome_version": "34",
"description" : "The extensions shares screens from my website",
"homepage_url": "https://mysupercat.com",
"background": {
"scripts": ["background-script.js"],
"persistent": false
},
"externally_connectable": {
"matches": [
"https://mysupercat.com/*",
"https://*.mysupercat.com/*",
"*://localhost/*",
"*://127.0.0.1/*"
]
},
"icons": {
"16": "logo16.png",
"48": "logo48.png",
"128": "logo128.png"
},
"permissions": [
"desktopCapture"
],
"web_accessible_resources": [
"logo48.png"
]
}
```
Упаковываем эти файлы в ZIP-архив со всеми иконками и другими картинками. Про иконки можно прочесть [здесь](https://developer.chrome.com/apps/manifest/icons). А про дополнительные картинки [здесь](https://developer.chrome.com/webstore/images).
Далее жмем **Add new item**.
Далее, после ознакомления с соглашением, заливаем наш ZIP-архив
После загрузки архива, нужно еще раз все внимательно проверить и сохранить
Осталось опубликовать расширение из Dashboard, нажав кнопку **Publish**.
Опубликованное расширение в Dashboard выглядит так:
Готово. Расширение упаковано, опубликовано и доступно для установки в браузер.
Инлайн инсталляция
------------------
Без инлайн инсталляции вашим пользователям пришлось бы переходить на сайт Chrome Store и устанавливать расширения там. Это конечно не смертельно, но:
* Для пользователя это не очень удобно.
* Пользователь может запутаться на странице установки расширения и не вернуться.
Инлайн инсталляцией расширения называется как раз вот это аккуратное окошко, которое не заставляет пользователя переходить на Chrome Store:
Чтобы настроить инлайн инсталляцию, вам нужно иметь контроль над доменом и хостингом, который вы описали в манифесте (**файл manifest.json**).
Например, если ваш домен mysupercat.com, то нужно будет пройти стандартную процедуру верификации и подтвердить владение этим доменом.
Чтобы включить инлайн инсталляцию, установите флаг **This item uses inline install** на странице редактирования расширения.
Далее добавляете свой веб-сайт.
В новом окне открывается Search Console, где можно пройти процедуру верификации.
Следующим шагом нужно залить файл-идентификатор на ваш хостинг чтобы подтвердить владение доменом / сайтом
Процедура верификации пройдена успешно.
Верифицированный сайт становится доступен в списке для данного расширения и на нем теперь можно использовать инлайн инсталляцию
Интеграция скринкастинга в веб-страницу
---------------------------------------
Расширение готово и настроено для инлайн инсталляции. Остается внедрить код вызова расширения в HTML-страницу и протестировать.
Cкринкастинг в браузере Google Chrome использует **WebRTC API**. Поэтому чтобы завершить этот тест, нам потребуется WebRTC — платформа.
В качестве серверной WebRTC — платформы мы будем использовать [Web Call Server](https://flashphoner.com) и [Web SDK](https://flashphoner.com/wcs-web-sdk) — набор скриптов API для этого сервера.
1. Создаем HTML-страницу для скринкастинга **screen-sharing.html**
Страница состоит из 20 строк кода и выглядит так:
```
Screen Sharing
Screen Sharing
==============
Install Now
Capture
-------
Preview
-------
Connect and share screen
```
Давайте ее разберем.
1) Подгружаем файл API flashphoner.js
2) Подгружаем скрипт screen-sharing.js — его мы разберем немного позже.
3) Указываем где искать расширение для скринкастинга.
4) Добавляем кнопку, по нажатию на которую будет происходить установка расширения.
```
Install Now
```
5) Добавляем div — элемент localVideo, в котором будет отображаться захваченный экран локально
6) Добавляем div — элемент remoteVideo, который будет плеером, отображающим то, что пришло с сервера, т.е. будет воспроизводить видеопоток, который был захвачен в localVideo и отправлен на сервер.
7) Кнопка, по которой будем начинать скринкастинг и отображение статуса потока
```
Connect and share screen
```
В «дизайне» наша страница выглядит так.
2. Создаем **JavaScript код** для скринкастинга **screen-sharing.js**
Весь код доступен для скачивания [здесь](https://flashphoner.com/downloads/examples/screen-sharing-0.5.16.1977.2113.zip). Код занимает пару страниц и содержит 5 основных функций.
```
var SESSION_STATUS = Flashphoner.constants.SESSION_STATUS;
var STREAM_STATUS = Flashphoner.constants.STREAM_STATUS;
var localVideo;
var remoteVideo;
var extensionId = "nlbaajplpmleofphigmgaifhoikjmbkg";
function init_page() {
//init api
try {
Flashphoner.init({screenSharingExtensionId: extensionId});
} catch (e) {
//can't init
return;
}
var interval = setInterval(function () {
chrome.runtime.sendMessage(extensionId, {type: "isInstalled"}, function (response) {
if (response) {
document.getElementById("installExtensionButton").disabled = true;
clearInterval(interval);
localVideo = document.getElementById("localVideo");
remoteVideo = document.getElementById("remoteVideo");
} else {
document.getElementById("installExtensionButton").disabled = false;
}
});
}, 500);
}
function connectAndShareScreen() {
var url = "wss://wcs5-eu.flashphoner.com:8443";
console.log("Create new session with url " + url);
Flashphoner.createSession({urlServer: url}).on(SESSION_STATUS.ESTABLISHED, function (session) {
//session connected, start streaming
startStreaming(session);
}).on(SESSION_STATUS.DISCONNECTED, function () {
setStatus(SESSION_STATUS.DISCONNECTED);
}).on(SESSION_STATUS.FAILED, function () {
setStatus(SESSION_STATUS.FAILED);
});
}
function startStreaming(session) {
var streamName = "test123";
var constraints = {
video: {
width: 320,
height: 240,
frameRate: 10,
type: "screen"
}
};
session.createStream({
name: streamName,
display: localVideo,
constraints: constraints
}).on(STREAM_STATUS.PUBLISHING, function (publishStream) {
setStatus(STREAM_STATUS.PUBLISHING);
//play preview
session.createStream({
name: streamName,
display: remoteVideo
}).on(STREAM_STATUS.PLAYING, function (previewStream) {
//enable stop button
}).on(STREAM_STATUS.STOPPED, function () {
publishStream.stop();
}).on(STREAM_STATUS.FAILED, function () {
//preview failed, stop publishStream
if (publishStream.status() == STREAM_STATUS.PUBLISHING) {
setStatus(STREAM_STATUS.FAILED);
publishStream.stop();
}
}).play();
}).on(STREAM_STATUS.UNPUBLISHED, function () {
setStatus(STREAM_STATUS.UNPUBLISHED);
//enable start button
}).on(STREAM_STATUS.FAILED, function () {
setStatus(STREAM_STATUS.FAILED);
}).publish();
}
//show connection or local stream status
function setStatus(status) {
var statusField = document.getElementById("status");
statusField.innerHTML = status;
}
//install extension
function installExtension() {
chrome.webstore.install();
}
```
Разберем этот код детально.
1) В начале объявляется несколько переменных: статусы, элементы localVideo и remoteVideo, и extensionId, содержащий уникальный идентификатор расширения для скринкастинга.
```
var SESSION_STATUS = Flashphoner.constants.SESSION_STATUS;
var STREAM_STATUS = Flashphoner.constants.STREAM_STATUS;
var localVideo;
var remoteVideo;
var extensionId = "nlbaajplpmleofphigmgaifhoikjmbkg";
```
2) Далее в Flashphoner API передается extensionId и в результате API знает какое расширение будет использовано для скринкастинга.
```
Flashphoner.init({screenSharingExtensionId: extensionId});
```
3) Периодически обращаемся к Chrome и проверяем, установлено ли расширение. Если расширение установлено, нам больше не требуется кнопка **Install extension** и ее можно скрыть.
```
chrome.runtime.sendMessage(extensionId, {type: "isInstalled"}, function (response) {...}
```
4) Функция connectAndShareScreen устанавливает соединение с сервером и как только соединение установлено (ESTABLISHED), начинает захват и отправку видеопотока, передавая управление функции startStreaming.
```
function connectAndShareScreen() {
var url = "wss://wcs5-eu.flashphoner.com:8443";
console.log("Create new session with url " + url);
Flashphoner.createSession({urlServer: url}).on(SESSION_STATUS.ESTABLISHED, function (session) {
//session connected, start streaming
startStreaming(session);
}).on(SESSION_STATUS.DISCONNECTED, function () {
setStatus(SESSION_STATUS.DISCONNECTED);
}).on(SESSION_STATUS.FAILED, function () {
setStatus(SESSION_STATUS.FAILED);
});
}
```
5) Перед началом скринкастинга устанавливаются такие параметры потока, как разрешение видео и FPS.
```
var constraints = {
video: {
width: 320,
height: 240,
frameRate: 10,
type: "screen"
}
};
```
6) Далее создается сам поток и вызывается метод publish(). Обратите внимание, что потоку задается имя test123
```
session.createStream({
name: streamName,
display: localVideo,
constraints: constraints
}).publish();
```
7) После успешной отправки потока test123 на сервер, код попадает в обработчик события **PUBLISHING**.
```
on(STREAM_STATUS.PUBLISHING, function (publishStream) {...}
```
8) Осталось только проиграть поток в соседнем div-блоке **remoteVideo**. Для этого вызываем функцию **play()**.
```
session.createStream({
name: streamName,
display: remoteVideo
}).play();
```
Страница и скрипт готовы и можно начинать тестирование.
Подготовка к тестированию
-------------------------
В результате у нас есть следующие файлы:
* screen-sharing.html
* screen-sharing.js
* flashphoner.js
flashphoner.js находится в составе сборки Web SDK. Последнюю сборку можно скачать с [этой страницы](https://flashphoner.com/wcs-web-sdk).
Кроме html и js-файлов, потребуется сервер-ретранслятор, который будет принимать видеопоток и ретранслировать его другим (в данном случае обратно на эту же страницу).
Мы используем для тестирования **Web Call Server 5**. Поэтому есть несколько вариантов:
* [Установить на свой хост](https://flashphoner.com/download)
* [Запустить на Amazon EC2](https://habrahabr.ru/post/323376/)
* [Воспользоваться демо-сервером](https://wcs5-eu.flashphoner.com/) по адресу **wss://wcs5-eu.flashphoner.com:8443**
Схема тестирования скринкастинга будет такой:
С таким же успехом можно раздать скринкастинг-поток на множество подключившихся пользователей
Тестируем скринкастинг в Chrome
-------------------------------
1. Открываем страницу **screen-sharing.html** по HTTPS в браузере Google Chrome
2. Нажимаем кнопку Install Now чтобы добавить расширение методом **инлайн инсталляции**
3. Нажимаем **Add extension** и можно сразу стартовать скринкастинг по кнопке **Connect and share screen**. Chrome попросит выбрать что именно мы будем захватывать. Это может быть вкладка либо окно Chrome или другое приложение.
4. Нажимаем кнопку **Share** и приходим к окончательному результату. Экран захватывается, отправляется на сервер по WebRTC и проходит обратно, отображаясь в блоке **Preview**.
Подведем итоги
--------------
Таким образом мы успешно протестировали скринкастинг с простой тестовой страницей screen-**sharing.html** в браузере **Google Chrome**. Тестовая страница содержит расширение для скринкастинга, которое мы опубликовали в **Chrome Store** и которое устанавливается в один клик без перехода на Store.
При тестировании страница работала по **HTTPS** и отправляла / получала видео через [Web Call Server](https://flashphoner.com) — **WebRTC медиасервер** для трансляций потокового видео.
Для интеграции скринкастинга в HTML-страницу использовался скрипт **flashphoner.js**, который является частью сборки [Web SDK](https://flashphoner.com/wcs-web-sdk) для сервера WCS.
Ссылки
------
[API Chrome для захвата видео с десктопа](https://developer.chrome.com/extensions/desktopCapture)
[Dashboard для разработчиков под Chrome](https://chrome.google.com/webstore/developer/dashboard)
[Минимальный код для расширения скринкастинга](https://github.com/flashphoner/flashphoner_client/tree/wcs_api-2.0/examples/demo/dependencies/screen-sharing/chrome-extension)
[Упаковка иконок в расширении](https://developer.chrome.com/apps/manifest/icons)
[Упаковка дополнительных картинок в расширении](https://developer.chrome.com/webstore/images)
[Скачать код примера скринкастинга](https://flashphoner.com/downloads/examples/screen-sharing-0.5.16.1977.2113.zip)
[Установка Web Call Server на свой хост](https://flashphoner.com/download)
[Запуск Web Call Server на Amazon EC2](https://habrahabr.ru/post/323376)
[Демо-сервер Web Call Server 5](https://wcs5-eu.flashphoner.com/)
[Web Call Server](https://flashphoner.com)
[Web SDK](https://flashphoner.com/wcs-web-sdk) | https://habr.com/ru/post/323486/ | null | ru | null |
# Релиз InterSystems IRIS 2020.1
В конце марта [вышла](https://community.intersystems.com/post/intersystems-iris-and-iris-health-20201-are-ga-generally-available) новая версия платформы данных InterSystems IRIS 2020.1. Даже пандемия коронавируса не предотвратила релиз.
Из важного в новом релизе — повышение быстродействия ядра, генерация REST-приложения по спецификации OpenAPI 2.0, шардинг для объектов, новый вид Портала Управления, поддержка MQTT, универсальный кеш запросов, новый фреймворк для создания элементов продукции на Java или .NET. Полный список изменений и Upgrade Checklist на английском языке можно найти по [ссылке](https://irisdocs.intersystems.com/iris20201/csp/docbook/Doc.View.cls?KEY=GCRN). Подробнее — под катом.
InterSystems IRIS 2020.1 — это релиз с расширенной поддержкой. InterSystems выпускает два вида релизов InterSystems IRIS:
* Continuous delivery релизы. Выходят три-четыре раза в год в виде образов Docker. Предназначены для разработки приложений и развёртывании в облаке или контейнерах Docker.
* Релизы с расширенной поддержкой. Выходят реже, но для них выпускаются релизы с исправлениями. Выпускаются на всех платформах, поддерживаемых InterSystems IRIS.
Между релизами с расширенной поддержкой 2019.1 и 2020.1 выходили релизы только в образах Docker — 2019.2, 2019.3, 2019.4. Все новые функции и исправления из этих релизов вошли в 2020.1. Некоторые возможности из перечисленных ниже впервые появились в одном релизов 2019.2, 2019.3, 2019.4.
Итак.
Разработка REST-приложений по спецификации
------------------------------------------
В дополнение к [InterSystems API Manager](https://habr.com/ru/company/intersystems/blog/475670/), поддерживаемому с версии 2019.1.1, в релизе 2020.1 появилась возможность генерировать костяк кода для REST-сервиса по спецификации в формате OpenAPI 2.0. Подробнее смотрите в разделе документации «[Creating REST Services](https://irisdocs.intersystems.com/iris20201/csp/docbook/Doc.View.cls?KEY=GREST_preface)».
Конвертация инсталляции Caché или Ensemble
------------------------------------------
Этот релиз позволяет при установке конвертировать инсталляцию Caché или Ensemble в InterSystems IRIS. Сама конвертация возможно потребует изменений в программном коде, настройках или других скриптах, но в большинстве случаев будет простой.
Перед конвертацией прочитайте InterSystems IRIS In-Place Conversion Guide и InterSystems IRIS Adoption Guide. Эти документы находятся на сайте Всемирного центра поддержки InterSystems в разделе «[Документы](https://wrc.intersystems.com/wrc/coDistDocs.csp)».
Клиентские языки
----------------
### InterSystems IRIS Native API для Python
Низкоуровневый быстрый доступ из Python к многомерным массивам, в которых InterSystems IRIS хранит данные. Подробнее — «[Native API for Python](https://irisdocs.intersystems.com/iris20201/csp/docbook/Doc.View.cls?KEY=BPYNAT_preface)».
### InterSystems IRIS Native API для Node.js
Низкоуровневый быстрый доступ из Node.js к многомерным массивам, в которых InterSystems IRIS хранит данные. Подробнее — «[Native API for Node.js](https://irisdocs.intersystems.com/iris20201/csp/docbook/Doc.View.cls?KEY=BJSNAT_preface)».
### Реляционный доступ для Node.js
Поддержка ODBC-доступа к InterSystems IRIS для разработчиков на Node.js
### Двусторонняя связь в Java и .NET-шлюзах
Соединения .NET и Java-шлюзов теперь двусторонние. То есть, программа на .NET или Java, вызванная из IRIS через шлюз, использует это же соединение для обращения к IRIS. Подробнее — «[Java Gateway Reentrancy](https://irisdocs.intersystems.com/iris20201/csp/docbook/Doc.View.cls?KEY=EJVG_using#EJVG_using_reenterancy)».
### Улучшения в Native API для Java и .NET
IRIS Native API для Java и .NET поддерживает списки $LIST и передачу параметров по ссылке.
Новый вид Портала Управления
----------------------------
В этот релиз вошли первые изменения в Портале Управления. Они пока касаются только внешнего вида и не затрагивают функционал.
SQL
---
* Универсальный кеш запросов. Начиная с 2020.1, все запросы, включая встроенные запросы и запросы классов, будут сохранятся как кешированные запросы. Раньше использование встроенных запросов требовало перекомпиляции программы для генерации нового кода запроса, например если появился новый индекс или изменилась статистика таблицы. Теперь все планы запросов хранятся в одном кеше и очищаются независимо от программы, в которой используется запрос.
* Большее число типов запросов теперь параллелизуется, включая запросы DML.
* Запросы к таблице, разделённой по шардам, теперь могут использовать неявный join "->".
* Запросы, запускаемые из Портала управления, теперь исполняются в фоновом процессе. Долгие запросы теперь не будут отваливаться по таймауту веб-страницы. Затянувшиеся запросы теперь можно отменять.
Интеграционные возможности
--------------------------
### Новый фреймворк для создания элементов продукции на Java или .NET
В этот релиз вошёл новый фреймворк PEX (Production EXtension), дающий дополнительный выбор языка реализации компонентов продукции. В этом релизе PEX поддерживает Java и .NET для разработки бизнес-служб, бизнес-процессов и бизнес-операций, а также для входящих и исходящих адаптеров. Раньше можно было создавать только бизнес-службы и бизнес-операции и приходилось вызывать кодогенератор в Портале Управления. Фреймворк PEX предоставляет более гибкие средства включения кода на Java и .NET в компоненты продукции, зачастую без программирования на ObjectScript. В пакет PEX входят следующие классы:
* [EnsLib.PEX.BusinessService](https://irisdocs.intersystems.com/iris20201/csp/documatic/%25CSP.Documatic.cls?APP=1&LIBRARY=ENSLIB&CLASSNAME=EnsLib.PEX.BusinessService)
* [EnsLib.PEX.BusinessProcess](https://irisdocs.intersystems.com/iris20201/csp/documatic/%25CSP.Documatic.cls?APP=1&LIBRARY=ENSLIB&CLASSNAME=EnsLib.PEX.BusinessProcess)
* [EnsLib.PEX.BusinessOperation](https://irisdocs.intersystems.com/iris20201/csp/documatic/%25CSP.Documatic.cls?APP=1&LIBRARY=ENSLIB&CLASSNAME=EnsLib.PEX.BusinessOperation)
* [EnsLib.PEX.InboundAdapter](https://irisdocs.intersystems.com/iris20201/csp/documatic/%25CSP.Documatic.cls?APP=1&LIBRARY=ENSLIB&CLASSNAME=EnsLib.PEX.InboundAdapter)
* [EnsLib.PEX.OutboundAdapter](https://irisdocs.intersystems.com/iris20201/csp/documatic/%25CSP.Documatic.cls?APP=1&LIBRARY=ENSLIB&CLASSNAME=EnsLib.PEX.OutboundAdapter)
* [EnsLib.PEX.Message](https://irisdocs.intersystems.com/iris20201/csp/documatic/%25CSP.Documatic.cls?APP=1&LIBRARY=ENSLIB&CLASSNAME=EnsLib.PEX.Message)
Подробнее — «[PEX: Developing Productions with Java and .NET](https://irisdocs.intersystems.com/iris20201/csp/docbook/Doc.View.cls?KEY=EPEX)».
### Мониторинг использования портов в продукциях.
Утилита Port Authority отслеживает порты, используемые бизнес-службами и бизнес-операциями. С её помощью можно определить доступные порты и зарезервировать их. Подробнее — «[Managing Port Usage](https://irisdocs.intersystems.com/iris20201/csp/docbook/Doc.View.cls?KEY=EMONITOR_ports)».
### Адаптеры для MQTT
В этот релиз входят адаптеры, поддерживающие протокол MQTT (Message Queuing Telemetry Transport), который часто используется в приложениях для Интернета Вещей (Internet of Things — IoT). Подробнее — «[Using MQTT Adapters in Productions](https://irisdocs.intersystems.com/iris20201/csp/docbook/Doc.View.cls?KEY=EMQTT)».
Шардинг
-------
### Упрощённая архитектура
В этом релизе появился более простой и понятный способ создания кластера — на базе отдельных серверов (node level), а не областей, как в предыдущих версиях. Новый API — [%SYSTEM.Cluster](https://irisdocs.intersystems.com/iris20201/csp/documatic/%25CSP.Documatic.cls?APP=1&CLASSNAME=%25SYSTEM.Cluster). Новый подход совместим со старым — кластер на базе областей (namespace level), — и не требует изменений в существующих инсталляциях. Подробнее — «[Elements of Sharding](https://irisdocs.intersystems.com/iris20201/csp/docbook/Doc.View.cls?KEY=GSCALE_sharding#GSCALE_sharding_oview_elements)» и «[Sharding APIs](https://irisdocs.intersystems.com/iris20201/csp/docbook/Doc.View.cls?KEY=GSCALE_sharding#GSCALE_sharding_reference_api)».
### Другие улучшения в шардинге:
* Теперь можно кошардить (распределять по одним и тем же шардам часто соединяемые части двух таблиц) любые две таблицы. Раньше так можно было делать только с таблицами у которых был общий шард-ключ. Начиная с этого релиза синтаксис COSHARD WITH применяется и для таблиц с системным Id. Подробнее — «[Create the Tables](https://irisdocs.intersystems.com/iris20201/csp/docbook/Doc.View.cls?KEY=GSCALE_sharding#GSCALE_sharding_tables_create_create)» и «[Defining a Sharded Table](https://irisdocs.intersystems.com/iris20201/csp/docbook/Doc.View.cls?KEY=GSQL_tables#GSQL_tables_sharded)».
* Раньше отметить таблицу как кластерную можно было только через DDL, теперь это можно сделать и в описании класса — новое ключевое слово Sharded. Подробнее — «[Defining a Sharded Table by Creating a Persistent Class](https://irisdocs.intersystems.com/iris20201/csp/docbook/Doc.View.cls?KEY=GSQL_tables#GSQL_tables_via_classes_sharded)».
* Объектная модель теперь поддерживает шардинг. Методы %New(), %OpenId и %Save() работают с объектами класса, данные которого распределены по нескольким шардам. Обратите внимание, что код выполняется на том сервере, к которому подключен клиент, а не на том, где хранится объект.
* Улучшен алгоритм выполнения кластерных запросов. Менеджер очереди запросов (Unified Shard Queue Manager) ставит запросы в очередь на выполнение пулу процессов, вместо запуска новых процессов на каждый запрос. Число процессов в пуле определяется автоматически, исходя из ресурсов сервера и нагрузки.
Инфраструктура и развёртывание в облаке.
----------------------------------------
В этот релиз вошли улучшения в инфраструктуре и развёртывании в облаке, включая:
* Поддержка Tencent Cloud. InterSystems Cloud Manager (ICM) теперь поддерживает создание инфраструктуры и развёртывание приложений на базе InterSystems IRIS в Tencent Cloud.
* Поддержка именованных томов (named volumes) в Docker, в дополнение к монтированию папок (bind mount).
* ICM поддерживает гибкое масштабирование — конфигурации теперь могут масштабироваться, то есть пересоздаваться с большим или меньшим числом узлов. Подробнее — «[Reprovisioning the Infrastructure](https://irisdocs.intersystems.com/iris20201/csp/docbook/Doc.View.cls?KEY=GICM_using#GICM_using_provision_reprovision)» и «[Redeploying Services](https://irisdocs.intersystems.com/iris20201/csp/docbook/Doc.View.cls?KEY=GICM_using#GICM_using_deploy_redeploy)».
* Улучшения в создании собственного контейнера.
* ICM поддерживает новую архитектуру шардинга.
* Пользователь по умолчанию в контейнерах теперь не root.
* ICM поддерживает создание и развёртывание частный сетей, в которых узел-бастион соединяет частную сеть с публичной сетью и предоставляет дополнительную защиту от Denial-of-Service атак.
* Поддержка обнаружения сервисов по защищённому RPC.
* ICM поддерживает развёртывание в нескольких регионах. Так обеспечивается высокая доступность системы, даже если весь регион перестал работать.
* Возможность обновить ICM и сохранить информацию об уже развёрнутых системах.
* Бесконтейнерный режим — ICM теперь может напрямую, не в контейнерах, разворачивать кластерные конфигурации на Google Cloud Platform, а также устанавливать Web Gateway на Ubuntu или SUSE.
* Поддержка слияния iris.cpf из двух файлов. Это помогает ICM запускать InterSystems IRIS с разными настройками в зависимости от режима, в котором инсталляция работает. Эта возможность упрощает автоматизацию и поддержку различных инструментов управления конфигурациями, таких как Kubernetes.
Аналитика
---------
### Выборочная перестройка куба
Начиная с этого релиза InterSystems IRIS Business Intelligence (прежде известный как DeepSee) поддерживает выборочное построение куба — только одного показателя или измерения. Можно изменить описание куба и перестроить только то, что изменилось, сохраняя доступность всего куба, во время перестройки.
### PowerBI коннектор
Microsoft PowerBI теперь поддерживает работу с таблицами и кубами InterSystems IRIS. Коннектор поставляется с PowerBI, начиная с релиза апреля 2019 года. Подробнее — «[InterSystems IRIS Connector for Power BI](https://irisdocs.intersystems.com/iris20201/csp/docbook/Doc.View.cls?KEY=APOWER)».
### Предпросмотр результатов запроса
В этом релизе появился новый режим предпросмотра при составлении сводных таблиц в Analyzer. Так можно быстро оценить правильность запроса, не дожидаясь его полных результатов.
Другие улучшения
----------------
* Обход глобала функцией $ORDER в обратном порядке (direction = -1) теперь так же быстр, как и в прямом.
* Улучшена производительность журналирования.
* Добавлена поддержка Apache Spark 2.3, 2.4.
* Добавлена поддержка клиента WebSocket. Класс %Net.WebSocket.Client.
* Класс контроля версий теперь обрабатывает события при изменениях на странице продукции.
* Белые списки для фильтрации допустимых запросов к CSP, ZEN и REST.
* Поддержка .NET Core 2.1.
* Улучшена производительность ODBC.
* Структурированный лог для облегчения анализа messages.log.
* API для проверки ошибок и предупреждения. Класс %SYSTEM.Monitor.GetAlerts().
* Компилятор классов теперь проверяет, что имя глобала в описании хранения не превышает максимальной длины (31 символ) и возвращает ошибку, если это не так. Раньше имя глобала без предупреждения обрезалось до 31 символа.
Где взять
---------
Если у вас есть поддержка — скачайте дистрибутив с раздела [Online Distributions](https://wrc.intersystems.com/wrc/coDistribution2.csp) сайта wrc.intersystems.com
Если вы только хотите попробовать InterSystems IRIS — <https://www.intersystems.com/ru/try-intersystems-iris-for-free/>
Ещё проще через Docker:
```
docker run --name iris20 --init --detach --publish 51773:51773 --publish 52773:52773 store/intersystems/iris-community:2020.1.0.215.0
```
Вебинар
-------
7 апреля в 17:00 по московскому времени пройдёт вебинар, посвящённый новому релизу. Его проведут Джефф Фрид (Director, Product Management) и Джо Лихтенберг (Director of Product & Industry Marketing). [Регистрируйтесь!](https://event.on24.com/wcc/r/2216696/2E6012CC2EA58CDA0FE377FC5F7947DA) Вебинар будет на английском языке. | https://habr.com/ru/post/495292/ | null | ru | null |
# Компиляторы против компиляторов
### Сравнение производительности Rust, Delphi и Lazarus (а также Java и Python)
Давно хотел познакомиться с Rust. Язык с экосистемой сборки из коробки, компилятор в машинный код, но самое главное — автоматическое управление памятью, но без сборщика мусора. С учетом того, что управление памятью обещается как zero-cost в runtime — просто сказка! По ходу изучения и возник вопрос – а насколько код Rust быстрее/медленнее компилятора в машинный код давно известного, например, Delphi?
### О тесте
Для ответа на вопрос были написаны два простых теста: "обход конем доски" (в основном работа с памятью) и "поиск простых чисел" (в основном целочисленная математика). Ну и раз пошло такое дело, то почему бы не вовлечь в соревнования языки из другой "весовой категории" — чисто для сравнения и забавы. Так, в качестве специально приглашенных гостей, в забеге стали участвовать Java (компилируемый в байт-код) и Python (чистый интерпретатор). Си к соревнованию допущен не был по причине моего слабого знания оного (кто напишет свою реализацию тестов — добро пожаловать, включу в статью).
Алгоритмы сделаны по-простому, главное, чтобы создавалась нужная нагрузка. Для обхода конем доски выбрана доска 4х7, это разумная величина, чтобы тест не проходил слишком быстро, но и не закончился лишь после угасания Солнца. Простые числа ищем начиная со 100 млн, иначе слишком быстро.
Обход конем доски, реализация на java.
```
/**
* Store for statistic
*/
static class State {
int path_count_total = 0;
int path_count_ok = 0;
}
/**
* Calc and print all full knight's tours over specified board
*
* @param size_x board size x
* @param size_y board size y
* @param x0 tour start cell x
* @param y0 tour start cell y
*/
static void calc_horse(int size_x, int size_y, int x0, int y0) {
System.out.println(String.format("Hello, horse, board %sx%s", size_x, +size_y));
int[][] grid = new int[size_y][size_x];
State state = new State();
Date time_0 = new Date();
step_horce(1, state, x0, y0, grid);
Date time_1 = new Date();
System.out.println(String.format("Board %sx%s, full path count: %s, total path count: %s", size_x, size_y, state.path_count_ok, state.path_count_total));
double duration_sec = (time_1.getTime() - time_0.getTime()) / 1000.0;
System.out.println("duration: " + duration_sec + " sec");
}
private static void step_horce(int step_no, State state, int x0, int y0, int[][] position) {
// ---------------------
// Make my step
position[y0][x0] = step_no;
// ---------------------
// Try to do next 8 steps
int size_y = position.length;
int size_x = position[0].length;
int board_size = size_x * size_y;
int[][] step_diffs = {{1, -2}, {2, -1}, {2, 1}, {1, 2}, {-1, 2}, {-2, 1}, {-2, -1}, {-1, -2}};
int steps_done = 0;
for (int s = 0; s < 8; s++) {
int[] step_diff = step_diffs[s];
int x1 = x0 + step_diff[0];
int y1 = y0 + step_diff[1];
if (x1 < 0 || x1 >= size_x) {
continue;
}
if (y1 < 0 || y1 >= size_y) {
continue;
}
if (position[y1][x1] != 0) {
continue;
}
step_horce(step_no + 1, state, x1, y1, position);
steps_done = steps_done + 1;
}
// ---------------------
// Whe have no more cell to step?
if (steps_done == 0) {
state.path_count_total = state.path_count_total + 1;
}
if (steps_done == 0 && step_no == board_size) {
state.path_count_ok = state.path_count_ok + 1;
System.out.println(String.format("Full path count: %s/%s", state.path_count_ok, state.path_count_total));
print_board(position);
System.out.println();
}
// ---------------------
// Make my step back
position[y0][x0] = 0;
}
```
Поиск простых чисел, реализация на java.
```
public static void print_primes(int start_from, int count) {
System.out.println("Hello, print_primes!");
int n = start_from;
while (count > 0) {
Date time_0 = new Date();
boolean is_prime = is_prime_number(n);
Date time_1 = new Date();
if (is_prime) {
long duration = (time_1.getTime() - time_0.getTime());
System.out.println(n + ", " + duration + " msec");
count = count - 1;
}
n = n + 1;
}
}
public static boolean is_prime_number(int number) {
int i = 2;
while (i < number) {
if (number % i == 0) {
return false;
}
i = i + 1;
}
return true;
}
```
На всех языках алгоритм одинаковый. Полный комплект тестов [выложен на GitHub](https://github.com/SazonovDenis/test-speed).
### Ожидания
Мои ожидания были такими: первое-второе места разделят Delphi/Lazarus и Rust, с разницей плюс-минус 50% — машинный код он и в Африке машинный код.
С заметным отставанием, от двух раз и более — Java. Все-таки байт-код это дополнительный уровень не бесплатной абстракции.
Ну и в хвосте, задыхающийся и вспотевший, с отставанием в десяток и более раз будет Python.
### Тестовая машина
Windows 10
i5-3470, 3.2 ГГц
ОЗУ 8 ГБ
По наблюдениям - каждый тест нагружает одно ядро четырехъядерного процессора (так и должно быть). Сборщику мусора, судя по всему, не приходится срабатывать, т.к. память выделяется небольшая.
Загрузка процессора.### Итог испытаний
Результат лично для меня оказался неожиданным. Вот вы какого результата ожидали бы?
Python не разочаровал, стабильность результата — признак профессионала :-).
Код Rust оказался медленнее на 50%-400%, чем Delphi/Lazarus, что несколько разочаровывает, хотя и в пределах ожиданий.
А вот Java сильно удивила. За много лет работы с ней не доводилось вот так, напрямую, замерять производительность и её скорость оказалась приятным сюрпризом. Нет, мы знаем — JIT творит чудеса и все такое, но, чтобы на равных с машинным кодом...
### Итого
Выводы для себя я сделал следующие:
* Java рулит;
* Если на Java есть кусок тормозного кода, который хочется переписать на чем-нибудь компилируемом — не следует ожидать кратного прироста скорости. Проблема, скорее всего, в другом месте, а не в "тормознутости" Java;
* Если хочется чего-нибудь компилируемого и быстрого, но C++ пугает, то использовать Rust вместо Си пока рано. Нужен язык с компилятором и быстрым кодом - это пока все-таки Си или Free Pascal.
### UPD 1:
В [комментариях](https://habr.com/ru/post/678628/#comment_24557980) справедливо [ткнули](https://habr.com/ru/post/678628/#comment_24558008) носом в то, что мои тесты на Rust собраны в отладочном режиме. Каюсь, это огромное упущение. В оправдание скажу, что в языках, с которыми работал до этого (Delphi, Java и Python), скорость "релизной" и "отладочной" версий хоть и различается, но не так драматично. Учет замечания радикально меняет вывод об "отставании" Rust. Собрав тесты в релизе (Rust, Delphi, Lazarus) получаем результат:
Оптимизированный код Rust оказался на 20%-200%, быстрее чем Delphi/Lazarus, что приятно и в пределах ожиданий.
### Итого (исправленное):
* Java рулит;
* Если на Java есть кусок тормозного кода, который хочется переписать на чем-нибудь компилируемом — не следует ожидать кратного прироста скорости. Проблема, скорее всего, в другом месте, а не в "тормознутости" Java;
* Если хочется чего-нибудь компилируемого и быстрого, но C++ пугает, то Rust вместо Си — прекрасная альтернатива.
### UPD 2:
В [комментариях](https://habr.com/ru/post/678628/#comment_24557908) указали на [влияние](https://habr.com/ru/post/678628/#comment_24557988) лишнего лишнего консольного вывода на результаты. Да, действительно, он заметно влияет на время выполнения, особенно на "быстрые" языки. Согласен, его нужно было сразу убрать, однако лишний вывод влияет *одинаково на всех*и мало влияет на *сравнительные*результаты.
Влияние лишнего вывода. | https://habr.com/ru/post/678628/ | null | ru | null |
# Django throttling
Как-то раз пришлось использовать чужое django-app, в котором было много форм, методов и всего остального. И, что само собой разумеется, автор решил не заморачиваться и не делать никакой защиты от спамеров, или от любителей понажимать F5 на тяжелой форме. Переписывать и форкать у меня желания не было, поэтому решил написать middleware, режущий кислород нехорошим людям.
##### Функционал
* maintenance режим, позволяет выключать view в целом, или отдельные http методы
* глобальные fallback-таймауты сайта для PATCH, POST и т.д.
* локальные таймауты для view в целом, или для отдельных http-методов
Проще показать пример конфига:
```
DJANGO_THROTTLING = {
'all': 1000,
'post': 'callable:helpers.trash.my_callback',
'congestion': 'forum.views.congestion',
'django.contrib.admin.options.change_view': {
'post': False,
'all': None,
'uri': '/admin/forum/post/23/',
},
}
```
Остальные примеры с описанием под катом.
#### Установка
```
git clone http://github.com/night-crawler/django-throttling.git
cd django-throttling
python setup.py install
```
##### Global throttling
Конфиг состоит из секций, самая верхняя — fallback, применяется для всего сайта в целом, в случае, если не нашлось более детализированного правила.
```
DJANGO_THROTTLING = {
'all': 1000,
'post': 10000,
'congestion': 'forum.views.congestion',
}
```
В этом примере для запросов всех типов установлено ограничение в 1 запрос в секунду, post — запрос раз в 10 секунд.
**congestion** может быть uri, или вьюхой. В данном случае будет вызвана вьюха, живущая по соседству:
```
def congestion(request, congestion_bundle):
user = request.user
progress = int(float(congestion_bundle['delta']) / congestion_bundle['timeout'] * 100)
c = Context({'user': user, 'congestion_bundle': congestion_bundle, 'progress': progress})
return render_to_response(get_theme_template(user, 'congestion.html'), c,
context_instance=RequestContext(request)
)
```
Это позволит сказать юзеру, что он шалит и, к примеру, должен подождать N секунд. Вьюху можно снабдить скриптом с прогрессбаром, который автоматически зарелоадит форму. В **congestion\_bundle** передается оригинальная вьюха и весь набор ее аргументов, дабы можно было сказать юзеру что-то более детальное.
Можно отключить POST на всем сайте. Тогда юзер увидит HttpResponseBadRequest:
```
DJANGO_THROTTLING = {
'all': 1000,
'post': False,
'congestion': 'forum.views.congestion',
}
```
А можно отключить POST вот так, тогда юзер будет отправляться в корень:
```
DJANGO_THROTTLING = {
'all': 1000,
'post': '/',
'congestion': 'forum.views.congestion',
}
```
Если простого редиректа недостаточно, то можно сделать свой обработчик для maintenance-mode:
```
DJANGO_THROTTLING = {
'all': 1000,
'post': 'forum.views.maintenance',
'congestion': 'forum.views.congestion',
}
# forum.views.maintenance
def maintenance(request, maintenance_bundle):
return HttpPreResponse(maintenance_bundle)
```
Может быть так, что нужно блокировать вьюху только в определенных случаях, например, для блокирования одного топика в форуме, или для еще какого-то частного случая. Тогда можно написать кастомный обработчик для правила:
```
DJANGO_THROTTLING = {
'all': 1000,
'post': 'callable:helpers.trash.my_callback', # обратите внимание на callable:
'congestion': 'forum.views.congestion',
}
# helpers.trash.my_callback'
def my_callback(request, view_func, view_args, view_kwargs):
return 'some_strange_key_123', 10000
```
Он должен возвращать кортеж из названия ключа и таймаута. Таймаутом может снова быть int(), False, view, или uri.
##### Local throttling
В основном имеет аналогичный синтаксис. Отличается только наличием опционального ключа 'uri', который позволяет натравливать throttle check только на него.
```
DJANGO_THROTTLING = {
'all': 1000,
'post': 'callable:helpers.trash.my_callback',
'congestion': 'forum.views.congestion',
'django.contrib.admin.options.change_view': {
'post': False,
'all': None,
'uri': '/admin/forum/post/23/',
# 'post': 'callable:helpers.trash.my_callback',
# 'all': 4000,
},
}
```
Пупутно есть несколько настроек:
1. **DJANGO\_THROTTLING\_ENABLED**: включает троттлинг, по умолчанию выключен.
2. **DJANGO\_THROTTLING\_CACHE\_EXPIRE**: определяет сколько хранятся ключи в кэше. По умолчанию 60\*60.
3. **DJANGO\_THROTTLING\_CACHE\_PREFIX**: кэш-префикс, по умолчанию «THROTTLING»
4. **THROTTLING\_CACHE\_KEY\_PATTERNS**: тут хранятся паттерны для генерации ключа. Всего есть 4 разновидности: view\_method, view, site\_method, site. Можно переопределить.
5. **DJANGO\_THROTTLING\_IGNORE\_ADMIN**: выключает троттлинг, если пользователь — админ. Соответственно, требует подключенного auth
На [github'е](https://github.com/night-crawler/django-throttling) есть описание на «английском». | https://habr.com/ru/post/189858/ | null | ru | null |
# Ant+Tomcat: небольшая автоматизация рутины
День добрый всем. Решил написать заметку о небольших средствах автоматизации, которые возникли в процессе моей работы со связкой Ant+Tomcat. Работаю java-разработчиком, с недавних пор пришлось окунуться в web-разработку на Java (надо сказать не без удовольствия). Никогда с серьезными проектами для web на java не сталкивался, игрался пару раз с примерами в рамках книжек по java из серии «обо всем по немного», но ничего серьезного. А здесь проект из полноценного портала с backend`ом для отвественных за контент, большими объемами данных в БД. Ну что же столкнулся да и столкнулся. Работа пошла, новая область знаний — интересно, мелочи не достают. Но со временем процесс сборки и развертывания приложения стал очень сильно доставать, так как в самые «жаркие» дни приходилось выполнять эту операцию раз по 40, чтобы посмотреть результат работы и прощелкать его. Вот тут и возник вопрос, нельзя ли это как то автоматизировать.
Для тех кто так же как и я раньше не особо представляет процесс сборки и развертывания web-приложений на Java распишу чуток подробнее.
1. Итак, приложение необходимо собрать. Это можно сделать и через IDE, но на больших проектах, где несколько разработчиков и у каждого может быть свой IDE лучше использовать ANT — универсально и удобно. Итак делаем сборку, например так: ant jar. У меня сборка одного модуля jar в нашем проекте в среднем занимает секунд 15-20. Само web-приложение представляет собой war-файл (аналог jar файла в Java SE). Но конечный war-файл может иметь (и как правило имеет) несколько зависимостей от jar-файлов других модулей. Соотвественно, если изменился код модуля, от которого зависит конечный war-файл, то сначала пересобираем модуль, потом собираем само приложение. У нас таких модулей 2, как правило в процессе работы изменения идут в пределах одного модуля, хотя бывает, что необходимо пересобрать оба модуля или ничего не надо пересобирать (кроме конечного war, в коде которого что-то изменилось). В общем, как правило пересобирается 1 модуль. Поэтому последовательность команд такая будет:
````
cd {директория модуля}
ant jar
cd {директория конечного приложения}
ant war
````
В итоге получим war-файл приложения. На сборку с учетом переключений между директориями уходит 50-60 секунд. Сразу скажу, что в проекте конечных war-файлов два: публичная часть и закрытая часть, и для общей сборки есть само собой своя команда, но ее неудобство в том, что происходит сборка «ненужного» сейчас war — что тоже время.
2. Для того, чтобы увидеть само приложение в деле, полученный war-файл необходимо развернуть на сервере. Для этого через браузер заходим в панель управления Tomcat, удаляем старую версию приложения (если оно было), указываем расположение нового war-файла и ждем некоторое время (40-60 секунд), после этого можем начинать «щупать» созданное приложение.
Я не зря пишу примерное время сборки и развертывания приложения — в сумме эти два на первый взгляд простых шага занимают 2-3 минуты. Вроде немного, но при частых изменениях или поиске решения какого-то бага приходится снова и снова пересобирать проект, делать undeploy (удаление) старой версии приложения с сервера, а потом deploy (развертывание) новой версии приложения. Бывает что за день повторяешь эту операцию считанные разы, а бывает, как писал выше, повторы этой операции происходят десятками раз. В итоге само собой возник вопрос об оптимизации данного процесса, т.к. повтор этой операции 10-20 раз ведет к затратам в 30-60 минут. Ладно б если в это время можно было отвлечься от компьютера, а получается, что необходимо плотное участие человека.
Сначала возникла идея в ant добавить одну команду для выполнения шага №1 (отдельно по каждому war), но потом возник вопрос «можно ли автоматизировать шаг №2?», то есть научить ant управлять развертыванием приложения на tomcat. Немного поискав в гугле, нашел несколько решений из которых собрал свое, взяв из каждого какие то моменты.
Процесс сборки приложения в ant я опущу, так как это описано в любом справочном материале по этой утилите, к тому же это специфично для каждого отдельного проекта. Сразу перейду к решению шага №2.
Прежде всего необходимо узнать есть ли в системе tomcat, чтобы было с чем работать:
````
````
Создаем задачу «if-has-tomcat», суть которой в том, чтобы проверить доступность директории указанной в системной переменной CATALINA\_HOME и результат этой проверки представить в виде переменной «has.tomcat». Выражение `property environment="env"` как раз позволяет получить доступ к системным переменным.
Теперь когда мы знаем, что tomcat есть в системе, можно подключать его библиотеки, которые позволят управлять tomcat из ant. Заодно здесь же проверим, есть ли старая версия war-файла на сервере.
````
````
Сначала объявляем необходимые переменные для работы с tomcat: домашнюю папку tomcat, URL tomcat, URL менеджера, логин и пароль. Затем создаем условие, которое проверяет, размещено ли уже приложение (то есть перед тем разворачивать новую версию приложения необходимо будет старую удалить). Здесь ${ant.project.name} содержит название приложения, которое объявляется выше (я объявил в шапке скрипта ant, т.к. эта переменная участвует в тасках по сборке проекта). Следующий шаг — подключение библиотек, которые позволят управлять сервером через ant. Ну и последнее — объявляем таски для ant для управления tomcat.
Теперь когда мы знаем все исходные данные, можно удалять старую версию war-файла (если она есть) — команда undeploy и разворачивать новый war-файл — команда deploy.
````
````
Здесь по большому счету ничего сложно. Всегда используются команда ant deploy, которая выполняет очистку всех папок с class файлами (clean), потом выполняется сборка war-файла(war), потом выполняется проверка наличия tomcat (if-has-tomcat), затем при положительном исходе предыдущей проверки выполняется таска undeploy, которая проверяет наличие старой версии war-файла на сервере и при необходимости удаляет его, ну и в последнюю очередь выполняется непосредственно развертывание приложения на сервере. Свойство war в таске deploy, как раз указывает где расположен новый war файл.
В таске undeploy, как видно так же, как и в deploy выполняется проверка на наличие tomcat в системе. Сделано это для того, чтобы можно было безопасно выполнять команду ant undeploy.
В итоге, получилось, что все выполняется одной командой — ant deploy. Дальше можно на 1-2 минуты отвлечься — ant сделает все сам. Чисто время сборки и развертывания осталось тем же, а вот экономия в этом проекте на «ручном» щелканьи и вбивании нескольких команд составила 1-1,5 минуты с каждого deploy. Что за день выходит в 20-30 лишних минут и что самое главное: deploy выполняется с помощью одной команды и не требует к себе внимания, то есть во время сборки и развертывания можно слегка отвлечься и расслабиться. | https://habr.com/ru/post/134568/ | null | ru | null |
# Создание Doodle jump на HTML5
[](http://borodinart.ru/projects/1)
Здравствуйте, Хабражители!
В этом топике я хочу рассказать о том, как я создал браузерную игру «DoodleJump» на HTML5 без использования каких либо то фреймворков. Для тех кто не знает, [DoodleJump](http://itunes.apple.com/us/app/doodle-jump-be-warned-insanely/id307727765?mt=8) — это популярная мобильная игра где главный герой «doodler» бесконечно прыгает вверх по платформам, преодолевая различные препятствия, и собирая бонусы. Эта игра широко распространена почти на всех мобильных платформах, но приличной браузерной версии этой игры нет, поэтому я и решили написать браузерную версию этой игры, пусть даже управляемую клавишами а не гироскопом.
Итак, начнем. Для начало обозначим сцену, где и будет все происходить:
и применяем к ней стили:
```
#stage{
position:absolute;
top:0px; left:0px;
background-color:#fff3f7;
background-image:url(grid.gif);
width:320px;
height:480px;
}
```
где мы заливаем сцену клетчатым фоном (grid.gif), и делаем разрешение 320 на 480 пикселей. В эту сцену мы помещаем ещё несколько div'ов: верхняя панель (tray), где будут писаться набранные очки и распологатся кнопка паузы(pause), основной персонаж игры (doodler) и пулька (bullet), которой будет стрелять наш персонаж. Для таких объектов как платформы и бонусы мы создаем div'ы — контейнеры в которые, с помощью ява-цикла, мы поместим отдельно по диву для каждого объекта.
```
```
Теперь надо применить стили к нашим объектам, залить их спрайтами, задать ширину и высоту объектам, а также сделать им абсолютное позиционирование, для того чтобы мы смогли размещать каждый объект не зависимо от других объектов на сцене.
Я подготовил несколько спрайтов и картинок для раскраски нашей игры:
Вот пример стилей к элементу doodler:
```
#doodler{
position:absolute;
background:url(sprite.png);
width:62px;
height:59px;
}
```
Зная координаты расположения элементов на спрайте, мы можем залить все объекты по образцу выше.
А вот стили к пружинками и платформам будут немного отличаться, так как они лежат в контейнере, и остальные параметры к ним будут задаваться из java-скрипта:
```
#objects div{
position:absolute;
background:url(sprite.png);
}
```
После того как мы создали все объекты на сцене и придал им стили, мы можем приступать к написанию java скрипта. Сначала для удобства написания кода игры, мы запихнем селекторы объектов в переменные:
```
var d = document.getElementById('doodler');
var tray = document.getElementById('tray');
var header = document.getElementById('header');
var ammun = document.getElementById('ammunition');
// и другие...
```
Как я и говорил ранее, div'ы — контейнеры такие как: platforms и objects мы заполняем ява циклом:
```
for(i=0;i'
```
';
}
где numPlatform — это количество платформ в контейнере (максимальное количество платформ, умещаемых на сцене, в нашем случае их 16). Для удобства можно создать функцию для перемещения платформ:
```
function setPlatform(n,x,y,t){
p = document.getElementById('p'+n);
p.style.top = y+"px";
p.style.left = x+"px";
if(t==-1){p.style.backgroundPosition = "100px 100px";}
if(t>=0&&t<8){
p.style.height=16+"px";
p.style.backgroundPosition = "-399px -"+(16*t)+"px";
}
if(t==8){p.style.height=24+"px"; p.style.backgroundPosition = "-399px -128px";}
if(t==9){p.style.height=16+"px"; p.style.backgroundPosition = "-399px -151px";}
if(t==10){p.style.height=34+"px"; p.style.backgroundPosition = "-399px -168px";}
}
```
Теперь можно легко переместить любую платформу на желаемое место на сцене, и изменять её тип:
```
setPlatform([номер платформы],[координаты платформы по иксу],[координаты по игрику],[тип платформы]);
setPlatform(9,50,100,0);
```
создадим еще несколько подобных функций:
```
setBullet(x,y);//перемещает пульку
setObstacle(x,y,t);//перемещает монстров и дырки
setObject(n,x,y,t);//перемещает пружинки и бонусы
doodle(x,y,t,a,alpha);//перемещает Дудлера.
```
Создадим несколько глобальных переменных и массивов, которые нам понадобятся в дальнейшем.
Вот некоторые из них:
```
var life = true;//жив ли дудлер
var stageSpeed = 0;//скорость движения сцены
var gravitation = 0.08;гравитация
var ySpeed = 5;//начальная скорость дудлера
var numPlatform = 16;//количество платформ
var numObjects = numPlatform;//количество объектов
var xObject = new Array;//X объекта
var yObject = new Array;//Y объекта
var tObject = new Array;//тип объекта
var yFooter = 1000;//обрыв бумаги (footer.png)
var tAmmunition = 0;//начальная амуниция на дудлере
var xPlatform = new Array;//X платформы
var yPlatform = new Array;//Y платформы
var tPlatform = new Array;//тип платформы
var xDoodler = 136;//начальный X дудлера
var yDoodler = 136;//начальный Y дудлера
var tDoodler = 136;//начальное направление дудлера
var record = 0;//текущее количество очков
var xBullet;//X пульки
var yBullet;//Y пульки
var xSpeedBullet;//горизонтальная скорость пули
var ySpeedBullet;//вертикальная скорость пули
var pause = false;//пауза
...
```
Теперь рассмотрим основную часть ява-скрипта самой игры, бóльшая часть кода будет находится в функции **frame()**, и запускается 100 раз в секунду. Внутри этой функции дудлер будет постоянно проверятся на столкновение с монстрами и бонусами, а так же там будет находится цикл, внутри которого мы будим проверять дудлера на столкновение с каждой платформой по отдельности:
```
function frame(){//функция фрейма запускаемая 100 раз в секунду
ySpeed -= gravitation;//уменьшаем скорость дудлера
yDoodler -= ySpeed;//перемещаем дудлера
if(xDoodler+46>=xObstacle&&xDoodler+16<=xObstacle+65&&yDoodler+59>=yObstacle&&
yDoodler+59<=yObstacle+60&&tObstacle != 0){//проверяем на столкновение с припядствием
if(tObstacle != 6){//если это не дырка
if(tAmmunition>=1){//и на дудлере есть амуниция
tObstacle = 0;//то убираем монстра
}else if(ySpeed<0){//в противном случае, если дудлер падает на монстра
tObstacle = 0;//монстр исчезает
ySpeed = 10;//дудлер отпрыгивает
}else{//если на монстре нет амуниции
tAmmunition = 8;//даем дудлеру амуницию звездочек
stageSpeed = 7;//смещаем все элементы сцены вверх
ySpeed = 0;//дудлера вниз
life = false;//обозначаем что он мертв
}
}else{//если это дырка
if(tAmmunition == 0){//и на дудлере нет амуниции
ySpeed = 0;//останавливаем дудлера
gravitation = 0;//останавливаем падение дудлера
yDoodler -= (yDoodler - yObstacle)/6;//засасываем дудллера в дыру по X
xDoodler -= (xDoodler - (xObstacle+10))/6;//засасываем дудллера в дыру по Y
alphaDoodler -= 3;//уменьшаем прозрачность дудлера
life = false;//убиваем дудлера
}
}
}
yObstacle -= stageSpeed;//в случае падения монстры сместятся вверх
setObstacle(parseInt(xObstacle), parseInt(yObstacle+obstacleYPosition), tObstacle);//перемещаем монстра
doodle(parseInt(xDoodler), parseInt(yDoodler), tDoodler, tAmmunition, alphaDoodler);//перемещаем дудлера
...
for(i=0;i < numPlatform;i++){
yPlatform[i]-=stageSpeed;//в случае падения все блоки смещаются вверх
if(xDoodler+46>=xPlatform[i]&&xDoodler+16<=xPlatform[i]+65&&
yDoodler+59>=yPlatform[i]&&yDoodler+59<=yPlatform[i]+16&&tPlatform[i]!=-1&&life&&
tAmmunition == 0||tAmmunition == 7){//если живой дудлер столкнулся с активной платформой
if(tPlatform[i]==2){//если платформа белая
if(ySpeed<0){//и дудлер падает на нею
ySpeed = 5;//дудлер отпрыгивает от платформы
tPlatform[i]=-1;//платформа исчезает
}
}else if(tPlatform[i]==9){//если это не белая а коричневая платформа
if(ySpeed<0){ //и дудлер падает на неё
tPlatform[i]=10;//коричневая платформа ломается
}
}else{//если это не коричневая и не белая
if(ySpeed<=0){//и дудлер падает на неё
ySpeed = 5;//дудлер отпрыгивает от этой платформы
}
}
}
...//проверяем на столкновение с пружинами и бонусами (см. далее)
}
if(tAmmunition>0&&tAmmunition<7&&ySpeed<2){ //если дудлер падает с амуницией
gravitation = 0.08;
ySpeed -= 2;
tAmmunition=0;//убираем амуницию
}
if(yFooter > 434){//если обрыв бумаги не на сцене
yFooter -= stageSpeed;//смещаем его
}else{//как только он встал на нужное место
death();//вызываеи меню с результатами
}
footer.style.top = yFooter+"px";
if(xDoodler>296){lDoodler = xDoodler = -24;} //делаем сцену «безграничной»
if(xDoodler<-24){lDoodler = xDoodler = 296;}
}
fr = setInterval("frame()", 10);//интервал запуска функции frame() (100раз в секунду)
```
Что бы обеспечить падение сломанных платформ пишем:
```
if(tPlatform[i]==10){//если это сломанная платформа
yPlatform[i]+=4;//смещаем ее вниз на 4 пикселя
}
```
Все платформы которые уезжают за нижний край сцены должны появляется сверху, то есть если `yPlatform[i] > 480 то yPlatform[i] = -30,` но так как у нас есть коричневые платформы, которые могут падать вниз не в зависимости от других, нарушая порядок исчезновения — этот вариант приведет к произвольному расстоянию между платформ:
Поэтому все платформы которые вышли за область видимости мы ставим на 30 пикселей выше предыдущей скрываемой платформы:
```
if(yPlatform[i] > 480){
xPlatform[i] = parseInt(Math.random()*260);
yPlatform[i] = yPlatform[lastPlatform]-30;
lastPlatform = i;
...
}
```
В зависимости от того, на какой бонус натыкается дудлер — выполняется одно из следующих условий: например если дудлер падает на пружинку:
```
if(tObject[i] == 0&&ySpeed<0){ //если дудлер падает на пружинку
ySpeed = 10;//его скорость становится равна 10 (начальная скорость обычного прыжка = 5)
tObject[i] = 1;//и пружинка меняет свой тип на раскрытый
}
```
Вот что происходит когда дудлер натыкается на другие бонусы:
```
if(tObject[i] == 2){//шапка
gravitation = 0.01;
ySpeed = 10;
tObject[i] = -1;//скрываем шапку
tAmmunition = 1;
}
if(tObject[i] == 3){//ранец
gravitation = 0.008;
ySpeed = 15;
tObject[i] = -1;
tAmmunition = 5;
}
if(tObject[i] == 4){//сфера
tObject[i] = -1;
tAmmunition = 7;
setTimeout('stopBonus()',5000);//запускает функцию отключения бонуса через 5 секунд
}
```
Конечно это не все, осталось много всего необъясненного, но ведь мы рассматривали основную часть нашей работы. Думаю принцип понятен, далее нам оставалось сделать так чтобы сложность игры увеличивалась в зависимости от набранных очков:
далее мы добавили заставку (с возможностью пропуска), меню, рекорды, справку, меню паузы, звуковое сопровождение, и информацию о достижениях после падения дудлера:
При запуске игры, она обращается к серверу и получает список результатов, который доступен по кнопке «Рекорды». Если пользователь преодолевает минимальный рекорд, (расположенный в списе на 16-ой строчке), то игра спрашивает его никнэйм, далее в зависимости от набранных очков располагает его на определенной позиции, смещая меньшие рекорды вниз.
Простой рабочий пример: [тут](http://borodinart.ru/projects/1) | https://habr.com/ru/post/128347/ | null | ru | null |
# Clojure — трансдьюсеры, редьюсеры и прочая муть
 В последнее время определенную известность получили [transducers](http://clojure.org/transducers) — новая фишка из еще не вышедшей Clojure 1.7. На момент написания статьи актуальна Сlojure 1.7-alpha5, но уже успело появиться изрядное количество портов трансдьюсеров на разнообразные языки: [Python](https://github.com/abingham/python-transducers), [Ruby](https://github.com/cognitect-labs/transducers-ruby), [JavaScript](https://github.com/jlongster/transducers.js), [PHP](https://github.com/mtdowling/transducers.php), [Java](https://github.com/cognitect-labs/transducers-java), [C++](https://github.com/kirkshoop/transducer), [Lua](https://github.com/gordonbrander/transducers.lua), [Erlang](https://github.com/sfwc/erlang-transducers). И… это немного обескураживает. Ведь довольно давно (еще в Clojure 1.5) добавили библиотеку [reducers](http://clojure.org/reducers).Так вот про редьюсеры никто особо не говорил,никуда ничего не портировал, хотя, вроде как, делают они схожие вещи… Или нет?
Давайте разберемся, для чего нам в Clojure понадобились все эти reducers & transducers (они нам правда нужны?), как они работают, как их использовать… И выясним наконец, не пора ли выкидывать reducers на свалку.
Будет неправильным описывать концепции, возникшие в Clojure, вне контекста данного языка. Потому дальше будет много листингов на Clojure. Но зато не будет никакого матана. В общем начальные знания Clojure уместны (особенно представление о [sequences](http://habrahabr.ru/post/160235/)), а вот знать Haskell не обязательно. Также заранее предупреждаю, что все приведенные листинги стандартных функций на самом деле очень сильно изменены, иногда даже «слегка» поломаны. Все во благо упрощения. Ах да, на картинке тот самый [буррито](https://www.youtube.com/watch?v=6mTbuzafcII).
Сворачиваемся…
--------------
Итак, Clojure язык функциональный, а значит [обыкновенный](https://clojuredocs.org/clojure.core/doseq) [императивный](https://clojuredocs.org/clojure.core/while) [цикл](https://clojuredocs.org/clojure.core/recur) не есть хорошо.
Ну и ладно, не очень нам хотелось — есть же функциональноугодный [reduce](https://clojuredocs.org/clojure.core/reduce)!
```
(defn my-reduce
([rf coll] ;; этот вариант для удобства
(if-let [s (seq coll)]
(my-reduce rf (first s) (next s))
(rf)))
([rf acc coll]
(if-let [[x & xs] (seq coll)]
(recur rf (rf acc x) xs)
acc)))
```
В действительности `reduce`, конечно же, реализован [несколько иначе](https://github.com/clojure/clojure/blob/clojure-1.7.0-alpha5/src/clj/clojure/core.clj#L6496), но нам это сейчас не важно, забудем. Функция `rf` (назовем ее редукт-функция) тут принимает два аргумента: первый — некое «скользящее состояние»; второй — элемент из последовательности `coll`. Если начальное состояние не задано, то используется `(first coll)` или `(rf)`. Пробегаемся по всей коллекции `coll`, для каждого элемента вызываем `rf`, при этом «протаскивая» состояние `acc`. Когда элементы закончились, то просто возвращаем `acc`.
Небольшой пример. Допустим, у нас есть список строк, хотим подсчитать их суммарную длину.
Вот императивный код с циклом:
```
(defn length-of-strings [strings]
(with-local-vars [acc 0] ;; да-да, в Clojure есть локальные переменные!
(doseq [c strings]
(var-set
acc
(+ @acc (count c)))) ;; собственно вся работа
@acc))
```
Состояние цикла — простой счетчик `acc` (число). На каждой итерации мы полагаем его равным `(+ @acc (count c))`.
А теперь еще разок, только через `reduce`:
```
(defn length-of-strings [coll]
(my-reduce
(fn ([acc c] (+ acc (count c)))) ;; наша редукт-функция
0 ;; начальное значение
coll))
```
В случае, если временно «подзабыть» о ленивости, то можно многие примитивные операции реализовать, вроде `map` или `filter`.
```
(defn my-map [f coll]
(my-reduce
(fn [acc c] (conj acc (f c)))
[]
coll))
(defn my-filter [p coll]
(my-reduce
(fn [acc c] (if (p c) (conj acc c) acc))
[]
coll))
```
Для реализации `take` приведенный вариант `reduce` уже не сгодится — цикл всегда пробегает по всей последовательности (это не какой то там Haskell, где все ленивое).
Дабы побороть сей недостаток, в версию 1.5 добавили специальный ~~костыль~~ маркер [reduced](https://github.com/clojure/clojure/blob/clojure-1.7.0-alpha5/src/clj/clojure/core.clj#L2694) и соответствующий ему предикат `reduced?`. Заодно переписали `reduce`, получив что-то наподобие этого:
```
(defn my-reduce
([rf coll]
(if-let [s (seq coll)]
(my-reduce rf (first s) (next s))
(rf)))
([rf acc coll]
(if-let [[x & xs] (seq coll)]
(let [ret (rf acc x)]
(if (reduced? ret)
@ret
(recur rf ret xs)))
acc)))
```
Как только редукт-функция вернет нам `(reduced ...)`, цикл обрывается и возвращается значение `@ret`.
```
(defn take-r [n coll]
(my-reduce
(fn [[n1 acc] c]
(if (pos? n1)
[(dec n1) (conj acc c)]
(reduced acc)))
[n []]
coll))
;; функция поддерживает бесконечные последовательности!
(take-r 5 (range))
;; => [0 1 2 3 4]
```
Нельзя не вспомнить про замечательнейшую функцию [reductions](https://clojuredocs.org/clojure.core/reductions). По сути своей это аналог `reduce`, только возвращает *ленивый* список из всех промежуточных значений `acc`, а не только последнее. Ее весьма удобно использовать при отладке. Пишем шаг алгоритма в виде функции, запускаем `reduce` на коллекции с входными данными. Если вдруг что-то не так, заменяем `reduce` на `reductions`, запускаем в REPL и получаем все промежуточные шаги. С циклами так просто не получится — надо будет городить отладочные костыли, что не очень удобно.
Бывает `reductions` полезна и сама по себе, факториалы там какие посчитать:
```
;; => *ленивая* последовательность факториалов
(def factorials (reductions *' (cons 1 (map inc (range)))))
(nth factorials 20)
;; => 2432902008176640000
```
Clojure использует [sequences](http://clojure.org/sequences) для прохода по коллекциям. Если мы решим пробежаться по вектору, хеш-таблице или простому итератору, то в куче будет создано изрядное количество временных объектов.
Очевидная оптимизация, которая просится в такой ситуации — реализовать специализированный вариант `reduce` для тех коллекций, для которых это имеет смысл. Ну а если уж коллекция не поддается такой оптимизации, тогда использовать стандартную реализацию, сходную с той, что приведена в начале статьи. Для этого имеется специальный протокол [clojure.core.protocol/CollReduce](https://github.com/clojure/clojure/blob/clojure-1.7.0-alpha5/src/clj/clojure/core/protocols.clj#L13). Когда объект-коллекция его поддерживает, то эта реализация и будет использоваться внутри `clojure.core/reduce`. Поэтому `reduce` в Clojure обычно быстрее аналогичного цикла `doseq`.
Трансформеры
------------
Трансформер — это такая функция, которая принимает одну редукт-функцию и возвращает новую.
Например, вот трансформер «увеличить на 1»:
```
(defn inc-t [rf]
(fn [acc c] (rf acc (inc c))))
;; и сразу пример использования
(reduce + 0 (map inc [1 2 3 4]))
;; => 14
(reduce (inc-t +) 0 [1 2 3 4])
;; => 14
```
Можно это дело несколько обобщить, разрешив вместо `inc` указывать любую функцию:
```
(defn map-t [f]
(fn [rf]
(fn [acc c] (rf acc (f c)))))
(def inc-t (map-t inc))
(def dec-t (map-t dec))
;; ...
(reduce (inc-t +) 0 [1 2 3 4])
;; => 14
```
А вот, например, трансформер «фильтратор»:
```
(defn filter-t [pred]
(fn [rf]
(fn [acc c]
(if (pred c)
(rf acc c)
acc))))
(def odd?-t (filter-t odd?))
(def even?-t (filter-t even?))
;; пример
(reduce (even?-t *) 1 [1 2 3 4])
;; => 8
```
А можно ли совместить несколько трансформеров? Разумеется!
```
(defn odd?-inc-t [rf]
(odd?-t (inc-t rf)))
;; ..или чуть более канонично
(def odd?-inc-t (comp (filter-t odd?) (map-t inc)))
;; что логически эквивалентно..
(def odd?-inc-t
(comp
(fn [rf]
(fn [acc c]
(if (odd? c) (rf acc c) acc)))
(fn [rf]
(fn [acc c]
(rf acc (inc c))))))
;; что даст эквивалент такой функции
(defn odd?-inc-t [rf]
(fn [acc c]
(if (odd? c)
(rf acc (inc c))
acc)))
;; пример использования
(reduce * 1 (->> [1 2 3 4 5] (filter odd?) (map inc)))
;; => 48
(reduce (odd?-inc-t *) 1 [1 2 3 4 5])
;; ==> 48
```
Стоит обратить внимание, что трансформеры идут в «обратном» порядке. Если мы хотим, чтобы элементы коллекции обрабатывались трансформером `A` до того, как они попадут в `B`, то склеивать их нужно как `(comp A B)`. А теперь фокус:
```
(def cc (vec (range 1000000)))
(time (reduce + 0 (->> cc (filter odd?) (map inc))))
;; "Elapsed time: 171.390143 msecs"
;; => 250000500000
(time (reduce ((comp (filter-t odd?) (map-t inc)) +) 0 cc))
;; "Elapsed time: 93.246015 msecs"
;; => 250000500000
```
Вот как, ощутимый прирост скорости на ровном месте! Все, конечно, зависит от множества деталей и различных ньансов, поэтому в реальности выигрыш может быть иным. В общем я хочу сказать, что не стоит воспринимать этот кусок кода как бенчмарк.
Но в целом результаты совсем не удивительные. При использовании `map` и `filter` создается 2 промежуточных последовательности. Мы пробегаем по исходному вектору, создаем временный список из отфильтрованных значений. Затем пробегаем по этому списку и строим еще один, но с увеличенными элементами. И, наконец, пробегаемся уже по нему, суммируя значения.
С другой стороны, вариант с трансформерами не создает никаких временных коллекций. Вместо этого над исходными элементами сразу же применяется и `odd?`, и `inc`.
Где мои редьюсеры?
------------------
И было все хорошо, пока версия 1.5 не привнесла новую стандартную библиотеку `clojure.core.reducers`. Именно так, [отдельная библиотека](https://github.com/clojure/clojure/blob/clojure-1.7.0-alpha5/src/clj/clojure/core/reducers.clj), придется ее явно импортировать. А еще в ней объявлены свои версии `map`, `filter`, `take-while`, и другие. И, конечно же, они не совместимы с обычными версиями из `clojure.core`. Поэтому лучше писать `(require '[clojure.core.reducers :as r])` вместо простого `(use 'clojure.core.reducers)`.
Итак, что же такое редьюсер? Кратко и глупо: редьюсер — это всякий объект, по которому можно редьюситься. Любая коллекция в терминах `clojure.core.reducers` — это редьюсер. Хеш-таблица — редьюсер. И `java.lang.String` редьюсер. Ну и `nil`, разумеется, [тоже](https://github.com/clojure/clojure/blob/clojure-1.6.0/src/clj/clojure/core/protocols.clj#L34). Посмотрим определение:
```
(defn reducer [coll xf]
;; `xf` - это трансформер
(reify
clojure.core.protocols/CollReduce
(coll-reduce [this f1]
(let [f2 (xf f1)]
(clojure.core.protocols/coll-reduce coll f2 (f2))))
(coll-reduce [this f1 init]
(let [f2 (xf f1)]
(clojure.core.protocols/coll-reduce coll f2 init)))))
```
Тут берется коллекция `coll`, и возвращается новая, по которой можно запустить `reduce`, и только это. Ни добавить элемент, ни удалить, ни даже пройтись по элементам. Зато перед каждым запуском `reduce` редукт-функция будет пропущена сквозь трансформер `xf`.
```
(def nums [1 2 3 4 5])
(def nums+1 (reducer nums inc-t))
(reduce + 0 nums)
;; => 15
(reduce + 0 nums+1)
;; => 20
```
Как уже упоминалось, в библиотеке reducers объявлены свои варианты `map`, `filter`, `take-while` и подобные. Все они принимают редьюсер и возвращают новый, к которому «прикреплен» соответствующий трансформер.
Так бы могла выглядеть `clojure.core.reducers/map` (она, конечно же, выглядит совсем [иначе](https://github.com/clojure/clojure/blob/clojure-1.7.0-alpha5/src/clj/clojure/core/reducers.clj#L161)):
```
(def map-r [f coll]
(reducer coll (map-t f)))
```
И теперь несколько примеров как все это добро можно использовать:
```
(require '[clojure.core.reducers :as r])
(def nums [1 2 3 4 5 6 7 8])
(type (map inc nums))
;; => clojure.lang.LazySeq
(reduce conj [] (map inc nums))
;; => [2 3 4 5 6 7 8 9]
(type (r/map inc nums))
;; => clojure.core.reducers$folder$reify__1234
;; совсем-совсем не sequence
(reduce conj [] (r/map inc nums))
;; => [2 3 4 5 6 7 8 9]
;; но все еще умеет редьюситься
(reduce conj [] (r/filter odd? nums))
;; => [1 3 5 7]
(reduce + 0 (->> nums (r/map inc) (r/map inc)))
;; => 52
;; ~~ (+ 0 (inc (inc 1)) (inc (inc 2)) ...)
(reduce + 0 (->> nums (r/filter odd?) (r/map inc)))
;; => 20
;; ~~ (+ 0 (inc 1) (inc 3) ...)
```
Параллелимся
------------
Если честно, то «reducers» зря так назвали. Правильнее было бы «folders». Ведь помимо протокола `CollReduce` (который появился задолго до reducers), в библиотеке объявлен другой, более важный, протокол `CollFold`:
```
(defprotocol CollFold
(coll-fold [coll n combinef reducef]))
```
В принципе очень похоже, только редукт-функций теперь две, а еще добавился непонятный аргумент `n`. Идея: по некоторым коллекциям можно пробегаться в несколько потоков. Кратко: разбиваем ее на блоки размером примерно `n` элементов, каждый кусок сворачиваем при помощи `#(reduce reducef (combinef) %)`, затем список результатов (по одному на блок) сворачиваем еще раз, но уже при помощи `#(reduce combinef %)`.
Редьюсер, который умеет сворачивать себя параллельно, называется [folder](https://github.com/clojure/clojure/blob/clojure-1.7.0-alpha5/src/clj/clojure/core/reducers.clj#L114).
Всего 2 стандартных коллекции поддерживает протокол `CollFold` — вектора и хеш-таблицы.
```
(def v (vec (range 10000000)))
;; линейно, в 1 поток
(time (reduce + v))
;; "Elapsed time: 648.897616 msecs"
;; => 49999995000000
;; в несколько потоков
(time (r/coll-fold v 512 + +))
;; "Elapsed time: 187.414147 msecs"
;; => 49999995000000
```
Все стандартные редьюсеры, для которых это имеет смысл, реализуют `CollFold`. Это, например, `r/map`, `r/filter`, `r/mapcat`, `r/flatten`. С другой стороны, `r/take`, `r/take-while`, `r/drop` не поддерживают параллелизацию. Выше приводилась реализация `r/map`. Вот ее обновленный вариант:
```
(def map-r [f coll]
;; просто заменили `reducer` на `folder`
(folder coll (map-t f)))
```
Напрямую использовать `coll-fold` не нужно — для повседневных нужд имеется обертка [fold](https://github.com/clojure/clojure/blob/clojure-1.7.0-alpha5/src/clj/clojure/core/reducers.clj#L84). В ней задано значение по умолчанию для `n` (размер блока) — 512. В общем намек ясен — reducers явно предназначены для больших коллекций (>1K элементов). И еще раз: не используйте `coll-fold` напрямую, вызывайте `fold`.
Ах, есть же еще [foldcat](https://github.com/clojure/clojure/blob/clojure-1.7.0-alpha5/src/clj/clojure/core/reducers.clj#L314). Эдакий ускоренный (за счет многопоточности) вариант `#(reduce conj [] %)`. Возвращает эта функция объекты [clojure.core.reducers.Cat](https://github.com/clojure/clojure/blob/clojure-1.7.0-alpha5/src/clj/clojure/core/reducers.clj#L263), которые реализуют и `Counted`, и `Sequable`, и `CollFold`.
```
(r/map inc [1 2 3])
;; => # [2 3 4]
;; что там со скоростью...
(def v (vec (range 1000000)))
(time (count (reduce conj [] (r/map inc v))))
;; "Elapsed time: 90.124397 msecs"
;; => 1000000
;; что-то не очень, а если через `foldcat`
(time (count (r/foldcat (r/map inc v))))
;; "Elapsed time: 25.054988 msecs"
;; => 1000000
(time (count (r/foldcat (r/map inc (r/foldcat (r/map inc v))))))
;; "Elapsed time: 32.054988 msecs"
;; => 1000000
;; результат `foldcat`, кстати, тоже foldable (привет, многопоточность)
(satisfies? r/CollFold (r/foldcat []))
;; => true
```
На сцену врываются…
-------------------
В отличие от редьюсеров, трансдьюсеры уже не отдельная библиотека. Это скорее концепция (читай идея), которая будет интегрирована прямо в модуль `clojure.core`. Ждем это добро в версии 1.7 (совсем чуть-чуть осталось).
Кратко: трансдьюсеры — это те же трансформеры, только ~~[после ребрендинга](https://github.com/clojure/core.async/commit/81fc946a4d80dd57f641282831e72ae0d829f1b0)~~ иначе названные. Ну ладно, почти: редукт-функции отныне могут принимать не только 0 и 2 аргумента, а еще и 1. А трансдьюсер, соответственно, это функция от 0-1-2-арной редукт-функции в 0-1-2-арную новую.
```
(def typical-transducer
(fn [rf]
(fn ([] ...) ;; возвращаем начальный элемент
([acc] ...) ;; непонятно...
([acc c] ...))) ;; собственно, тут все самое важное, как и раньше
;; новый вариант `map-t`, на 33% лучше старого
(defn map-t-improved [f]
(fn [rf]
(fn ([] (rf)) ;; пробрасываем дальше
([acc] (rf acc)) ;; пробрасываем дальше
([acc c] (rf acc (f c)))))) ;; заменяем `c` на `(f c)`
```
0-арная редукт-функция как и раньше, может быть вызвана, если нужен начальный элемент. Вариант 2-арный используется для, собственно, самой редукции. А 1-арный вариант вызывается в самом конце всей работы (по завершению `reduce`). Он нужен в тех случаях, когда нужно «дописать» новые элементы за последним.
Пример: трансдьюсер [dedupe](https://github.com/clojure/clojure/blob/clojure-1.7.0-alpha5/src/clj/clojure/core.clj#L7307), пропускающий повторы из коллекции:
```
(defn my-dedupe []
(fn [rf]
;; острожно, состояние!
(let [prev (atom ::none)]
(fn ;; это наша редукт-функция
([] (rf))
([acc] (rf acc))
([acc c]
(let [p @prev]
(reset! prev c)
(if (= p c)
acc
(rf acc c))))))))
(def rf ((my-dedupe) +))
(reduce rf 0 [1 1, 2 2, 3, 1 1])
;; => 7
(reduce rf 0 [1 1, 2 2, 3, 1 1])
;; => 6
;; упс... `rf` не чистая, нельзя ее использовать 2 раза
```
Тонкий момент — наш трансдьюсер возвращает новую редукт-функцию. Причем эта редукт-функция обладает мутабельным состоянием и умеет делать по сути 3 разных вещи (по 1 на арность). ~~Ну прям объект какой-то.~~ Но при этом сам трансдьюсер состоянием не обладает, он лишь выступает в роли некой фабрики.
Как пример использования 1-арного варианта редукт-функции приводят [partition-all](https://github.com/clojure/clojure/blob/clojure-1.7.0-alpha5/src/clj/clojure/core.clj#L6942). Упрощенная реализация:
```
(defn partition-all-t [n]
(fn [rf]
(let [buffer (java.util.ArrayList. n)] ;; состояние!
(fn
([] (rf))
([acc]
(if (.isEmpty buffer)
;; если буффер пустой - пробрасываем дальше
(rf acc)
;; иначе...
(let [v (vec (.toArray buffer)) ;; превращаем буфер в вектор
acc' (rf acc v)] ;; сбрасываем при помощи 2-арной `rf`
;; а теперь можно и пробросить дальше
(rf acc'))))
([acc c]
(.add buffer c)
(if (= n (.size buffer))
;; если буффер переполнился - "сбрасываем" его
(let [v (vec (.toArray buffer))]
(.clear buffer)
(rf acc v))
;; иначе - ничего не делаем
acc))))))
;; пользуем то, что наваяли (не указали начальный элемент, ведь (conj) => [])
(reduce ((partition-all-t 3) conj) (range 10))
; >> ClassCastException java.lang.Long cannot be cast to clojure.lang.IPersistentCollection
;; не работает...
;; ну ладно, а если указать []...
(reduce ((partition-all-t 3) conj) [] (range 10))
;; => [[0 1 2] [3 4 5] [6 7 8]]
;; работает, но неверно...
```
Хм… Ни 0-арный, ни 1-арный варианты `((partition-all-t 3) conj)` так и не были вызваны — обычная `reduce` ничего не знает про все эти новшества. Она 0-арный вариант вызывает только если коллекция пустая, 1-арный не вызывает вообще никогда.
Потому создали новую функцию `transduce`. Вот она уже, в отличие от «устаревшей» `reduce`, вызывает `(rf)` всегда, если только начальное состояние явно не задано. А еще эта функция гарантированно вызывает `(rf acc)`, причем *ровно один раз*. А еще `transduce` сама вызывает наш трансдьюсер и прячет мутабельную редукт-функцию от наших глаз. Другими словами, вся грязная работа (в плане побочных эффектов) выполняется «под капотом».
```
;; передаем сам иммутабельный трансдьюсер, а не результат его работы
(transduce (partition-all-t 3) conj (range 10))
;; => [[0 1 2] [3 4 5] [6 7 8] [9]]
;; ии... работает!
;; композиция трансдьюсеров (опять работает)
(transduce (comp (filter odd?) (partition-all-t 3)) conj (range 10))
;; => [[1 3 5] [7 9]]
```
А что, если попробовать `transduce` вместо `reduce` использовать?
```
(reduce (identity -) 0 [1 2 3 4])
;; => -10
;; ~~ (- (- (- (- 0 1) 2) 3) 4)
(transduce identity - 0 [1 2 3 4])
;; => 10
;; не верно!
```
Оказывается, напрямую заменить `reduce` на `transduce` не получается — мешает новое требование 1-арной редукт-функции. В нашем примере после окончания вычислений `transduce` вызывает `(- acc)`, что меняет знак результата на противоположный. Исправить ситуацию поможет [completing](https://github.com/clojure/clojure/blob/clojure-1.7.0-alpha5/src/clj/clojure/core.clj#L6559):
```
((completing -) 3 2)
;; => 1
((identity -) 1)
;; => -1
((completing -) 1)
;; => 1
(transduce completing - 0 [1 2 3 4])
;; => -10
;; вот теперь правильно!
```
В ядре языка появились специальные функции для работы с ~~трансформерами~~ трансдьюсерами. Вполне ожидаемо, что также добавлен набор стандартных этих самых трансдьюсеров. А дабы не плодить множество новых функций (их и так много, запутаешься в два счета), решили проапгрейдить существующие `map`, `filter`, `take`, `interpose`, `mapcat` и компанию:
```
(map inc [1 2 3])
;; => (2 3 4)
(map inc)
;; => #
;; это трансдьюсер!
;; можно делать так
(transduce (map inc) + [1 2 3])
;; => 9
(transduce (comp (map inc) (filter even?)) + [1 2 3])
;; => 6
;; ~~ (+ (inc 1) (inc 3)) => 6
```
Помимо `transduce` есть еще несколько функций для работы с трансдьюсерами:
```
;; применяем трансдьюсер к коллекции
(sequence (map inc) [1 2 3])
;; => (2 3 4)
;; это равносильно такому коду
(transduce (map inc) conj [1 2 3])
;; => [2 3 4]
;; Но...
;; функция `sequence` выполняет трансдьюсер *лениво* !
;; с `transduce` такой фокус уже не сработает
(take 5 (sequence (map inc) (range)))
;; => (1 2 3 4 5)
;; в функцию `into` также добавили поддержку трансдьюсеров
(into [9] (map inc) [1 2 3])
;; => [9 2 3 4]
```
Но самая забавная функция, это [eduction](https://github.com/clojure/clojure/blob/clojure-1.7.0-alpha5/src/clj/clojure/core.clj#L7348). Она возвращает прокси-объект, на котором можно вызывать `seq`, `reduce` или получить java-iterator. Ожидаемо, что этот объект просто вызовет `transduce` или `sequnce`. Мелочь, но удобно.
```
(def odds (eduction (filter odd?) (range)))
(def evens (eduction (remove odd?) (range)))
;; можно работать как с sequential
(take 5 odds)
;; => (1 3 5 7 9)
;; в памяти будет строится sequence из первых 100500 чисел
;; но ссылки на начало не останется - sequence соберется GC
(nth odds 100500)
;; => 2010001
;; а вот тут сразу будет запущен reduce (никаких временных LazyCol)
;; ~= (reduce ((filter even?) ((take 100500) +)) 0 (range))
(transduce (take 100500) + evens)
;; => 10100149500
```
Стоп, стоп, стоп. Оно ведь подозрительно напоминает `clojure.core.reducers/reducer`… Тот, правда, можно было только сворачивать, а тут еще `seq` разрешили запускать. Так что `r/reducer` выкидываем на помойку! Но только не `r/folder`, он умеет в многопоточность!
```
(require '[clojure.core.reducers :as r])
(def v (vec (range 1000000)))
(time (transduce (map inc) + v))
;; "Elapsed time: 120.193971 msecs"
;; => 500000500000
(time (r/fold + (r/folder v (map inc))))
;; "Elapsed time: 37.597224 msecs"
;; => 500000500000
;; но соблюдайте осторожность!
(transduce (take 100500) + v)
;; => 5050074750
(r/fold + (r/reducer v (take 100500)))
;; => 5050074750
;; верно
;; reducer устарел - лучше использовать eduction
(r/fold + (eduction (take 100500) v))
;; => 5050074750
(reduce + (r/folder v (take 100500)))
;; => 5050074750
;; даже так верно
(r/fold + (r/folder v (take 100500)))
;; => 109071345018
;; упс...
;; не всякий трансдьюсер параллелизируется (можно превратить в фолдер)
```
При использовании трансдьюсеров достигается как б**о**льшая производительность по сравнению с обычными `map`/`filter`/`etc` (на основе ленивых последовательностей), так и б**о**льшая гибкость/абстрактность. Замечу, что речь тут идет именно о clojur'ных последовательностях: по уровню абстракции и скорости трансдьюсеры сопоставимы с обычными итераторами/энумераторами/генераторами (в разных языках их принято звать по-разному).
Но вернемся к Clojure. Раньше в [core.async](https://github.com/clojure/core.async) была целая уйма функций вида `map>`, `map<`, `filter<`, `filter>`, и т.п. Нынче их [убрали](https://github.com/clojure/core.async/blob/v0.1.346.0/src/main/clojure/clojure/core/async.clj#L944) (ну как убрали, пока лишь задепрекейтили). Зато разрешили указать ~~трансформер~~ трансдьюсер при создании канала:
```
;; не забыли подключить библиотеку в project.clj
(require '[clojure.core.async :as a])
;; самый такой обычный трансдьюсер
(def xf (filter odd?))
;; и канал с буфером
(def ch (a/chan 10 xf))
;; положили в канал числа от 0 до 9 да и закрыли его
(a/onto-chan ch (range 10))
;; достаем числа из канала
(a/ [1 3 5 7 9]
```
Трансдьюсер можно навесить только на буферизированные каналы. И перед тем, как элемент окажется в буфере, его обрабатывает наш трансдьюсер. Есть еще всякие [pipeline](https://github.com/clojure/core.async/blob/v0.1.346.0/src/main/clojure/clojure/core/async.clj#L500)'ы, они тоже с трансдьюсерами работают.
Подводим итоги
--------------
Разнообразные редьюсеры/трансдьюсеры — все суть обобщение операции свертки. А посему, требуют они редукт-функцию с 2-мя аргументами для работы своей полезной.
Помимо 2-арного варианта лучше заодно определить еще и 0-арный — он может быть использован, если не задано начальное состояние свертки. А может быть и не использован: если исходная коллекция не пустая, тогда `reduce` возьмет ее первый элемент. А вот `transduce` так подло не поступает — либо начальное состояние передается в него явно, либо используется 0-арный вызов редукт-функции.
С другой стороны, `transduce` требует от редукт-функции большего — обязательно нужен 1-арный вариант. Который, в общем случае, чаще всего совсем ничего не делает. Серьезно, обычно `([x] x)` — самая осмысленная реализация в данном случае. Но ведь мы ленивые, переписывать старые функции (0/2-арные) нам лень, поэтому используем обертку `completing`, которая добавляет пустой 1-арный вариант.
Далее, редьюсеры основаны на трансформерах. Трансформер = функция с типом `rf -> rf`. Фактически редьюсер — это коллекция, к которой намертво прикрутили трансформер. И, всякий раз, как мы `reduce` по этой коллекции запускаем, сначала трансформер «портит» нашу редукт-функциию.
Трансдьюсер ~= трансформер, только требует еще поддержку 1-арной редукт-функции. Так что всегда определяем этот самый злополучный 1-арник, и гордо так всем заявляем: «ну конечно же я не использую устаревшие трансформеры, только трансдьюсеры».
При всем этом трансдьюсеры не ограничиваются работой с коллекциями. Можно их прикрутить к каналам, потокам ввода-вывода, очередям, обсерверам и т.п. В общем ко всему, на что фантазии хватит.
Итого:
* если создаем новый алгоритм обработки последовательностей, то стоит попробовать его написать как трансдьюсер;
* когда куча данных в памяти, нету I/O, не нужна ленивость — используем `reducers`;
* хотим обработать коллекцию и запустить на ней `reduce` — неплохо бы попробовать `transduce`;
* но это вовсе не обязательно — преждевременные оптимизации не есть добро;
* фильтрованные каналы, хитрые подписчики на события… трансдьюсеры тут так и просятся;
* нужны ленивые последовательности или не знаем что же нам использовать — старые добрые `map`, `filter` и их друзья. | https://habr.com/ru/post/247889/ | null | ru | null |
# Разработка тайловой игры на JavaScript (Robbo)
#### Дорогие жители Хаброхабра!
В этот раз я принёс вам историю про javascript, atari и canvas! Игра называется Robbo и является портом одноименного творения 1989 года.
[Сама игрушка](http://dizaina.net/z/robbo/). [Игрушка с выключенным звуком](http://dizaina.net/z/robbo/?nosound). [Версия для игры на работе](http://dizaina.net/z/robbo/?nosound?ascii). [Ссылка на github](https://github.com/Zibx/robbo).
Управление осуществляется стрелками. Если есть патроны, то shift+стрелка выстрелит в нужном направлении.
#### История
Кому не интересна предыстория — пролистывайте сразу следующие несколько абзацев до раздела «Техническая реализация».
В детстве у меня был компьютер Atari 130 XE. Родители купили его когда мне было 2 года. По их рассказам именно в этом возрасте я падал со стула с джойстиком, убегая от совы на втором уровне Robbo.
##### Robbo
Эта игра была написана польским програмистом Janus Pelc и выпущена в 1989 году. Это была моя любимая игра детства.
В институте моей маме преподавали программирование и она решила в 4 года научить меня бэйсику. Тогда и была предпринята первая попытка переписать роббо самостоятельно. Плохо было то, что я знал только операторы PRINT, INPUT и POKE. Ни к чему хорошему это не привело/ Z не мог даже представить как возможно написать такую игру, то что я делал было похоже на брутфорс по всем ходам. Пользователь нажал вправо и отпринтилось состояние где персонаж смещен на одну клетку вправо, то есть это была аскиарт стэйтмашина в чистом виде. Если бы я знал о текстовых квестах, то их бы таким методом реализовать вышло, но я не знал.
Следующая итерация была в девятом классе. Это был уже Visual Basic и AMD-K6 II 500. В то время журнал Upgrade решил выпустить свой первый номер с диском, а у меня как раз была некоторая реализация игры. В MS Paint была нарисована груда спрайтов с их фирменными пионерами, после чего я выслал им эту игрушку. Через несколько месяцев сдох винт и код был утерян. В коде были только массивы, даже структуры не использовались, один алгоритм обхода лабиринта по правилу правой руки NPC занимал восемь А4 страниц кода (я не шучу). Нормального интернета тогда ещё не было, только диалап.
В 11 классе всё на том же Visual Basic была написано новая версия. Тут код стал заметно лучше, я не расписывал разное поведение для 4 направлений движения.
Прошло 8 лет. Познание паттернов, чтение уймы литературы и практического опыта, изучение вереницы языков, любовь к функциональному стилю и js в частности, развитие HTML 5. И я вновь вернулся к Robbo. Все эти годы я иногда вечерами запускал эмулятор атари (Atari800Win) и играл в любимую игру детства. За 2 дня я написал код, где было намного меньше строк чем раньше. После чего наступило прозрение что это надо отрефакторить. Рефакторинг растянулся на несколько месяцев. Это некоммерческий проект, то есть хобби, потому я старался вылизывать код, хотя до сих пор остались огрехи за которые мне стыдно. Более подробно с чем я столкнулся я опишу в технической части.
##### GnuRobbo.
Есть похожий open source проект GnuRobbo. Они реализовывали robbo на c++ кроссплатформенно (сейчас есть даже рабочая версия под Андроид в гугл плэй). Последние несколько лет когда меня тянуло вспомнить robbo — я запускал именно эту реализацию. Когда я начал работу над этим проектом меня подмывало посмотреть как что сделано у них, так вот, при общей схожести (если переключить скин в classic) создаётся ощущение что это robbo, но на самом деле отличающихся мест чертовски много. Создаётся ощущение что разработка не была пропитана любовью, как бы странно это не звучало.
#### Техническо популярная часть.
Любая игрушка, где есть живой мир строится вокруг некоторой реализации бесконечного цикла. Тут нет ничего сложного, обычный вызов функции через setInterval. В этой функции находится расчёт нового состояния мира и перерисовка изменившихся частей.
Рассмотрев игру я понял что многие объекты в этом мире реализуют одинаковое поведение. Так бомбу, камень, некоторые пушки, звездолёт можно двигать, уперевшись в них.
Сами объекты получились предельно простыми. Вот, для примера код двери (door.js):
```
(function( R ){
'use strict';
R.objects.Door = {
// дверь можно взорвать
explodable: true,
// если ткнуться в дверь, то случится поведение поедания двери
eatable: true,
eat: function( eater ){
// если у того кто хочет съесть дверь есть хотя бы один ключ
if( eater.keys > 0 ){
// отнимем у него один ключ
eater.set( 'keys', eater.keys - 1 );
// уничтожим дверь
this.game.setCell( this, 'Empty' );
// и сыграем звук отворяющейся дверь
this.game.playSound('door_default')
}
// функция eat вызывается извне, и если она возвращает false, то это значит
// что объект на самом деле есть нельзя. В случае двери она сама уничтожает себя,
// потому что в оригинальном роббо мы не едим дверь как болт, а только отворяем её.
return false;
}
};
} )(window.R);
```
С таким подходом сделать простые объекты вышло быстро. А вот с лавой, бомбами, взрывами, пулями и телепортом пришлось повозиться.
##### Бомба и взрыв
Бомба — это объект, который взрывается и разносит всё что находится на расстоянии одной клетки от него. В оригинальном роббо это действительно похоже на взрыв, а в gnuRobbo на всю красоту забили.
Было записано большое количество видео того как взрывается бомба в эмуляторе, после чего на бумагу была переписана раскадровка спрайтов взрыва. Два дня я созерцал цифры. За это время я узнал что анимация взрыва имеет 5 состояний сначала взрыв усиливается, а потом затухает, но делает он это не равномерно во всех направлениях, а по некоторому паттерну. На форуме гнуроббо кто-то уже замечал что взрывы отличаются и предполагали что это рэндом, но нет, это не мог быть рэндом. В те времена получение псевдослучайных чисел было дорогой забавой.
Насмотревшись на цифры достаточно я вывел закономерности и две матрицы взрывов. Матрица накладывается на соседние клетки и там где число больше нуля ставится объект взрыва с анимацией, соответствующей числу из матрицы. Если там уже был взрыв, то к его анимации добавляется число из матрицы, после чего делается max( 5, animation ).
1) Матрица момента после касания бомбы пулей или соседним взрывом:
```
0, 0, 0,
0, 0, 2,
5, 4, 5
```
В этот момент бомба ещё жива как объект и визуально.
2) На следующем такте накладывается матрица:
```
5, 4, 5,
4, 3, 2,
0, 0, 0
```
Для одной бомбы результат получается идентичен оригинальной игре.
Для нескольких бомб — ещё не идентичен. Выглядит похоже на оригинальную анимацию, но ещё требует доработки *(стыдно)*.
Сам взрыв же представлен объектом, занимающим одну клетку и уменьшающим свою анимацию на 1 за каждый шаг. После взрыва этот объект умеет позвать коллбэк или выставить на своё место заранее заданный другой объект.
Фактически взрывов в игре много:
Дым от разорвавшегося патрона, уничтожение объекта, взрыв бомбы, телепортация из, телепортация в (тут анимация взрыва идёт в обратном порядке)
##### Телепорт
Телепорт работает собственно как телепорт. Перемещает роббо из одной части карты в другую. Во входной точке роббо дематериализуется, а на выходе — материализуется обратно. Если войдёт справа, то выйдет с левой стороны. Интересные случаи начинаются когда в выходной точке нужный выход заблокирован, иногда и все стороны выхода закрыты, а иногда точку выхода могли взорвать. Телепорты не обязательно связаны попарно, они могут быть закольцованы и большим числом выходов. В своей реализации я сделал возможность выхода и не в другом телепорте, но это на будущее, когда буду делать игру со своей идеей. На эмуляторе я проверял все эти состояния и записывал что к чему приводит. Любовь к оптимизации пришла ко мне из ассемблера, потому я постароил таблицу начальное -> конечное состояние и свёл выбор выходной клетки к выражению без условного оператора. Это была больше игра в подбери выражение, в данном случае она не оправдана, но раз уж потратил время, то оставил. Фактически вышло что надо инкрементивно проделывать операцию xor текущего направления с 11|10|11|10.
У нас есть входное направление. Допустим мы вошли справа, что соответствует направлению 2 (вошли справа, значит шли в левую сторону). Алгоритм попробует клетки 2 (влево), 1 (вниз) (10^11 = 01), 3 (вверх) (01^10 = 11), 0 (вправо) (11^11 = 0), после чего вернёт направление в исходное состояние (в случае если все выходы заблокированы).
В виде алгоритма это выглядит так:
```
var tryCell, i;
for( i = 0; i < 4; i++ ){
tryCell = this.game.getCell( R.addDirection( this.teleportX, this.teleportY, obj.direction ) );
if( tryCell.is( 'Empty' ) )
break;
obj.direction = obj.direction ^ ( 3 - i % 2 );
}
```
##### Лава.
Объект, который двигается слева направо (или наоборот) всей строкой. Сметает на своём пути всё кроме стен. Сначала я пытался реализовать это поведение на уровне одной клетки, как у остальных объектов, но оказалось что гораздо проще в одном шаге одного объекта рассмотреть всех соседей на горизонтальной линии, ограниченной стенами, подвинуть их и сказать им что в этом шаге мира их действия больше не нужны.
#### Техническая часть
Код игры разделён на логические модули, основные: контроллер, вьюха, менеджер спрайтов, обработчик клавиатуры, объекты (по модулю на каждый отдельный объект и фабрика объектов).
Модель смешана с основным контроллером, а непосредственно объекты являются маленькими контроллерами, отвечающими только за своё поведение. Отдельно стоит вьюха, которая инициализирует кэнвасы, следит за обновлением спрайтов, скроллит игровое поле и запрашивает у R.sprites отрисовку необходимого изображения в нужной позиции.
Изначально мне показалось что перебирать всё игровое поле и смотреть является ли объект живым — не самый оптимальный подход. Так родился список активных объектов. В шаге мира обрабатывается только их поведение.
В контроллер были вынесены общие функции работы с картой, такие как:
swap — поменять местами два объекта. Активно используется при перемещении одиночных объектов (шаг, одиночный выстрел, npc)
getCell( x, y ) — вернёт объект с заданной позицией
getCell( obj ) -> вернёт объект, находящийся в координатах obj.x, obj.y
setCell( x, y, obj, data ) — ставит объект в заданную позицию. Obj может быть как другим объектом, так и именем объекта (например, 'Explosion'). В случае имени объекта — позовётся фабрика объектов.
setCell( obj1, obj2, data ) -> делает то же самое, только координаты выдирает из obj1.x, obj1.y
Всё выглядело просто, пока не началось тестирование оригинального геймплея. Тут выяснилось что в оригинальной игре если упереться камнем в летающую вверх-вниз птицу справа, то в следующем шаге роббо умрёт, а если слева, то проскочит над ней. Пришлось сортировать actionObjects в соответствии с порядком обхода оригинальным игры.
##### Спрайты
Перерисовывать всё игровое поле на каждом шаге было бы неправильно с точки зрения производительности (хотя и не критично для современных компьютеров). Здесь я реализовал хэш по изменным спрайтам объектов, который состоит из координат key: y объекта, а в нём лежит хэш всех объектов, измененных с последней отрисовки в этой строке с key: object.x, а value: самим объектом. Этим я убил сразу двух зайцев: не делается лишний обход всего поля и отрисовывается измененная клетка только один раз, даже если там было несколько изменений (например, птица передвинулась в клетку вниз, а потом её поглотила лава, и всё это за один шаг мира).
Сами спрайты были сначала честно утянуты из gnu robbo, но очень скоро я понял что это было сделано зря. Проще было сразу делать оригинальные, чем возиться и играть в пикселькэтчинг (некоторые они допиксельартили до большего разрешения, неоторые доантиалиасили, а некоторые придумали свои), также у них не хватало процентов 80 спрайтов стен (их в игре оказалось заметно больше, чем я предполагал).
С анимацией была похожая беда. В итоге записывал видео с эмулятора и покадрово наблюдал что должно происходить. Как пример: при шаге персонажей — анимация смены спрайта должна происходить уже на новом месте где-то между обсчётом мира.
То есть в основной цикл добавился шаг, в котором не происходит перемещение объектов, а только меняется изображение.
#### Отдельной главы заслуживает палитра спрайтов.
Я не сразу заметил что в оригинальном роббо на каждом уровне используется свой набор цветов.
Это очень частое решение тех лет разработки игр и демосцены. Памяти было мало, а визуальных эффектов уже хотелось, потому в старых компьютерах была простая возможность поменять соответствие номера из палитры к непосредственно цвету.
Решение было сделано в лоб — в конфиг каждого уровня добавились все цвета, выдранные из оригинальных уровней игры, все спрайты были приведены к 4 общим цветам. На загрузке уровня идёт попиксельное перекрашивание всей картинки в новую цветовую схему.
Буквально на прошлой неделе я сделал отдельный проект (будет пост, если интересно), который позволяет производить изменение палитры без попиксельных манипуляций. Поразительно, но этот метод работает в IE7.
Но эту технологию я ещё не втянул в текущий код игры.
#### Заключение
В игре ещё есть некоторые огрехи.
В планах:
* Доразрулить взрыв группы бомб.
* Сделать поддержку старых браузеров.
* Вытянуть цвета общего фона вокруг игрового поля и цифр из оригинальной игры.
* Сделать кончающиеся жизни (сейчас это уже олдскул, но ведь и игрушка сама из тех времён).
* Доделать поддержку тач управления для мобильных платформ, сделать поддержку smart tv для игры с пульта телевизора.
* Ну и, конечно, портировать финальный мультик.
В отдалённых планах:
* Сделать редактор уровней с редактором объектов, где пользователь сможет нарисовать свой объект, нарисовать ему цепочку спрайтов и выбрать различные поведения из обширного предефайнд списка. Это даст возможность сделать из роббо сокобан, пакмэна (тут надо ещё межклеточное перемещение продумать), боулдердаш, тетрис, да хоть арканоид.
* Сделать общую базу уровней, где пользователи смогут добавлять свои, а другие смогут голосовать за понравившиеся.
Я пообещал себе выложить этот релиз до нового года и написать в общих чертах о разработке. Вроде удалось. Есть ещё места, за которые мне стыдно (в частности вся работа с загрузкой уровней, анимация смены уровней).
Всех с наступающими праздниками! | https://habr.com/ru/post/207920/ | null | ru | null |
# Алгоритм для запоминания иностранных слов
На данный момент создано множество приложений для запоминания слов. Из тех что мне запомнились могу выделить такие Android приложения как **Lingualeo**, **Английские слова**, **СловоУч**.
Главным недостатком этих приложений для меня был платный аккаунт для добавления своей базы слов. Поэтому встал вопрос о написании своего приложения для запоминания слов. Главной идеей было подключения внешнего API словаря и переводчика для переводов слов на родной язык. В качестве такого API было выбрано Yandex API (**API Переводчика** и **API Словаря**).
Первым делом необходимо было получить ключи разработчика. [Для переводчика](https://tech.yandex.ru/keys/get/?service=trnsl) и [для словаря](https://tech.yandex.ru/keys/get/?service=dict).
В качестве языка и платформы разработки был выбран JavaScript и библиотека JQuery.
Для получения перевода слова на нужный язык я использовал следующий код:
```
var oneWord = function() {
$.post("https://dictionary.yandex.net/api/v1/dicservice.json/lookup",
{
key: apiKey,
lang: lang,
text: words[index].text
}, function(data)
{
words[index].tr = "";
words[index].ts = "";
for (var j = 0; j < data.def.length; j++) {
var def = data.def[j];
for (var k = 0; k < def.tr.length; k++) {
var tr = def.tr[k];
words[index].tr += tr.text + "; ";
}
if (def.ts)
words[index].ts = def.ts;
}
if (words[index].tr == "") {
translateWords();
tsWords();
return;
} else {
var str = words[index].tr;
words[index].tr = str.substring(0, str.length - 2);
}
complete();
},
"json");
};
var tsWords = function() {
var text = words[index].text;
var tsText = "";
var tsWords = text.match(/\S+/gi);
var tsIndex = 0;
var tsPost = function() {
$.post("https://dictionary.yandex.net/api/v1/dicservice.json/lookup",
{
key: apiKey,
lang: lang,
text: tsWords[tsIndex]
}, function(data)
{
var ts = "";
for (var j = 0; j < data.def.length; j++) {
var def = data.def[j];
if (def.ts)
ts = def.ts;
}
tsText += ts + " ";
if ((tsIndex < (tsWords.length - 1)) && (tsIndex < 5)) {
tsIndex++;
tsPost();
} else {
words[index].ts = tsText.trim();
complete(false, true);
}
},
"json");
};
tsPost();
};
var translateWords = function() {
$.post("https://translate.yandex.net/api/v1.5/tr.json/translate",
{
key: apiKeyTranslate,
lang: slang,
text: words[index].text
}, function(data)
{
words[index].tr = "";
for (var j = 0; j < data.text.length; j++) {
var text = data.text[j];
words[index].tr += text + "; ";
}
var str = words[index].tr;
words[index].tr = str.substring(0, str.length - 2);
complete(true, false);
},
"json");
};
var qu = function() {
if (!words[index].tr) {
oneWord();
} else {
complete();
}
};
qu();
```
Тут функция oneWord переводит одно слово, tsWords находит транскрипции первых пяти слов в выражении (если дано не слово, а предложение), translateWords переводит предложение.
Результирующая функция complete вызывается для заполнения формы слова с транскрипцией и переводом:
```
var complete = function(tr, ts) {
if (ts == undefined) ts = true;
if (tr == undefined) tr = true;
var word = words[index];
if (tr) $("#text").html(word.text);
if (ts) $("#ts").html("[" + word.ts + "]");
$("#tr").hide();
$("#attempt").hide();
$("#show").show();
$("#tr").html(word.tr);
$("#tts").show();
};
```
В массиве слов words index отражает текущее слова для запоминания. Следующее слово выбирается по следующему алгоритму:
```
var words = [],
patternCount = 5,
indexMemory = {},
indexMemoryCount = 0,
patternIndex = [],
lastIndex = -1,
lastIndexs = [],
lastIndexsCount = 2,
wasAttempt = false,
wasMemory = false,
deep = 0,
deepMax = 100;
var index = nextIndex();
var nextIndex = function() {
deep++;
if (lastIndexsCount - words.length >= 0) {
lastIndexsCount = 0;
}
if ((patternIndex.length < patternCount) && (indexMemoryCount < words.length)) {
if (deep > deepMax) {
var index = maxAttemptsIndex(true);
return index;
}
var index = Math.floor(Math.random() * words.length);
if (indexMemory[index]) {
return nextIndex();
}
indexMemory[index] = "do";
indexMemoryCount++;
patternIndex.push(index);
lastIndex = index;
pushIndex(lastIndex);
return index;
} else {
var index = Math.floor(Math.random() * (patternIndex.length + 1));
if (index == patternIndex.length || (patternIndex.length == 0)) {
wasMemory = true;
var ind = maxAttemptsIndex();
if (inArray(lastIndexs, ind))
{
if (deep > deepMax) {
ind = Math.floor(Math.random() * words.length);
lastIndex = ind;
pushIndex(lastIndex);
return ind;
}
return nextIndex();
}
lastIndex = ind;
pushIndex(lastIndex);
return ind;
}
if (inArray(lastIndexs, patternIndex[index])) return nextIndex();
lastIndex = patternIndex[index];
pushIndex(lastIndex);
return patternIndex[index];
}
};
var maxAttemptsIndex = function(notAttempts) {
var arr = sortMemoryIndexes(indexMemory);
var index = getRandomFishIndex(arr, notAttempts);
return index;
};
var pushIndex = function(index) {
if (lastIndexsCount == 0) return;
if (lastIndexs.length < lastIndexsCount) {
lastIndexs.push(index);
} else {
lastIndexs[0] = lastIndexs[1];
lastIndexs[1] = index;
}
};
var inArray = function(arr, elem) {
for (var i = 0; i < arr.length; i++) {
if (arr[i] == elem)
return true;
}
return false;
};
function getRandomFishIndex(arr, notAttempts) {
var fishForLevel = arr;
var fishTotalWeight = 0, fishCumWeight = 0, i;
// sum up the weights
for (i = 0; i < fishForLevel.length; i++) {
fishTotalWeight += fishForLevel[i].attempts;
}
if (notAttempts) {
fishTotalWeight = 0;
}
var random = Math.floor(Math.random() * fishTotalWeight);
// now find which bucket out random value is in
if (fishTotalWeight == 0) return fishForLevel[Math.floor(Math.random() * fishForLevel.length)].index;
for (i = 0; i < fishForLevel.length; i++) {
fishCumWeight += fishForLevel[i].attempts;
if (random <= fishCumWeight) {
return fishForLevel[i].index;
}
}
}
function sortMemoryIndexes(indexMemory) {
var arr = [];
for (var key in indexMemory) {
if (indexMemory[key] == "do") {
var word = jQuery.extend(true, {}, words[key]);
word.index = key;
arr.push(word);
}
}
var sAttempt = function(first, second) {
if (first.attempts < second.attempts)
return 1;
else if (first.attempts > second.attempts)
return -1;
else
return 0;
};
return arr.sort(sAttempt);
}
```
Суть в том, что требуется выбрать следующее слово из набора ранее не изученных, а также предыдущих изученных слов. При этом вероятность показа последних должна быть больше, если слово плохо запоминается.
Именно кнопка «Неправильно» реализует перестановку вероятностей показа слов.
```
$("#attempt").click(function()
{
words[index].attempts++;
wasAttempt = true;
$("#attempt").hide();
});
```
Данный метод запоминания слов показался мне наиболее эффективным. В остальном программный код приложения реализует события и действия элементов интерфейса. HTML и сопутствующий JavaScript код был обернут в Cordova для платформы Android.
Приложение «EnglishWords» позволяет учить английские слова и слова многих других языков. В программе имеется базовый набор слов для изучения. Главной особенностью программы является возможность создавать ***свои наборы слов для изучения***. ИНФОРМАЦИЯ НА ЭКРАНЕ \* Процент. Означает процент изученных слов в словаре. КАК ЭТО РАБОТАЕТ. Процесс изучения слов начинается с того, что программа набирает из выбранных словарей 5 случайных слов и начинает их показывать в случайном порядке. После того, как слова выучены из словаря извлекаются следующие 5 случайных слов. Если вы отвечаете не правильно на слово, то слово будет показываться чаще. Когда все слова выучены показываются только те слова на которые чаще всего давался не правильный ответ. СЛОВАРЬ Базовый набор слов содержит около 1000 наиболее употребляемых английских слов.
Приложение использует yandex и google api для получения перевода, транскрипции и звукового воспроизведения. Для работы приложения необходим доступ в интернет.
Приведу скриншоты приложения:
   | https://habr.com/ru/post/335212/ | null | ru | null |
# Настраиваем отказоустойчивый Keycloak с Infinispan в Kubernetes
В этой статье мы поделимся опытом развертывания в кластере Kubernetes устойчивой и масштабируемой инсталляции популярного решения для обеспечения «единого входа» (SSO) — Keycloak в связке с Infinispan (для кэширования пользовательских метаданных).
### Keycloak и область применения
[Keycloak](https://www.keycloak.org/) – проект с открытым исходным кодом компании Red Hat, предназначенный для управления аутентификацией и авторизацией в приложениях, функционирующих на серверах приложений WildFly, JBoss EAP, JBoss AS и прочих web-серверах. Keycloak упрощает реализацию защиты приложений, предоставляя им бэкенд авторизации практически без дополнительного кода. За подробной информацией о том, как это осуществляется, можно обратиться к [этому руководству](https://www.keycloak.org/docs/latest/securing_apps/).
Как правило, Keycloak устанавливается на отдельный виртуальный или выделенный сервер приложений WildFly. Пользователи однократно аутентифицируются с помощью Keycloak для всех приложений, интегрированных с данным решением. Таким образом, после входа в Keycloak пользователям не нужно снова входить в систему для доступа к другому приложению. Аналогично происходит и с выходом.
Для хранения своих данных Keycloak поддерживает работу с рядом наиболее популярных реляционных систем управления базами данных (РСУБД): Oracle, MS SQL, MySQL, PostgreSQL. В нашем случае использовалась CockroachDB — современная распределенная СУБД *(изначально Open Source, а впоследствии —* [*под BSL*](https://habr.com/ru/company/flant/blog/456756/)*)*, которая обеспечивает согласованность данных, масштабируемость и устойчивость к авариям. Одной из её приятных особенностей является совместимость с PostgreSQL на уровне протокола.
Кроме того, в своей работе Keycloak активно использует кэширование: кэшируются пользовательские сессии, авторизационные и аутентификационные токены, успешные и неуспешные попытки авторизации. По умолчанию для хранения всего этого используется Infinispan. На ней мы остановимся подробнее.
### Infinispan
[Infinispan](https://github.com/infinispan/infinispan) — это масштабируемая, высокодоступная платформа для хранения данных типа ключ-значение, написанная на Java и распространяемая под свободной лицензией (Apache License 2.0). Основная область применения Infinispan — распределенный кэш, но также её применяют как KV-хранилище в базах данных типа NoSQL.
Платформа поддерживает два способа запуска: развертывание в качестве отдельно-стоящего сервера / кластера серверов и использование в виде встроенной библиотеки для расширения функций основного приложения.
KC в конфигурации по умолчанию использует встроенный кэш Infinispan. Он позволяет настраивать распределенные кэши, чтобы репликация и перекаты данных осуществлялись без простоя. Таким образом, даже если мы полностью отключим сам KC, а потом поднимем его обратно, авторизованных пользователей это не затронет.
Сам IS хранит всё в памяти, а на случай переполнения (или полного отключения IS) можно настроить сбрасывание его данных в БД. В нашем случае эту функцию выполняет CockroachDB.
### Постановка задачи
Клиент уже использовал KC как бэкенд авторизации своего приложения, но переживал за устойчивость решения и сохранность кэшей при авариях / развертываниях. Поэтому перед нами стояли две задачи:
1. Обеспечить надежность/устойчивость к авариям, высокую доступность.
2. Сохранить пользовательские данные (сессии, токены) при потенциальном переполнении памяти.
Описание инфраструктуры и архитектуры решения
---------------------------------------------
Изначально KC был запущен в 1 реплике и настройками кэширования по умолчанию, т.е. использовался встроенный Infinispan, который все держал в памяти. Источником данных был кластер CockroachDB.
Для обеспечения надежности потребовалось развернуть несколько реплик KC. Keycloak позволяет это сделать, используя несколько механизмов автообнаружения. В первой итерации мы сделали 3 реплики KC, использующих IS в качестве модуля/плагина:
К сожалению, IS, используемый как модуль, предоставлял недостаточно возможностей для настройки поведения кэшей (кол-во записей, объем занимаемой памяти, алгоритмы вытеснения в постоянное хранилище) и предлагал только файловую систему как постоянное хранилище для данных.
Поэтому на следующей итерации мы развернули отдельный кластер Infinispan и отключили встроенный модуль IS в настройках Keycloak:
Решение было развернуто в кластере Kubernetes. Keycloak и Infinispan запущены в одном namespace по 3 реплики. За основу для такой инсталляции был взят [этот Helm-чарт](https://github.com/codecentric/helm-charts). CockroachDB разворачивалась в отдельном пространстве имен и использовалась совместно с другими компонентами клиентского приложения.
Практическая реализация
-----------------------
Полные примеры Helm-шаблонов доступны в нашем репозитории [flant/examples](https://github.com/flant/examples/tree/master/2021/07-keycloak).
### 1. Keycloak
КС поддерживает несколько режимов запуска: *standalone*, *standalone-ha*, *domain cluster*, *DC replication*. Режим *standalone-ha* является идеальным вариантом для запуска в Kubernetes, потому что легко добавлять/удалять реплики, общий конфиг-файл хранится в ConfigMap, правильно выбранная стратегия развертывания обеспечивает доступность узлов при обновлении ПО.
Хотя для KC не требуется постоянного файлового хранилища (PV/PVC) и можно было выбрать тип Deployment, мы используем StatefulSet. Это делается для того, чтобы задавать имя узлов в Java-переменной `jboss.node.name` при настройке обнаружения узлов на основе `DNS_PING`. Длина этой переменной должна быть меньше 23 символов.
Для настройки KC используются:
* переменные окружения, которые задают режимы работы KC (*standalone*, *standalone-ha* и т.д.);
* конфигурационный файл `/opt/jboss/keycloak/standalone/configuration/standalone-ha.xml`, который позволяет выполнить максимально полную и точную настройку Keycloak;
* переменные `JAVA_OPTS`, определяющие поведение Java-приложения.
По умолчанию KC запускается со `standalone.xml` — этот конфиг сильно отличается от HA-версии. Для получения нужной нам конфигурации добавим в `values.yaml`:
```
# Additional environment variables for Keycloak
extraEnv: |
…
- name: JGROUPS_DISCOVERY_PROTOCOL
value: "dns.DNS_PING"
- name: JGROUPS_DISCOVERY_PROPERTIES
value: "dns_query={{ template "keycloak.fullname". }}-headless.{{ .Release.Namespace }}.svc.{{ .Values.clusterDomain }}"
- name: JGROUPS_DISCOVERY_QUERY
value: "{{ template "keycloak.fullname". }}-headless.{{ .Release.Namespace }}.svc.{{ .Values.clusterDomain }}"
```
После первого запуска можно достать из pod’а c KC нужный конфиг и на его основе подготовить `.helm/templates/keycloak-cm.yaml`:
```
$ kubectl -n keycloak cp keycloak-0:/opt/jboss/keycloak/standalone/configuration/standalone-ha.xml /tmp/standalone-ha.xml
```
После получения файла переменные `JGROUPS_DISCOVERY_PROTOCOL` и `JGROUPS_DISCOVERY_PROPERTIES` можно переименовать или удалить, чтобы KC не пытался создавать этот файл при каждом повторном деплое.
Устанавливаем `JAVA_OPTS` в `.helm/values.yaml`:
```
java:
_default: "-server -Xms64m -Xmx512m -XX:MetaspaceSize=96M -XX:MaxMetaspaceSize=256m -Djava.net.preferIPv4Stack=true -Djboss.modules.system.pkgs=org.jboss.byteman --add-exports=java.base/sun.nio.ch=ALL-UNNAMED --add-exports=jdk.unsupported/sun.misc=ALL-UNNAMED --add-exports=jdk.unsupported/sun.reflect=ALL-UNNAMED -Djava.awt.headless=true -Djboss.default.jgroups.stack=kubernetes -Djboss.node.name=${POD_NAME} -Djboss.tx.node.id=${POD_NAME} -Djboss.site.name=${POD_NAMESPACE} -Dkeycloak.profile.feature.admin_fine_grained_authz=enabled -Dkeycloak.profile.feature.token_exchange=enabled -Djboss.default.multicast.address=230.0.0.5 -Djboss.modcluster.multicast.address=224.0.1.106 -Djboss.as.management.blocking.timeout=3600"
```
Для корректной работы `DNS_PING` указываем:
```
-Djboss.node.name=${POD_NAME}, -Djboss.tx.node.id=${POD_NAME} -Djboss.site.name=${POD_NAMESPACE} и -Djboss.default.multicast.address=230.0.0.5 -Djboss.modcluster.multicast.address=224.0.1.106
```
Все остальные манипуляции проводим с `.helm/templates/keycloak-cm.yaml`.
Подключение базы:
```
jdbc:postgresql://${env.DB\_ADDR:postgres}/${env.DB\_DATABASE:keycloak}${env.JDBC\_PARAMS:}
postgresql
IdleConnections
${env.DB\_USER:keycloak}
${env.DB\_PASSWORD:password}
SELECT 1
true
60000
org.postgresql.xa.PGXADataSource
…
```
Настройки кэшей:
```
true
org.keycloak.cluster.infinispan.KeycloakHotRodMarshallerFactory
```
Настройки `JGROUPS` и `DNS_PING`:
```
${env.JGROUPS\_DISCOVERY\_QUERY}
...
${env.JGROUPS\_DISCOVERY\_QUERY}
...
```
Наконец, подключаем внешний Infinispan:
```
…
…
```
Подготовленный XML-файл монтируем в контейнер из ConfigMap’а `.helm/templates/keycloak-cm.yaml`:
```
apiVersion: apps/v1
kind: StatefulSet
metadata:
name: keycloak-stand
spec:
serviceName: keycloak-stand-headless
template:
spec:
containers:
image: registry.host/keycloak
name: keycloak
volumeMounts:
- mountPath: /opt/jboss/keycloak/standalone/configuration/standalone-ha.xml
name: standalone
subPath: standalone.xml
volumes:
- configMap:
defaultMode: 438
name: keycloak-stand-standalone
name: standalone
```
### 2. Infinispan
Настройка Infinispan гораздо легче, чем KC, поскольку шаги с генерацией нужного конфиг-файла отсутствуют.
Достаем конфиг по умолчанию `/opt/infinispan/server/conf/infinispan.xml` из Docker-образа `infinispan/server:12.0` и на его основе готовим `.helm/templates/infinispan-cm.yaml`.
Первым делом настраиваем auto-discovery. Для этого устанавливаем уже знакомые нам переменные окружения в `.helm/templates/infinispan-sts.yaml`:
```
env:
{{- include "envs" . | indent 8 }}
- name: POD_IP
valueFrom:
fieldRef:
fieldPath: status.podIP
- name: JGROUPS_DISCOVERY_PROTOCOL
value: "dns.DNS_PING"
- name: JGROUPS_DISCOVERY_PROPERTIES
value: dns_query={{ ( printf "infinispan-headless.keycloak-%s.svc.cluster.local" .Values.global.env ) }}
```
… и добавляем секцию `jgroups` в XML-конфиг:
```
```
Для корректной работы Infinispan c CockroachDB нам пришлось пересобрать образ Infinispan, добавив в него новую версию SQL-драйвера PostgreSQL. Для сборки использовалась утилита werf с таким простым `werf.yaml`:
```
---
image: infinispan
from: infinispan/server:12.0
git:
- add: /jar/postgresql-42.2.19.jar
to: /opt/infinispan/server/lib/postgresql-42.2.19.jar
shell:
setup: |
chown -R 185:root /opt/infinispan/server/lib/
```
Добавим в XML-конфиг секцию :
```
value
```
В Infinispan мы должны описать те кэши, которые в KC были созданы с типом *distributed-cache*. Например, `offlineSessions`:
```
```
Таким же образом настраиваем и остальные кэши.
Подключение XML-конфига происходит аналогично тому, что мы рассматривали Keycloak.
На этом настройка Keycloak и Infinispan закончена. Повторюсь, что полные листинги доступны на GitHub: [flant/examples](https://github.com/flant/examples/tree/master/2021/07-keycloak).
Заключение
----------
Использование Kubernetes в качестве фундамента позволило легко масштабировать решение, добавляя по мере необходимости или узлы Keycloak для обработки входящих запросов, или узлы Infinispan для увеличения емкости кэшей.
С момента сдачи данной работы клиенту прошло 2 месяца. Каких-либо жалоб и недостатков за этот период не выявлено. Поэтому можно считать, что поставленные цели достигнуты: мы получили устойчивое, масштабируемое решение для обеспечения SSO.
P.S.
----
Читайте также в нашем блоге:
* «[Обзор операторов PostgreSQL для Kubernetes. Часть 1: наш выбор и опыт](https://habr.com/ru/company/flant/blog/520616/)»;
* «[Наш опыт с графовой базой данных Dgraph в Kubernetes](https://habr.com/ru/company/flant/blog/524750/)»;
* «[Миграция Cassandra в Kubernetes: особенности и решения](https://habr.com/ru/company/flant/blog/475036/)». | https://habr.com/ru/post/567626/ | null | ru | null |
# Использование подобия паттерна наблюдатель на С
Недавно вспоминал о том как читал книгу по паттернам проектирования для java и из-за того что я всё также не пойму как это делается по памяти в ооп, решил написать свою реализацию на си.
Я решил посмотреть ещё раз в этой книге по java как реализуется этот паттерн. Полистал всю главу, посмотрел код, но в голове ничего не отложилось. Почему так? ) Правильно ли мыслить в стиле ооп? Например я знаю немного java и c++, но насколько удобно можно сделать реализацию так, чтобы ей было приятно пользоваться и не забывалось? Также для эксперимента я посмотрел как это делается на c++. Ну честное слово, на такой код мне сложно смотреть, надо вчитываться в каждую строку и думать.
Так что же я сделал, что мне может пригодиться в будущем в программировании? Встречайте, реализация на [github](https://github.com/xverizex/publisher). Хочу объяснить простоту использования того что я написал. В этой реализации не нужно создавать структуру, которая будет хранить данные. Сама же основная структура находится за кулисами. Например я хочу подписаться в одном файле на издателя TRADE. Этот издатель например будет мне предоставлять скидки по товару. Я рассматриваю наблюдателя как обычную функцию и объявляю её согласно правилу.
```
void sub_trade ( void *event, void *data ) {
/* здесь выводиться к примеру новые скидки на экран. */
}
```
Теперь я хочу создать издателя и подписаться на события. В данном случае ничего лишнего вызывать не нужно. Надо только указать к какому издателю передать подписчика.
```
enum { TRADE };
init_publisher ( TRADE, sub_trade, NULL );
```
И всё. мы подписались на издателя. Теперь в другом файле я например хочу сделать рассылку в онлайн чате. Я не знаю как удобно было бы это сделать в ооп, да тем более на java, но с помощью моей реализации это делается просто. Да кстати, на java наверное пришлось бы использовать статические методы.
Я объявляю ещё функцию подписчика.
```
enum { TRADE };
void notify_chat_trade ( void *event, void *data ) {
/* здесь я рассылаю сообщения в чат */
}
...
init_publisher ( TRADE, notify_chat_trade, NULL );
```
Теперь в файле где происходит получение и парсинг новых данных, приходят данные о скидках. Мне всего лишь нужно вызвать такую функцию и данные передадутся куда надо.
```
/* для простоты я передал число 10, но конечно нужно отправлять специальные данные. */
send_event ( TRADE, 10 );
```
Вот так вот удобно и просто без сложностей использования можно получить нужный результат. Я думаю у меня хорошо получилось.
Кстати, кто может мне объяснить, это структурное программирование или процедурное? | https://habr.com/ru/post/483520/ | null | ru | null |
# Готовим Open Build Service 2.6
1. Привет.
==========
На хабре подозрительно мало информации про [Open Build Service](https://ru.wikipedia.org/wiki/Open_Build_Service) (далее OBS) и прочие платформы.
А про свежесть имеющегося и говорить не хочется.
Недавно был [релиз версии 2.7](http://openbuildservice.org/2016/06/06/version-2.7/), пришли долгожданные изменения.
Но, для истории, хочу немного рассказать об одном варианте использования 2.6 (релиз — февраль 2015 года).
Пример для материала навеян недавней потребностью.
Итак, собирем php-ffmpeg на базе ffmpeg 3.0 для Centos (7, и даже 6\*!).
2. Схема
========
Все необходимые команды я долгое время выполнял методом copy-paste из своей wiki.
Абсолютно все выполняется в консоли, в т.ч. через API OBS.
Сейчас весь процесс разбит на 4 этапа:
**это все что надо будет запустить в консоль**
```
cd ~ && git clone https://github.com/BOPOHA/obs-fast-c7ffmpeg && cd obs-fast-c7ffmpeg
bash -x obs-fast-c7ffmpeg-n1-prepare.sh # при успешном окончании сервер перезагрузится
cd ~/obs-fast-c7ffmpeg
bash -x obs-fast-c7ffmpeg-n2-mkvps.sh
bash -x obs-fast-c7ffmpeg-n3-buildtargets.sh
bash -x obs-fast-c7ffmpeg-n4-buildpkgs.sh
```
* n1 — под готавливаем хост для работы, устанавливаем средства виртуализации, ребут.
* n2 — сетапаем VPS на базе подготовленного .qcow2 образа
* n3 — настраиваем OBS: добавляем свои центосы, создаем целевой проект
* n4 — отправляем тарболы и спеки на сборку
Все необходимое для сброки доступно в [github](https://github.com/BOPOHA/obs-fast-c7ffmpeg).
Используемое железо: Xeon E3-1230 3.2 GHz / 8GB / 2x500GB / 100Mbs / CentOS 7.x
Затраченное время ~2 часа (40мин на rsync rpm-ок, и чуть более часа на сам процесс сборки ).
Далее, по каждому из скриптов, я отмечу наиболее важные, на мой взгляд, моменты.
n1-prepare.sh
-------------
Тут добавляем в GRUB\_CMDLINE\_LINUX некоторые опции, для повышения производительности.
Отдельно стоит kvm-intel.nested=1, это позволяет использовать возможности виртуализации внутри контейнера OBS, тем самым ускорить процесс сборки и снизить нагрузку на диски.
Тут в общем-то больше ничего интересного, устанавливаем сторонний репозиторий openSUSE:Tools для работы через API, и пакеты libvirt/kvm.
n2-mkvps.sh
-----------
Все необходимые данные для настройки окружения были почерпнуты отсюда: [openSUSE:Build\_Service\_private\_installation](https://en.opensuse.org/openSUSE:Build_Service_private_installation).
**obs-server\_os.raw**
```
wget http://download.opensuse.org/repositories/OBS:/Server:/2.6/images/obs-server.x86_64.qcow2
qemu-img create -f raw -o size=128G obs-server_os.raw
virt-resize --expand /dev/sda1 obs-server.x86_64.qcow2 obs-server_os.raw
losetup /dev/loop0 obs-server_os.raw
kpartx -a /dev/loop0
mount /dev/mapper/loop0p1 /mnt
echo "rcsshd start
swapon /dev/vdb1
sleep 360 && screen -dmS upgraderepos bash -x /root/upgrade.repos.bash &
# " >> /mnt/etc/init.d/boot.local
mkdir /mnt/root/.ssh
ssh-keygen -t rsa -N "" -f ~/.ssh/id_rsa
cat ~/.ssh/id_rsa.pub > /mnt/root/.ssh/authorized_keys
cat ~/$REPONAME/___env/upgrade.repos.bash >> /mnt/root/upgrade.repos.bash
chmod -R 700 /mnt/root/.ssh
umount /mnt/
kpartx -d /dev/loop0
losetup -d /dev/loop0
```
Тут берем подготовленный образ. Он по умолчанию не имеет достаточно свободного места для нормальной работы, поэтому производим изменения размера, и небольшое изменения в ФС:
* добавление нескольких команд в автозагрузку
* генерация ssh-key на хосте и копирование pub-key в OBS.
* копирвоание скрипта для обновления rpm-ок.
**obs-server\_lvm.raw**
```
qemu-img create -f raw -o size=128G obs-server_lvm.raw
losetup /dev/loop0 obs-server_lvm.raw
parted -s /dev/loop0 mklabel msdos
parted -s /dev/loop0 mkpart primary 0.00GB 8GB
parted -s /dev/loop0 mkpart primary 8GB 128GB
parted -s /dev/loop0 set 2 lvm on
kpartx -a /dev/loop0
sleep 2
mkswap /dev/mapper/loop0p1
pvcreate /dev/mapper/loop0p2 -ff -y
vgcreate "OBS" /dev/mapper/loop0p2
lvcreate -L 32G -n "server" /dev/OBS
vgscan
mkfs.ext4 /dev/OBS/server
vgchange -an OBS
kpartx -d /dev/loop0
losetup -d /dev/loop0
```
Как описано в Build\_Service\_private\_installation, этот кусок кода создает второй диск, с LVM разделом и необходимой разметкой.
При загрузке, система его опознает и самостоятельно продолжит настройку.
**virt-install --name OBS\_server**
```
virt-install \
--name OBS_server \
--ram 7168 --vcpus 4 \
--disk path=/home/libvirt_images/obs-server_os.raw \
--disk path=/home/libvirt_images/obs-server_lvm.raw \
--graphics spice \
--os-variant sles11 \
--boot=hd &
sleep 180 && virsh reboot OBS_server
sleep 60
```
sleep 180 — ждем первую загрузку OBS и инициализацию LVM, после чего ребут OBS.
sleep 60 — после этого считаем что OBS готова к работе
**поиск IP OBS**
```
VPS_MAC=`virsh dumpxml OBS_server | grep -o '..:..:..:..:..:..'`
VPS_IP=`arp -an | grep $VPS_MAC | sed 's|^.*(\(.*\)).*$|\1|'`
touch /etc/hosts /root/.ssh/known_hosts
sed -i "/linux/d; /$VPS_IP/d;" /etc/hosts /root/.ssh/known_hosts
echo "$VPS_IP linux" >> /etc/hosts
ssh linux -oStrictHostKeyChecking=no uptime
```
Тут по mac-адресу ищем IP OBS, и прописывае его hosts.
Следует отметить, что параметры размера диска 128G, и количества vcpus — взаимосвязаны.
По умолчанию, количество веркеров равно количеству vcpu. Если вам потребуется собрать большой проект, то 5GB может не хватить, потребуется либо увеличить рамер раздела, либо уменьшить количество ядер, либо изменить соотв. параметр в /etc/sysconfig/obs-server. Ниже пример:
**lsblk OBS**
n3-buildtargets.sh
------------------
**скрипт**
```
#!/bin/bash
set -e
LANG=en_US.UTF-8
REPONAME='obs-fast-c7ffmpeg'
export ACC=Admin
export REPO_NAME="home:$ACC:$REPONAME"
export TMP_DIR="/home/tmp"
export PKG_DIR="$HOME/$REPONAME"
mkdir -p $TMP_DIR
rm -rf /root/.config/osc/trusted-certs/linux_443.pem
yes 2 |osc list
osc meta prj -F - centos7 << EOF
centos7
x86\_64
x86\_64
x86\_64
EOF
cd $PKG_DIR
osc meta prjconf -F ___env/centos7.conf centos7
osc meta prj home:$ACC -F - << EOF
$ACC's Home Project
EOF
osc meta prj $REPO_NAME -F - << EOF
$REPO\_NAME
$REPO\_NAME
x86\_64
i586
x86\_64
EOF
```
На первый взгляд и тут все просто, но самом деле, подобные манипуляции нигде явно в документации не освещены.
```
osc meta prj -F - centos7 << EOF
```
Регистрируем подключаемый репозиторий centos7.
```
osc meta prj home:$ACC -F - << EOF
```
Создаем "Home Project" home:Admin.
```
osc meta prj $REPO_NAME -F - << EOF
```
Создаем c суб-проект home:Admin:obs-fast-c7ffmpeg.
А самое сложное было найти команду *osc meta prjconf -F \_\_\_env/centos7.conf centos7*.
Это билд-конфиг соответствующей ОС.
Файл centos7.conf можно накурлить из комьюнити проекта одним из приведенных способов:
```
osc -A https://api.opensuse.org meta prjconf CentOS:CentOS-7 > centos7.conf
curl https://api.opensuse.org/public/source/CentOS:CentOS-7/_config > centos7.conf
```
n4-buildpkgs.sh
---------------
Последний этап, создание пакетов, реализуется функцией:
**function push**
```
function push {
cd $TMP_DIR
PKG_NAME=$1
osc meta pkg $REPO_NAME $PKG_NAME -F - << EOF
$PKG\_NAME
EOF
cd $TMP_DIR/$REPO_NAME
osc up
cd $TMP_DIR/$REPO_NAME/$PKG_NAME
rsync -av --delete --exclude=".osc/" $PKG_DIR/$PKG_NAME/ .
osc addremove
osc ci -m "init"
}
```
Функция регистрирует в OBS пакет,
переходит в локальную папку с проектом (/home/tmp/home:Admin:obs-fast-c7ffmpeg/),
обновляет папку с пакетом,
синхронизирует данные с OBS и делает комит.
Сразу после этого пакет начинает собираться одним из свободных веркеров.
Для сборки php-ffmpeg в Centos7 потребуется совсем не много:
```
push lame
push ocl-icd
push x265
push x264
push xvidcore
push opencl-headers
push ffmpeg
push php-ffmpeg
```
**процесс сборки можно контролировать по разному**
Откуда взять материал для сборки?
---------------------------------
Наиболее простой способ — воспользоваться готовым из src.rpm fedora (поиск тут <https://www.rpmfind.net/> ).
**список использованых src.rpm**
```
ftp://195.220.108.108/linux/fedora-secondary/development/rawhide/source/SRPMS/o/ocl-icd-2.2.8-2.git20151217.0122332.fc24.src.rpm
ftp://195.220.108.108/linux/fedora-secondary/development/rawhide/source/SRPMS/o/opencl-headers-1.2-9.fc24.src.rpm (centos 6)
ftp://195.220.108.108/linux/sourceforge/u/un/unitedrpms/repository/srpm/lame-3.99.5-5.fc24.src.rpm
ftp://195.220.108.108/linux/sourceforge/u/un/unitedrpms/repository/srpm/x264-0.148-2.20160420git3b70645.fc24.src.rpm
ftp://195.220.108.108/linux/sourceforge/u/un/unitedrpms/repository/srpm/x265-1.9-1.20160221git40ba1eb.fc24.src.rpm
ftp://195.220.108.108/linux/sourceforge/u/un/unitedrpms/repository/srpm/xvidcore-1.3.4-1.fc24.src.rpm
ftp://195.220.108.108/linux/sourceforge/u/un/unitedrpms/repository/srpm/ffmpeg-3.0.1-2.fc24.src.rpm
```
В некоторых случаях, потребовались небольшие правки спеков, в таком случае оригинальный файл имеет расширение .orig.
\*Centos 6
----------
Система хорошая, надежная ) но, вот беда, пакетная база устарела для сборки многих пакетов актуальных версий.
Для успешной сборки ffmpeg, потребуется дополнительно собрать ocl-icd-devel, soxr-devel, и их зависимости.
Но самое сложное, это обновить несколько важных системных пакетов: autoconf, automake, m4,… а они взаимозависимые.
Так как эта задача одноразовая, и мы ленивые, то воспользуемся <https://pkgs.org/> для поиска необходимых пакетов.
Добавим найденное в репу OBS и перезапустим сервис:
**c6hack**
```
cd /srv/obs/build/centos6/epel/x86_64/:full/
wget http://springdale.math.ias.edu/data/puias/computational/6/x86_64/ocl-icd-devel-2.2.8-1.git20151217.0122332.sdl6.x86_64.rpm
wget http://springdale.math.ias.edu/data/puias/computational/6/x86_64/ocl-icd-2.2.8-1.git20151217.0122332.sdl6.x86_64.rpm
wget http://springdale.math.ias.edu/data/puias/6/x86_64/os/Addons/soxr-devel-0.1.1-3.sdl6.x86_64.rpm
wget http://springdale.math.ias.edu/data/puias/6/x86_64/os/Addons/soxr-0.1.1-3.sdl6.x86_64.rpm
rcobsscheduler restart
obs_admin --deep-check-project centos6 x86_64
```
Как использовать
----------------
Для начала, необходимо пробросить порты. На 443 висит веб-морда, на 82 — репозиторий.
Наиболее простым и гибким вариантом будет установка nginx и добавление двух строк в дефолтный конфиг:
```
# grep location\ / -A3 /etc/nginx/nginx.conf
location / {
proxy_pass http://192.168.122.218:82/;
proxy_redirect off;
}
#
```
Далее необходимо создать файл /etc/yum.repos.d/obs-fast-c7ffmpeg.repo примерно следующего содержания:
```
[obs-ffmpeg-c7]
name = obs-ffmpeg-c7
baseurl = http://123.123.123.123/home:/Admin:/obs-fast-c7ffmpeg/CentOS_7/
gpgkey = http://123.123.123.123/home:/Admin:/obs-fast-c7ffmpeg/CentOS_7/repodata/repomd.xml.key
gpgcheck = 1
```
На последок.
============
Для тех, кому требуется собирать пакеты без затрат, может понравится этот ресурс <https://build.opensuse.org/>.
Среди минусов:
* устаревшая пакетная база ОС. Например при актуальной Centos 6.6, сборка проходила на базе Centos 6.3 (а там openssl очень старый и т.д.)
* нет возможности подключения сторонних репозиториев (тот же epel-release)
* множественные ограничение по пакетам <https://en.opensuse.org/openSUSE:Build_Service_application_blacklist>
Полезные ссылки:
<https://ru.opensuse.org/openSUSE:OSC>
<https://en.opensuse.org/openSUSE:Build_Service_private_installation>
<https://en.opensuse.org/openSUSE:Build_Service_private_instance_software_live_cycle>
<https://en.opensuse.org/openSUSE:Build_Service_Tips_and_Tricks>
<https://en.opensuse.org/openSUSE:Build_Service_adding_build_targets>
<https://en.opensuse.org/openSUSE:Build_Service_Concept_CrossDevelopment> | https://habr.com/ru/post/303902/ | null | ru | null |
# Oracle cloud: превращаем ubuntu 20.04 в gentoo
Oracle cloud предлагает [некоторые ресурсы](https://interface31.ru/tech_it/2019/10/oracle-razdaet-besplatnye-vps-navsegda.html) совершенно бесплатно. В частности на халяву можно получить 2 виртуальные машины. При создании машины у вас есть выбор из centos, Ubuntu или oracle linux. С учетом ограниченности ресурсов витруальной машины мне стало интересно нельзя ли использовать на этой машине gentoo?
В документации gentoo [описано](https://wiki.gentoo.org/wiki/Replace_a_Linux_installation_with_Gentoo_in-place) как можно на лету превратить любой линукс в gentoo. К сожалению инструкция последний раз обновлялась в 2014 и если ее применять в лоб скорее всего у вас возникнут проблемы. Однако на гитхабе можно найти [скрипт](https://github.com/oglueck/to-gentoo), который по утверждению автора может в автоматическом режиме превратить любой линукс в gentoo. Скрипт давно не обновлялся, но после небольших изменений отработал как надо. Автор исходного скрипта решил не применять мой пулл реквест, но модифицировал свой скрипт базируясь на моих предложениях. Мой вариант скрипта можно найти [тут](https://github.com/kt97679/to-gentoo).
Итак, давайте осуществим превращение ubuntu 20.04 в gentoo. Для этого создаем виртуальную машину используя образ ubuntu 20.04 minimal и логинимся на него как пользователь ubuntu. После этого переключаемся на юзера root:
```
sudo -i
```
Переходим в режим single user:
```
systemctl rescue
```
В нормальных условиях при этом отваливается сеть. В oracle cloud этого не происходит, однако завершается процесс systemd-resolved и как следствие перестает работать dns. Давайте это исправим:
```
rm /etc/resolv.conf && echo 'nameserver 8.8.8.8' >/etc/resolv.conf
```
Теперь можно запустить скрипт миграции и пойти выпить чаю, это займет какое-то время:
```
wget -qO- https://raw.githubusercontent.com/kt97679/to-gentoo/master/to-gentoo|bash
```
Когда выполнения скрипта закончится он предложит вам перезагрузиться. Прежде чем это делать надо убедиться, что вы не потеряете root доступ после перезагрузки. Для этого надо разрешить доступ root по ssh:
```
sed -i -e '/^PermitRootLogin.*/d' /etc/ssh/sshd_config && echo -e "\nPermitRootLogin without-password" >>/etc/ssh/sshd_config
```
И поправить файл /root/.ssh/authorized\_keys:
```
sed -i -e 's/.*\(ssh-rsa.*\)/\1/' /root/.ssh/authorized_keys
```
Теперь можно перезагружаться, но команда reboot не поможет, так что давайте привлечем тяжелую артиллерию:
```
sync && echo 1 > /proc/sys/kernel/sysrq && echo b > /proc/sysrq-trigger
```
Машина уходит в перезагрузку и через пару минут вы сможете залогиниться на нее по ssh как root. Вы находитесь в gentoo окружении, но по прежнему используете старые ядро и initrd. Давайте это исправим.
Включим swap, без этого вам не хватит памяти скомпилировать новое ядро.
```
fallocate -l2G /var/tmp/swap && chmod 0600 /var/tmp/swap && mkswap /var/tmp/swap && swapon /var/tmp/swap
```
Я не планирую использовать на этой машине systemd, так что маскирую его и udev:
```
echo -e 'sys-apps/systemd\nsys-fs/udev'> /etc/portage/package.mask/systemd
```
После этого можно установить пакеты необходимые для компиляции ядра:
```
emerge gentoo-sources app-arch/lz4
```
Теперь можно перейти в директорию с исходниками ядра,
```
cd /usr/src/linux
```
сгенерировать конфиг нового ядра используя конфиг загруженного ядра,
```
yes ""|make oldconfig
```
и оставить в конфиге только те модули, которые используются в настоящий момент.
```
yes ""|make localmodconfig
```
Я планирую не использовать на этой машине initrd, так что все модули будут вкомпилированы в ядро:
```
yes ""|make localyesconfig
```
Запускаем компиляцию и установку ядра:
```
make && make INSTALL_MOD_STRIP=1 modules_install && make install
```
Наша машина весьма маломощна, так что этот процесс займет много времени. Когда компиляция закончится надо обновить конфигурацию загрузчика. Я добавил параметры ядра, которые применялись в исходной ubuntu.
```
cat >/boot/grub/grub.cfg <
```
Имеет смысл разрешить логин на последовательной консоли если будут проблемы с сетью:
```
sed -i -e 's/^#\(.*ttyS0.*\)/\1/' /etc/inittab
```
Осталось немного. После перезагрузки сетевой интерфейс будет называться не ens3, а eth0. Надо удалить скрипт инициализации старого интерфейса и добавить инициализацию нового:
```
cd /etc/init.d && rm net.ens3 && ln -s net.lo net.eth0
```
На случай необходимости залогиниться через последовательную консоль надо задать пароль для пользователя root:
```
passwd
```
Все готово, можно перезагружаться.
Если после перезагрузки вам не удастся залогиниться на машину по ssh создайте консольное подключение и используйте его для отладки.
Теперь у вас есть базовая установка gentoo которую можно модифицировать под ваши нужды. В системе остались артефакты от исходной ubuntu. Они больше не нужны и их можно удалить. Скрипты с командами миграции можно найти [тут](https://github.com/kt97679/misc/tree/master/gentoo/oracle-cloud). | https://habr.com/ru/post/537452/ | null | ru | null |
# Как подружить django и vue.js
Введение
--------
Мне часто по жизни доводится работать с проектами, где есть SPA на Vue и какой-то бэк на Django + DRF. Раскидывать их по разных контейнерам в докере и рулить маршрутами на стороне nginx, конечно, круто, но а что если нужно передать какой-то параметр (например, токен) в Vue и мы не можем авторизовать пользователя просто так?
Кейс
----
Есть такая штука, как битрикс (да, я знаю, питону не место там, но всё же он там может быть). У него есть возможность установки внешних приложений из маркетплейса. И работает оно просто - открывается iframe и посылается POST запрос на URI обработчика приложения. В этом запросе битрикс передаёт токены для доступа, id пользователя, домен портала и прочую полезную инфу (место вызова приложения, тариф и прочее). Кстати, в битриксе это называют приложением второго типа (Первый тип без бэка вообще. А третий без фронта xD).
Подкручиваем бэк
----------------
Для начала стоит создать приложение, которое будет сёрвить фронт (можно и не создавать, но мне кажется, что пилить проект по кускам, когда одно приложение отвечает за пользователей, другое за фронт, третье за посты/товары/корзины и многое другое и так далее). Сделаем с нуля проект django, вкинем туда venv и приступим
```
django-admin startproject vue_django_test_app
cd vue_django_test_app
python3 -m venv venv
source venv/bin/activate
pip install django
pip freeze > requirements.txt
python3 ./manage.py startapp app
```
Вот проект и создан, мы в виртуальном окружении. Побалуемся :)
Во-первых, нам нужно подредачить *settings.py* и добавить приложение app в `INSTALLED_APPS`, прописать `STATIC_ROOT` и указать путь к шаблонам
```
INSTALLED_APPS = [
...
'app'
]
...
TEMPLATES = [
{
...
'DIRS': [BASE_DIR / 'templates'],
...
}
]
...
STATIC_ROOT = BASE_DIR / 'static/'
```
Для любителей HerokuЕсли вы хотите дружить и с Heroku, то вам желательно установить и настроить пакет whitenoise
Как это сделать, можно почитать туть:
https://whitenoise.evans.io/en/stable/django.html
*Напрямую сервить статику django через* ***staticfiles\_urlpatterns()*** *не желательно*
Теперь займёмся настройкой маршрутизации. По пути *vue\_django\_test\_app/urls.py* нужно подключить вьюху, которая отправит шаблон (чуть позже напишем). Также на деве будем обслуживать статику через встроенный механизм django
```
from django.urls import path
from django.contrib.staticfiles.urls import staticfiles_urlpatterns
from app.views import FrontendTemplateView
urlpatterns = [
path('', FrontendTemplateView.as_view())
]
urlpatterns += staticfiles_urlpatterns
```
Пишем представление Django
--------------------------
Как мы помним, нам нужно передать токены и GET параметры на фронт. Для этого нужно написать своё представление. Напишем его в app/views.py
```
from django.shortcuts import render
from django.views import View
import json
class FrontendTemaplteView(View):
def post(self, request):
# Собираем все параметры запроса в контекст
context = {
'post_data': request.body,
'get_data': json.dumps(request.GET) # Сериализуем в JSON
}
# Отправляем клиенту отрендеренный с контекстом шаблон
return render(request, 'index.html', context)
```
Абсолютно простая вьюшка. Думаю, легко понять, что осталось сделать, чтобы пробросить данные)
Создание и настройка сборки vue приложения
------------------------------------------
Допустим, какой-то бэк на django у нас уже есть. Заходим в корень проекта и создаём проект vue.js (пусть будет frontend)
```
vue create frontend
```
Там vue поспрашивает за конфигурацию приложения. Выбирать можно что угодно, но нужно, чтобы конфиг хранился в раздельных .js файлах.
Про vue routerVue router желательно не использовать в history mode, так как на каждый url фронта, нужно будет докидывать маршрут и в django
Затем нам нужно подредачить vue.config.js, чтобы webpack автоматом клал шаблон и статику в директории django
```
// Путь к приложению в котором храниться статика django
const static_dir = '../app/static'
// Путь, относительно static_dir
// В него webpack положит шаблон Vue приложения
const template_path = '../../templates/index.html'
module.exports = {
// Paths
// Рабочая директория сборки
// Я обычно указываю директорию приложения django, которое отвеает за фронт
outputDir: process.env.NODE_ENV === 'production' ? static_dir : 'dist/',
// Куда пойдёт шаблон проекта
indexPath: process.env.NODE_ENV === 'production' ? template_path : 'index.html',
// Куда пойдут ассеты (относительно outputDir)
assetsDir: '', // ассеты храним там же, где и JS/CSS
// Путь по которому можно достать статику
// Нужно указать тот, который прописан в STATIC_URL настроек django
publicPath: process.env.NODE_ENV === 'production' ? 'static' : '/',
}
```
Проверка на NODE\_ENV нужна для того, что дев сервер webpack мог нормально отработать при запуске *npm/yarn run serve* (ну мало ли нужно будет)
Модификация шаблона webpack
---------------------------
Осталось лишь дать понять django куда пихать контекст. И нам в этом поможет файл public/index.html - из него webpack соберёт окончательный html файл и положит его в папку templates. Добавим в этот файл маленький скрипт в котором создадим переменную глобального скоупа и положим туда наши JSON-чики
```
...
window.data = {
post: {{post\_data | safe}},
get: {{get\_data | safe}},
}
...
```
Фильтр safe отключает экранирование символов, чтобы JSON остался валидным.
Финиш
-----
Вот и всё готово! Осталось лишь собрать проект!
Из корня проекта:
```
cd frontend; npm run build; cd ../
python3 ./manage.py collectstatic --noinput
python3 ./manage.py makemigrations; python3 ./manage.py migrate
pip install gunicorn
gunicorn vue_django_test_app.wsgi
``` | https://habr.com/ru/post/568666/ | null | ru | null |
# Статические анализаторы кода на примере ClickHouse
Чуть больше месяца назад была опубликована [статья](https://habrahabr.ru/company/pvs-studio/blog/337182/), содержащая анализ [исходного кода ClickHouse](https://github.com/yandex/ClickHouse/) с помощью PVS-Studio. Статья оказалась достаточно успешной: так, ссылку на неё мне отправили по меньшей мере десять раз в день её публикации. Общий тон статьи позитивный, а посещаемость сайта [clickhouse.yandex](https://clickhouse.yandex/) в день её выхода заметно выросла.
Я очень уважаю, когда какая-либо компания или человек делает свою работу исчерпывающим образом. Так, у PVS-Studio исчерпывающий подход к продвижению: одних только статей на Хабре 337 штук. Они проводят доклады почти на всех российских конференциях по C++. В любом случае стоит отметить: люди стараются и своим трудом приносят пользу другим людям.
Та статья пробудила в нас интерес к статическим анализаторам, и мы решили проверить работу нескольких общедоступных аналогов PVS-Studio на кодовой базе ClickHouse. В сегодняшней статье мы поделимся с вами результатами этого исследования.
В день выхода статьи мы исправили все отмеченные в ней баги. Результат можно посмотреть [в этом коммите](https://habrahabr.ru/company/pvs-studio/blog/337182/#comment_10401018). Некоторых багов на момент публикации уже не было в `master`, так как мы исправили их ранее.
Сомнений в полезности статических анализаторов нет. Некоторые комментаторы отмечают, что гораздо полезнее иметь code review, тесты, запуски под sanitizer'ами. Польза этих решений очевидна. Тем более, у нас уже есть code review (посредственный), покоммитные тесты (с недостаточно хорошим покрытием) и запуски под sanitizers (покоммитно только ASan, раз в сутки Valgrind). Статические анализаторы могут находить другие баги – например, copy-paste в коде, который никогда не выполняется и который надо было удалить год назад. И что-нибудь более серьёзное тоже есть шанс найти (читайте дальше). То есть, польза от статических анализаторов ненулевая.
В статье были указаны не все обнаруженные дефекты, и для поиска оставшихся нам предложили воспользоваться триальной лицензией PVS-Studio. Но перед тем, как запрашивать лицензию, ограниченную по времени, нам хотелось сначала убедиться, что мы достаточно хорошо подготовлены и не потратим время зря.
Мы решили сначала изучить несколько альтернатив PVS-Studio, в результате чего попробовали Clang-Tidy, Сppcheck, Coverity и Svace. Для каждого из них удалось составить инструкции о том, как правильно использовать их для кода ClickHouse.
### CppCheck
Инструкция по использованию: [cppcheck.txt](https://github.com/yandex/ClickHouse/blob/master/dbms/tests/instructions/cppcheck.txt).
У этого инструмента есть несколько важных достоинств: он очень прост в использовании и работает чрезвычайно быстро. Так, наш репозиторий был проанализирован за несколько секунд. Стандартный режим запуска привёл к получению лишь нескольких ложно-положительных предупреждений. В режиме `--enable-all` было получено около 200 предупреждений, некоторые из которых оказались содержательными:
* [Кто-то забыл ввести один символ](https://github.com/yandex/ClickHouse/commit/8b313ab99ec6330d26d64596666725f717a29e51#diff-8b268ddacef447bca1660a97b8ef0e4cL2307). Повезло – ошибка не влияет на поведение программы.
* Неиспользование функции [log1p](https://github.com/yandex/ClickHouse/commit/8b313ab99ec6330d26d64596666725f717a29e51#diff-b3ef0d50782d4803e19506c1b9a5ad2fR104) – не знал, что такая существует. В данном случае тоже не влияет на поведение программы.
Помимо этого, анализатор также нашёл некоторые неоптимальности при передаче параметров в функции, забытые explicit-определения, слишком широкие области видимости некоторых переменных и так далее.
Многие ложно-положительные срабатывания связаны с тем, что анализатор очень примитивный. По-видимому, он даже не до конца парсит C++. Например, следующий код
```
int x = 0;
auto lambda = [&]{ x = 1; };
```
рассматривается так же, как код:
```
int x = 0;
{ x = 1; };
```
Тем не менее, большое количество false positives – норма для статических анализаторов кода. Сценарий их использования состоит в том, чтобы просмотреть несколько сотен ошибок и, возможно, найти среди них несколько действительно существенных.
### Clang-Tidy
Инструкция по использованию: [clang-tidy.txt](https://github.com/yandex/ClickHouse/blob/master/dbms/tests/instructions/clang-tidy.txt)
Важным достоинством этого инструмента является то, что он находится в экосистеме Clang. Это значит, что, если ваша система компилируется при помощи Clang, то Clang-Tidy будет корректно учитывать все особенности сборки вашего проекта. Есть инструкция, как добавлять свои проверки.
На анализ каждого translation unit'а Clang-Tidy тратит около десятка секунд. Это достаточно медленно.
Clang-Tidy отличается от Clang static analyzer (также известного под названием scan-build) наличием проверок стиля. Некоторые из проверок стиля позволяют автоматически переписывать код. Стоит отметить, что Clang static analyzer, в отличие от Clang-Tidy, умеет генерировать HTML-страницы с результатами, тогда как Clang-Tidy лишь выводит сообщения о найденных проблемах в окно терминала.
Использовать все типы проверок нет смысла. Так, одна из проверок [CERT Secure Coding Standards](https://www.securecoding.cert.org/confluence/pages/viewpage.action?pageId=637), [C++ Core Guidelines](https://github.com/isocpp/CppCoreGuidelines) или [HTC++](http://www.codingstandard.com/section/index/) говорит «не используйте арифметику указателей». Это в каком-то смысле разумно, но явно отмечать все исходники, для которых эта проверка должна быть выключена, слишком мучительно.
Полезные сообщения нашлись в группах проверок static analyzer и performance. Performance обнаружил два типа ошибок: постинкременты итераторов и передачи аргументов по значению вместо передачи по ссылке. К сожалению, проверка передачи аргументов по ссылке срабатывает даже для небольших структур, например:
```
struct S
{
int x;
};
```
или `STRONG_TYPEDEF`.
В этом случае замена передачи по значению на передачу по ссылке может оказаться бесполезной или даже вредной (при условии, что функция не инлайнится и не клонируется, ведь в этих случаях никакой разницы нет). В других ситуациях проверка оказалось более полезной, см. [коммит](https://github.com/yandex/ClickHouse/commit/d29c77adea08af7922d7b82e56ccee2f2d11783f#diff-4a276210b42fab5b36975206847b0d85L253) с исправлениями. Конечно, такие ошибки должны обнаруживаться на этапе code review – при условии, что вы были достаточно внимательны. Заметим, что после исправления всех предупреждений performance реальная производительность ClickHouse не изменилась. Это ожидаемо: если бы соответствующие ошибки были в узких местах, мы бы это заметили при первом же запуске `sudo perf top`.
Предупреждения от static analyzer весьма полезны:
* [Вызов виртуальной функции в конструкторе](https://github.com/yandex/ClickHouse/commit/e9ae1938706c8c6e4aab478c0356b1dcf4d300e9#diff-9b62998c55ce7cf34c0e6d37ed6b08b3L50). Оказалось, что virtual написали по ошибке.
* [Потеря точности в вычислениях](https://github.com/yandex/ClickHouse/commit/d19d9f8589d8e39d104a7ad8cd7d56c79324c250#diff-c77cad8ee42ebae8e1ae03d0abf3336eL287)
* [Разыменование нулевого указателя](https://github.com/yandex/ClickHouse/commit/4799f28dadc31f4c967f5304cf5465c307ee1573#diff-4650bcb54ab5af2e8c26f4c200075c7cR37).
### Coverity
Инструкция по использованию: [coverity.txt](https://github.com/yandex/ClickHouse/blob/master/dbms/tests/instructions/coverity.txt).
Coverity – закрытый коммерческий продукт, но для проектов с открытым исходным кодом его можно использовать бесплатно. В числе известных продуктов, использующих Coverity есть, например, Linux.
Схема работы: с сайта скачивается утилита, которая оборачивает любую систему сборки (вместо `make` просто указывается `cov-build make`) и перехватывает вызовы компилятора. Заставить её работать удалось не с первого раза – пришлось перебрать несколько вариантов, как указать ей, какой компилятор используется.
Для некоторых единиц трансляции время работы инструмента достигает часа, а общее время анализа всего проекта – 4 часа. Результатом является tar-архив, который можно загрузить на сайт Coverity. Архив размером 1.5 GB загрузился успешно. Можно загружать и более объёмные результаты.
Затем, чтобы получить доступ к результатам работы анализатора, необходимо пройти проверку на возможность работать с исходным кодом анализируемого проекта. Например, мне доступ предоставили в течение полутора дней.
После этого стал доступен красивый веб-интерфейс, в котором можно в интерактивном режиме изучать код с аннотациями дефектов, а также отмечать резолюции (false positive, intentional, fix required и т. п.).
Сразу же выдали ачивку, правда я не понял за что.
Нашли 312 неких дефектов.
* [Неинициализированная переменная](https://github.com/yandex/ClickHouse/commit/ed1c0820f00c33b54eda7750b3b3c746a70038c7), если пользователь в конфиге не укажет ни одного элемента в одной из секций.
* [Разыменование итератора end](https://github.com/yandex/ClickHouse/commit/9cafeb9e85ce094969e79ce46b85233bc682de4f) только для того, чтобы превратить его в адрес.
* [Всякая мелочь](https://github.com/yandex/ClickHouse/commit/5e25c40a26f5499afa09916cad2df243a1a4daef#diff-909f5a9f60a9cc746f7b737de5241901L50).
Некоторые обнаруженные дефекты на самом деле являются частью задуманного дизайна.
* Тавтологические условия в if'ах в шаблонном коде. Это полностью нормально, является распространённой практикой и стилем кода. Более того, код пишется, исходя из предположения, что компилятор об этом прекрасно знает и удалит ненужный код.
* Неинициализированный член класса в конструкторе по умолчанию. Иногда это действительно ошибка, но в некоторых случаях бывает допустимо.
* Необработанное исключение в функции main в тестовой программе. Это допускает наш стиль. Если исключение вылетело из функции main, то оно будет обработано с помощью std::terminate, стандартная библиотека сделает несколько полезных вещей за вас (verbose terminate handler): выведет тип исключения, для наследников std::exception выведет what, позовёт функцию abort; программа получит сигнал abort, операционная система запишет core dump, и программа завершится с ненулевым кодом. Всё это очень полезно.
Кроме того, одна из ошибок выглядела как `Unrecoverable parse error` при виде std::shared\_mutex. Это значит, что Coverity не поддерживает C++17.
### Svace
30 ноября 2016 я попал на конференцию [«Технологии Баз Данных»](http://ospcon.osp.ru/tbd_dbms2017/), на которой мне удалось договориться с коллегами из ИСП РАН об использовании их инструмента статического анализа Svace. Этот инструмент внедрен в корпорации Samsung, но малоизвестен в среде отечественных программистов.
Результаты анализа доступны в удобном веб-интерфейсе с просмотром исходного кода и аннотаций к нему. Самая серьёзная из обнаруженных ошибок – отсутствие freeaddrinfo [в одной из веток кода](https://github.com/yandex/ClickHouse/commit/861684c5544970a2db9e8cdf2f3fabe4e0659c4e). Стоит отметить, что и результаты анализа, и выборку дефектов для изучения нам предоставили коллеги из ИСП РАН.
### Выводы
Использование статических анализаторов – не первая по важности мера для улучшения кода вашего продукта. Например, если у вас нет автосборки с запуском тестов хотя бы под Address Sanitizer – полезнее будет сначала это обеспечить. Разбор результатов работы статических анализаторов требует большого количества времени, по меньшей мере, в самом начале. Правильное их использование требует наличия интеграции в систему CI. Только если вы сделали более простые вещи – можно попробовать такую замечательную вещь как статические анализаторы. Впрочем, зачем это я вас отговариваю – обязательно попробуйте!
Напоследок, хочется ещё раз поблагодарить коллег из PVS-Studio за работу, которую они делают, в частности – за статью, посвящённую ClickHouse. Они не только помогли нам, обнаружив несколько важных проблем в нашем коде, но и вдохновили исследование, которому посвящена настоящая статья. | https://habr.com/ru/post/342018/ | null | ru | null |
# Как Apple и другие крупные компании настиг программный баг
Сегодня мы отобрали свежие случаи программных ошибок, чтобы вы могли немного отвлечься и возможно узнать что-то новенькое. Если вам интересно узнать, как программисту удалось сломать Интернет по всему миру, удалив крошечный фрагмент кода, и прочитать про другие неочевидные на первый взгляд ошибки, то эта статья для вас!
Появление "error" на экране монитора может напугать даже опытного разработчика. Однако все рано или поздно сталкиваются с этим. Прочитав эту статью, вы убедитесь в том, что облажаться может каждый, и ошибки – не повод расстраиваться. Ранее мы публиковали что-то похожее, [истории о новогодних багах](https://pvs-studio.com/ru/blog/posts/0463/) – одна из таких. В конце статьи мы оставили для вас ещё больше интересных ссылок.
### Чилийская адаптация шоу "Кто хочет стать миллионером"
Здесь речь пойдёт о случайной ошибке, которая сделала жителя Чили миллионером. В мае 2022 года мужчине в Чили как обычно начислили зарплату, только в этот раз с неожиданной премией (даже для самого начальника). Начисленная сумма составляла 165 миллионов чилийских песо (примерно 11 миллионов рублей), что в 330 раз превысило его зарплату.
Работник сообщил об ошибке заместителю руководителя. Тот попросил его вернуть банку случайно начисленные деньги. И что вы думаете? Работник вернул деньги и история на этом закончилась? Как бы не так.
Да, мужчина пообещал начальнику вернуть сумму в банк. Однако спустя сутки он исчез. Через два дня он объявился и вновь пообещал вернуть сумму в ближайшее время. Могу предположить, что свалившееся богатство не давало ему покоя :). Согласно информации в местной газете, через некоторое время работник отправил заявление об увольнении через своего адвоката и исчез навсегда.
Сейчас компания, в которой он работал, пишет жалобы в различные агентства в попытке вернуть деньги. Она уже выставила жалобу против сотрудника за незаконное присвоение денежных средств. Будем надеяться это ещё не конец :).
### Как потребить за месяц электричество на 50 миллионов фунтов стерлингов?
Супружескую пару из Ланкашира поверг в шок их ежемесячный счет за электричество, который увеличился с 87 фунтов стерлингов до 53 480 062. "У меня не было даже таких денег на счету. Мы с супругой были шокированы", – рассказал мистер Бразертон, 63-летний бухгалтер.
Найджелу и Линде Бразертон на днях установили новый счётчик электроэнергии, но электрик ошибся и подсоединил провода неправильно. Из-за этого электричество автоматически подсчитали за всю улицу. Их компания по снабжению электроэнергией видимо не заметила этого, и счёт был отправлен их банку, который списывал деньги автоматически.
"Моя жена волновалась, что из-за этого наша кредитная история будет испорчена", – рассказал мистер Бразертон. Оправившись от шока, пара связалась с компанией по снабжению электроэнергией, те извинились и пообещали исправить ситуацию.
### Первые сбои спустя месяц релиза новой модели iPhone
Спустя неделю после выхода iPhone 14 Pro, некоторые владельцы новой модели сообщили о проблеме с камерой при её открытии в TikTok, Instagram и Snapchat.
Некоторые пользователи опубликовали в Twitter видео о том, как это выглядело — камера в приложениях начинает странно дрожать, и всё это сопровождается скрежещущими звуками. Немного жутковато... Однако со встроенной камерой таких проблем нет.
По словам Apple, это ошибка в программном обеспечении iPhone, а не в сторонних приложениях. Официальный представитель Apple Алекс Киршнер по почте заявил The Verge, американскому сайту о современных технологиях, что компания "осведомлена о проблеме, и ошибка будет устранена на следующей неделе". Однако Apple не объяснила, что именно вызвало ошибку и почему с этой проблемой сталкиваются не все.
В новой модели iPhone 14, Apple представила новую функцию — детектор ДТП. Ваш iPhone 14 способен распознать серьёзную автомобильную аварию, и в случае возникновения происшествия телефон поможет вам связаться со службами экстренной помощи. Впечатляюще. Но как насчёт ДТП на американских горках? Реальная ситуация или бред сумасшедшего? Что ж, iPhone 14 уверен, что это возможно.
Функция детектора ДТП вызвала ложную тревогу и направила сигнал сотрудникам экстренных служб рядом с парком развлечений Кингс-Айленд в Цинциннати. Такой же сбой был обнаружен и у пользователей новеньких часов Apple Watch 8. Решение проблемы у Apple довольно простое: перевести iPhone 14 и Apple Watch 8 в режим полёта перед аттракционном. Что же, тогда насущный вопрос: стоит ли ожидать появления в парке развлечений предупреждающих табличек – "выключите свои айфоны, прежде чем садиться на американские горки"?
Будем надеяться, что больше не будет никаких странных сбоев и ещё чего-либо, что могло бы испортить безупречную репутацию компании.
### Разработчик Windows – похититель Рождества (2022)
В канун Нового 2022 года команда Windows решила поздравить своих подписчиков в Twitter с наступающим Новым годом. Официальный аккаунт разработчика Windows написал в Twitter следующее:
Код написан на С#. Приложение должно было работать по следующему принципу: если вы запустите его ровно в полночь, в канун Нового года, вы получите сообщение "С Новым годом!", а в любое другое время, он покажет вам "Сейчас ещё 2021". Механизм вроде простой, однако что-то пошло не так.
А именно то, что вы можете получить новогоднее поздравление ровно в полночь и ни секундой ранее или позднее. Помимо этого, даже если уже 2022 год, приложение покажет, что сейчас всё ещё 2021 год. Оно работает только в полночь...
Разработчик Windows удалил сразу же твит, как только заметил ошибку. Если вам интересно подробнее изучить проблемы в этом коде, посмотрите [анализ Скотта Хансельмана](https://www.youtube.com/watch?v=Y195oMMLlqM&t=624s), он всё подробно объясняет. Особенно рекомендую начинающим разработчикам.
### Неразбериха с "left-pad", или как программист сломал Интернет, удалив крошечный фрагмент кода
В марте 2016 года Азер Кочулу, программист из Окленда, штат Калифорния, сломал Интернет по всему миру, удалив 11 строк кода. Кочулу опубликовал свой код на [npm](https://www.npmjs.com/about), популярном инструменте среди JavaScript разработчиков, которым пользуются для поиска и установки программного обеспечения с открытым исходным кодом.
Кочулу написал проект, именовав его незамысловатым словом "Kik". Программист хотел, чтобы этот проект помог программистам создавать шаблоны для своих проектов. По иронии судьбы, еще в 2010 году в Онтарио создали мессенджер с аналогичным названием. 11 марта Кочулу получил электронное письмо от Боба Стрэттона, патентного поверенного компании, которая занималась разработкой этого приложения. Боб Стрэттон попросил Кочулу изменить название проекта по юридическим причинам. Кочулу не согласился. По [этой ссылке](https://medium.com/@mproberts/a-discussion-about-the-breaking-of-the-internet-3d4d2a83aa4d) вы можете почитать их полное обсуждение на английском языке (и узнать, почему две стороны не смогли прийти к соглашению).
После всех обсуждений Кочулу захотел удалить все свои зарегистрированные пакеты на npm. "У меня есть авторское право удалить все свои материалы из npm", - написал Кочулу Бобу Стрэттону по электронной почте. Этим письмом в их дальнейшей коммуникации была поставлена точка.
Через несколько дней программисты JavaScript по всему миру начали получать странное сообщение об ошибке при попытке запустить свой код:
```
Npm ERR! 404 'left-pad' is not in the npm registry.
```
Код, который они пытались запустить, требовал пакета под названием *left-pad*, но в реестре npm его не было. После этого разработчики обратились к GitHub, где поддерживался "left-pad". Вот код, который им удалось откопать:
```
module.exports = leftpad;
function leftpad (str, len, ch) {
str = String(str);
var i = -1;
if (!ch && ch !== 0)
ch = ' ';
len = len - str.length;
while (++i < len) {
str = ch + str;
}
Return str;
}
```
Всего одиннадцать строк кода. Но насколько жизненно важных! Эта функция не представляет из себя каких-либо сложностей, она универсальна и достаточно проста для самостоятельного написания. Однако многие пакеты npm были автоматически настроены под неё. Именно поэтому отсутствие *left-pad* стало настолько критичным.
Некоторые крупнейшие платформы, которые использовали пакеты npm, внезапно были сломаны. Одной из таких была [React](https://ru.reactjs.org/), библиотека JavaScript для создания пользовательских интерфейсов, которая широко используется Facebook. И множество небольших веб-сайтов, таких как [Atlas](https://qz.com/434425/atlas-the-new-home-for-charts-and-data/) – платформы для работы с графиками от компании Quartz. Проблема затронула весь мир – разработчики из Австралии, Германии, Соединенных Штатов и Чешской Республики оставляли свои комментарии с проблемами отсуствия "left-pad" на GitHub. Даже в Онтарио, где всё произошло, разработчики "Kik" жаловались на проблему с "left-pad".
Два часа спустя разработчики npm всё же добавили эти 11 строк кода в реестр. Эта ситуация послужила ценным уроком для разработчиков. Она показала, что интересы масс важнее формальностей в отношении авторских прав.
### Заключение
Надеюсь, эта статья помогла вам понять, что ошибки, какими бы масштабными они не были, это не повод расстраиваться, они лишь ступень к улучшению. Если вы все ещё боитесь ошибок, различные инструменты помогут улучшить ваш код и обезопасить его от взломов. Например, наша компания — PVS-Studio — разрабатывает статический анализатор, который может легко обнаруживать даже неоднозначные ошибки и потенциальные уязвимости в коде. У нас также есть целая подборка открытых проектов, в которых мы находили ошибки с помощью анализатора, среди которых Chromium, ядро Linux, Tizen OS и даже Windows Calculator. В основном там проекты не столь масштабные, как описаны в статье, но всё же известные. Список проектов доступен по [этой ссылке](https://pvs-studio.com/ru/blog/inspections/) :).
В заключении, хотелось бы процитировать фразу из "Симпсонов", где Ленни говорит: "Все ошибаются. Ведь даже на карандашах есть ластики." Повод задуматься.
PS: Ошибки показались недостаточно смешными? Тогда вот вам подборка картинок об ошибках, с которыми люди сталкиваются в повседневной жизни:
1. "Задача успешно провалена"
2. "К сожалению, время остановилось"
3. "Нельзя скопировать файлы потому, что нельзя" – нельзя, вот и всё!
4. "Кажется, мой водитель в беде"
5. Ваш результат: 107%
Повезет в следующий раз!
16 из 15 верных ответов!
6. Без комментариев...
8. "Ваш компьютер убежал". Печалька :(.
Картинки взяты с сайта [boredpanda.com](http://boredpanda.com).
### Дополнительные ссылки
1. [Toyota: 81 514 нарушений в коде](https://pvs-studio.com/ru/blog/posts/0439/)
2. [Баг-убийца. Фигак, фигак и Therac-25](https://pvs-studio.com/ru/blog/posts/0438/)
3. [Истории о новогодних багах](https://pvs-studio.com/ru/blog/posts/0463/)
4. [Первый баг на Марсе](https://pvs-studio.com/ru/blog/posts/0462/)
5. [Космическая ошибка: 370.000.000 $ за Integer overflow](https://pvs-studio.com/ru/blog/posts/cpp/0426/)
6. [Баги из СССР](https://pvs-studio.com/ru/blog/posts/0479/) | https://habr.com/ru/post/698404/ | null | ru | null |
# Как добавить независимый Dagger Сomponent в иерархию SubComponnet-ов Hilt используя подход «component dependencies»?
[Версия на английском](https://medium.com/@a.brazhkin/how-to-include-independent-dagger-component-into-hilt-subcomponent-hierarchy-as-component-2d7f022f68b6)
Существуют 2 способа связи компонентов в Dagger: *Subcomponents* и *Component Dependencies* и каждый из них имеет свои преимущества.
Например, при использовании подхода *Subcomponents* весь код генерируется в :app модуле и это может привести к ошибке компиляции вроде “*cannot access SomeClass*” из-за транзитивной зависимости на этот класс. *Component dependencies* может быть использован для решения такой проблемы. Подробнее об этом можно прочитать в статье [Lock your Dagger in Gradle Modules](https://proandroiddev.com/lock-your-dagger-in-gradle-modules-e4270d61e138).
Hilt базируется на подходе subcomponents и описание этих компонентов скрыто от нас, поэтому мы не можем добавить зависимость на внешний компонент. Давайте посмотрим, как это можно обойти.
Предположим, у нас есть 2 gradle модуля *:app* -> *:feature*и есть независимый dagger component в *:feature* модуле (здесь только чистый Dagger, нет плагина и зависимостей для Hilt) который мы хотим добавить как component dependency в иерархию компонентов Hilt.
```
// :feature module
@Singleton
@Component
interface SomeFeatureComponent {
fun someFeature(): SomeFeature
}
```
Для этого можно создать «proxy» Hilt модуль, который будет хранить в себе внешний компонент и предоставлять зависимости в граф Hilt. Теперь *`someFeature`* из внешнего dagger component’а может быть инжектирована через Hilt везде, где вам потребуется в *:app* модуле.
```
// :app module
@Module
@InstallIn(SingletonComponent::class)
internal class SomeFeatureProxyModule {
// Pass as method args any dependencies from :app you need to build component
@Singleton
@Provides
fun someFeatureComponent(application: Application): SomeFeatureComponent {
return DaggerSomeFeatureComponent.builder().build()
}
// Use someFeature in Hilt
@Provides
fun someFeature(someFeatureComponent: SomeFeatureComponent): SomeFeature {
return someFeatureComponent.someFeature()
}
}
```
Стоит заметить, что это решение работает не только для Hilt, но для и подхода через subcomponents в целом. Когда вы не используете Hilt и вручную описываете граф, вы можете определить зависимости только для корневого компонента, аннотированного *@Component*, но для любого дочернего компонента, аннотированного *@Subcomponent* такой возможности уже нет. Тем не менее, можно добавить *@Module* к *@Subcoponent* и использовать описанный обходной путь.
Исходный код доступен на [GitHub](https://github.com/sirbralex/hilt-hack) | https://habr.com/ru/post/571434/ | null | ru | null |
# Управление LCD и OLED дисплеями на AVR-ассемблере
Сразу предупреждаю, что не собираюсь разводить холивары насчет преимуществ AVR-ассемблера перед С/Arduino, или даже перед BASCOM-AVR и MikroPascal for AVR — каждый инструмент уместен в своей области. У ассемблерного подхода в ряде случаев имеются свои преимущества — в основном это небольшие проекты, а также системы, в которых требуется точный расчет времени. Немаловажное достоинство этого подхода — простота необходимого инструментария. Но один из крупнейших недостатков в сравнении с языками высокого уровня — отсутствие готовых библиотек хотя бы для базовых задач. Для того же Arduino они имеются на все случаи жизни, но, к сожалению, совмещать их с ассемблером оказывается сложно и потому нецелесообразно — проще уж все и сделать с помощью самого Arduino. Поэтому некоторое время назад я задался целью создать более-менее законченную экосистему для проектов на основе AVR-контроллеров с программированием на чистом ассемблере.
Основные результаты по созданию такой экосистемы изложены в книжке под названием «[Программирование микроконтроллеров AVR: от Arduino к ассемблеру](https://bhv.ru/product/programmirovanie-mikrokontrollerov-avr-ot-arduino-k-assembleru)». Там же вы найдете подробное изложение целесообразности и границ применимости изложенного подхода. Руководствуясь приведенными в книге примерами, можно строить вполне законченные проекты с минимальной затратой сил и средств, и получить в результате девайс, ласкающий взор своей компактностью, экономичностью и скоростью работы. В этой статье я привожу один из примеров обращения с современными периферийными устройствами с помощью ассемблера, который работает лучше, быстрее и стабильнее, чем его аналог на Arduino.
Примеры тестовых программ, приведенные в этой статье далее, показывают, как на ассемблере работать со строчными дисплеями (алфавитно-цифровыми, текстовыми, знакосинтезирующими — все это разные называния одного и того же типа) на базе HD44780-совместимых контроллеров, взамен LiqudCrystal — одной наиболее широко применяемых Arduino-библиотек. В этих программах вы, кроме того, встретите примеры использования на ассемблере портов UART и I2C (TWI).
**Пара предварительных замечаний**
Один неглупый человек некоторое время назад [заметил](https://habr.com/ru/post/442112/), что современное программирование напоминает ему ремонт автомобиля через выхлопную трубу, «*которая становится с каждым годом все длиннее и длиннее*». Не будучи специалистом, не могу судить о собственно программировании, хотя со стороны такое сравнение кажется вполне адекватным современным реалиям. Но я немного о другом: как я заметил в своей области, программисты все больше подменяют электронщиков. Апофеоз такого подхода представлен вот [в этой публикации](https://habr.com/ru/post/443188/): типичный ход программистского ума, когда для изготовления садовой скамейки сначала строится технико-экономическое обоснование и приобретается лесообрабатывающий комбинат. Но, бог весть, я-то ни разу не программист: я готов изучать какие-то необходимые для практики инструменты, но меня совершенно не интересуют подробности обращения с оптимизирующими компиляторами и не импонируют гадания над смыслом фразы «*встроенная в MS Visual Studio поддержка комитов в локальном репозитории*». Я убежден, что для дела гораздо полезнее потратить время на изучение нюансов встроенного АЦП или таймеров.
Когда очередная версия монстра, в который превратился когда-то компактный и быстрый инструмент, ныне известный под названием Atmel Studio, отказалась устанавливаться на то железо, которым я располагаю и потребовала более современный комп, я окончательно решил попробовать вернуться к истокам, когда никаких AVR GCC еще не существовало. Обдумав ситуацию, я понял, что в ряде случаев отказ от высокоуровневых инструментов позволит сэкономить деньги и время, позволяя при этом получать при этом более надежные и эргономичные девайсы. Остальные подробности по этому поводу см. в упомянутой книге. И еще раз хочу повторить: это не развязывание холивара, это напоминание о том, что инструмент обязан быть адекватен задаче.
**Замечание по поводу практического применения AVR-ассемблера.** Для того, чтобы создавать на нем программы, достаточен минимальный набор инструментов: собственно ассемблер (программы далее рассчитаны на *avrasm2*), набор файлов макроопределений для имеющихся у вас контроллеров (*inc*-файлов) соответствующей ассемблеру версии, текстовый редактор а-ля Блокнот и AVR-программатор. Ассемблер *avrasm2.exe* и *inc*-файлы извлекаются из любой версии AVR Studio с номером 5 и выше. Все это прелестно заработает хоть на самом древнем 386-м десктопе с экраном 640х480 и Windows 98. Но если вы в упор не можете обойтись без продвинутых средств отладки, то никто, конечно, не мешает вам ваять свои программы в самой AVR Studio или всяческих Протеусах, если вам это по душе — примеры ниже не содержат ничего такого специфического. Для старых контроллеров (в том числе ATmega8, ATmega16 и ATtiny2313, на которые я в основном ориентируюсь, можно употреблять и версию AVR Studio 4.х (с ассемблером *avrasm32*), куда более компактную и дружелюбную к пользователю. Подробнее обо всех этих особенностях также см. упомянутую книгу.
**И еще замечание о терминологии**: в ассемблере никаких, разумеется «функций» не существует и все подпрограммы оформляются одинаково (несколько отличаются от обычных подпрограмм только обработчики прерываний). Я их по привычке все скопом называю процедурами, хотя, строго говоря, это тоже не совсем верно — чаще всего они что-то где-то все-таки возвращают, как функции.
Описанные далее программы рассчитаны на работу в принципе с любыми строчными дисплеями LCD или OLED, имеющими HD44780-совместимый контроллер. Проверялись они на продукции Winstar (OLED, LCD), BLAZE (LCD BCB1602), российской фирмы МЭЛТ (с отечественными же контроллерами внутри) и др. Демо-примеры ориентированы на наиболее часто применяющийся тип 16 символов в 2 строки (1602), но базовые ассемблерные процедуры без изменений или с минимальной коррекцией могут применяться для любой конфигурации без специального указания типа: однострочные дисплеи (с числом символов больше 8) или 4-строчные все равно логически разбиты на две строки.
Демо-программа на Arduino
-------------------------
Начнем с того, что создадим простенькую демо-программу вывода на экран часов с термометром — для иллюстрации того, как это выглядит на Arduino. Для этого примера возьмем OLED-дисплей, как наиболее сложный случай для библиотеки LiqudCrystal — как я неоднократно писал (например, [здесь](https://habr.com/ru/post/400833/)), для OLED ее приходится несколько допиливать. Доработанную версию русифицированной библиотеки LiquidCrystalRus\_OLED с примером применения можно скачать [отсюда](http://revich.lib.ru/AVR/LC_OLED.zip). Несколько видоизмененный текст этого примера (назовем его *OLED\_Liquid\_Crystal\_1602\_test*) мы и возьмем здесь за основу. На рис. ниже приведена схема подключения дисплея к отечественному клону Arduino mini (Iskra mini):
Тогда программа будет такой:
**Текст скетча OLED\_Liquid\_Crystal\_1602\_test**
```
#include
// RS, E, DB4, DB5, DB6, DB7
LiquidCrystalRus OLED1(3, 4, 5, 6, 7, 8);
volatile byte month=0; //месяцы 0-11
//год постояный 2020, число 01
volatile word time=0; //минуты 0-1440 (23:59)
//названия месяцев по-русски, дополненные до 8 символов пробелами:
const char \*m\_name[] = {" января ","февраля "," марта "," апреля "," мая "," июня "," июля ","августа ","сентября","октября "," ноября ","декабря "};
byte degree[8] = { //значок градуса
0b00001100,
0b00010010,
0b00010010,
0b00001100,
0b00000000,
0b00000000,
0b00000000,
0b00000000
};
void setup() {
delay (1000);
OLED1.begin(16,2); //16 символов 2 строки
OLED1.clear();
OLED1.createChar(0, degree);//создаем значок градуса
OLED1.setCursor(9,0); //верхняя строка, 9 позиция
OLED1.print("-22,3"); //-22.3
OLED1.write(byte(0));//градусов
OLED1.print('C'); //Цельсия
OLED1.setCursor(0,0); //верхняя строка, 0 позиция
OLED1.print("00:00"); //время
OLED1.setCursor(0,1); //нижняя строка нулевая позиция
OLED1.print("01 января 2020"); //дата
OLED1.setCursor(2,0); //верхняя строка, 2 позиция ":"
OLED1.blink(); //двоеточие мигает
delay(1000);
}
void loop() {
time++; if (time==1440) time=0; //1440 число минут в сутках
byte hours=time/60; //число условных часов
OLED1.setCursor(0,0); //верхняя строка, 0 позиция
if (hours>=10) OLED1.print(hours);
else
{OLED1.print('0'); OLED1.print(hours);} //с ведущим нулем
OLED1.print(':');
byte minits=time%60; //минуты - остаток от часов
if (minits>=10) OLED1.print(minits);
else
{OLED1.print('0'); OLED1.print(minits);} //с ведущим нулем
OLED1.setCursor(3,1); //нижняя строка 3 позиция
//выводим месяцы:
OLED1.print(m\_name[month]); //выводим месяц на место января
OLED1.setCursor(2,0); //верхняя строка, 2 позиция ":"
OLED1.blink(); //двоеточие мигает
delay(1000);
month++;
if (month==12) month=0;
}//конец loop
```
Этот скетч, вместе с приводимыми дальше ассемблерными примерами, вы сможете найти в архиве, ссылка на который размещена в конце статьи. Программа каждую секунду (что задается с помощью функции `delay()`) меняет название месяца и добавляет единицу к значению минут. При достижении числа 23:59 отсчет времени сбрасывается в нули и начинается заново. Эти операции демонстрируют, как обращаться со строками и делить длинное число времени на минуты и часы. При прямом получении значений часов, минут и секунд из часов реального времени (RTC) делить ничего не потребуется, но организация отсчета времени в программе может быть самой разнообразной, так что это знание будет не лишним.
Результат работы программы показан на фото:
Условное число (01), год (2020) и значение температуры остаются в этой демо-программе неизменными, а примеры подключения к Arduino различных градусников вы найдете и без меня. В верхнюю строку вы можете также запихнуть и значение влажности со значком процентов, особенно если удалить последнюю букву «C» и сдвинуть температуру еще на один знак вправо. Я намеренно не конкретизирую этот вопрос, так как в подключении фирменных датчиков при ассемблерном подходе имеются свои особенности (подробности см. в упомянутой книге).
Здесь мы создаем значок градуса с помощью функции `createChar`. Увы, нормальный значок градуса я встречал только в знакогенераторе [отечественных дисплеев фирмы МЭЛТ](https://habr.com/ru/post/430828/), для остальных требуется его отрисовка. Ранее (в том числе и в библиотеке LiquidCrystalRus\_OLED) я заменял значок градуса на верхний квадратик (символ 0xdf, восьмеричный код \337), но это некрасиво. Отметим, что функция `createChar` библиотеки LiquidCrystal в отношении OLED-дисплеев Winstar работает не очень надежно (иногда значок просто пропадает при первом включении), и причины мне установить не удалось. Соответствующая ассемблерная процедура (см. далее) не сбоила ни разу.
Напомню также, что [в доработанной библиотеке](https://habr.com/ru/post/400833/) LiquidCrystalRus\_OLED введена замена кода нуля (0x30) на код буквы «O» (0x4f). Желающие могут вернуть перечеркнутый ноль обратно, просто удалив или закомментировав строку замены (строка 308 измененного файла *LiquidCrystalRus\_OLED.cpp*).
Отметим еще, что теоретически к одному контроллеру можно подключать сколько угодно подобных дисплеев, если вывод Enable (E) каждого подключать к отдельному порту, остальные линии подключаются просто параллельно. И необязательно это должны быть дисплеи одного типа (может быть один текстовый, другой графический, один LCD, другой OLED и т.д.), лишь бы интерфейсы управления у них совпадали. На практике, так как контроллер при этом еще что-то делает, одновременно лучше подключать не более 2-3 дисплеев, чтобы сильно не тормозить все остальное — процедуры управления дисплеем в Arduino-версии достаточно долгие.
По поводу мигания двоеточия. Здесь мы в конце каждого цикла устанавливаем курсор на соответствующую позицию и включаем аппаратное мигание функцией `blink()`. Это отлично работает как раз на OLED-вариантах, в вот во всех прошедших через мои руки LCD аппаратный «блинк» реализован совершенно безобразно. Поэтому в них приходится мигание реализовывать программно и мы предусмотрим в ассемблерной «библиотеке» возможность отключения-включения функции аппаратного мигания.
Нужно добавить про вывод русских символов на дисплей, с чем в Arduino традиционно творится жуткая путаница. У меня несколько лет назад была надежда, что ситуация как-то выправится, но [судя по обсуждениям](http://forum.amperka.ru/threads/arduino-ide-%D0%B8-utf-8.9491/), вплоть до последних версий IDE этого не произошло. В программе я просто указал русские символы, так как LiquidCrystalRus\_OLED работает с кодировкой UTF-8, и в большинстве случаев это проходит безболезненно. Если же у вас будут выводиться «кракозябры», можно попробовать рецепты, приведенные [в статье на iarduino](https://wiki.iarduino.ru/page/encoding-arduino/), где попытались вывести некоторую закономерность. Загляните также [в официальную статью](https://playground.arduino.cc/Main/Utf8ascii/) (довольно мутную) на *arduino.cc*. В ассемблерных программах мы будем работать с таблицей знакогенератора напрямую, и такой проблемы не возникнет.
Ассемблерная демо-программа
---------------------------
### Подключение к ATmega8
Все примеры далее рассчитаны на ATmega8, но ничто не может вам помешать адаптировать их для любого подходящего AVR. Для этого придется сменить ссылку на *inc*-файл (у нас тут это будет *m8def.inc*), а также, возможно, заменить номера и названия портов, к которым подключается дисплей. Учтите, что при выводе через параллельный интерфейс на ассемблере удобно работать с выводами, идущими подряд и относящимися к одному порту, о чем подробнее далее. Не стоит применять какой-нибудь Tiny, у которого четырех подряд идущих выводов портов не имеется: конечно, это вполне возможно, но приведет к необходимости слишком существенных переделок программ и схем.
Как указано в программе и на схеме выше, дисплей WEH1602 подключается к выводам 3-8 Arduino. Для Arduino это удобно — выводы идут подряд, причем важные для применения в качестве часов-термометра выводы I2C и АЦП остаются свободными. А вот для ассемблера такое подключение не очень хорошо: если посмотрите [соответствие выводов Arduino-AVR](https://www.arduino.cc/en/Hacking/PinMapping168), то увидите, что выводы портов идут вразбивку; последний вывод данных оказывается подключенным к порту PB0, тогда как первые три — к старшим битам порта D. Можно просто сдвинуть эту тетраду на младшие биты порта B, но тогда мы «наедем» на выводы программирования (PB3 = MISO), а без нужды этого делать не следует. Да и просто неудобно в отладке: придется все время отключать-подключать программатор.
В ATmega8 удобно подключиться к четырем младшим битам порта C, которые идут подряд в том числе и в разводке выводов (и не только для DIP-корпуса). При этом мы теряем младшие входы АЦП (ADC0-ADC3), но у нас остаются еще два (ADC4-ADC5), а в планарном 32-выводном корпусе TQFR еще имеются и дополнительные ADC6-ADC7. Выводы PC4-PC5 (ADC4-ADC5), кроме того, заняты аппаратным I2C (SDA, SCL), но на ассемблере удобней пользоваться программным, которому можно назначить любые два вывода любых портов, и программа при этом получается как минимум не сложнее официального способа. Ее применение мы увидим ближе к концу этой статьи на примере чтения часов реального времени (RTC).
Выводы RS и E мы оставим подключенными к портам PD3 и PD4. В результате получим такую схему:
На схеме к контроллеру подключен кварцевый резонатор 4 МГц, все программы подогнаны под эту частоту тактирования. Однако, для управления дисплеями источник частоты неважен — можно работать и от встроенного генератора (для ATmega8 частоту 4 МГц дает установка фьюзов `CKSEL3:0=0011`) и от внешнего кварца (для ATmega8 фьюзы `CKSEL3:0=1111`). Источник тактирования выбирается в зависимости от требований остальной части схемы: так, например, для нормальной работы UART встроенный генератор применять не рекомендуется (у нас далее последовательный порт применяется для начальной установки часов). Для другой частоты тактирования нужно будет пересчитать постоянные для подсчета задержек, о чем подробнее далее.
Я традиционно пользуюсь 10-контактным разъемом программирования (под него заточены крайне удобные программаторы AS-2/3/4), и именно он приведен на схеме. Для подключения к более распространенному и компактному 6-контактному потребуется элементарный переходник или просто установка другого разъема (см. [конфигурации](http://4put.ru/pictures/max/333/1023926.jpg)). Если у вас контроллер в DIP-корпусе, то его удобно программировать отдельно (можно просто на макетке), а потом установить в схему на панельку.
### Программа
Обычный ATmega8 существует в нескольких разновидностях, соответственно в последних версиях Atmel Studio имеются две модификации файла макроопределений: *m8def.inc* просто и *m8adef.inc*. Разницы между ними я не нашел никакой, потому можно применять любой из них для любой модификации контроллера.
Общие части программы управления (инициализацию дисплея, вывод команд и данных) я вынес в отдельный файл, назвав его *LCD1602.prg*. Такое расширение файла — неофициальная придумка, с целью отличия его от законченной программы, можно оставить и официальное *.asm*, если хочется. Таким образом мы получаем некий аналог библиотеки, его добавляют в конечную программу через обычную директиву `.include`. Учтите, что никакой оптимизации тут нет, и `.include` просто тупо копирует исходный текст указанного в ней файла в конечную программу, учитываются только директивы условной компиляции, если они есть.
Для начала нам потребуются процедуры задержек, они необходимы для формирования правильного обмена контроллера с дисплеем — контроллер ведь работает гораздо быстрее дисплея. Кроме самой первой задержки на установление питания перед инициализацией, в принципе без них можно обойтись, если сформировать полностью корректный протокол с проверкой флага занятости (*busy flag* — см. процедуры инициализации и загрузки в даташитах на дисплеи), но этого никто не делает, так как проверка сильно загромождает программу. Проще просто немного задержать подачу следующей команды.
Задержки будем формировать программным путем (подобно функции `delayMicroseconds()` в Arduino), последовательным уменьшением на единицу некоего числа:
```
Delay:
subi Razr0,1
sbci Razr1,0
;sbci Razr2,0 – если потребуется 3-й регистр
brcc Delay
```
Длительность такой процедуры — по одному такту на каждое вычитание (команды `subi` или `sbci`), плюс два такта на переход обратно к началу цикла (`brcc`). В общем случае число N, соответствующее нужному интервалу времени T (с) при тактовой частоте fтакт (Гц) можно получить по формуле N = T∙fтакт/(r+2), где r — число регистров. Соответственно, один задействованный регистр при частоте 4 МГц даст максимальную задержку (N = $FF = 255) примерно 200 мкс, два (N = $FFFF = 65535) — 65,5 мс, три (N = $FFFFFF = 16777215) — около 21 сек. Нам понадобятся задержки 150 мкс, 5 мс и 500 мс, они определены опытным путем, и подходят для любых типов дисплеев.
Можно сделать одну универсальную процедуру `Delay` (сэкономив количество команд в коде), но для удобства программирования сделаем три отдельных процедуры задержек:
```
Del_150mks: ;процедура задержки на 150 мкс
cli ;запрещаем прерывания
push Razr0
ldi Razr0,200 ;
Del_50: dec Razr0
brne Del_50
pop Razr0
sei ;разрешаем прерывания
ret
;N = TF/4 5 ms N= 5000 при 4 МГц
Del_5ms:
cli ;запрещаем прерывания
push Razr0
push Razr1
ldi Razr1,high(5000) ;старший байт N
ldi Razr0,low(5000) ;младший байт N
R5_sub:
subi Razr0,1
sbci Razr1,0
brcc R5_sub
pop Razr1
pop Razr0
sei ;разрешаем прерывания
ret
;N = TF/5 500 ms N= 400000 при 4 МГц
Del_500ms:
cli ;запрещаем прерывания
push Razr0
push Razr1
push Razr2
ldi Razr2,byte3(400000) ;старший байт N
ldi Razr1,high(400000) ;средний байт N
ldi Razr0,low(400000) ;младший байт N
R200_sub:
subi Razr0,1
sbci Razr1,0
sbci Razr2,0
brcc R200_sub
pop Razr2
pop Razr1
pop Razr0
sei ;разрешаем прерывания
ret
```
Итого нам потребуется три регистра. Чтобы их можно было задействовать в основной программе для каких-то других целей, прерывания на время задержек запрещаются (команды `cli/sei`), а регистры помещаются в стек в начале и извлекаются в конце (команды `push/pop`). Конечно, если регистров хватает, то лучше для других целей использовать свободные, как мы и будем поступать далее. Ассемблер *avrasm2* (в отличие от старого *avrasm32*) не любит переименований, и будет на них выдавать предупреждения (*warnings*, см. программу реальных часов далее).
Кроме этих трех регистров, нам в этом «библиотечном» файле еще потребуется всего одна рабочая переменная, которую назовем традиционно `temp`. Итого инициализация регистров в начале программы будет выглядеть так:
```
. . . . .
.def temp = r16 ; рабочий регистр
;регистры r17-r19 помещаются в стек:
.def Razr0 = r17 ;счетчик задержки
.def Razr1= r18 ;счетчик задержки
.def Razr2 = r19 ;счетчик задержки
. . . . .
```
Кроме этого, мы для удобства присвоим имена битам, управляющим выводами RS и E дисплея, а также битам установки адреса знакогенератора и установки номера строки для соответствующих команд::
```
.equ E = 4 ;PD4 (вывод 6 контроллера)
.equ RS = 3 ;PD3 (вывод 5 контроллера)
.equ Addr = 7 ;бит7=1 команда установки адреса в RAM
.equ Str = 6 ;бит6=0 - строка 1, бит6=1 - строка 2
```
Теперь можно приступать к процедурам. Сначала придется оформить две процедуры для вывода команд по 4-битовому интерфейсу:
```
LCD_command: ;выводим тетраду команды из младших бит temp
cbi PortD,RS ;RS=0
out PortC,temp ;выводим младшую PC3..0
sbi PortD,E ;E=1 - строб 1 mks
nop ;1 mks при 4 МГц
nop
nop
nop
cbi PortD,E ;E=0
ret
LCD_command_4bit: ;выводим байт команды из temp в два приема
cbi PortD,RS ;RS=0
swap temp ;
out PortC,temp ;выводим старший PC0..3
sbi PortD,E ;E=1 - строб 1 mks
nop ;1 mks
nop
nop
nop
cbi PortD,E ;E=0
nop ;1 mks
nop
nop
nop
swap temp ;
out PortC,temp ;выводим младший PC0..3
sbi PortD,E ;E=1 - строб 1 mks
nop ;1 mks
nop
nop
nop
cbi PortD,E ;E=0
ret
```
Почему две? Первая выводит в порт данных дисплея только четыре бита (младших), вторая осуществляет вывод полного байта по 4-битовому интерфейсу в один прием. Иными словами, две процедуры `LCD_command` заменяют одну `LCD_command_4bit`. То есть в принципе достаточно одной (второй), но я слизнул эту идею из кода LiquidCrystal — хотя в даташитах на дисплеи процедура указана обычно иначе, но это соответствует [оригинальному описанию HD44780](https://www.sparkfun.com/datasheets/LCD/HD44780.pdf) от фирмы Hitachi, и все работает отлично («работает — не трогай!»). Первая процедура понадобится только в начале инициализации, которая здесь выглядит следующим образом:
```
LCD_ini: ;все почти как в LiqidCrystal
ldi temp,0b00011000 ;PB3,PB4 на выход
out DDRD,temp
cbi PortD,E ;E=0
ldi temp,0b00001111 ;PC0-PC3 на выход
out DDRC,temp
rcall Del_500ms ;ждем 0,5 с - установление питания
ldi temp,0b00000011
rcall LCD_command
rcall Del_5ms
ldi temp,0b00000011
rcall LCD_command
rcall Del_5ms
ldi temp,0b00000011
rcall LCD_command
rcall Del_5ms
#ifdef Rus_table
;для Wistar OLED
ldi temp,0b00101010 ;DL=1-4 bit N=1–2 строки, FT=10-рус/англ таблица
#else
;для остальных рус/англ дисплеев
ldi temp,0b00101000 ;DL=1 - 4 bit N=1 – 2 строки,
#endif
rcall LCD_command_4bit
rcall Del_5ms
ldi temp,0b00001000
rcall LCD_command_4bit ;дисплей Off
rcall Del_5ms
ldi temp,0b00000001
rcall LCD_command_4bit ;дисплей clear
rcall Del_5ms
ldi temp,0b00000110
rcall LCD_command_4bit ;I/D=1 - инкремент S=0 - сдвиг курсора
rcall Del_5ms
#ifdef Blink
;включение с миганием
ldi temp,0b00001101 ;D=1-дисплей On B=1-мигает символ в позиции курсора
#else
;просто включение
ldi temp,0b00001100 ;D=1- дисплей On
#endif
rcall LCD_command_4bit
rcall Del_5ms
ldi temp,0b10000000 ;курсор в позицию 0,0
rcall LCD_command_4bit ;
rcall Del_5ms
ret
```
Задержки подобраны, как уже говорилось, опытным путем и процедура работает безупречно на всех проверенных мной типах дисплеев, причем запуск проходит быстрее и совершено без сбоев, в отличие от LiquidCrystal в Arduino. В отдельных случаях может потребоваться включение-выключение питания после первой загрузки программы.
Здесь применена условная компиляция в двух местах. Во-первых, это опция мигания в позиции курсора, о которой мы говорили ранее. Для включения этой опции нужно в основной программе где-то перед строкой `.include "LCD1602.prg"` вставить строку `#define Blink`. Во-вторых, опция включения русской таблицы в OLED-дисплеях Winstar (она имеет номер 0x02), она включается строкой `#define Rus_table`.
Правкой значений двух младших бит в этой опции можно также включать и другие кодировочные таблицы. У русифицированных LCD-дисплеев по умолчанию (то есть номер 0x00) стоит таблица, аналогичная таблице 0x02 Winstar, но часто встречаются и другие случаи. Например, у дисплеев МЭЛТ вторая таблица (номер 0x01) содержит кириллицу в кодировке 1251 (ANSI), что позволяет вводить русский текст в ассемблерной программе непосредственно с клавиатуры (при условии, что именно такая кодировка установлена у вас в редакторе кода).
Далее нам понадобится процедура вывода данных (она отличается от вывода команды сочетанием уровней на RS и E):
```
LCD_data: ;выводим код сисмвола из temp в 2 приема
#ifdef Zerosymb
cpi temp,$30 ;код цифры ноль
brne Z_ok
ldi temp,'O' ;подменяем ноль на букву О
Z_ok:
#endif
sbi PortD,RS ;RS=1
swap temp ;
out PortC,temp ;выводим старший PC0..3
sbi PortD,E ;E=1 - строб 1 mks
nop ;1 mks
nop
nop
nop
cbi PortD,E ;E=0
nop ;1 mks
nop
nop
nop
swap temp ;
out PortC,temp ;выводим младший PC0..3
sbi PortD,E ;E=1 - строб 1 mks
nop ;1 mks
nop
nop
nop
cbi PortD,E ;E=0
rcall Del_150mks
ret
```
Все процедуры вывода данных в дисплей, как видите, обременены некоторым количеством команд `nop` — таким образом реализована пауза в 1 мкс для надежной установки уровней на выводах контроллера дисплея (частота 4 МГц все-таки для него высоковата). Здесь также применена условная компиляция — для замены ненавидимого мной перечеркнутого нуля на букву «О» (все иллюстрации в этой статье сделаны с такой заменой). Чтобы включить эту опцию, в основной программе должно стоять `#define Zerosymb`.
Осталось две необходимых процедуры. Одна из них — установка курсора на нужное место *строка: позиция* (в обратном порядке, чем в LiquidCrystal, что кажется мне более естественным). Эту процедуру оформляем в виде макроса для удобства указания параметров:
```
.macro Set_cursor
push temp ;чтобы не думать о сохранности temp
ldi temp,(1<
```
Сохранение рабочей переменной temp в стеке здесь применено для того, чтобы можно было помещать вызов этого макроса в любое место основной программы, в которой рабочая переменная также будет широко использоваться.
И последняя процедура рисует значок градуса и помещает его на место символа номер 1. Здесь, в отличие от LiquidCrystal, она оформлена в единую подпрограмму вместе с данными:
```
Symbol_degree: ;рисуем символ градуса
ldi temp,0b01001000 ;CGRAM адрес 0х01
rcall LCD_command_4bit ;
rcall Del_5ms
ldi temp,0b00001100
rcall LCD_data
ldi temp,0b00010010
rcall LCD_data
ldi temp,0b00010010
rcall LCD_data
ldi temp,0b00001100
rcall LCD_data
ldi temp,0b00000000
rcall LCD_data
ldi temp,0b00000000
rcall LCD_data
ldi temp,0b00000000
rcall LCD_data
ldi temp,0b00000000
rcall LCD_data
ldi temp,0b10000000 ;курсор в позицию 0,0
rcall LCD_command_4bit ;
rcall Del_5ms
ret
```
### Демо-программа на ассемблере
Демо-программа будет работать аналогично показанной ранее на примере Arduino. Нам надо решить несколько проблем, которые в Arduino решаются как бы автоматически. Во-первых, это размещение строк-констант с названиями месяцев: их можно размещать в программной памяти, в SRAM (как в Arduino) или в EEPROM. Последний способ плох тем, что он не очень надежен (EEPROM может испортиться при невнимательном отношении к включению-выключению питания), зато строки можно загрузить заранее и отдельно от программы. Мы здесь для демонстрации применим два других способа: в демо-программе разместим массив строк в программной памяти, а в реальной программе часов (см. далее) загрузим их в SRAM в начале программы.
Вторая проблема заключается в том, что мы можем выводить информацию на дисплей только посимвольно, команд для выгрузки целой строки или числа (подобно тому, как это сделано в функции `print()`), разумеется, не существует. Поэтому нам придется любое число, содержащее больше одного десятичного разряда, преобразовывать в десятичное (BCD) и выводить разряды по отдельности. Повторяю, что в RTC все величины (часы-минуты-секунды-дни-месяцы-годы) хранятся по отдельности и уже в BCD-форме, потому там у нас встанет обратная задача по формированию номера месяца из BCD-кода. Но проблема эта в реальных программах все равно встает при выводе данных с различных датчиков. Поэтому мы в демо-программе сразу покажем, как решается и эта задача, облегчив себе ее тем, что будем считать отдельно часы и минуты — чтобы не возиться с преобразованиями больших чисел.
Создадим новый файл *OLED1602\_proba.asm*, в той же папке, где размещена «библиотека» *LCD1602.prg*. Объявим регистры-переменные и включим опции (для OLED-дисплея я их включаю все). Начало программы будет таким:
```
.include "m8def.inc"
#define Blink ;включено мигание в позиции курсора
#define Rus_table ;включена поддержка русской таблицы (для OLED)
#define Zerosymb ;вкл подмена 0 на букву О
;.def temp = r16 ; рабочий регистр - определен в LCD1602.prg
;.def Razr0 = r17 ;счетчик задержки - определен в LCD1602.prg
;.def Razr1= r18 ;счетчик задержки - определен в LCD1602.prg
;.def Razr2 = r19 ;счетчик задержки - определен в LCD1602.prg
.def temp1 = r20 ;вспомогательный регистр
.def month = r21 ;номер месяца
.def hour = r22 ;число часов
.def min = r23 ;число минут
rjmp RESET ;Reset Handler
```
Закомментированные определения — для памяти, чтобы все время не вспоминать, какие регистры уже заняты в «библиотечном» файле *.prg* и подо что.
Здесь из всех векторов прерывания задействован только самый первый `Reset`, по нулевому адресу в памяти. Сразу после него можно уже размещать массив названий месяцев:
```
m_name:
.db $20,$C7,$BD,$B3,'a','p',$C7,$20, \
$E4,'e',$B3,'p','a',$BB,$C7,$20, \
$20,$BC,'a','p',$BF,'a',$20,$20, \
$20,'a',$BE,'p','e',$BB,$C7,$20, \
$20,$20,$BC,'a',$C7,$20,$20,$20, \
$20,$20,$B8,$C6,$BD,$C7,$20,$20, \
$20,$20,$B8,$C6,$BB,$C7,$20,$20, \
'a',$B3,$B4,'y','c',$BF,'a',$20, \
'c','e',$BD,$BF,$C7,$B2,'p',$C7, \
'o',$BA,$BF,$C7,$B2,'p',$C7,$20, \
$20,$BD,'o',$C7,$B2,'p',$C7,$20, \
$E3,'e',$BA,'a',$B2,'p',$C7,$20
```
Обратный слеш, если кто не знает, позволяет в AVR-ассемблере разбивать длинные строки. Как и в случае Arduino, название каждого месяца дополнено пробелами до 8 символов. Русские буквы обозначаются HEX-кодами, в соответствии с таблицей знакогенератора. Для удобства я ее привожу здесь в максимально обезличенном виде (на пустых местах в разных дисплеях размещаются разные символы; например, для МЭЛТ в позиции $99 имеется нормальный значок градуса):
Размещение массива в самом начале программы имеет смысл, заключающийся в том, чтобы он занял место в пределах одного байтового сегмента. Извлекать данные мы будем через двухбайтовый указатель `ZH:ZL`, и чтобы не возиться с добавлением смещения конкретного месяца к двухбайтовому числу, мы будем добавлять только его только к младшему регистру `ZL`.
Далее нам надо не забыть добавить нашу библиотеку:
`.include "LCD1602.prg"`
Мы могли бы добавить массив и после нее — код библиотеки занимает 300 байт (с учетом первой команды rjmp — 302 байта), а объем массива 96 байт, так что он оказался бы все равно в пределах одного байтового сегмента (второго, а не самого первого). Но это нужно все считать, и несложно промахнуться при изменениях программы, так что надежнее либо размещать в самом начале, либо уж делать по правилам: добавлять смещение к двухбайтовому указателю.
Далее нам понадобится одна-единственная вспомогательная процедура bin2bcd8 — преобразование 8-битового HEX-числа в BCD-код:
```
;преобразование 8-разрядного hex в неупакованный BCD
;вход hex = temp, выход BCD temp1 — старший, temp — младший
bin2bcd8: ;вход hex= temp, выход BCD temp1-старш; temp - младш
clr temp1 ;clear result MSD
bBCD8_1:
subi temp,10 ;input = input - 10
brcs bBCD8_2 ;abort if carry set
inc temp1 ;inc MSD
rjmp bBCD8_1 ;loop again
bBCD8_2:
subi temp,-10 ;compensate extra subtraction
ret
```
Англоязычные комменты перекочевали сюда из старой атмеловской аппноты 204, откуда заимствована эта процедура.
Теперь можно писать собственно программу. Она, согласно традиции, начинается с необходимых установок по метке `Reset` (аналог функции `setup()`):
```
RESET:
ldi temp,low(RAMEND)
out SPL,temp
ldi temp,high(RAMEND) ;указатель стека
out SPH,temp
clr hour ;
clr min ;обнулили минуты и часы
rcall LCD_ini ;инициализация дисплея
rcall Symbol_degree ;рисуем символ градуса
. . . . .
```
Далее идет начальное заполнение дисплея символами, которые больше не будут меняться:
```
;=== начальный вывод
Set_cursor 0,0 ;курсор строка 0 позиция 0
ldi temp,'0' ;0
rcall LCD_data
ldi temp,'0' ;0
rcall LCD_data
ldi temp,':' ;:
rcall LCD_data
ldi temp,'0' ;0
rcall LCD_data
ldi temp,'0' ;0
rcall LCD_data
Set_cursor 0,9 ;курсор строка 0 позиция 9
ldi temp,'-' ;минус
rcall LCD_data
ldi temp,'1' ;1
rcall LCD_data
ldi temp,'2' ;2
rcall LCD_data
ldi temp,',' ;запятая
rcall LCD_data
ldi temp,'3' ;3
rcall LCD_data
ldi temp,$01 ;рисованный значок градуса
rcall LCD_data
ldi temp,'C' ;C
rcall LCD_data
. . . . .
< и так далее – вторая строка>
. . . . .
;в конце обязательно ставим курсор в позицию двоеточия:
Set_cursor 0,2 ;курсор строка 0 позиция 2 - мигает аппаратно
. . . . .
```
Далее программа в цикле посекундно меняет названия месяцев, а также после каждого такого 12-секундного цикла увеличивает значение минут и часов (в отличие от Arduino-программы, которая обновляла часы вместе с месяцами каждую секунду). Обратите внимание, что здесь месяцы нумеруются с нуля, то есть в реальности при получении их с часов нужно вычитать единицу:
```
Gcykle:
;=== перебираем месяцы по названию
ldi month,0 ;нулевой месяц - январь
mon_num: ;перебираем месяцы от 0 до 11
Set_cursor 1,3 ;курсор строка 1 позиция 3 (0-15)
mov temp,month
lsl temp
lsl temp
lsl temp ;умножили на 8
ldi ZH,high ((m_name)*2) ;адрес начала массива названий
ldi ZL,low ((m_name)*2)
add ZL,temp ;прибавляем адрес названия
ldi temp1,8 ;повторяем для 8 символов месяца
mon_view: ;загружаем строку 8 символов
lpm ;очередной байт массива в r0
mov temp,r0
rcall LCD_data
adiw ZL,1
dec temp1
brne mon_view
Set_cursor 0,2 ;курсор строка 0 позиция 2 - мигает аппаратно
rcall Del_500ms
rcall Del_500ms ;пауза 1 с
inc month
cpi month,12
brlo mon_num
;=== добавляем минуты и часы
inc min ;увеличиваем минуты
cpi min,60
brlo out_time ;если меньше 60, то на вывод времени
clr min ;иначе обнуляем минуты
inc hour ;увеличиваем часы
cpi hour,24
brlo out_time ;если меньше 24, то на вывод времени
clr hour ;иначе обнуляем минуты
;==== выводим минуты и часы
out_time:
mov temp,hour
rcall bin2bcd8 ;преобразуем в BCD, temp1 — старший, temp — младший
subi temp,-$30 ;код младшей цифры часов = значение +$30
Set_cursor 0,1 ;курсор строка 0 позиция 1
rcall LCD_data ;выводим младший
mov temp,temp1
subi temp,-$30 ;код старшей цифры часов = значение +$30
Set_cursor 0,0 ;курсор строка 0 позиция 0
rcall LCD_data ;выводим старший
mov temp,min
rcall bin2bcd8 ;преобразуем в BCD, temp1 — старший, temp — младший
subi temp,-$30 ;код младшей цифры минут = значение +$30
Set_cursor 0,4 ;курсор строка 0 позиция 4
rcall LCD_data ;выводим младший
mov temp,temp1
subi temp,-$30 ;код старшей цифры часов = значение +$30
Set_cursor 0,3 ;курсор строка 0 позиция 3
rcall LCD_data ;выводим старший
rjmp Gcykle ;к самому началу
```
Развернуто комментировать тут особо нечего, все основное сказано ранее. Программа *OLED1602\_proba* займет в памяти 702 байта (Arduino-аналог занимает почти 4 кбайта, притом, что данные у него размещаются в ОЗУ, а не вместе с программой). Полностью архив со всем приведенным здесь программами можно скачать по ссылке в конце статьи.
### Рабочая программа часов
Тут необходима даже не одна, а две программы. Для начала нам понадобится начальная установка часов, и я ее выделил в отдельную программу, так как коррекция требуется нечасто — популярный модуль на основе DS3231 вполне прилично держит время как минимум в течение полугода-года. Так что перегружать основную программу редко используемой функциональностью я не стал — здесь она приводится все-таки в иллюстративных целях. А при желании объединить установку с основной программой можно и самостоятельно.
Полная схема подключения часов:
В схеме можно применять как готовые модули RTC (выводы обозначены красным цветом), так и самостоятельно изготовленные. Программа далее рассчитана на два типа RTC — стандартный DS1307, и более точный DS3231. Схема типового модуля на основе стандартной DS1307 обведена красным прямоугольником, DS3231 мало от нее отличается, только выводов у самой микросхемы больше. Вне зависимости от типа RTC, готовый модуль обязательно должен иметь вывод частоты SQW.
Основная программа (подробнее о ней далее) представляет собой просто часы, датчик температуры мы подключать не будем, чтобы не загромождать пример — для него потребуется еще много дополнительной функциональности, а статья не резиновая. И так придется растекаться в стороны, так как и для установочной и для основной программы потребуются манипуляции с I2C-интерфейсом. Соответствующие ассемблерные процедуры софтового I2C-порта у меня также выделены в отдельную «библиотеку» *i2c.prg*. Разбирать я ее подробно не буду — все подробности см. в книге. Работает «библиотека» с любыми двумя цифровыми выводами контроллера, по умолчанию настроена на выводы PD6 (SCL) и PD7 (SDA), (выводы 12 и 13 ATmega8 в DIP-корпусе). Для изменения выводов, в том числе и под другие контроллеры, следует править файл *i2c.prg*, в нем самом все подробно расписано в комментариях.
### Программа начальной установки часов
Установочная программа *rtc\_set.asm* рассчитана на работу с монитором последовательного порта Arduino, как самого доступного и простого в использовании, но при этом самого замороченного с точки зрения форматов данных — он ведь рассчитан на Arduino-библиотеку `print()`, которая как бэ автоматически с этими форматами разбирается. При работе через другой монитор порта учтите, что посылать команды следует в текстовом (ASCII) виде, как указано далее. Как мы говорили, программа рассчитана на два типа RTC — DS1307 и DS3231. У них несколько различаются регистры управления и состояния по умолчанию, потому в программе применена условная компиляция: для стандартной DS1307 перед компиляцией необходимо закомментировать строку `#define ds3231`.
После загрузки программы к порту UART контроллера (PD0 и PD1, выводы 2 и 3 DIP-корпуса) подключается любой USB-UART адаптер (напомню, что выводы RxD и TxD разных устройств соединяются перекрестно). При подключении адаптера не забудьте, что у контроллера может быть только одно питание: либо от адаптера, либо от внешнего источника (в последнем случае вывод VCC адаптера не должен подключаться к схеме!). Скорость работы порта установлена 9600, такую же скорость надо установить и в мониторе порта. UART-адаптер (кроме питания!) можно подключать без отключения дисплея и датчика — в установочной программе задействованы только выводы UART и установленные нами выводы I2C, остальные не затрагиваются.
Обратите внимание на соединение вывода часов SQW с портом PD2. На этом выводе после инициализации выдается секундный меандр, который будет вызывать прерывание INT0, и через него управлять работой контроллера. В данном случае это просто чтение значений из часов и посылка их через UART, но в основной программе это управление немного усложнится.
Пошлите через монитор порта заглавную букву «R» (read). По этой команде часы инициализируются и значения времени будут выдаваться в порт каждую секунду в том порядке, в каком они размещены в регистрах часов: *Секунды, Минуты, Часы, День недели, Дата, Месяц, Год*. Остановить вывод можно, подав в качестве команды английское «T» (terminate). При первом включении, скорее всего, будет выдаваться полная несуразица. Однако, для корректной инициализации необходимо команду «R» послать перед остальными действиями.
Установка часов выполняется посылкой команды «S» (set), в одной строке с которой посылаются значения времени и даты в том же порядке (в текстовом виде, обязательно в двухразрядном исполнении, то есть с ведущим нулем, если это необходимо). Секунды не посылаются, они автоматически установятся в ноль. Например, такая строка установки: `S 23 17 03 27 01 21` установит часы на 25.01.21, среда (03 день недели), время 17:23. Для установки удобно использовать часы Windows, предварительно уточнив их показания через интернет. Строку следует сформировать заранее на минуту-другую раньше указанного в ней времени, и отправить ее нажатием клавиши Enter в момент, когда секундная стрелка на часах Windows дойдет до начала указанной минуты. Вместе с установкой всего времени секунды сбросятся в нулевое значение и часы пойдут с начала установленной минуты.
### Программа часов
Здесь нам понадобится больше переменных, и мы применим частичное пересечение регистров с уже задействованными (тем более, что еще некоторые применяются в процедурах I2C):
```
;.def temp = r16 ; рабочий регистр - определен в LCD1602.prg и в i2c.prg
;.def Razr0 = r17 ;счетчик задержки - определен в LCD1602.prg
;.def Razr1= r18 ;счетчик задержки - определен в LCD1602.prg
;.def Razr1= r19 ;счетчик задержки - определен в LCD1602.prg
; регистр r17 занят также в i2c.prg
.def sek = r18 ;счетчик сeкунд
.def bcdD = r19 ;дес. часов
.def bcdE = r20 ;ед. часов
.def month = r21 ;месяц
.def temp1 = r22 ;вспомогательный
```
На это дело ассемблер выдаст ряд *warnings*, но не обращайте на них внимания — в программе рассчитано все так, чтобы одни и те же регистры не мешали друг другу в различных применениях.
Программа часов отличается от демо-программы выше размещением массива названий месяцев не в программной памяти, а в SRAM. Поскольку здесь это единственный объект, размещаемый в этой памяти, то пользоваться директивой `.byte`, резервирующей место в памяти, нет никакой нужды — мы просто разместим массив подряд, начиная с начала SRAM (ориентируясь на константу `SRAM_start`). К сожалению, никаких средств, столь же удобных, как директивы типа `.db` для размещения констант в программной памяти и EEPROM, для SRAM не предлагается. Поэтому мы составим длиннющую процедуру, которая в начале программы будет посимвольно загружать русские названия месяцев. Они такие же, как в массиве `m_name` демо-программы, только выровнены пробелами до 10 знаков, а не до 8:
```
Store_month: ;пишем в SRAM названия месяцев, не более 8 символов
;выровненные пробелами справа и слева до 10 символов
ldi ZH,High(SRAM_START) ;старший байт начала RAM = 0
ldi ZL,Low(SRAM_START) ;младший байт начала RAM
;января
ldi temp,' ';пробел
st Z+,temp
ldi temp,' ';пробел
st Z+,temp
ldi temp,$C7 ;буква я
st Z+,temp
ldi temp,$BD ;буква н
st Z+,temp
ldi temp,$B3 ;буква в
st Z+,temp
ldi temp,'a'
st Z+,temp
ldi temp,'p'
st Z+,temp
ldi temp,$C7 ;буква я
st Z+,temp
ldi temp,' ';пробел
st Z+,temp
ldi temp,' ';пробел
st Z+,temp
. . . . . ;остальные месяцы
;декабря
ldi temp,' ';пробел
st Z+,temp
ldi temp,$E3 ;буква д
st Z+,temp
ldi temp,'e'
st Z+,temp
ldi temp,$BA ;буква к
st Z+,temp
ldi temp,'a'
st Z+,temp
ldi temp,$B2 ;буква б
st Z+,temp
ldi temp,'p'
st Z+,temp
ldi temp,$C7 ;буква я
st Z+,temp
ldi temp,' ';пробел
st Z+,temp
ldi temp,' ';пробел
st Z+,temp
ret
```
Массив займет в памяти 120 байт, память у ATmega8 начинается с адреса 96 (`SRAM_start`), то есть весь массив уложится в один байтовый сегмент, и мы, как и ранее, спокойно можем манипулировать одним младшим регистром указателя ZL. Только в прошлый раз для определения смещения мы умножали на 8 троекратным сдвигом, а здесь применим операцию аппаратного умножения `mul` (иным словами, этот алгоритм годится только для Mega). Вот так мы будем извлекать название месяца из памяти по его номеру, и выводить символы на дисплей:
```
. . . . .
;извлекаем месяц из памяти
ldi ZH,High(SRAM_START) ;старший байт начала RAM
ldi ZL,Low(SRAM_START) ;младший байт начала RAM
dec month ;адрес на 1 меньше, чем номер месяца
ldi temp,10
mul month,temp ;умножили на 10
add ZL,r0 ;прибавили к адресу результат - он уместится в один байт
ldi temp1,10 ;10 символов выводим
out_month: ;выводим символы месяца
ld temp,Z+
rcall LCD_data
dec temp1
brne out_month
. . . . .
```
Курсор при этом уже установлен на нужную позицию ранее выведенными символами даты — потому здесь названия и выравниваются до 10 знаков, чтобы не было нужды переставлять курсор каждый раз.
Вернемся к извлечению данных из часов — например, как мы получаем номер месяца для приведенного фрагмента программы? В часах реального времени все хранится в BCD-форме, то есть минуты-часы, а также дату и год нам надо просто поделить поразрядно и преобразовать в символы. Начало процедуры извлечения и преобразования тогда выглядит так:
```
ReadClk_m: ;чтение часов и вывод
ldi YL, 0b11010000 ;адрес device DS1307
ldi YH,1 ;адрес регистра минут
sbis PinD,pSDA
ret ;выход, если линия занята
rcall start
mov DATA,YL ;адрес device DS1307, r/w=0
rcall write
mov DATA,YH ;адрес регистра минут
rcall write
rcall start
sbr YL,1 ;r/w=1
mov DATA,YL ;адрес device DS1307, r/w=1
rcall write
set ;put ACK
rcall read ;min
;BCD минуты - в temp, выход - bcdD:bcdE
mov bcdE,temp
andi bcdE,0b00001111 ;выделяем младший
mov bcdD,temp
andi bcdD,0b11110000 ;выделяем старший
swap bcdD ;меняем тетрады местами
;минуты прочитали - выводим, верхняя строка - время
Set_cursor 0,9 ;курсор строка 0 позиция 9 минуты
subi bcdD,-$30 ;код старшей цифры минут = цифра +$30
mov temp,bcdD
rcall LCD_data
subi bcdE,-$30 ;код младшей цифры минут = цифра +$30
mov temp,bcdE
rcall LCD_data
. . . . .
; <далее аналогично минуты, часы, день недели, дату, месяц, год>
ret
```
С месяцем сложнее, его номер придется вычислять преобразованием BCD-числа в HEX, то есть совершать обратное преобразование к тому, что мы делали в предыдущем случае:
```
bcd2bin8: ;bcd -> в обычное число
;только для Mega!!!
;на входе в temp упакованное BCD-значение
;на выходе в month hex-значение
ldi temp1,10
mov month,temp
andi temp,0b11110000 ;выделяем старший
swap temp ;старший в младшей тетраде
mul temp,temp1 ;умножаем на 10, в r0 результат умножения
mov temp,month ;возвращаемся к исходному
andi temp,0b00001111 ;выделяем младший
add temp,r0 ;получили hex
mov month,temp ;возвращаем в month
ret
```
В результате вывод строки месяца получается такой:
```
. . . . .
;BCD месяц
rcall read ;month
rcall bcd2bin8 ;месяц - число в регистре month
;извлекаем месяц из памяти
ldi ZH,High(SRAM_START) ;старший байт начала RAM
ldi ZL,Low(SRAM_START) ;младший байт начала RAM
dec month ;адрес на 1 меньше, чем номер месяца
ldi temp,10
mul month,temp ;умножили на 10
add ZL,r0 ;прибавили к адресу результат - он уместится в один байт
ldi temp1,10 ;10 символов выводим
out_month: ;выводим символы месяца
ld temp,Z+
rcall LCD_data
dec temp1
brne out_month
. . . . .
```
Сама программа работает следующим образом: по прерыванию INT0, возникающему от вывода SQW часов каждую секунду, выполняется чтение только секунд. Прочитанное число сравнивается с нулем, и при совпадении вызывается описанная процедура полного чтения и вывода. Несмотря на ее кажущуюся навороченность, выполняется она всего за время порядка миллисекунды. Результат работы программы – на фото:
Полный текст программы *OLED16x02\_clock.asm* и всех остальных, представленных статье — в [архиве](http://revich.lib.ru/AVR/winstar-asm.zip).
В следующей статье я покажу то, что в книге освещено недостаточно подробно: беспроводную передачу данных и заодно работу с одним из самых приличных и одновременно недорогих датчиков температуры. | https://habr.com/ru/post/541648/ | null | ru | null |
# Пятёрочка — Интегрируй меня полностью
Всем привет! Меня зовут Виталий, я ведущий frontend-разработчик в KTS.
В этой статье я делюсь опытом проектирования архитектуры frontend-приложения, которое взаимодействует с большим количеством внешних систем. Фронтенд состоит из главного проекта и отдельных модулей — микрофронтендов. Главный проект делаем мы в KTS, а микрофронтенды разрабатывают сторонние команды.
В статье мы рассмотрим следующие аспекты:
* [Архитектура монорепозитория](#architecture_lk2)
* [Что находится в UI-библиотеке](#uikit)
* [Структура ядра проекта](#core)
* [Микрофронтенды](#microfrontends). Мы попробовали три подхода ко встраиванию модулей. В статье проанализируем преимущества и недостатки каждого. Поделюсь, почему мы переходили от одного способа к другому.
+ [iframe](#iframe)
+ [NPM-пакеты](#npm)
+ [Webpack Module Federation](#wmf)
* [Как мы встраивали свой сервис в мобильное приложение](#mobile)
Пятёрочка, что ты?
------------------
Два года назад в KTS пришел X5 Retail Group с проектом нового личного кабинета сотрудника Пятёрочки — ЛК2. Через личный кабинет сотрудник может посмотреть зарплату и рабочее расписание, запланировать и согласовать отпуск, запросить справки с места работы, подписать документы электронной подписью и т.д. Руководитель нанимает, увольняет или переводит сотрудника, управляет командой... В общем, это продукт с огромным количеством бизнес-процессов, ролей и доступов.
Много процессов уже автоматизировалось в независимых сервисах, некоторые процессы выполнялись вручную. Поэтому чтобы продукт оправдывал ожидания, работа должна идти быстро. Конечная цель — получить продукт, который объединяет взаимодействие всех систем в одном приложении.
Часто процессы независимы — они не влияют друг на друга, и их можно развивать параллельно. Например, раздел расписания сотрудника можно разрабатывать одновременно с разделом выплат. Это значит, что проект можно разделить между несколькими командами и за счет этого увеличить скорость перехода на новый портал.
Спустя полгода разработки MVP сформировалось ядро проекта и появилась возможность распараллелить работы. Здесь начинается интересное: особенность параллельной разработки ЛК2 заключается в том, что продукт разрабатывается не единой командой и даже не одной компанией, а многими независимыми командами и компаниями. В таком режиме невозможно взаимодействовать в одном репозитории, поскольку это сразу же привело бы к хаосу. Поэтому нужно было придумать удобный механизм независимой разработки многих проектов и их интеграции в базовый проект.
Архитектура ЛК2
---------------
Базовый проект ЛК2 разрабатываем мы в KTS. В ЛК2 содержится корневая логика и большая часть бизнес-процессов. И мы же занимаемся подключением модулей других команд.
Зафиксируем требования и принципы, исходя из которых мы проектировали архитектуру:
* Проект должен быть в одном визуальном стиле;
* Для удобства пользователя проект должен быть SPA;
* Авторизация, навигация и др. — это базовая логика ядра проекта. Взаимодействие с ядром должно быть предсказуемым, единообразным и легким для всех команд;
* Сторонняя команда должна затратить минимум усилий, чтобы разработать модуль и встроить его в ЛК2.
Проект представляет из себя [монорепозиторий](https://ru.wikipedia.org/wiki/%D0%9C%D0%BE%D0%BD%D0%BE%D1%80%D0%B5%D0%BF%D0%BE%D0%B7%D0%B8%D1%82%D0%BE%D1%80%D0%B8%D0%B9), который содержит три пакета:
* `lk2` — главный пакет, который реализует всю бизнес-логику. `lk2` использует остальные пакеты монорепозитория, а также именно в него подключаются сторонние модули.
Следующие два пакета монорепозитория используют все команды, поэтому мы публикуем их в приватном NPM-registry.
* `@five/uikit` — библиотека UI-компонентов;
* `@five/core` — ядро содержит основные сторы, React-контексты и часть пользовательского интерфейса.
Подробнее о том, как засетапить монорепозиторий, можете почитать в [нашей статье](https://habr.com/ru/company/kts/blog/553806/).
На рисунке ниже изображена получившаяся схема.
Текущая схема компонентов фронтендаПреимущества монорепозитория следуют из того, что проект состоит из единой кодовой базы:
* `@five/uikit` и `@five/core` часто дорабатываются. Эти пакеты входят в монорепозиторий, поэтому после каждого их изменения не нужно публиковать новую версию. Во время сборки `lk2` будет использован код библиотек не из registry, а из репозитория, поэтому он всегда актуален. Новую версию публикуем только чтобы предоставить изменение сторонним командам.
* Удобно разрабатывать проект по веткам: и в `@five/uikit` и в `@five/core` могут быть специфичные для ветки изменения.
* Ориентироваться в одном проекте гораздо проще, чем в трёх отдельных проектах.
UI-библиотека @five/uikit
-------------------------
`@five/uikit` — это библиотека UI-компонентов. В неё мы выносим все основные компоненты: кнопки, панели, календари и т.д. Компоненты из библиотеки используются во всех микрофронтендах и не завязаны на бизнес-логике.
Пример компонента из @five/uikitNPM-пакеты собираем с помощью Rollup. Этот сборщик, в отличие от Webpack, собирает ES-модули и лучше подходит для библиотек. На момент написания статьи в пятом Вебпаке уже появилась сборка ES-модулей в экспериментальном режиме. Когда эта функция станет стабильной, мы откажемся от Rollup в пользу Webpack, чтобы сборки на проекте выполнялись одним инструментом.
Для документирования используем [Storybook](https://storybook.js.org/).
Подробнее о том, как собрать свою UI-библиотеку, расскажу в одной из следующих статей.
Ядро проекта @five/core
-----------------------
`@five/core` — это ядро проекта. Его использует `lk2` и каждый микрофронтенд.
### Сторы
В первую очередь `core` нужен для того, чтобы у всех встраиваемых модулей был общий контекст, который содержит данные о сессии и о пользователе. Поэтому `core` включает в себя базовые Redux-сторы.
* `userStore` содержит данные пользователя. Этот стор испускает глобальные Redux-экшены. Например, экшен `USER_NOT_AUTHORIZED` срабатывает, когда пользователь разлогинился или запрос к api завершился со статусом 401. Называем эти экшены глобальными, т.к. они предназначены всему приложению, и их должен обработать каждый стор. Например, перетереть или перезагрузить данные.
* Все запросы к API проходят через `apiStore`. В нём обрабатываются глобальные ошибки:
+ в случае ответа со статусом 401 показываем экран авторизации;
+ в случае некоторых внутренних ошибок сервера показываем сообщение.Именно благодаря тому, что все запросы проходят через `apiStore`, мы можем обработать ошибки на любой запрос и инициировать глобальные экшены, например, `USER_NOT_AUTHORIZED`. В `apiStore` нет своего Redux-стейта, он содержит только [thunk](https://github.com/reduxjs/redux-thunk)-экшены и вспомогательные утилиты.
* `navigationStore`. Как писал выше, личным кабинетом пользуются сотрудники с разными ролями. Роль влияет на доступность раздела. У сотрудника магазина есть раздел с графиком работы, а у офисного сотрудника этого раздела нет, потому что офисный сотрудник работает с понедельника по пятницу. Информацию о доступных разделах заполняет наш менеджер в панели администратора.
В `navigationStore` хранится конфиг пользователя, который вычисляется на основе его данных. Например, можем показать баннер только в определенном регионе или показать кнопку для сотрудников определенной должности.
Итого: `navigationStore` хранит информацию о доступах пользователя в зависимости от параметров, с которыми открыт ЛК2:
+ сессия пользователя;
+ платформа, с которой открыт ЛК2 (десктопный браузер, мобильный браузер или WebView мобильного приложения).
### Корневой React-компонент X5LkApp
`@five/core` экспортирует React-компонент `X5LkApp`. И `lk2`, и микрофронтенды должны иметь доступ к данным из ядра. Для этого их нужно обернуть в `X5LkApp`. `X5LkApp` содержит глобальный контекст приложения и часть пользовательского интерфейса.
#### Глобальный контекст
Для взаимодействия микрофронтендов и главного приложения нужен общий контекст. Этот контекст задаётся несколькими React-провайдерами. Провайдеры содержатся в `@five/core`, поэтому данные контекста одинаково доступны и в `lk2` и во встраиваемых модулях. Рассмотрим некоторые контексты:
* Глобальный Redux-стор. Есть два способа, которыми модуль может взаимодействовать с глобальным стором:
1. Через контекст `X5UserContext`. В таком случае доступен только ограниченный набор данных и экшенов.
2. Через inject в глобальный стор. Тогда можно обращаться ко всем Redux-сторам проекта.Второй вариант менее безопасен и используется в редких случаях. Например, его используем мы в `lk2`, т.к. на нашей стороне полностью контролируется взаимодействие с данными.
* React-роутер.
* `ConnectToMobX` — коннектор глобальных сторов из Redux к MobX. Да, на проекте есть оба стейт-менеджера. Сначала мы использовали только Redux, но затем попробовали MobX, и жить стало веселее: кода становится меньше, а задачи закрываются быстрее. Сейчас мы постепенно переписываем сторы c Redux на MobX.
* `StatisticsProvider` — провайдер контекста для сбора статистики.
Всего есть 7 таких провайдеров.
#### Пользовательский интерфейс X5LkApp
* Страница авторизации.
* Разметка авторизованного пользователя. Она включает в себя боковое меню и шапку с информацией о текущем пользователе.
Главная страница сервиса
Обёртка `X5LkApp` используется и в `lk2` и в микрофронтендах, поэтому разработка нового раздела выглядит одинаково и для нас, и для сторонних команд.
Рассмотрим использование `X5LkApp` на примере.
**В стороннем модуле:**
Корневой компонент микрофронтенда:
```
// externalModule/src/ExternalModuleApp.tsx
import { X5LkApp } from '@five/core';
import ExternalModuleContent from './ExternalModuleContent';
const ExternalModuleApp = () => (
);
export default ExternalModuleApp;
```
Компонент с бизнес-логикой:
```
// externalModule/src/ExternalModuleContent.tsx
import { useX5Data } from '@five/core';
// Используем UI-компоненты из библиотеки
import { Typo, UserCard } from '@five/uikit';
const ExternalModuleApp = () => {
// ExternalModuleApp обёрнут в контекст X5LkApp,
// поэтому внутри доступен контекст
const { user } = useX5Data();
return (
<>
Привет из стороннего модуля
);
};
export default ExternalModuleApp;
```
**В lk2:**
```
// five/packages/lk2/src/Root.tsx
import { useX5Data } from '@five/core';
import SomePage from './pages/Page';
// В этом компоненте импортируется модуль
import ExternalComponentPage from './pages/ExernalComponentPage';
export const Root = () => (
// Контент lk2 тоже оборачиватеся в контекст из @five/core
);
```
### Вспомогательные компоненты
`@five/core` экспортирует вспомогательные компоненты. Они упрощают работу с разметкой. Например:
* `Layout.LayoutContent` — обёртка добавляет отступы, заголовок страницы и кнопку "Назад".
Границы встраиваемого модуля
* Также среди вспомогательных компонентов есть компоненты, которые нужны всем командам, но они сильно завязаны на бизнес-логику, поэтому их нельзя вынести в `@five/uikit`, в котором содержатся только "глупые" компоненты.
Пример — панель для выбора сотрудника.
Компонент EmployeeSelectPanel для выбора сотрудника
В итоге получается такая схема взаимодействия `@five/core`, `lk2` и микрофронтендов. Стрелки показывают использование одних компонентов другими.
Схема взаимодействия модулей с @five/coreКак мы подключаем микрофронтенды
--------------------------------
О микрофронтендах много говорят, в нашем случае этот подход полностью оправдан и необходим:
* Команды разрабатывают модули изолированно и не влияют друг на друга.
* Команды появляются и уходят, конечный результат их работы — отдельный модуль, который легко доработать, переместить или удалить, но команда не может внести изменения в архитектуру системы — преимущество с точки зрения надёжности и безопасности.
* Команды придерживаются отличающихся практик и требований к написанию, качеству и стилю кода, у команд по-разному построены процессы. Изолированность позволяет каждой команде работать в привычном режиме, что ускоряет разработку и внедрение.
* Бизнес-процессы в некоторых модулях очень сложны, поэтому их разрабатывают специальные команды.
Мы пробовали три варианта подключения модулей. Ниже проанализирую преимущества и недостатки каждого из них, а также поделюсь, почему мы переходили от одного к другому.
### iframe
В самом начале ещё не было пакета `@five/core`, но необходимость во встраивании модулей уже была. `iframe` стал первым способом, с помощью которого мы встраивали модули.
Перед нами стояла задача — подключить модуль в кратчайшие сроки. В тех условиях `iframe` показался самым простым вариантом.
В React-приложении достаточно сделать страничку, в которой растянуть `iframe` и вставить в него ссылку на модуль. С учётом того, что у нас уже был администрируемый [navigationStore](#navigation_store), это сделать особенно просто.
Модуль использует API бэкенда ЛК2. Но т.к. содержимое `iframe` и родительская страница изолированы друг от друга, модуль должен пройти авторизацию в ЛК2. Для этого на бэкенде нужен соответствующий механизм. Его разработка означает дополнительные расходы, но в дальнейшим и для других способов встраивания пригодится авторизация, поэтому это не недостаток, а необходимость.
Механизм авторизации должен возвращать модулю токен, далее с этим токеном модуль ходит в наш API. В значительной своей части бэкенд представляет из себя proxy к уже существующим бэкенд-сервисам. И чаще всего модуль создаёт для него интерфейс. Но в этом бэкенд-сервисе тоже нужна авторизация, поэтому вне зависимости от того, использует ли модуль данные из бэкенда ЛК2, он должен авторизоваться, чтобы получить токен к целевому бэкенд-сервису.
Изолированность `iframe` повышает стабильность фронтенда: если внутри модуля всё сломается, и страница упадёт, это никак не повлияет на работу остального проекта. Но есть и обратная сторона медали: сильная изолированность усложняет взаимодействие модуля с приложением:
* Родительская страница общается с iframe с помощью [postMessage](https://developer.mozilla.org/ru/docs/Web/API/Window/postMessage). Это значит, что, нужно прорабатывать протокол сообщений, реализовывать механизм асинхронного взаимодействия модуля и ядра. Это явно менее удобно, чем, например, React-пропсы.
* Поскольку встраиваемый модуль находится вне контекста ядра, в него сложно бесшовно интегрировать роутинг, а также другие контексты приложения.
* Возрастает интенсивность использования API: данные, уже полученные в `lk2`, должны повторно запрашиваться в `iframe`. Можно, конечно, синхронизировать данные через `postMessage`, но кажется, что это ещё сложнее.
* Сложно поддерживать в актуальном состоянии внешний вид и корневой функционал: при обновлении `@five/uikit` команда модуля должна актуализировать версию пакета. Может появиться расхождение.
В случае встраивания через `iframe` модуль — это отдельный сервис. Команда менее ограничена стеком корневого модуля, она может настроить собственный CI/CD. Это плюс, поскольку даёт большую свободу действий. Но это и минус, так как команде нужны дополнительные ресурсы:
* нужно выделить сервера, на которых будет хоститься сервис;
* чтобы разложить сервис, нужно затратить усилия на настройку инфраструктуры.
Важный плюс встраивания через `iframe` — этот подход позволяет разрабатывать и обновлять модули без привлечения фронтендеров команды ЛК2: для встраивания достаточно в панели администратора добавить ещё один раздел со ссылкой, и он автоматически появится в проекте. Так же и с обновлением: команда модуля просто раскладывает новую версию приложения и эти изменения оперативно, независимо от команды ЛК2, оказываются в продакшене. Поскольку количество модулей постоянно растёт, и обновляются они довольно часто, эта особенность очень полезна. Следует учесть, что в данном случае ответственность и контроль за работоспособностью модуля полностью лежит на команде, разрабатывающей его.
Сложности начинаются, когда модуль должен предоставлять более одного компонента. Приведу конкретный пример: в личном кабинете есть главная страница, на которой расположены виджеты некоторых разделов. [На рисунке выше](#main_screen) можно видеть виджеты разделов "Деньги", "График работы" и "Задачи". Если модуль встраивается через `iframe`, нужно продумывать дополнительные механизмы экспортирования нескольких компонентов: виджета и основной страницы модуля. Это можно сделать, например, через поддомены или с помощью параметров пути, но в любом случае это не выглядит удобно.
#### Итоги встраивания через iframe
**Преимущества:**
* Относительная простота минимальной реализации;
* Изолированность, а следовательно, надежность;
* Свобода выбора технологий;
* Независимость обновления и добавления модуля.
**Недостатки:**
* Сложное взаимодействие `lk2` и встраиваемого модуля;
* Отсутствие общего контекста, например, для роутинга;
* В пакете требуется поддерживать актуальную версию `@five/uikit`;
* Изолированность может привести к потере взаимозаменяемости микрофронтендов;
* Для разработки модуля требуются дополнительные ресурсы:
+ Инфраструктура prod / test;
+ Компетенции;
+ Время на настройку CI/CD.
* Сложно предоставлять сразу несколько компонентов из пакета.
В итоге недостатки перевесили преимущества, и мы перешли к следующему подходу, успев встроить с помощью `iframe` только один небольшой модуль.
Дальше интересней!
### NPM-пакеты
Следующим шагом мы решили подключать микрофронтенды как NPM-пакеты. Этому способствовало то, что у нас уже был `@five/uikit`, оставалось только добавить `@five/core`.
У подключения через NPM-пакеты есть важные преимущества:
**Простота первой настройки** — грубый вариант: копируем конфиги из уже существующего пакета и всё работает!
**Не нужны дополнительные DevOps-ресурсы.**
Технически версия NPM-пакета — это просто архив собранного проекта, лежащий в NPM-registry, а публикация очередной версии — это просто вызов команды `yarn publish`. В итоге NPM-пакет попадает в сборку ЛК2. Это значит, что в отличие от подхода с `iframe`, не нужны сервера, которые отдавали бы статику модуля. Более того, очень просто настроить пайплайн, который собирал бы модуль и публиковал новую версию.
**Не дублируется код библиотек**, используемых сразу в нескольких пакетах.
Справка, как работают dependencies, devDependencies и peerDependencies.В `package.json` есть три секции с зависимостями. Рассмотрим на примере модуля `@five/someModule`, который использует `react` и собирается сборщиком `rollup`.
```
{
"name": "@five/someModule",
"version": "1.0.0",
"dependencies": {
"react": "17.0.1"
},
"devDependencies": {
"rollup": "2.0.4"
},
"peerDependencies": {
"react": ">=17"
}
}
```
**dependencies**Зависимости из `dependencies` устанавливаются **транзитивно** при установке пакета.
```
# Потянет за собой зависимость react,
# т.к. она указана в dependencies
yarn add @five/someModule
```
**devDependencies**Зависимости из данной секции **не устанавливаются транзитивно**. Это значит, что в `devDependnecies` можно указать `rollup` и при установке модуля этот пакет установлен не будет.
```
# Rollup установлен не будет, т.к. он указан в devDependencies
yarn add @five/someModule
```
**peerDependencies**Данная секция нужна для того, чтобы декларативно указать пакеты и их версии, которые нужны для функционирования устанавливаемой библиотеки. Если пакет `react` укажем в `peerDependencies`, то при установке библиотеки увидим сообщение с требованием установить React.
```
# Увидим сообщение с требованием установить React
yarn add @five/someModule
```
В нашем подходе все пакеты указываем в секции `devDependecies`, а `dependencies` пуст. Все библиотеки, которые работают на клиенте (`@five/core`, `@five/uikit`, `react`, `mobx` и другие), помимо `devDependecies` указаны и в `peerDependecies`. Уже внутри пакета `lk2` мы можем явно контролировать, от каких пакетов зависят встраиваемые модули и в каких версиях эти пакеты нужны. Ничего не подтянется автоматически без нашего контроля.
В настройках Rollup используем плагин `rollup-plugin-peer-deps-external`. Этот плагин исключает из бандла модуля код библиотек, указанных в `peerDependecies`. В итоге используется только те библиотеки, которые установлены в `lk2`. Это положительно влияет на итоговый размер бандла.
**Версии** `@five/core` и `@five/uikit` всегда актуальны, даже если команда не успела актуализировать версию в своём модуле. Поскольку в бандл микрофронтенда не попадают `@five/core` и `@five/uikit`, эти зависимости берутся из пакета `lk2`. А т.к. проект организован в виде монорепозитория, то код библиотек берётся из текущего проекта, а не из NPM-registry.
**Из модуля легко экспортировать сразу несколько компонентов.**
Использование нескольких компонентов встраиваемого модуля выглядит гораздо проще, чем в случае с `iframe`:
```
import { SomePage, SomeWidget } from '@five/someModule';
```
**Удобное взаимодействие с модуля с ЛК2.**
Модуль экспортирует обычные React-компоненты. Это значит, что взаимодействие с ним позволяет использовать все функции из React: общий контекст для роутинга, авторизации, статистики, данных пользователя. В самом простом варианте, мы можем просто передать в компонент пропсы! Как мало нужно для удобного взаимодействия)
Большинство команд разрабатывает модуль с использованием Typescript, что даёт множество преимуществ при разработке модуля. Но для нас это важно тем, что при подключении пакета мы можем просто посмотреть его интерфейс. Это сильно упрощает взаимодействие команд и повышает надёжность совместной работы.
Требования к единому стеку повышают **взаимозаменяемость команд**.
**Единая точка ответственности.**
В отличие от варианта с `iframe`, команда ЛК2 полностью контролирует процесс подключения модуля, а также его финальную работу. Мы оборачиваем модуль в [Error Boundary](https://ru.reactjs.org/docs/error-boundaries.html). Если пайплайн с пакетом упадёт, то сломанный модуль не попадёт в продакшен. Более того, перед релизом мы можем просто протестировать работоспособность модуля.
#### Недостатки подключения с помощью NPM-пакетов
Проблемы, которые описаны ниже, заставили задумываться о новом варианте встраивания:
**Длинная цепочка попадания модуля в продакшен.**
Процесс обновления модуля выглядит следующим образом:
1. Команда модуля публикует новую версию и сообщает об этом нашему менеджеру;
2. Менеджер ЛК2 заводит для этого задачу на разработчика;
3. Разработчик делает отдельную ветку с новой версией пакета, раскладывает ветку для тестирования;
4. Проверяем, что всё собралось, ветка разложилась, пакет работает;
5. Ждём тестирования и одобрения менеджеров;
6. Вливаем ветку в `dev`, ждём релиза (или стартуем релиз только ради новой версии);
7. Вливаем `dev` в `master` и заводим релизную ветку;
8. Публикуем релиз.
На всех этапах, где что-то куда-то вливается, ждём пайплайн, разработчик в это время делает другие задачи (или пьёт чай, потому что переключать контекст работы не очень продуктивно).
А если учесть, что модулей много, их количество постоянно возрастает, и работа ведётся довольно интенсивно, это приводит к тому, что много ресурсов команды ЛК2 уходит только на обновление версий микрофронтендов.
**yarn integrity check failed**
Слова, которые не греют мне душу... Эта ошибка возникает, если сделать `yarn publish` без поднятия версии пакета в `package.json`. При установке пакета в файл `yarn.lock` попадает хэш от содержимого пакета. Этот хэш специфичен для версии пакета. Если опубликовать версию без поднятия цифры в `package.json`, пайплайн, использующий данную версию пакета, упадёт. А если конфликтный номер версии уже в релизе, то упадут вообще все сборки, т.к. они опережают релиз. Работа стоит, программисты модуля заняты публикацией новой версией, а программисты ЛК2 заняты новым релизом и актуализацией версий. Звучит неприятно и глупо, но это человеческий фактор и пару раз такая ситуация происходила.
**Код модуля в конечном счете попадает в общую сборку с ЛК2.**
Есть вероятность, что ошибка в модуле повлияет на весь проект. Но я бы не сказал, что это существенный недостаток. Проблема теоретически существует, но мы с ней ни разу не столкнулись. Всё-таки профессионализм команд, разрабатывающих модули, а также Error Boundary делают своё дело.
#### Итоги подключения через NPM-пакеты
С технической точки зрения этот подход очень хорош: он удобен и надёжен и для разработки, и для встраивания. Ключевым его недостатком оказалось сильное растягивание процессов во времени. Для обновления приходится тратить ресурсы команды ЛК2, от чего страдает эффективность нашей работы.
**Преимущества:**
* Простота первой настройки;
* Не нужны дополнительные DevOps-ресурсы;
* Не дублируется код библиотек;
* Версии `@five/core` и `@five/uikit` всегда актуальны;
* Из модуля легко экспортировать сразу несколько компонентов;
* Удобное взаимодействие с модуля с ЛК2.
**Недостатки:**
* Длинная цепочка попадания модуля в продакшен;
* yarn integrity check failed;
* Возможно влияние модуля на ЛК2 и его состояние.
Дальше интересней! Следующий способ, на мой взгляд, обладает большей частью преимуществ подключения с помощью NPM-пакетов, и при этом он позволяет обновлять модули независимо от команды ЛК2 как с `iframe`.
### Webpack Module Federation
Это актуальный метод, с помощью которого мы встраиваем микрофронтенды.
Технология позволяет подключить модули не во время сборки проекта, а подтягивать их динамически, когда пользователь открыл вкладку браузера. Эти модули хранятся в отдельном репозитории, собираются независимо, их статика предоставляется по фиксированному URL.
Данный способ появился недавно в пятом Вебпаке. Ниже опишу его принцип. Если вы уже знакомы с Module Federation, можете пропустить пояснение.
Пояснение: как работает Module FederationПредставим, что есть React-компонент `ChildComponent`, который мы хотим использовать у себя в проекте. Код данного компонента расположен в отдельном React-приложении `child_project` в отдельном репозитории `child_repo`.
Проект собирается и его индекс-файл находится по фиксированному пути:
`https://modules.x5.ru/static/child_project/child_project.js`
Чтобы использовать компонент `ChildComponent` в проекте `lk2` , нужно сначала доработать дочерний проект. Для этого добавим Webpack-плагин со следующими параметрами:
```
// child_project/wepback.config.babel.ts
new ModuleFederationPlugin({
// берём имя из package.json "child_project"
name,
// данный бандл собирается как библиотека с именем "child_project".
// наружу предоставляется переменная, поэтому указываем type: 'var'
library: { type: 'var', name },
// указываем название index-файла: 'child_project.js'
filename: `${name}.js`,
exposes: {
// Указываем, что какой файл экспортировать из модуля по пути
// ./ChildComponent
'./ChildComponent': './src/ChildComponent'
},
// Здесь указываем разделяемые зависимости между текущим модулем
// и тем, в который будет встраиваться данный компонент.
// Аналог того, что указано в peerDependecies в случае с NPM-пакетом
shared: { /* ... */ }
})
```
Дочерний проект настроен! Теперь добавляем такой же плагин в `lk2` , но уже с другими параметрами:
```
// five/packages/lk2/webpack.babel.config.ts
new ModuleFederationPlugin({
name: '@five/lk2',
remotes: {
// ключ — это алиас, по которому будем импортировать модуль
'@five/childModule':
// формат: @
'child\_module@https://modules.x5.ru/static/child\_project/child\_project.js'
},
shared: { /\* То же, что и в child\_project \*/}
})
```
Далее нужно добавить скрипт со ссылкой на дочерний модуль в шаблон будущего `index.html` ЛК2
```
```
И после этого можем импортировать компонент внутри `lk2`, как обычный React-компонент:
```
// five/packages/lk2/src/modules/ChildComponentWrapper.tsx
import { Loader } from '@five/uikit';
import * as React from 'react';
import SentryErrorBoundary from 'components/SentryErrorBoundary';
// Импортируем компонент с помощью React.lazy
const LazyComponent = React.lazy('@five/childModule/ChildComponent');
type Props = {/* ... */};
// Оборачваем компонент в Error Boundary
const WrappedComponent: React.FC = (props: Props) => (
}>
);
// Экспотрируем финальный компонент
export default WrappedComponent;
```
Готово! Компонент разрабатывается в удалённом репозитории, хранится так же удаленно, а мы взаимодействует с ним максимально нативно!
Безусловно, это довольно поверхностный пример, но он наглядно демонстрирует, что такое федерация модулей, и как её использовать. В одной из следующих статей я подробно расскажу, как настроить Module Federation, а также какие подводные камни и тонкости могут быть в данном методе. Эта технология очень свежа, поэтому есть много моментов, которые либо противоречат документации, либо выясняются только экспериментальным путём.
#### Что нам дало подключение через Module Federation
Этот подход объединяет преимущества встраивания через iframe и через NPM-пакеты.
**Независимость разработки и обновления.**
Для обновления модуля команда должна собрать проект и разложить статику таким образом, чтобы она была доступна по заранее зафиксированному пути. При этом команда ЛК2 делать ничего не должна.
Возникает два вопроса:
1. **Куда складывать статику модуля?** Личный кабинет ранее уже использовал хранилище S3 для некоторой статики. Оказалось, что S3 также очень удобно использовать и для хранения статики модулей. Тогда в пайплайне сборки модуля его деплой заключается в простом копировании файлов по фиксированному пути S3:
```
aws s3 cp /dist s3://$BUCKET_NAME/$PACKAGE_NAME \
--recursive \
--endpoint-url $ENDPOINT_URL \
--acl public-read
```
Обратите внимание, что при формировании пути используется `$PACKAGE_NAME` — это имя проекта из `package.json`. Фактически, это единственный уникальный параметр, используемый при сборке модуля.
Это удобно по двум причинам:
* Для того, чтобы встроить новый модуль в `lk2`, нам нужно знать лишь `name` из `package.json` и название экспортируемого React-компонента. Весь остальной путь к модулю фиксирован.
* Команда, которая разрабатывает модуль, использует шаблонный проект. Фактически ей вообще не нужно ничего делать для настройки деплоя.
2. **Что делать с** [**кешированием**](https://webpack.js.org/guides/caching/) **модуля?**
Кеширование нужно, чтобы клиент загружал статику (js, стили и т.д.) не при каждом открытии сайта, а только если эта статика изменяется, т.е. если сделали новый релиз. Обычно механизм кеширования выглядит так:
* В названия статических файлов добавляется хеш от их содержимого: `main.js` → `main.[contenthash].js`
* Добавляем статике HTTP-заголовок `cache-control` с долгим временем жизни.Клиент загрузит файл один раз и далее будет брать его из кеша, пока не поменяется ссылка на него, т.е. пока не изменится его содержимое, а следовательно, и хэш в названии.
В случае с федерацией модулей подход с добавлением хэша не сработает, т.к. ссылка на файл зафиксирована. Эта проблема была описана ещё в [feature request](https://github.com/webpack/webpack/issues/10352) с Module Federation. Решается она добавлением кеширующего HTTP-заголовка ETag — это такой же хэш, но он добавляется не сборщиком в имя файла, а сервером статики в момент отдачи файла клиенту. В нашем случае ничего не пришлось дорабатывать, поскольку данный заголовок автоматически проставляется сервером S3, в котором мы храним всю статику модулей.
**Удобно экспортировать сразу несколько компонентов**.
Для этого в секции `exposes` просто указываем несколько полей:
```
// child_module/webpack.config.babel.ts
exposes: {
'./Page': './src/Page',
'./Wiget': './src/Widget'
},
```
**Модули подключаются как обычные React-компоненты**.
* Можно передать пропсы
* Есть доступ к общему контексту приложения
**Код модулей подгружается динамически.**
Это положительно влияет на размер бандла и, следовательно, на скорость первоначальной загрузки.
**Модули собираются в отдельных репозиториях.**
`lk2` собирается быстрее, потому что сборщику не приходится обрабатывать код модулей. Соответственно, и пайплайны проходят быстрее.
**Легко** **засетапить новый модуль с использованием шаблонного проекта.**
Сейчас для сетапа нового модуля достаточно сделать fork от шаблонного проекта. Нужно сделать примерно 0 дополнительных настроек. Каждый раз делать fork немного костыльно: после обновления шаблонного проекта нужно вручную обновлять каждый модуль. Поэтому в планах внести шаблонный проект в монорепозиторий и оформить его в виде NPM-библиотеки. Получится что-то вроде `create-react-app`, только `create-x5-app`.
**В процессе загрузки общие модули грузятся один раз**.
`ModuleFederationPlugin` позволяет указать в `shared` общие пакеты для нескольких модулей. Например, в **модуле A** React версии 17.0.1, а в **модуле B** — 17.0.2.
При сборке **модуля A** `react` попадает в отдельный чанк. Аналогично при сборке **модуля B** `react` тоже попадает в отельный чанк.
Далее уже когда открывается вкладка в браузере, плагин Вебпака видит, что на текущей странице используется один и тот же пакет разных версий в разных модулях. Загружен будет чанк из того модуля, в котором версия пакета выше.
Обратите внимание, что в данном случае не важно, какой из модулей A или B является родительским, а какой дочерним. Такое поведение можно изменять, с чем связано несколько интересных моментов, о которых расскажу в статье про Module Federation. Но в общем случае разделяемые пакеты позволяют уменьшить размер чанков и грузить только нужное.
#### Конечно, у подключения с помощью Module Federation есть и недостатки:
Основной недостаток вытекает из того, что это свежая технология. **Первая настройка заняла много времени**. В основном проблемы возникали из-за того, что документация местами не соответствовала реальности, местами приходилось открывать на Гитхабе тайпинги Вебпак-плагинов, чтобы понять, что же на самом деле туда можно передать. Многие тонкости выяснялись экспериментально.
**Нужно где-то хранить статику.**
Как и писал выше, в нашем случае проблема оказалась несущественной, но забывать о ней не стоит. На некоторых проектах она может привести к дополнительным работам, а следовательно, и затратам.
**Ошибка в модуле может повлиять на весь проект.**
Конечно, каждый модуль оборачивается в Error Boundary, он поможет отловить исключения, но есть проблемы, от которых компонент-предохранитель обезопасить не сможет.
Пример: ваш проект должен открываться в IE11. В конфиге Babel допущена ошибка и проект собирается в ES6. Открываем сайт ЛК2, подгружается модуль, и страница падает: в код попала стрелочная функция, а для IE это синтаксическая ошибка. Подобные ошибки не могут быть обработаны Error Boundary.
В нашем случае проблема решается тем, что в шаблонном проекте все эти тонкости учтены, а после оформления шаблонного проекта в виде NPM-пакета вероятность такой проблемы станет ещё ниже. Тогда же можно будет добавить этапы пайплайна с проверками, но в любом случае это ведет к дополнительным работам.
Так же, как и в случае с NPM-пакетом, модуль может повлиять на данные приложения.
**Сложности с типизацией.**
После установки NPM-пакета в `node_modules/some-package` оказываются `*.d.ts` файлы, в которых описаны типы данного пакета. В случае подключения через Module Federation в нашем проекте нет файлов, описывающих типы модуля: есть только ссылка на модуль. В случае подключения модулей в проект это не существенно, т.к. модуль взаимодействует с окружением через контексты из пакета `@five/core`, а в ЛК2 микрофронтенд подключается как React-компонент с парой пропсов:
* `baseRoute` — базовый путь для относительного React-роутинга
* `user` — объект с информацией о пользователе.
Эта проблема станет существенной в случае, если вы решите, например, предоставлять через Module Federation библиотеку UI-компонентов. UI-библиотеки экспортируют много "глупых" компонентов, интерфейс которых должен быть заранее известен, поэтому без подробной декларации типов не обойтись. На мой взгляд, по этой причине Module Federation пока не очень хорошо подходит для таких целей.
#### Выводы по Module Federation
Коротко: продолжаем использовать.
У данного подхода есть и преимущества, и недостатки, но на данный момент он кажется самым удобным и оптимальным. На мой взгляд, текущие проблемы решаются усовершенствованием механизма подключения и не требуют чего-то принципиально нового. За полгода использования Module Federation сэкономил много времени разработчиков и менеджеров, а это значит, что крайне мала вероятность того, что в скором времени мы от него откажемся.
**Преимущества:**
* Удобно экспортировать сразу несколько компонентов;
* Модули подключаются как обычные React-компоненты;
* Легко засетапить новый модуль с использованием шаблона;
* В процессе загрузки общие модули грузятся один раз.
**Недостатки:**
* Очень свежая технология;
* Нужно где-то хранить статику;
* Ошибка в модуле может повлиять на весь проект и на его состояние;
* Сложности с типизацией.
Встраиваются не только в нас, но и мы!
--------------------------------------
На самом деле, ЛК2 — не самый верхний слой в этой матрёшке. Существует мобильное приложение для сотрудников Пятёрочки. Мобильное приложение реализует логику авторизации и несколько специфичных функций. Приложение открывает WebView, в котором открывается сайт ЛК2. Все основные бизнес-процессы реализованы на нашей стороне.
Взаимодействие ЛК2 с мобильным приложением базируется на следующих моментах:
* При встраивании через WebView в `window` появляется специальный объект `MobileApp`. Через него `@five/core` (а следовательно, и `lk2`) узнает, что сайт открыт в мобильном приложении и активирует специфичные функции. Например, изменяется внешний вид навигации. Также объект `MobileApp` нужен для передачи информации между ЛК2 и мобильным приложением.
* [Выше](#navigation_store) писал про `navigationStore`. Повторю: этот стор хранит информацию о различных доступах пользователя в зависимости от параметров, с которыми открыт ЛК2. Платформа — один из таких параметров. Он может принимать следующие значения:
+ `web` — ЛК2 открыт в десктопном браузере;
+ `mobile` — ЛК2 открыт в мобильном браузере;
+ `android` — ЛК2 открыт в Android-приложении;
+ `ios` — ЛК2 открыт в iOS-приложении.Вид приложения тоже влияет на то, какие разделы доступны пользователю.
Заключение
----------
Итоговая схема фронтенда ЛК2В итоге имеем архитектуру как на картинке:
* Мобильное приложение открывает `lk2` в WebView;
* `lk2` использует `@five/core` и `@five/uikit`, а также микрофронтенды;
* Каждый модуль создается на основе шаблонного проекта и также использует `@five/core` и `@five/uikit`.
Надеюсь, вы узнали что-то новое, и эта статья поможет вам эффективнее проектировать подобные системы.
Пожалуйста, делитесь в комментариях, какими способами вы решали похожие задачи, а также предлагайте улучшения, если вы заметили пробелы или неточности в моём варианте. Спасибо)
В следующих статьях уже с технической точки зрения рассмотрю:
* Проектирование современной UI-библиотеки;
* Проектирование `@five/core`;
* Создание шаблонного проекта наподобие create-react-app;
* Тонкости использования Webpack Module Federation. | https://habr.com/ru/post/569448/ | null | ru | null |
# PHP'шные фишечки
Хочу рассказать вам о некоторых приемах, которыми я пользуюсь во время разработки сайтов. Возможно, они окажутся для вас полезными.
Заполнители в SQL-запросах
==========================
Удивительно, но в PHP-расширении mysql не реализованы заполнители, которые в шаблоне SQL-запроса стоят на месте необработанных данных. Значения, переданные заполнителям, автоматически обрабатываются mysql\_real\_escape\_string(), что избавляет нас от опасности SQL-инъекции.
Пример использования этого механизма:
`$name = "O'Reilly";
mysql_exec("SELECT * FROM people WHERE name = ?", $name);`
Без него у нас получился бы такой код:
`$name = "O'Reilly";
$name = mysql_real_escape_string($name);
mysql_query("SELECT * FROM people WHERE name = '$name'");`
Преимущество первого метода на лицо.
А теперь сам код:
`function mysql_exec($sql) {
$args = func_get_args();
$args = array_map("mysql_real_escape_string", $args); // Применяем mysql_real_escape_string ко всем аргументам
$sql = str_replace("?", "'%s'", $sql); // Подготавливаем шаблон для передачи его в sprintf
$args[0] = $sql;
$sql = call_user_func_array("sprintf", $args);
return mysql_query($sql);
}`
unregister\_globals
-------------------
Бывает, что register\_globals включена, и изменить это невозможно, в этом случае можно прибегнуть к хитрости:
`function unregister_globals() {
// Нам нечего делать, если register_globals = off
if (!ini_get("register_globals")) {
return;
}
// Список разрешенных переменных
$allowed = array("GLOBALS", "_COOKIE", "_ENV", "_FILES", "_GET", "_POST", "_SERVER");
// Проходим по переменным...
foreach ($GLOBALS as $name => $value) {
if (!in_array($name, $allowed)) {
unset($GLOBALS[$name]);
}
}
}`
Вызывать эту функцию надо в начале скрипта.
Боремся с magic\_quotes
=======================
То же самое касается и magic\_quotes\_gpc, если она включена то можно сделать следующее:
`function magic_quotes_gpc_off() {
if (!get_magic_quotes_gpc()) {
return;
}
function array_stripslashes($array) {
return is_array($array) ? array_map("array_stripslashes", $array) : stripslashes($array);
}
$_GET = array_stripslashes($_GET);
$_POST = array_stripslashes($_POST);
$_COOKIE = array_stripslashes($_COOKIE);
}`
Надеюсь эта информация оказалась кому-либо полезной. | https://habr.com/ru/post/21971/ | null | ru | null |
# Pebble + Marlight: управляем светом жестами
Привет, Хабр и хабровчане. Хочу рассказать об одном эксперименте, который провел на днях. Очень мне понравились два девайса из статей от [Madrobots](http://habrahabr.ru/company/madrobots/): [лампы Marlight](http://habrahabr.ru/company/madrobots/blog/230473/) и [часы Pebble](http://habrahabr.ru/company/madrobots/blog/212927//). Причем понравились именно тем, что конфигурируемы, т.е. подвластны так сказать воле и воображению хозяина. Пока ребенок на даче, решил я устроить ему сюрприз и показать настоящую современную «техномагию», а именно: управление светом жестами.
**Задача:** с помощью неких движений выбирать комнату, а затем взмахом руки или включаем, или выключаем свет в выбранной комнате.
В процессе работы над поставленной задачей, было использовано несколько любопытных решений, которые могут пригодится в разнообразных проектах домашней автоматизации, кому интересно — добро пожаловать под кат.
Многие из статей, что я здесь читал… Они классные! Читаются на одном дыхании и кажется, что господи – ведь так же просто все, чего ж я сам-то не сделаю так же. Собственно именно такие мысли и натолкнули меня на вот это все, что ниже описано. НО! Есть одно важное «но». Я хотел помимо конечного результата описать еще свои мытарства в областях, в которых я, строго говоря, ничего не смыслю. Я никогда не писал под php и js, а c++ был в институте и очень давно. Кому-то покажется, что я очень много внимания уделяю элементарным вещам, а может даже в некоторых моментах я откровенно ошибаюсь или что-то понимаю не правильно, однако я добился поставленной задачи и хотел продемонстрировать не только результат (возможно не такой уж и впечатляющий), но и путь, которым я к нему шел.
Итак, что у нас есть из железа:
* наручные часы pebble с акселерометром
* телефон с iOS на борту
* комп с виндой, выполняющий функции сервера (т.е. включенный 24х7)
* wi-fi коннектор marlight, подключенный к домашнему wi-fi и имеющий статический IP
* освещение в квартире на базе ламп marlight (8шт) в каждой комнате(3)
Лампы купил сразу все. [Здесь](http://madrobots.ru/catalog/ustroystva_upravlyaemye_so_smartfona/marlight-wifi-lampochka/). Не дешево конечно, но они все же экономичные по энергопотреблению, а менять – так уж все сразу. Так что у меня четыре лампы в большой комнате, три в детской и одна в спальне (мало! Надо минимум три – световой поток одной лампы в максимальной яркости: 500 люмен, что не дотягивает даже до 50 ваттной лампы накаливания). Каждая комната – отдельный канал на [коннекторе](http://madrobots.ru/catalog/ustroystva_upravlyaemye_so_smartfona/marlight-wifi-konnektor/), и даже еще один остается на расширение: в ванную, например (pebble же водонепрницаемые… Чем плохо: лежишь в ванной и управляешь светом! Правда, придется сделать больше функций, чем просто включение-выключение).
C wifi-коннектором вышла легкая заминка: при включении он предлагает выбрать тип шифрования и не смотря на наличие инструкции в которой в качестве примера показано WPA2, в списке выбора такого варианта не обнаруживается. Однако специалисты тех. поддержки магазина мне разъяснили, что выбирать тип шифрования не надо – мол указываешь SSID, пароль и вуаля – коннектор в сети. Собственно все это было и есть в [инструкции](http://madrobots.ru/files/rus_manual.pdf) у них на сайте.
Биндинг ламп на конкретный канал так же не вызвало затруднений – благо я уже знал, где лежит инструкция! (Что характерно – в бумажке, что шла с коннектором процедура была описана несколько иначе – так вот работает именно та, что на сайте продавца).
Протестировав штатное iOS-приложение, я убедился, что могу управлять освещением с телефона (что само по себе уже удивительно), причем мне для этого не надо переключать сеть, как было бы, будь коннектор в stand-alone режиме. Пора переходить к тому, что я раньше никогда не делал: настраивать web-сервер.
Зачем web-сервер, спросите вы? А потому, что в упомянутой выше статье про лампочки была [ссылка](https://github.com/vvzvlad/marlight-wifi/tree/master/marlight_php) на php-скрипт, который при получении GET (и POST) запросов – пересылает соответствующий udp-пакет коннектору, заставляя того выполнить то или иное действие с освещением. Я кстати вполне допускаю, учитывая архитектуру pebble, о которой речь пойдет чуть ниже, что без сервера можно было обойтись, но… Я был вполне уверен, что http-запрос с часов инициировать можно, а вот на счет всего остального уверен не был.
Запустить php под IIS7 мне помогла вот [эта хабра-статья](http://habrahabr.ru/post/30154/). В принципе ничего сложного, главный урок, который я для себя извлек: у MS весьма своеобразное представление о user-frendly экране об ошибке. Только отключив эту опцию, я понял, что php у меня работает, а ошибки следует искать в скрипте (вернее в отсутствии библиотеки sockets, которую скрипт использует). Пробуем через localhost – бинго! Работает.
Установив на pebble/телефон приложение [smartwatch+](http://smartwatchplusapp.appspot.com/index.htm) пробую http-запросы. Конечно же натыкаюсь на брандмауэр, после добавления нужного порта в исключения – я таки могу уже управлять светом в комнате используя часы. Правда, со сторонним приложением. Значит нам пора в [cloudpebble.net](https://cloudpebble.net)
С этого момента хабр ответы на возникающие вопросы не давал, пришлось гуглить. Гуглил я много и далеко не всегда результативно, пока не набрел на вот этот [замечательный ресурс](http://ninedof.wordpress.com/2014/02/02/pebble-sdk-2-0-tutorial-6-appmessage-for-pebblekit-js/). Беглого просмотра оказалось достаточно, что бы понять, что это то, что нам нужно. И вот тут меня ждал сюрприз! Оказывается sdk pebble предоставляет возможность разработать решение, включающее в себя связку из кода, исполняемого как на часах, так и на телефоне! Уже потом я нагуглил, что у них так же есть наработки по js-приложению, которое полностью исполняется на телефоне, используя pebble сугубо как устройство вывода, но сейчас речь не об этом.
Итак, зачем же нам использовать два устройства и как это работает. Ну, по задумке у нас на часах акселерометр и именно его мы и хотим использовать в качестве управляющего устройства. А вот http-запрос… Даже если предположить, что это возможно напрямую (использую телефон в качестве условного «роутера»), то это неоправданно сложно. Возникает вопрос: зачем? Если реализован механизм обмена сообщениями, и на каждой из сторон может быть выполнен свой код? Как показала практика http запрос на стороне телефона – не просто, а очень просто!
Начнем пожалуй. В качестве темплейта нового приложения воспользуемся демкой из sdk pebble – appMessage. У нас сразу создастся два исходника — .c для часов и .js для телефона. Да-да, на телефоне используется java-sсript (помните, я упомянул, что вполне вероятно можно udp-пакеты управляющие напрямую слать на коннектор? Я просто не силен в js, поэтому понятия не имею можно ли это сделать и если можно, то как, но… Что-то мне подсказывает, что если есть в php, то должно быть и в js. Разве что возможности виртуальной машины в приложении pebble могут быть сильно урезаны).
Вот как выглядит мой файл .js (от дефортного он отличается, прямо скажем, не сильно):
```
// Событие при запуске - можно протестировать доступность URL... Но я просто шлю сообщение
Pebble.addEventListener("ready",
function(e) {
Pebble.sendAppMessage({0: “Ready!”});
});
// Обработка входящих сообщений: отправляем GET запрос, посылаем "эхо" обратно на часы
Pebble.addEventListener("appmessage",
function(e) {
var msg = e.payload.message; // SETTINGS : PEBBLE KIT JS : MESSAGE KEYS
var req = new XMLHttpRequest();
req.open('GET', "http://srv:8080/marlight.php?command="+msg, true);
req.send(null);
Pebble.sendAppMessage({0: msg});
});
```
Знаете, что я долго не мог понять? Что такое e.payload.message. Нет, серьезно! Я понимаю, что мы как-то передаем сообщение, что эта вот конструкция должна то, что мы передаем возвращать, но… Как? Как видно из исходника модуля для часов мы по сути передаем словарь, где значения идут по индексу… Оказывается дело в этом:
Это настройки именно для этого проекта в облачной IDE. И именно это связывает e.payload.message и MESSAGE\_KEY в строчке dict\_write\_cstring(iter, MESSAGE\_KEY, command), модуля для часов, и там и там некое осмысленно представление индекса.
В общем, не суть. Все тут понятно – при получении сообщения, мы извлекаем из него строку команды, которая должна дополнить имеющийся у нас URL, для получения конкретного GET-запроса, который заставит наш скрипт попросить коннектор переключить лампочки! Круто. На всякий случай шлем «эхо» обратно на часы.
Так, переходив в модуль .c, который соответственно исполняется на часах. Процедура отправки сообщения с часов на телефон у нас есть по дефолту:
```
/* Запись сообщения (параметр command) в буфер и отправка на телефон */
void send_message(char* command){
DictionaryIterator *iter; // создание словаря
app_message_outbox_begin(&iter); // начало сообщения
dict_write_cstring(iter, MESSAGE_KEY, command); // отправка команды на телефон
dict_write_end(iter); // конец сообщения
app_message_outbox_send(); //отправка
}
```
Ну, почти по дефолту… Все, что я сделал с этой процедурой – это добавил параметр-команду и заменил тип отправляемого пакета на строковый… О эти строки в С++! Кто не работал с указателями, кто не пытался вывести число в строку, тому не понять. Но благодаря примерам и SDK, я все же выяснил, что функция snprintf поддерживается, поэтому вывод форматированного текста (с преобразованием числа в строку) на экран, хоть и не так прост, как в привычных языках высокого уровня, но все же понятен:
```
channel = 1; // по умолчанию у нас включен 1-ый канал
snprintf(channel_s, sizeof("Channel: 0"), "Channel: %d", channel);
text_layer_set_text(channel_layer, channel_s); /* показываем сообщение при запуске программы */
```
Я привел только само преобразование и вывод текста, инициализацию текстового слоя полностью можно посмотреть в статье про [программирование под Pebble](http://habrahabr.ru/company/avi/blog/204514/) или в исходнике, ссылку на который я приведу в конце статьи.
Попробовав переслать пару статичных команд, и убедившись, что это работает – я перешел к самой сути: акселерометру. Что собственно такое акселерометр? В SDK есть пример работы с ним – часы по тамеру получают значение ускорения для каждой из трех осей и применяют его к паре десятков «дисков», которые имеют условную массу в зависимости от размера, а, следовательно, инерцию. Все это отрисовывается на экране часов.
Диски двигаются при наклоне в ту или иною сторону – все красиво… Но так сразу даже и не понятно, что из этого следует и как это применить на практике. Тогда я взял и тупо вывел данные текущего ускорения по осям в лог!
```
/* структура для хранения значений ускорения по всем трем осям */
AccelData accel = (AccelData) { .x = 0, .y = 0, .z = 0 };
/* для начала получим текущее значение ускорений */
accel_service_peek(&accel);
APP_LOG(APP_LOG_LEVEL_DEBUG, "x:%d, y:%d, z:%d", accel.x, accel.y, accel.z);
```
*Лирическое отступление: команда вывода в лог APP\_LOG(APP\_LOG\_LEVEL\_DEBUG, «SPARTAAA!!!»); встречается в исходниках часто, однако не так очевидно, где же этот самый лог! Ну, во-первых, это кнопочка VIEW LOGS после загрузки приложения на телефон:
А во-вторых, лог можно найти в меню: COMPILATION – VIEW APP LOGS.*
Но, вернемся к акселерометру. Медитируя на результаты, я понял, что есть одно ускорение, которое легко диагностировать – это ускорение свободного падения. Именно поэтому наклон проще отследить, чем движение в ту или иную сторону – по сравнению с гравитацией другие импульсы не так уж и значимы… Нет, конечно есть алгоритмы, позволяющие отследить даже то, какую фигуру в воздухе рисует оператор, но у нас приложение начального уровня, поэтому будем брать то, что попроще.
Итак, ускорение свободного падения с точки зрения акселерометра pebble равно 1000 ± 100 пунктов. Думаю именно так и задумывалось при калибровке. Значит порогом срабатывания можно считать 900 при совпадении направления оси и ускорения, и -900 когда ось и вектор ускорения полностью противоположны. Промежуточные значения пока рассматривать не будем.
Создадим структуру для хранения состояния осей, опишем возможные состояния, а так же заведем константу для гравитации:
```
typedef struct Vector {
int x, y, z;
} Vector;
static Vector current; //текущее состояние
/* Состояния осей акселерометра */
enum{
HYRO_NN = 0, // нейтральное
HYRO_UP = 1, // повернута вверх
HYRO_DN = 2 // повернута вниз
};
#define GRAVITY 900 // Ускорение свободного падения с точки зрения акселерометра pebble 1000 +/- 100
```
Тогда инициализацию состояния можно было бы прописать как:
```
if (accel.x > GRAVITY) current.x = HYRO_DN;
else if (accel.x < -GRAVITY) current.x = HYRO_UP;
else current.x = HYRO_NN;
if (accel.y > GRAVITY) current.y = HYRO_DN;
else if (accel.y < -GRAVITY) current.y = HYRO_UP;
else new.y = HYRO_NN;
if (accel.z > GRAVITY) current.z = HYRO_DN;
else if (accel.z < -GRAVITY) current.z = HYRO_UP;
else new.z = HYRO_NN;
```
Допустим. Однако нам нужен триггер, т.е. событие, на которое можно будет выдать ОДНОКРАТНУЮ реакцию (скажем, подняли руку, или повернули запястье). А значит нам нужно не столько состояние осей, сколько их изменение. Следовательно, нам надо хранить предыдущее измерение, что бы было с чем сравнивать, и обновлять его только если оно изменилось:
```
static Vector old; //старое
static Vector new; //новое
```
```
if (accel.x > GRAVITY) new.x = HYRO_DN;
else if (accel.x < -GRAVITY) new.x = HYRO_UP;
else new.x = HYRO_NN;
if (accel.y > GRAVITY) new.y = HYRO_DN;
else if (accel.y < -GRAVITY) new.y = HYRO_UP;
else new.y = HYRO_NN;
if (accel.z > GRAVITY) new.z = HYRO_DN;
else if (accel.z < -GRAVITY) new.z = HYRO_UP;
else new.z = HYRO_NN;
```
Теперь мы можем проверить изменилось ли состояние, и если да, то как изменилось. Если так, как задумано, то выполняем действие:
```
if (old.x!= new.x) { /* если оно изменилось по оси х */
/* проверим, как именно изменилось */
if (new.x == HYRO_UP){ // если руку подняли
snprintf(command_s, sizeof("ON_0"), "ON_%d", channel); // то надо послать команду включения
send_message(command_s); /* посылаем сообщение */
text_layer_set_text(command_layer, command_s); /* показываем сообщение */
}
if (new.x == HYRO_DN){ // если руку опустили
snprintf(command_s, sizeof("OFF_0"), "OFF_%d", channel); // то надо выключить
send_message(command_s); /* посылаем сообщение */
text_layer_set_text(command_layer, command_s); /* показываем сообщение */
}
/* зафиксируем изменение */
old.x = new.x;
}
if (old.y!= new.y) { /* если оно изменилось по оси y */
/* проверим, как именно изменилось */
if (new.y == HYRO_DN){ // если повернули кисть влево
channel++; // то следующий по порядку канал
if (channel == 5) channel = 1; // по кругу
snprintf(channel_s, sizeof("Channel: 0"), "Channel: %d", channel);
APP_LOG(APP_LOG_LEVEL_DEBUG, channel_s);
text_layer_set_text(channel_layer, channel_s); /* показываем сообщение */
}
if (new.y == HYRO_UP){ // если повернули кисть вправо
channel--; // то предыдущий канал
if (channel == 0) channel = 4; // по кругу
snprintf(channel_s, sizeof("Channel: 0"), "Channel: %d", channel);
APP_LOG(APP_LOG_LEVEL_DEBUG, channel_s);
text_layer_set_text(channel_layer, channel_s); /* показываем сообщение */
}
/* зафиксируем изменение */
old.y = new.y;
}
if (old.z!= new.z) { /* если оно изменилось по оси z */
/* пока просто зафиксируем изменение */
old.z = new.z;
}
```
Пробуем:
**Работает**!
**Эпилог**. Поставленная в начале задача выполнена. Думаю многие хотели бы знать, насколько это функционально – переключать свет жестом. Да в общем-то не очень. Практика показывает, что в 80% случаев проще всего пользоваться обычным выключателем. Необходимость удаленного включения/выключения/настройки света может возникнуть только тогда, когда ты, допустим, удобно устроился у телевизора, или лег спать и тебе лень вставать… В таком случае управление с часов удобнее, чем с мобильника (мобильника под рукой может и не быть), однако жесты… Жесты это скорее WOW-эффект. Даже с добавлением «горячих клавиш» от [pebblebits](http://pebblebits.com/firmware/) (позволяет запустить до четырех приложений не через меню, а нажатием комбинации кнопок), гораздо практичнее было бы грамотно организованное меню, предоставляющее быстрый и интуитивно-понятный доступ к основным функциям освещения. И тем не менее, я считаю этот проект для себя очень удачным. По нескольким причинам. Во-первых, развернутый web-сервер, управляемый GET-запросами – очень классная штука. Он может получать команду не только и не столько от часов, но от чего угодно: от датчиков движения и/или освещенности до какого-то обработчика голосовых команд. Так же по аналогии со скриптом marlight.php, я могу накидать скрипт, выполняющий действия, выходящие далеко за пределы управления освещением. Вполне допускаю, что для большинства здесь присутствующих это азы, но для меня опыт был полезен. Ну и конечно pebble! В ходе проекта я научился строить приложения для часов, которые умеют общаться с внешним миром, что открывает действительно широкие перспективы для их использования. Конечно, мне очень помогли статьи по программированию pebble, которые были на Хабре ранее (а MagicPebble я установил в часы на постоянной основе), но все эти примеры оставляют умные часы вещью в себе, при том, что простейший в общем-то код делает их частью общей «экосистемы» девайсов в доме.
Ссылки:
1. Исходник для pebble на GitHub: [PebbleToMarlight](https://github.com/Nehc/PebbleToMarlight)
2. php-скрипт для сервера: [marlight\_php](https://github.com/vvzvlad/marlight-wifi/tree/master/marlight_php)
3. Генератор русской прошивки для pebble с доп. опциями:[pebblebits.com](http://pebblebits.com/firmware/)
4. Хороший набор примеров с разъяснениями:[try { work(); } finally { code(); }](http://ninedof.wordpress.com/category/pebble/)
5. Статьи на хабре по программированию pebble: [раз](http://habrahabr.ru/post/202164/), [два](http://habrahabr.ru/company/avi/blog/204338/), [три](http://habrahabr.ru/company/avi/blog/204514/).
*P.S. Пока я писал эту статью, дважды обновилась прошивка pebble. Причем первый раз — с 2.3 на 2.4, что привело к невозможности загружать свои проекты на не обновленные часы, а так-как на pebblebits.com русского варианта не было — обновить до 2.4 означало бы отказаться от основной функции pebble: показывать звонки, сообщения, события и прочая, т.к. в оригинальной прошивке русский текст отображается квадратиками. Однако парни выложили новую платформу через неделю после выхода официальной, за что им глубокий респект!*
[](https://twitter.com/MadrobotsRu)[](http://vk.com/madrobots)[](http://instagram.com/madrobotsru)[](http://facebook.com/madrobotsrussia)
[](http://madrobots.ru) | https://habr.com/ru/post/233241/ | null | ru | null |
# Еще не используешь SVG фавиконки?
Тебе нужно использовать SVG фавиконки. Они поддерживаются во всех современных браузерах (Ну почти во всех).
Кроме того, не нужны все эти ссылки на значки и размеры, которые ты копируешь из проекта в проект. Давайте узнаем, какой абсолютный минимум для этого требуется.
Иконка
------
Главная фивиконка может быть SVG любого размера. Тип `type="image/svg+xml"` не нужен.
Тач-иконки
----------
Для иконки на IOS девайсах, а также для избранное на странице новой вкладки в браузере. Вам нужен только размер `180 x 180`, и атрибут sizes лишний.
Манифест
--------
Файл `manifest.json` предоставляет информацию о вашем веб-приложении или веб-сайте. Эти строки являются обязательными для прохождения [теста Lighthouse](https://developers.google.com/web/tools/lighthouse).
Значок используется Android и Chrome. Нужен только самый большой размер 512 x 512.
```
{
"name": "Starter",
"short_name": "Starter",
"icons": [{
"src": "google-touch-icon.png",
"sizes": "512x512"
}],
"background_color": "#ffffff",
"theme_color": "#ffffff",
"display": "fullscreen"
}
```
`theme-color` `meta` по-прежнему требуется для цвета иконки в Chrome и Android.
Готово
------
Вот и все, что вам нужно для современных браузеров, все остальное не нужно. `msapplication-TileImage` можно добавить, если вам нужен другой значок в плитках Windows, в противном случае используется `apple-touch-icon`. TileColor больше не используется.
Все остальное
-------------
К сожалению, не все используют современные браузеры, но это можно легко решить, поместив `favicon.ico` размером `32 x 32` в корень вашего веб-сайта. Это работает везде, даже у вашей бабушки.
Темный режим
------------
В заключение, вот совет по темному режиму. Одним из преимуществ значка SVG является то, что вы можете изменить цвет с помощью CSS. При использовании медиа-запроса `prefers-color-scheme` цвет вашего значка меняется в зависимости от темного или светлого режима пользователя. Этот метод не будет работать со `mask-icon`, так как цвет указан в атрибуте, но Safari добавляет белый фон, если контраста недостаточно.
```
path {
fill: #000;
}
@media (prefers-color-scheme: dark) {
path {
fill: #fff;
}
}
```
Результат
---------
Вот окончательный результат. Скопируйте его в вашего веб-сайта и не забудьте разместить `favicon.ico` в корне.
```
``` | https://habr.com/ru/post/552900/ | null | ru | null |
# Возможности обратной записи (Write Back) в кубах MS SQL Server Analysis Service
Сегодня все большую популярность завоевывают [In-Memory BI](http://en.wikipedia.org/wiki/In-Memory_Processing) решения. Кубы уже не в моде, их структура морально устарела, и хотя они довольно прилично масштабируются, требования к скорости работы современных BI систем значительно возросли. Тем не менее, многие компании до сих пор успешно используют аналитику, построенную на одном из [OLAP-серверов](http://ru.wikipedia.org/wiki/%D0%A1%D1%80%D0%B0%D0%B2%D0%BD%D0%B5%D0%BD%D0%B8%D0%B5_OLAP-%D1%81%D0%B5%D1%80%D0%B2%D0%B5%D1%80%D0%BE%D0%B2) (Microsoft, Oracle, Cognos, и др.). Мне, например, очень нравится Microsoft SQL Server Analysis Service, и я хотел бы рассказать, как в нем можно использовать немного необычную для аналитики функцию – обратную запись данных в источник (Write Back).
##### Постановка задачи.
Необходимо вносить план продаж на год в разрезе месяца, товара и региона. При этом, необходимо видеть фактические данные текущего года и посчитанный тренд на следующий год, который менеджер и будет менять. Инструмент ввода данных должен быть удобным, он должен позволять накладывать фильтры и смотреть итоги по разным группировкам (в целом по регионам, товарам и периоду) и еще не требовать от пользователя много времени на свое изучение.
##### Решение.
Будем использовать MS SQL Server 2008 R2 (Database Engine и Analysis Service) + Excel 2010. Создаем базу данных, несколько таблиц и заполняем их данными.
**Скрипт создание БД и заполнения таблиц**
```
CREATE DATABASE [MyDB] ON PRIMARY
( NAME = N'MyDB', FILENAME = N'C:\MyDB.mdf' , SIZE = 3072KB , FILEGROWTH = 1024KB )
LOG ON
( NAME = N'MyDB_log', FILENAME = N'C:\MyDB_log.ldf' , SIZE = 1024KB , FILEGROWTH = 10%)
GO
USE MyDB
GO
CREATE TABLE dbo.Dates (DayDate DATETIME, Month_Num SMALLINT, Month_Name VARCHAR(50), Year_Num SMALLINT, PRIMARY KEY (DayDate))
GO
INSERT INTO dbo.Dates (DayDate, Month_Num, Month_Name, Year_Num)
VALUES ('20130101', 1, 'Январь', 2013), ('20130201', 2, 'Февраль', 2013), ('20130301', 3, 'Март', 2013),
('20130401', 4, 'Апрель', 2013), ('20130501', 5, 'Май', 2013), ('20130601', 6, 'Июнь', 2013),
('20130701', 7, 'Июль', 2013), ('20130801', 8, 'Август', 2013), ('20130901', 9, 'Сентябрь', 2013),
('20131001', 10, 'Октябрь', 2013), ('20131101', 11, 'Ноябрь', 2013), ('20131201', 12, 'Декабрь', 2013)
GO
CREATE TABLE dbo.Regions (Region_Id INT, Region_Name VARCHAR(250), PRIMARY KEY (Region_Id))
GO
INSERT INTO dbo.Regions (Region_Id, Region_Name)
VALUES (1, 'Центральный'), (2, 'Северный'), (3, 'Южный'), (4, 'Западный'), (5, 'Восточный')
GO
CREATE TABLE dbo.SKU (SKU_Id INT, SKU_Name VARCHAR(250), PRIMARY KEY (SKU_Id))
GO
INSERT INTO dbo.SKU (SKU_Id, SKU_Name)
VALUES (1, 'Вино'), (2, 'Водка'), (3, 'Пиво'), (4, 'Коньяк'), (5, 'Виски'),
(6, 'Ликер'), (7, 'Ром'), (8, 'Шампанское'), (9, 'Текила'), (10, 'Абсент')
GO
CREATE TABLE dbo.Plan_Sale (DayDate DATETIME, Region_Id INT, SKU_Id INT, Sum_Sale MONEY, PRIMARY KEY (DayDate, Region_Id, SKU_Id))
GO
```
*Создаем куб.*
---
*Активируем для партиции Write Back, указываем источник данных и таблицу. Обрабатываем куб.*
*Вот так таблица будет выглядеть в БД:*
Ничего не меняйте в ее структуре – может поломаться обратная запись. В эту таблицу будут попадать изменения, корректирующие начальное значение. Для получения реального значения, данные из этой таблицы нужно сложить с данными исходной таблицы.
В качестве клиента используем Excel. До Excel версии 14.0 приходилось записывать данные с помощью макроса, или в версии 13.0 — надстройки (AddIn). Начиная с Excel 2010 возможность редактировать данные стала частью функционала. Поддерживается два режима записи данных: временная обратная запись (temporary writeback), также известная как Анализ Что Если (What If Analysis), и постоянная обратная запись (permanent writeback).
1. Подключите источник данных. В сводной таблице включите эти параметры
2. Находясь внутри сводной таблицы, которая подключена к кубу, нажмите вкладку **Работа со сводными таблицами**
3. Найдите группу **Анализ «что если»**
4. В этой группе есть элемент меню **Включить анализ «что если»**. При его включении появится возможность вносить данные в область данных сводной таблицы.
5. Вносимые Вами данные будут выделяться маркером в нижнем правом углу ячейки. Эти данные пока никуда не попадают и не влияют на остальные показатели в кубе.
6. 6. После внесения порции данных, в меню группы **Анализ «что если»** выберите **Учет изменений при расчете сводной таблицы** – все поля, которые зависят от вносимых Вами значений, обновятся (можно включить **Автоматически учесть изменения при расчете сводной таблицы**, тогда после каждого вносимого значения будет происходить обновление данных). Этот пункт можно пропускать и сразу публиковать изменения (п.6).
7. После того, как Вы учли изменения, нужно нажать **Опубликовать изменения**, иначе данные не попадут в таблицы постоянного хранения и будут потеряны. После публикации изменения, маркер в нижнем правом углу ячейки исчезнет, данные будут сохранены в базе данных.
*Посмотрим, что находится в нашей Write Back таблице в БД:*
##### Заключение
Распределение данных может быть более сложным, например: пользователь вводит данные на верхнем уровне иерархии, и данные распределяются на листовые элементы, используя коэффициенты, установленные в листовых элементах. Тут все будет зависеть от Вашей фантазии и поставленных задач.
Вот такой простой и главное привычный для простого пользователя инструмент бюджетирования. Легко использовать и быстро настраивать. Отвечу на все вопросы – пишите!
[Ссылка на используемые файлы](https://www.dropbox.com/sh/m14fu7joosq2u01/s7ywGALsDe). | https://habr.com/ru/post/198098/ | null | ru | null |
# Прототип голосового списка покупок для WP8, Win8, Android c бекендом в Azure за 2,5 часа
С 9 по 11 ноября проходил Windows 8 Хакатон RUWOWZAPP, куда я сначала зарегистрировался как участник, а потом удостоился чести присутствовать на мероприятии в качестве эксперта. Будучи в качестве эксперта я познакомиться со множеством замечательных людей и их проектов. Было настолько интересно что продолжал консультировать даже по ночам, и на сон оставалось 4-5 часов. Я настолько заразился позитивом и энергией и желанием людей создавать, что тоже не удержался от создания своего небольшого прототипа приложения — Списка покупок с поддержкой распознавания голоса.
За пару часов мне удалось сделать функциональный прототип, демонстрирующий идею приложения, с клиентами для WP, Win8, Android
Мне не хотелось участвовать в конкурсе приложений с таким сырым прототипом, но мне очень хотелось показать то что я сделал за пару часов, и в последний момент, перед выступлением последнего участника встал в очередь на выступление, и ведущий позволил мне продемонстрировать свои поделки:
Приложение вызвало большой интерес у участников хакатона и фактически это обещанная статья со всеми ответами на вопросы, на которые тогда у меня не хватило времени.
Для тех кто хочет сразу посмотреть код, исходники можно скачать [здесь](http://akhmed.ru/blogmaterials/sourcecode/voicegrocery.zip)
А остальных прошу под кат.
В отличие от этого видео во время выступления я очень торопился и не успел запустить android версию. Я ожидал что основной интерес будет к тому, как именно происходит распознавания голоса, но не ожидал такого большого интереса и ко всему остальному и за последующие полчаса пару десятков человек задавали самые разные вопросы по проекту, такие как: как именно происходит синхронизация, как происходит разбор команд, как писать под андроид, на чем сделана серверная часть и т.п. Я извиняюсь что тогда у меня не было возможности всем продемонстрировать исходники проекта и эта обещанная там статья, фактически, ответы на все вопросы что мне были заданы.
#### Идея приложения.
Фактически изначально я хотел наконец таки в деле попробовать распознавание голоса в WP8 которое стало доступна разработчикам. И мне хотелось сделать решение, которое бы дружило именно с русским языком.
Я остановился на следующем наборе команд:
**Купить [продукт]** – добавление продуктов в список
**Купил [продукт]** – установка галочек «куплено»
**Удалить [продукт]** – удаление продукта из списка
**Удалить список** – очистка списка
**Цена [продукт] [цена]** – установка цены
**[продукт] в магазине [магазин]** – указание магазина где можно купить продукт
Я посчитал что смогу сделать такое приложение для трех платформ за 6 часов, забегая вперед скажу что у меня оказалось меньше времени чем я рассчитывал и успел только первые 4 команды.
#### Распознавания голоса. – 1 час.
WP8 очень хорошо работает с английским языком и хорошо распознает даже для моего акцента. Но при этом оказалось что возможности распознавания на русском языке гораздо ограничено. Для русского языка WP8 распознавать только заранее заданный словарь. Убил на это примерно полчаса.
Мне очень хотелось сделать именно русский язык, и так как у меня был уже опыт работы с сервисами распознавания голоса, решил на время прикрутить какой нибудь коммерческий движок распознавания голоса. Однако с тех пор как я с ними работал последний раз у них ничего не изменилось и фактически ни у кого не было автоматизированного пробного или платного периода. И так как со всеми сервисами необходимо было общаться с менеджерами, решил прикрутить для демки распознавание голоса от гугла. Я специально поискал условия использования гугловского движка распознавания голоса и не смог найти, но помнил что где то видел что нельзя использовать в коммерческих целях (хотя, возможно, ошибаюсь). Огромное спасибо [Yakhnev](https://habrahabr.ru/users/yakhnev/) за прекрасную [статью](http://habrahabr.ru/post/117234/) с исходниками на C#. Понадобилось всего 10 минут для того что бы сделать из его десктопного проекта веб проект, с API для распознавания голоса. Но так как у приложения не было возможности сохранять файл на диске, а времени на переделывания распознавания в памяти не было, пришлось отказаться от бесплатного Web Role в Azure. Благо у меня уже было развернуто пара виртуалок в Azure, переделать и залить проект на сервер не составило никаких проблем. В итоге поднял сервис распознавания с точкой доступа [voice.akhmed.ru/recognize.ashx](http://voice.akhmed.ru/recognize.ashx) — куда POST Запросом заливаю WAV файл и на выходе получаю текст.
#### Приложение для WP7 – 30 минут
Больше всего времени понадобилось для приложения на WP7. Но только потому что эта платформа была тестовым полигоном и за время разработки постоянно менял код.
После того как поднял сервис распознавания голоса стал вопрос о распознавании голоса на устройстве.
Так как это был функциональный прототип, я решил выкинуть все лишнее, авторизация пользователей, обработка нажатий на кнопки, индикатор загрузки, повторная отправка, обработка ошибок (поэтому приложение может падать переодически), сохранение в БД, сохранение wav файлов и т.п.
Так как приложение надо было портировать еще и на андроид, решил прототип сделать без MVVM, поэтому получилась страшная каша кода.
Так как, теперь нам не надо было делать приложение именно под WP8 я решил сделать версию на WP7, что давало дополнительное преимущество – прототип работает на любом WP устройстве. Запись микрофона достаточно нетревиальная задача на WP7, но у меня уже была моя библиотека [WPExtensions](http://wpextensions.codeplex.com/) которая позволяла легко записать голос в WAV файл. В AppBar добавил одну фиктивную кнопку добавления в список записей руками и добавил кнопку с микрофоном, который при первом нажатии начинал запись, а при повторном нажатии отправлял запись на сервер и обрабатывал результат:
```
private bool isRecording = false;
private readonly MicrophoneWrapper microphone = new MicrophoneWrapper();
private void ApplicationBarRecordIconButton_Click(object sender, System.EventArgs e)
{
if (!isRecording)
{
microphone.Record();
PageTitle.Text= "Слушаю...";
}
else if (isRecording)
{
microphone.Stop();
var wav = microphone.GetWavContent();
Send(wav);
PageTitle.Text = defaultHeader;
}
isRecording = !isRecording;
}
```
Метод отправки тоже достаточно тривиален, в нем отправляю ответ на сервер и обрабатываю полученный ответ
```
private void Send(byte[] wav)
{
var client = new HttpWebClient();
client.Post("http://voice.akhmed.ru/recognize.ashx", wav, (result) => Dispatcher.BeginInvoke(() => ParseString(result)));
}
private void ParseString(string result)
{
logicLayer.Parse(result);
RefreshView();
}
```
Было очень много вопросов о том как именно осуществляется разбор команд, что за библиотеку использую для анализа текста, как фильтруются лишние слова типа «купить» или «и». Конечно в релизе надо делать гораздо более грамотное решение с морфологическим и синтаксическим анализом, но сейчас код до безобразия прост. Я просто использую первое слово в качестве команды и фильтрую все слова до двух букв.
```
public void Parse(string voiceText)
{
var words = voiceText.Split(new[]{' '}, StringSplitOptions.RemoveEmptyEntries);
if(words.Length>1)
{
var command = words.First();
if(command.Equals("купить"))
{
Add(words.Skip(1));
IncrementUpdate();
}
if(command.StartsWith("купил"))
{
SetBoughtStatusTrue(words.Skip(1));
IncrementUpdate();
}
if (command.Equals("удалить") || command.Equals("очистить"))
{
if (words[1].Equals("список"))
{
shopList.ShopItems.Clear();
}
else
{
RemoveShopListItems(words.Skip(1));
}
IncrementUpdate();
}
}
}
```
#### Бекенд приложения – 20 минут
Для того что бы обеспечить синхронизацию с другими устройствами, необходимо было сделать серверную часть. Конечно такой бекенд идеальный кандидат на размещение в Azure в качестве веб роли, но для прототипа можно было разместить на той же виртуалке в Azure, что и распознавание голоса. Так как у нас время сильно ограничено то имеет смысл сделать SOAP сервис, так как студия умеет генерировать быстро прокси на клиенте.
Сервис тоже прост до безобразия. У меня есть один список покупок, который я перенес с клиента на сервер (для клиента будет сгенерирован в прокси).
```
public class ShopList
{
public ShopList()
{
ShopItems=new List();
}
public List ShopItems { get; set; }
public int Version { get; set; }
}
public class ShopItem
{
public string Name { get; set; }
public decimal Price { get; set; }
public char Valute { get; set; }
public bool IsBought { get; set; }
}
```
Честно говоря два поля Price и Valute лишнее, так как я не успел их использовать, но привожу код «как есть».
Сохранение и получение списка тоже реализована очень просто
```
public class GroceryService : System.Web.Services.WebService
{
private LogicLayer logicLayer = new LogicLayer();
[WebMethod]
public ShopList GetVersion()
{
return logicLayer.GetShopList();
}
[WebMethod]
public void UploadVersion(ShopList request)
{
logicLayer.Update(request);
}
}
```
Конечно в релизе должно быть не полное обновление списка как есть а частичное обновление измененных данных, но для прототипа и так сгодится.
Логика тоже сделана очень просто до безобразия, так как это прототип, без БД с сохранением текущего значения в БД. Честно говоря и смысла не было в такой логике, но привожу «как есть». Имена методов неудачные но не стал менять.
```
public class LogicLayer
{
private static ShopList shopList = new ShopList();
public ShopList GetShopList()
{
return shopList;
}
internal void Update(ShopList newshopList)
{
shopList = newshopList;
}
}
```
В конечном итоге поднял этот сервис по адресу [voicegrocery.akhmed.ru/GroceryService.asmx](http://voicegrocery.akhmed.ru/GroceryService.asmx)
Теперь вопрос как доставлять обновления клиентам? Конечно же по PushNotification. Но его реализация могла отнять много времени, которого было в обрез и я сделал запрос с клиента в 5 секунд.
```
DispatcherTimer dispathcerTimer = new DispatcherTimer();
dispathcerTimer.Interval = TimeSpan.FromSeconds(5);
dispathcerTimer.Tick += dispathcerTimer_Tick;
dispathcerTimer.Start();
```
Логика обновления на/с клиента очень проста.
1. Если текущая версия меньше чем получено с сервера, текущий список заменяется серверным.
2. Если на клиенте происходит какое то изменение, то версия увеличивается на 1 и отправляется на сервер.
```
void dispathcerTimer_Tick(object sender, System.EventArgs e)
{
var client = new ServiceReference1.GroceryServiceSoapClient();
client.GetVersionCompleted += client_GetVersionCompleted;
client.GetVersionAsync();
}
void client_GetVersionCompleted(object sender, ServiceReference1.GetVersionCompletedEventArgs e)
{
if (e.Result.Version > logicLayer.GetVersion())
{
logicLayer.UpdateShopList(e.Result);
RefreshView();
}
}
private void IncrementUpdate()
{
var shopListItem = new ShopList()
{
Version = shopList.Version + 1,
ShopItems = shopList.ShopItems
};
var client = new ServiceReference1.GroceryServiceSoapClient();
client.UploadVersionAsync(shopListItem);
}
```
#### Портирование на Windows 8 – 10 минут.
Портирование приложения на Win8 получилось очень просто. Я не стал реализовывать распознавание голоса на клиенте и получилось одностороняя синхронизация. XAML был скопирован практически без изменений, немножко пришлось подправить код отправки на сервер. Стал чуть проще – в один метод
```
async void dispathcerTimer_Tick(object sender, object e)
{
var client = new ServiceReference1.GroceryServiceSoapClient();
var result = await client.GetVersionAsync();
if (result.Body.GetVersionResult.Version > logicLayer.GetVersion())
{
logicLayer.UpdateShopList(result.Body.GetVersionResult);
RefreshView();
}
}
```
#### Портирование приложения на Android – 15 минут.
Я обожаю платформу моно. Код остался практически без изменений, осталось подправить UI. Так как для Android-а представление делать значительно сложнее, я не стал тратить много времени на создание кастомного адаптера и после 5 минут откатился и сделал простой текстовый список с текстовыми крестиком в скобках:
```
void client_GetVersionCompleted(object sender, ru.akhmed.voicegrocery.GetVersionCompletedEventArgs e)
{
try
{
list.Clear();
var result = e.Result.ShopItems;
foreach (var item in result)
{
var checkBox = item.IsBought ? "( X ) " : "( ) ";
list.Add(checkBox + item.Name);
}
this.RunOnUiThread(() =>
{
this.ListAdapter = new ArrayAdapter(this, Resource.Layout.ListItem, list);
((BaseAdapter)this.ListAdapter).NotifyDataSetChanged();
});
}
catch (Exception)
{
}
}
```
#### Портирование на iOS — отсутствует
Конечно же я думал о том что бы портировать на iOS, но так как у меня не было i-устройств ~~а хакинтошами, который я использую в домашней разработке показывать на таких мероприятиях некорректно~~ и было очень мало времени отложил эту идею. ~~Тем более на ноуте с собой у меня хакинтоша не было~~
#### Итоги
Если не учитывать 40 минут которые были потрачены на исследования возможностей платформы WP8, то чуть менее чем за 2 часа с учетом затрат на заливку на сервер и мелкие багфиксы был реализован полноценный прототип, который показывает основную идею приложения и не жалко выкинуть и приступить к полноценной реализации.
Конечно код получился очень грязный, неоптимальный, с кучей недостатков и недоделанных фич. Но функциональные прототипы как раз нужны для того что бы на «бумажном эскизе» — на черновике показать заказчику/начальству продукт который получится на выходе. | https://habr.com/ru/post/158481/ | null | ru | null |
# Немножко про автоматизацию тестирования API
Тестирование сетевых приложений разделяется на несколько взаимосвязанных этапов и значительно зависит от корректности работы API. Нередко API публикует большое количество методов, манипулирующих объектами хранилища данных, часть из которых защищено механизмами авторизации. Тесты включают в себя последовательность операций по созданию-изменению-удалению объектов и могут состоять из большого количества запросов, которые предпочтительно проверять без участия тестировщика. В этой статье мы обсудим различные подходы к автоматизации тестов API с использованием Postman, Rest Assured и Karate DSL.
Начнем мы с наиболее известного инструмента для взаимодействия с API - [Postman](https://www.postman.com/). Обычно он используется для ручного выполнения запросов к API. При создании запроса могут использоваться переменные и окружение (определяются для коллекции или отдельного запроса). Но также сейчас возможно определение сценарных тестов с использованием встроенного интерпретатора, который может работать с преднастроенным объектом pm для извлечения значения переменных и выполнения запросов.
Создадим новое рабочее пространство (File -> New -> Workspace) и коллекцию (File -> New -> Collection). Обратите внимание, что при создании коллекции доступна вкладка Tests, где определяется сценарий, который будет выполняться после каждого запроса в коллекции.
Создание теста в PostmanДля выполнения запросов используется метод pm.sendRequest(url, function(err, response) { ... });, где в функцию передает объект с информацией об ответе сервере или объект описания ошибки. Для проверки выполнения условия можно использовать функцию `pm.test("message", function () { выражение })`, внутри которого может находиться `pm.expect()` для проверки условия внутри теста. Выражение записывается в виде фразы `<объект>.to.<условие>.<ожидаемое значение>`, например, `response.to.have.status(200)` или `except(response.text()).to.eql('OK')`. Содержимое ответа может быть извлечено из response.text() или response.json() и проверено через `pm.test` / `pm.expect`. Также есть доступ к переменным окружения (pm.environment), переменным коллекции (`pm.collectionVariables`), локальным переменным (`pm.variables`). В остальном код сценария может использовать все возможности JavaScript (функции, условные операторы, циклы, ...), в том числе вывод сообщений в консоль (она доступна в Postman через меню `View -> Show postman console`).
При определении запроса все тесты запускаются после выполнения запроса. При этом сценарий запроса может сохраняться промежуточные значения в `pm.environment` и передавать их в следующий запрос из коллекции или группы. Результаты запроса доступны в `pm.response`.
Для запуска тестов в контекстном меню коллекции необходимо выбрать Run collection, указать количество итераций и промежуток между ними. Результатом выполнения будет информация об итогам выполнения запросов в итерациях и отчет об успешности прохождения.
Для проверки создадим простой тест для Date Nager API (возвращает информацию о праздниках во многих странах мира). Для получения JSON-ответа обратимся к адресу <https://date.nager.at/api/v3/publicholidays/2017/RU> и проверим наличие праздника "Новый год" в ответе. Создадим GET-запрос к адресу и во вкладке Tests добавим следующий код:
```
pm.test("Status code is 200", function () {
pm.response.to.have.status(200);
});
pm.test("Response time is less than 400ms", function () {
pm.expect(pm.response.responseTime).to.be.below(400);
});
pm.test("Response have new year", function() {
const responseJson = pm.response.json();
pm.expect(responseJson[0].localName).to.eql("Новый год");
});
```
После запуска запроса (или всей коллекции) получим результат выполнения:
Результаты тестаДля обращения к методам, защищенным токеном авторизации, можно использовать привычные способы управления заголовками запроса в Postman.
Теперь перейдем к более специализированным инструментам и поговорим про Rest Assured. Код для Rest Assured создается на Java, каждый тест - это отдельная функция с аннотацией @Test, которая состоит из двух частей:
* when() - цепочка вызовов, создающая необходимый контекст, например, get("url")
* then() - цепочка проверок (statusCode проверяет код ответа, body("path", equalTo("значение") проверяет значение поля json-объекта или XML-структуры).
Например, наш тест в Rest Assured выглядел бы так:
```
@Test
public void testNewYear() {
when().get("https://date.nager.at/api/v3/publicholidays/2017/RU").
then().statusCode(200).body("[0].localName", equalTo("Новый год"))
}
```
Главное преимущество RestAssured в том, что она является полноценной java-библиотекой и позволяет выполнять сложную обработку полученных данных, а также встраиваться в существующие Java-Kotlin приложения (непосредственно в задачу запуска автоматических тестов, например через JUnit).
Последняя библиотека, которую мы сегодня посмотрим - Karate DSL. Ее возможности обширны и выходят далеко за рамки сценарного тестирования API, но сейчас мы обсудим только возможности по созданию тестов API. Сценарий для Karate DSL создается в виде текстового документа, определяющего спецификацию теста из выражение Given (определение переменных), When (определение запроса), Then (условия проверки). В нашем случае описание могло бы выглядеть следующим образом:
```
Scenario: Test Date Nager API
Given url 'https://date.nager.at/api/v3/publicholidays/2017/RU'
When method get
Then status 200
And match response[0].localName == 'Новый год'
```
Тест может быть интегрирован в JUnit, а также выполнен через автономный [jar-файл](https://github.com/karatelabs/karate/tree/master/karate-netty#standalone-jar) или через [расширение](https://marketplace.visualstudio.com/items?itemName=kirkslota.karate-runner) Visual Studio Code. Для запуска теста достаточно передать название feature-файла (`java -jar karate.jar datetest.feature`). Отчет о результате прохождения теста будет отображен в консоли и также будет установлено значение кода возврата в 0 (при успешном выполнении) или код ошибки, что позволяет использовать Karate DSL при автоматическом запуске тестов в CI/CD.
Как составить баг-репорт, чтобы коллеги сказали вам спасибо? Об этом и не только мои коллеги из OTUS расскажут на бесплатном уроке, который пройдет уже 10 августа. [Регистрация на урок доступна по ссылке](https://otus.pw/2Tny/). | https://habr.com/ru/post/681450/ | null | ru | null |
# NodeConf EU 2013 — впечатления
[Nodeconf.eu](http://nodeconf.eu/) в этом году проходила с 9 по 11 сентября, в городке Waterford, на юге Ирландии. Это одна из немногих конференций которая проходит в Европе и полностью посвящена Node.JS. Презентации проходили в центре города, а практические занятия закрепляющие выступления проводились на острове скромно названном (на время проведения мероприятия) Nodeland. Всего участвовало 140 человек. В этом посте я собрал материалы с конференции, а также свои впечатления.
#### Node.JS в индустрии
Большую роль получили выступления связанные с использованием Node.JS в индустрии. Ben Acker (@nvcexploder) из Walmart, Jacek Korycki из Skype, Clifton Cunningham (@clifcunn) из Mail Online, а также Bill Scott (@billwscott) из PayPal рассказывали что начали внедрять Node.JS чтобы частисто заменить старый стек программного обеспечения, который обычно состоит из огромных backend систем обычно написанных в Java.
Dav Glass из Yahoo показал какие инструменты команды используют (и пишут) во время разработки ([презентация](http://www.slideshare.net/davglass/node-confeu)). У меня создалось впечатление, что главной целью таких презентаций было заманивание девелоперов под свою крышу, что является обычным делом на такого рода мероприятиях.
#### Будущее асинхронного программирования в Node
Bert Belder (@piscisaureus), один из разработчиков Node.JS выступил с амбициозным проектом [Future of asynchronous programming in node](http://nujs.github.io/nodeland-2013/#/), где поделился мнением каким образом можно было бы решить вопрос long stacktraces. Для программиста с прошлым из Enterprise Java это больной вопрос, когда не знаешь какой же метод вызвал коллбэк в котором произошел сбой.
#### LevelDB
Rod Vagg (@rvagg) рассказал о эволюции баз данных в презентации [A Real Database Rethink](http://r.va.gg/presentations/nodeconfeu.2013/)
Max Ogden (@MaxOgden) представил свое видение работы с бинарными данными: [Working with binary + multidimensional data in JavaScript](http://maxogden.github.io/slides/nodeconfeu/#0). Некоторые называют LevelDB аналогом Node.JS для баз данных, ввиду минималичности, модулярности и простоты.
#### Сообщества (communities)
Isaac Schlueter (@izs) выступил в заключительной презентации [Compassionate Communities](https://dl.dropboxusercontent.com/u/3685/presentations/compassionate-communities/index.html) на тему каким образом строится эффективное и неконфликтующее Open Source сообщество. Выступление было встречено на ура.
#### Разное
Также на конференции выступали следующие спикеры:
Dominic Tarr (@dominictarr)
Paolo Fragomeni (@hij1nx)
Jake Verbaten (@raynos)
Trevor Norris (@trevnorris)
Richard Rodger (@rjrodger)
Emily Rose (@nexxylove)
Elijah Insua (@tmpvar)
Matteo Collina (@matteocollina)
James Halliday (@SubStack)
#### Практические занятия — LevelDB
[Самоучитель по levelup](https://github.com/rvagg/levelmeup)
Просто установите модуль из **npm** и запустите **levelmeup**
`npm install levelmeup -g`
`levelmeup`
Затем следуйте инструкции — начиная от простейших операций с levelup, заканчивая написанием сложных запросов к базе.
Такой подход немного похож на различные Koans (например [Scalakoans](http://www.scalakoans.org/), [Rubykoans](http://www.rubykoans.com/))
#### Практические занятия — Debugging
Max Bruning (@mrbruning) из Joyent показал использование Dtrace и mdb: [Example Debugging Session Using DTrace and mdb](https://github.com/max123/nodeconfeu).
#### Итоги
Я буду добавлять недостающие материалы как только найду. Если есть вопросы — прошу задавать в комментариях.
**EDIT:** добавил слайды о DTrace и mdb | https://habr.com/ru/post/193752/ | null | ru | null |
# Что вошло в релиз движка V8 версии 9.0
17 марта 2021 был опубликован релиз девятой версии движка V8. Этот пост - краткое описание того что вошло в список изменений релиза.
Оригинальный пост [V8 release v9.0](https://v8.dev/blog/v8-release-90)
### JavaScript
#### Индексы соответствия (match indices) в RegExp
Начиная с версии 9.0, разработчики могут получать массив начальных и конечных позиций, совпадающих c группами захвата, соответствующих регулярному выражению. Этот массив доступен через свойство `.indices` для объектов сопоставления, если регулярное выражение имеет флаг `/ d`.
```
const re = /(a)(b)/d; // Note the /d flag.
const m = re.exec('ab');
console.log(m.indices[0]); // Index 0 is the whole match.
// → [0, 2]
console.log(m.indices[1]); // Index 1 is the 1st capture group.
// → [0, 1]
console.log(m.indices[2]); // Index 2 is the 2nd capture group.
// → [1, 2]
```
Более подробное описание по [ссылке](https://v8.dev/features/regexp-match-indices)
#### Более быстрый доступ к свойствам через функцию super
Доступ к свойствам через функцию `super` (например, `super.x`) был оптимизирован за счет использования встроенной системы кеширования V8 и оптимизированной генерации кода в TurboFan. С этими изменениями, доступ к свойствам через функцию `super`, теперь ближе к тому, чтобы быть наравне с обычным доступом к свойствам, как видно из графиков ниже.
Детальное описание находится по [ссылке](https://v8.dev/blog/fast-super)
#### Запрет конструкции "for ( async of "
Была обнаружена и исправленна в V8 v9.0, [грамматическая неточность](https://chromium-review.googlesource.com/c/v8/v8/+/2683221). Теперь конструкция `for ( async of` не парсится больше.
### WebAssembly
#### Более быстрые вызовы в JS-to-Wasm
V8 использует разные представления для параметров функций WebAssembly и JavaScript. По этой причине, когда JavaScript вызывает экспортированную функцию WebAssembly, вызов проходит через так называемую оболочку JS-to-Wasm, отвечающую за адаптацию параметров из области JavaScript в область WebAssembly, а также адаптацию результатов вызова, в противоположном направлении.
К сожалению, это приводит к снижению производительности, а это означает, что вызовы из JavaScript в WebAssembly были не такими быстрыми, как вызовы из JavaScript в JavaScript. Чтобы свести к минимуму эти проблемы перфоманса, оболочка JS-to-Wasm теперь может быть встроена в место вызова., упрощая код и удаляя этот лишний фрейм.
Допустим, у нас есть функция WebAssembly, которая складывает два числа с плавающей запятой двойной точности, например:
```
double addNumbers(double x, double y) {
return x + y;
}
```
и например, мы вызывем эту функцию в JavaScript, чтобы сложить несколько векторов (представленных в виде типизированных массивов):
```
const addNumbers = instance.exports.addNumbers;
function vectorSum(len, v1, v2) {
const result = new Float64Array(len);
for (let i = 0; i < len; i++) {
result[i] = addNumbers(v1[i], v2[i]);
}
return result;
}
const N = 100_000_000;
const v1 = new Float64Array(N);
const v2 = new Float64Array(N);
for (let i = 0; i < N; i++) {
v1[i] = Math.random();
v2[i] = Math.random();
}
// Warm up.
for (let i = 0; i < 5; i++) {
vectorSum(N, v1, v2);
}
// Measure.
console.time();
const result = vectorSum(N, v1, v2);
console.timeEnd();
```
Эта функция все еще является экспериментальной, и ее можно включить с помощью флага `--turbo-inline-js-wasm-calls`.
Подробнее см. [дизайн документ](https://docs.google.com/document/d/1mXxYnYN77tK-R1JOVo6tFG3jNpMzfueQN1Zp5h3r9aM/edit). | https://habr.com/ru/post/555420/ | null | ru | null |
# Пишем сложное приложение на knockoutjs
Есть такая библиотека [knockout.js](http://www.knockoutjs.com). Она отличается от прочих [хорошим туториалом для начинающих](http://learn.knockoutjs.com/) и кучей понятных рабочих [примеров](http://knockoutjs.com/examples/). Еще там стройная MVVM модель, декларативные связи и так далее.
Короче, если вы, как и я, поиграли с этой библиотекой, понаписали красивых формочек, и вам это понравилось, то все это дело захотелось применить на реальном проекте. И тут проблема — в реальном проекте формочек больше чем одна. А раз такие инструменты, то хочется [single web page application](http://en.wikipedia.org/wiki/Single-page_application) и никак иначе. А делать один контроллер и все темплейты заверстывать на одну страницу тоже тупо и тормозно.
Под катом приведу основу своего сложного приложения. Само оно совсем не сложное, но модульное и допускает расширения, а темплейты и модели подгружаются динамически. Идея была подсмотрена в этой презентации — <http://www.knockmeout.net/2012/08/thatconference-2012-session.html>, код презентации выложен на github — <https://github.com/rniemeyer/SamplePresentation> — на базе этого кода будем писать свой.
##### Отступление
Вначале я упомянул про заверстывание нескольких форм на одну страницу — это не наш метод, но вполне нормальное решение. Пример небольшого single page application из двух заменяемых шаблонов можно найти в туториале прямо на родном сайте — <http://learn.knockoutjs.com/#/?tutorial=webmail>.
##### Еще отступление
Некоторые ругают knockout за его синтаксис, за идею об объявлении связей прямо в html-шаблоне в аттрибутах data-bind="...". Мол это похоже на возвращение в 90-е с вставками javascript-кода в onclick="..". Да еще все работает через eval. Претензии обоснованы — можно задолбаться отлаживать биндинг типа Борьба за чистоту html-кода обширно рассмотрена в этой статье — <http://www.knockmeout.net/2011/08/simplifying-and-cleaning-up-views-in.html>. Нужно использовать dependentObservable, делать custom-bindings, избегать анонимных функций. Можно написать свой bindingProvider или использовать этот <https://github.com/rniemeyer/knockout-classBindingProvider>.
##### Цель
Если писать реальное приложение, взяв за базу примеры из knockout-а, получаются огромные монолитные модели, и может быть непонятно, как их развивать и отлаживать. Главная цель моего примера — показать один из способов разбиения кода на обозримые куски.
Опишу, что будем иметь в итоге. У нас будут шаблоны в html-файликах в папке templates и knockout-js обвязка в соответствующих файликах в папке modules. При определенных действиях будет запускаться метод, который в нужный див с помощью require.js будет подгружать шаблон и код. Итоговый код примера лежит здесь: <https://github.com/Kasheftin/ko-test>.
##### StringTemplateEngine
Knockoutjs из коробки поддерживает два способа работы с шаблонами — [безымянный и именованный](http://knockoutjs.com/documentation/template-binding.html). Примеры:
```
// безымянный
// код шаблона
-
// именованный
// код шаблона
<h3 data-bind="text: name"></h3>
<p>Credits: <span data-bind="text: credits"></span></p>
```
Во всех случаях шаблоны — куски уже имеющегося dom-дерева. В нашем случае код будет приходить с сервера в виде строки, и самое органичное решение — написать свой template engine. Почерпнуть теорию можно из этой статьи, <http://www.knockmeout.net/2011/10/ko-13-preview-part-3-template-sources.html>. Есть, вероятно, хорошее готовое решение <https://github.com/ifandelse/Knockout.js-External-Template-Engine>, но мы напишем свое на основе той презентации, о которой написал вначале.
Здесь код stringTemplateEngine из презентации — <https://github.com/rniemeyer/SamplePresentation/blob/master/js/stringTemplateEngine.js>. Что не нравится: используется глобальный массив ko.templates, в который записываются загруженные шаблоны, и шаблонам нужно придумывать имена, по которым они вызываются. Мы не будем использовать этот массив, благо кешированием занимается require.js. Наш stringTemplateEngine будет вызываться примерно так:
```
```
То есть если указано свойство html, то вызывается наш stringTemplateEngine, в другом случае отдаем на выполнение в стандартный knockout. currentState — это объект, который должен иметь свойства html с html-кодом и возможно data с объектом-модулем.
Итак, делаем новый templateSource:
```
ko.templateSources.stringTemplate = function(element,html) {
this.domElement = element;
this.html = ko.utils.unwrapObservable(html);
}
ko.templateSources.stringTemplate.prototype.text = function() {
if (arguments.length == 0)
return this.html;
this.html = ko.utils.unwrapObservable(arguments[0]);
}
```
И переопределяем метод makeTemplateSource из объекта nativeTemplateEngine. Пока что никаких велосипедов — о переопределении makeTemplateSource написано в документации. Однако встроенный makeTemplateSource на вход принимает только template и templateDocument, где template — это имя шаблона, если оно есть, и ссылка на текущий dom в другом случае. Беспорядок со смешением типов — это не удачное решение. К тому же для подключения своего StringTemplateEngine нам нужно проверять не аттрибут name, а аттрибут html. Этих данных нет, но они приходят в метод renderTemplate, поэтому переопределим его тоже:
```
var engine = new ko.nativeTemplateEngine();
// Здесь переопределяем renderTemplate - запихиваем в makeTemplateSource все что имеем
engine.renderTemplate = function(template,bindingContext,options,templateDocument) {
var templateSource = this.makeTemplateSource(template, templateDocument, bindingContext, options);
return this.renderTemplateSource(templateSource, bindingContext, options);
}
// Частичный копипаст, новые только 2 строки
engine.makeTemplateSource = function(template, templateDocument, bindingContext, options) {
// Именованный engine стандартного knockout-а
if (typeof template == "string") {
templateDocument = templateDocument || document;
var elem = templateDocument.getElementById(template);
if (!elem)
throw new Error("Cannot find template with ID " + template);
return new ko.templateSources.domElement(elem);
}
// Наш stringTemplateEngine, используем options
else if (options && options.html) {
return new ko.templateSources.stringTemplate(template,options.html);
}
else if ((template.nodeType == 1) || (template.nodeType == 8)) {
// Анонимный engine из стандартного knockout-а
return new ko.templateSources.anonymousTemplate(template);
}
else
throw new Error("Unknown template type: " + template);
}
ko.setTemplateEngine(engine);
```
Переопределение renderTemplate не ломает knockout, потому что makeTemplateSource вызывается только в нем и еще в одном методе rewriteTemplate, описанном здесь: <https://github.com/SteveSanderson/knockout/blob/master/src/templating/templateEngine.js>. Однако последний не вызывается, поскольку в [nativeTemplateEngine](https://github.com/SteveSanderson/knockout/blob/master/src/templating/native/nativeTemplateEngine.js) установлено allowTemplateRewriting=false.
Полный код нашего stringTemplateEngine можно посмотреть здесь: <https://github.com/Kasheftin/ko-test/blob/master/js/stringTemplateEngine.js>.
##### State.js
Теперь будем писать [state.js](https://github.com/Kasheftin/ko-test/blob/master/js/state.js) — это объект, который при инициализации будет грузить указанный шаблон и модуль. Наши state-ы будут вложенными друг в друга, поэтому само приложение тоже будет state-ом, в него будет вложен state с меню, которое будет грузить другие state-ы c формами и данными.
```
define(["knockout","text"],function(ko) {
return function(file,callback) {
var s = this;
s.callback = callback;
s.data = ko.observable(null);
s.html = ko.observable(null);
require(["/js/modules/" + file + ".js","text!/js/templates/" + file + ".html"],function(Module,html) {
s.data(typeof Module === "function" ? new Module(s) : Module);
s.html(html);
if (s.callback && typeof s.callback === "function")
s.callback(s);
});
s.setVar = function(i,v) {
var data = s.data();
data[i] = v;
s.data(data);
}
}
});
```
Это весь код. AMD-скрипт, используем knockout и [text-плагин require.js](https://github.com/requirejs/text) для загрузки html-шаблонов. На вход — имя файла и callback-метод, внутри две observable-переменных data и html, те самые, которые требуются в нашем stringTemplateEngine. Еще вынесен метод setVar — несколько state-ов живут на странице одновременно, они должны обмениваться данными. Как правило в setVar будет передаваться ссылка на корневой state, и оттуда будет все доставаться.
##### Main.js
HTML-код главной страницы состоит из пары строк:
```
```
Пишем главный файл, который будет исполняться после загрузки страницы и require.js:
```
require(["knockout","state","stringTemplateEngine"], function(ko,State) {
var sm = new State("app",function(state) {
ko.applyBindings(state);
});
});
```
##### App.js, App.html
Я уже писал, что само приложение — это тоже state. Все друг в друга вложено. Страница состоит из меню и контента. Так вот html-код разметки страницы находится в templates/app.html, а инициализация меню и контента — в modules/app.js:
```
// templates/app.html:
Menu
```
```
// modules/app.js:
define(["knockout","state"],function(ko,State) {
return function() {
var app = this;
this.menu = new State("menu",function(state) {
// здесь, в callback-е, прописываем ссылку на app, чтобы app было доступно из меню и вложенных state-ов
state.setVar("app",app);
});
this.currentState = ko.observable(null);
}
});
```
##### Menu.js, Menu.html
Приведу еще пример меню. При клике на ссылки меняется содержимое другого state-а, переменной currentState, которая лежит в state-е app. Доступ к ней имеется потому, что app был отправлен в setVar при инициализации меню.
```
// menu.html
* [Hello World](javascript:void(0);)
* [Click counter](javascript:void(0);)
* [Simple list](javascript:void(0);)
...
```
```
// menu.js:
define(["jquery","knockout","state"],function($,ko,State) {
return function() {
var menu = this;
this.gotoSample = function(obj,e) {
var sampleId = $(e.target).attr("data-id");
var newState = new State("samples/sample" + sampleId,function(state) {
state.setVar("app",menu.app);
// здесь используется ссылка на app.currentState, т.е. меню изменяет observable-переменную currentState, которая лежит уровнем выше
menu.app.currentState(state);
});
}
}
});
```
На этом все. Код на модули уже разбит. Страницы примеров с разными формочками копипастнуты из [live examples](http://knockoutjs.com/examples/), только оформлены в amd-форме. Потом это все нагружается инициализациями, ajax-ами, но это уже «локальные» детали, которые лежат в state-ах.
Еще раз дам ссылку на конечный код примера — <https://github.com/Kasheftin/ko-test>. | https://habr.com/ru/post/154003/ | null | ru | null |
# Десктопные приложения на JavaScript. Часть 1
Ни для кого не секрет, что в наше время *JavaScript* стал одним из самых популярных языков программирования. В далекие 90е годы, в момент зарождения языка, когда он был создан с единственной целью добавить интерактивность веб страницам и улучшить процесс взаимодействия с пользователем, кто бы мог подумать, что он достигнет столь небывалых высот. Ведь сейчас на нем можно делать практически все что угодно. Хотите написать сайт: и бэкэнд и фронтэнд на JavaScript? пожалуйста! Хотите написать мобильное приложение на JavaScript? нет проблем. Программируете микроконтроллер – и тут вам на помощь придет JavaScript.
Есть конечно небольшие минусы в подходе использования JavaScript везде, но если поразмыслить, то сколько времени и сил можно сэкономить, изучив всего лишь одни язык, особенно, если то же самое приложение должно работать на разных платформах. Разных платформах говорите? Хм… Точно – разных платформах – теперь JS может позволить себе десктопные приложения для Windows, Linux, Mac, как спросите вы? Ответ прост: встречайте – *NW.js*.
По первым буквам можно прочитать – *Node.js + Webkit*, если данные понятия вам пока не знакомы, то скоро вы поймете о чем идет речь.
**Node.js** – программная платформа, основанная на движке V8, который транслирует наш скрипт в машинный код. Данная платформа была создана в 2009 году преимущественно для работы с бэкэндом сайтов.
**WebKit** — свободный движок, разработанный компанией Apple. Впервые был анонсирован в составе Safari в 2003 году
Итак, коду, написанному на JS для данной технологии, будут доступны как Node.js модули, так и стандартный браузерный API (соответственно WebKit)
### Быстрый старт
Все это конечно хорошо, но с чего же начать? На github можно найти и скачать [репозиторий с исходным кодом](https://github.com/nwjs/nw.js). Так же здесь можно найти прямые ссылки для скачивания под ту платформу, на которой будет вестись разработка. Помимо прочего нам понадобится установленная [node.js](https://nodejs.org).
После того, как необходимое ПО скачано и установлено, вы написали свое приложение на любимом JS (как это сделать читайте далее) и локализовали все в одну папку. Полдела сделано, теперь остается самое сложное и долгое – упаковать все в один файл и [подготовить для распространения](https://github.com/nwjs/nw.js/wiki/How-to-package-and-distribute-your-apps). Для упрощения вы можете воспользоваться готовыми библиотеками, например [nw-builder](https://github.com/nwjs/nw-builder). Установка библиотеки не составит труда, если вы уже работали с node.js. Как известно, в состав node.js входит *менеджер пакетов npm*, с которым нужно работать из командной строки. Для того, чтобы поставить какую-либо библиотеку, необходимо выполнить команду:
```
> npm install [имя_библиотеки] [опции]
```
Обратите внимание, что библиотеку можно ставить, как локально, так и глобально, для локальной установки используйте опцию *--save-dev*, для глобальной *-g*. Таким образом поставим наш сборщик для NW.js глобально, выполнив команду:
```
> npm install nw-builder -g
```
Для того, чтобы собрать наше приложение, необходимо выполнить команду (с большим количеством опций можно ознакомиться в [документации](https://github.com/nwjs/nw-builder)):
```
> nwbuild -p [имя_платформы] -o [путь_к_папке_для_собранной_версии] [путь_до_приложения]
```
В качестве имени платформы могут быть следующие значения: *win32, win64, osx32, osx64, linux32, linux64*.
Во время разработки нет нужды каждый раз собирать приложение, можно просто запустить его как есть и оно откроется в отдельном окне. Для этого нужно запустить приложение nw.exe из командной строки и передать в качестве параметров путь к папке с вашим приложением. Кроме того, если вы работаете под Windows, можно просто методом drag-n-drop перетащить папку с исходным кодом приложения на JS (обратите внимание, что именно папку целиком) в nw.exe.
### Hello, world!
Теперь, когда вы знаете, как запустить приложение, как собрать его в один файл, давайте напишем что-нибудь. По традиции знакомство с новой платформой начинается с написания приложения Hello, world.
Для данного приложения, нам даже не понадобится *JavaScript*, только *HTML*. Создадим папку с названием *HelloWorld*. Поместим внутрь файл *index.html* со следующей разметкой:
```
Hello, world
Hello, world, from NW.js
```
Кроме того для каждого приложения под NW.js необходим файл, который обязательно должен называться **package.json**. Из него будет браться информация для построения приложения. Создадим простейший вариант файла и поместим в папку *HelloWorld*. Итак:
```
{
"name": "hello-world",
"version": "1.0.0",
"description": "First application",
"main": "index.html",
"author": "Developer",
"window": {
"toolbar": false,
"width": 500,
"height": 200
}
}
```
Содержимое файла понятно без пояснений (обратите внимание, что обязательные поля только main и name). В **main** необходимо записать файл с разметкой, который будет являться точкой входа в приложение. Секция **window** настраивает параметры окна (в данном случае мы отключаем панель инструментов и задаем размеры окна 500x200).
Кроме того, можно настроить такие поля как (за полным списком опций обращайтесь в [документацию](https://github.com/nwjs/nw.js/wiki/Manifest-format)):
* **icon** – указываем путь до иконки (переопределить стандартную)
* **position** – можно указать позицию окна при загрузке (*null*, *center* или *mouse*)
* **min\_width**, **min\_height**, **max\_width**, **max\_height** – ограничение размеров окна
* **resizable** – логическое значение, которое показывает можно ли пользователю изменять размеры окна
* **fullscreen** – включить полноэкранный режим
* **kiosk** – включить режим киоска
* **transparent** – сделать окно прозрачным
Приложение создано и можно его запустить. После запуска (о том как это сделать, смотри раздел выше) вы должны получить следующее окно:
Приложение написано, но в нем всего один div элемент и совсем нет логики, а что делать, если у нас богатая на элементы разметка и сложная логика? На помощь к нам приходит элемент конфигурационного файла **toolbar**, который мы установили в false. Для того, чтобы сделать доступными средства отладки, необходимо установить toolbar в true. Проделав это при запуске приложения мы получим следующее окно:
После нажатия на кнопку в верхнем правом углу откроется еще одно окно, в котором будут отображены знакомые инструменты разработчика:
### Работа с нативными контролами
NW.js позволяет работать с нативными контролами. Рассмотрим работу на примере **меню**. Для работы с нативным UI контролами в nw.js необходимо использовать модуль **nw.gui**, который можно подключить следующим образом:
```
var gui = require('nw.gui');
```
Общий шаблон для использования контролов:
```
var element = new gui.ElementName(option);
```
Таким образом для создания элементов меню можно воспользоваться следующей конструкцией:
```
var menu = new gui.Menu();
```
Кроме того любые свойства созданного нами объекта можно легко изменить стандартными конструкциями JS, например так:
```
menu.title = 'New Title';
```
Меню создано, теперь нужно его заполнить, для манипуляции дочерними элементами существуют методы:
```
menu.append(new gui.MenuItem({label: 'Label of menu item'}));
menu.removeAt(0);
```
Кроме того для более гибкого добавления элементов в menu можно воспользоваться методом **insert**, в параметрах которого необходимо передать *MenuItem* и номер позиции, куда его вставить (*позиция перед первым элементом соответствует 0*).
Для доступа к созданным элементам можно использовать свойство **items**:
```
menu.items[0].title = "New title"
```
Обратите внимание, что нельзя напрямую создавать элементы:
```
menu.items[2] = new gui.MenuItem(); // НЕПРАВИЛЬНО
```
Самое главное при работе с нативными контролами, это помнить, что любая ошибка при работе с ними может привести к краху всего приложения, поэтому необходимо быть крайне внимательными и по возможности при удалении элементов, также присваивать переменной значение null. Таким образом *для удаления контрола*, можно выполнить следующее:
```
control.remove();
control = null;
```
Для более удобной работы с контролами, они унаследованы от [EventEmitter](https://nodejs.org/api/events.html), поэтому хорошая новость в том, что мы можем легко работать с событиями, например так:
```
menuitem.on('click', function() {
// сделать что-нибудь полезное
});
```
Меню было создано, но если запустить приложение, то никакого меню вы не увидите. Для отображения меню существует метод popup, в параметрах которого необходимо передать координаты для отображения меню.
Для демонстрации основных возможностей меню добавьте следующий скрипт к созданному ранее проекту *Hello, world*:
```
var gui = require('nw.gui');
var menu1 = new gui.Menu();
menu1.append(new gui.MenuItem({label: 'Item 1'}));
var subMenu1 = new gui.Menu();
subMenu1.append(new gui.MenuItem({label: 'Item 2'}));
menu1.append(new gui.MenuItem({
label: "Submenu",
submenu: subMenu1
}));
document.body.addEventListener('contextmenu', function(ev) {
ev.preventDefault();
menu1.popup(ev.x, ev.y);
return false;
});
```
После запуска приложения, мы можем увидеть созданное контекстное меню для body. Таким образом, мы можем определить контекстное меню для любого элемента.
Итак, теперь кроссплатформенные приложения может создавать каждый, но за все нужно платить. В данном случае мы жертвуем как скоростью, так и занимаемым объемом памяти (собранное приложение получается достаточно большим, более 50 Мб). Список приложений, созданных, используя данную технологию можно найти на [github](https://github.com/nwjs/nw.js/wiki/List-of-apps-and-companies-using-nw.js).
Во второй части статьи мы рассмотрим технологию более подробно. | https://habr.com/ru/post/272389/ | null | ru | null |
# Новый релиз TileMill
Совсем [недавно](http://developmentseed.org/blog/2011/nov/22/tilemill-070-released/) вышел новый релиз свободной картографической дизайн-студии с открытым исходным кодом [TileMill](http://habrahabr.ru/blogs/open_source/120676/). Среди новых возможностей — автодополнение при описании стилей [Carto](http://developmentseed.org/blog/2011/feb/09/introducing-carto-css-map-styling-language/) и загрузка готовых тайлов на хостинг MapBox, прямо из студии. Новый релиз также включает в себя улучшения пользовательского интерфейса и стабильности приложения.
Под катом короткое видео и небольшой changelog.
#### TileMill 0.7.0: автодополнение и загрузка тайлов
#### Автодополнение
Автодополнение облегчает изучение Carto новичкам и позволяет ускорить процесс написания стилей опытным пользователям. Работает при нажатии кнопки `Tab`.
#### Загрузка тайлов на хостинг
TileMill позволяет экспортировать ваши интерактивные карты как самостоятельный набор тайлов в спецификации [MBTiles](http://mapbox.com/mbtiles-spec/). Теперь вы можете загружать эти наборы прямо на [хостинг MapBox](http://mapbox.com/hosting/) не покидая приложение. После загрузки вы можете скопировать их в свой аккаунт или воспользоватся бесплатным 7-дневным хостингом.
#### Улучшения пользовательского интерфейса
Новый релиз включает в себя несколько улучшений пользовательского интерфейса и повышение стабильности работы. Теперь вы можете загружать свои данные из любого места на вашем компьютере, а не только из директории данных студии.
Теперь TileMill позволяет добавлять интерактивные подсказки (tooltips), которые буду появляться при наведении курсора на определённые регионы на карте. Стандартная система токенов, использовавшаяся ранее, заменена на [Mustache](http://mustache.github.com/).
В Mapnik, который используется как рендер в TileMill, наконец-то внесены багфиксы повышающие стабильность работы с SQLite; добавлена совместимость с PostGIS 2.x; и добавлена возможность отрисовки SVG иконок как маркеров на карте.
Вы можете [скачать TileMill](http://mapbox.com/tilemill/download/) с официального сайта MapBox или [воспользоваться репозиторием на GitHub](http://github.com/mapbox/tilemill).
#### Полезные ссылки
* [Changelog](http://mapbox.com/tilemill/docs/changelog/)
* [Документация](http://mapbox.com/tilemill/docs/manual/)
* [Техническая поддержка проекта](http://support.mapbox.com/) | https://habr.com/ru/post/133189/ | null | ru | null |
# Поиск на Drupal 7 с помощью Apache Solr ч.6 — настраиваем apache solr + tomcat
После долгого перерыва, я решил написать очередную статью об apache solr и drupal. В этот раз речь пойдёт о настройке tomcat для того, чтобы apache solr мог работать, как демон. В интернете уже есть много разных мануалов по настройке tomcat, но не всегда они подходят для работы с drupal. В частности я настраивал tomcat и apache solr работал прекрасно. Но после того, как я подменил стандартные конфиги солра на конфиги друпала, солр перестал работать (начали вылетать java эксепшены).
* [Поиск на Drupal 7 с помощью Apache Solr ч.1 — базовая настройка](http://habrahabr.ru/post/175527/)
* [Поиск на Drupal 7 с помощью Apache Solr ч.2 — учимся настраивать индекс](http://habrahabr.ru/post/177509/)
* [Поиск на Drupal 7 с помощью Apache Solr ч.3 — учимся добавлять собственные поля и опции в индекс](http://habrahabr.ru/post/178285/)
* [Поиск на Drupal 7 с помощью Apache Solr ч.4 — фасетные фильтры](http://habrahabr.ru/post/180083/)
* [Поиск на Drupal 7 с помощью Apache Solr ч.5 — виджеты для фасетных фильтров](http://habrahabr.ru/post/182820/)
* Поиск на Drupal 7 с помощью Apache Solr ч.6 — настраиваем apache solr + tomcat
* [Поиск на Drupal 7 с помощью Apache Solr ч.7 — полнотекстовый поиск на русском языке](http://habrahabr.ru/post/213085)
Итак перейдем к делу.
##### Моя конфигурация
Ubuntu server 12.04
Apache solr 3.6.1
Drupal 7
Модули для поиска — [search api](https://drupal.org/project/search_api) и [search\_api\_solr](https://drupal.org/project/search_api_solr)
##### А теперь установка
Устанавливаем tomcat
```
sudo apt-get install tomcat6
```
Скачиваем и распаковываем apache solr во временную директорию
```
mkdir /tmp/solr/
cd /tmp/solr/
wget http://archive.apache.org/dist/lucene/solr/3.6.1/apache-solr-3.6.1.tgz
tar xzvf apache-solr-3.6.1.tgz
```
Затем создаем директорию в которой будет работать на сервер Apache solr и копируем туда необходимые файлы
```
sudo mkdir /var/solr
Копируем war файл
sudo cp apache-solr-3.6.1/dist/apache-solr-3.6.1.war /var/solr/solr.war
Примеры ядер и конфиг для использования нескольких ядер.
sudo cp -R apache-solr-3.6.1/example/multicore/* /var/solr/
sudo chown -R tomcat6 /var/solr/
```
Связываем tomcat с нашим сервером Apache solr
```
echo -e '\n\n' | sudo tee -a /etc/tomcat6/Catalina/localhost/solr.xml
echo 'TOMCAT6_SECURITY=no' | sudo tee -a /etc/default/tomcat6
```
Теперь в файле /etc/default/tomcat6 необходимо указать домашнюю директорию solr — /var/solr. Для этого редактируем параметр JAVA\_OPTS
```
sudo nano /etc/default/tomcat6
```
И выставляем там:
```
JAVA_OPTS="$JAVA_OPTS -Dsolr.home=/var/solr"
```
После этого перезагружаем tomcat:
```
sudo /etc/init.d/tomcat6 restart
```
Убеждаемся что все работает, для этого можно перейти по урлу [localhost](http://localhost):8080/solr/
В случае успеха, вы должны увидеть примерно такую картинку
По умолчанию уже есть два ядра, но для того чтобы можно было использовать конфиг и схему из search\_api для друпала, создадим новое ядро.
Сперва вписываем его в /var/solr/solr.xml
В конце файла описаны ядра, в моем случае, после добавления ядра, конфиг выглядит следующим образом:
```
```
Затем копируем файлы из скачанного apache solr для нашего ядра которое будет работать с Drupal.
```
sudo mkdir /var/solr/drupal
sudo cp -R /tmp/solr/apache-solr-3.6.1/example/solr/* /var/solr/drupal
```
Кладем туда конфиг и схему из модуля search\_api\_solr
Снова перезагружаем tomcat командой
```
sudo /etc/init.d/tomcat6 restart
```
Устанавливаем настройки солра в Drupal
Теперь индексируем контент и наслаждаемся работой поиска!
Статьи вроде хорошие, но активности что-то мало. В некоторых статьях из этого цикла даже комментариев нет, вдруг никому не интересно? Буду рад конструктивным замечаниям в комментариях. | https://habr.com/ru/post/189840/ | null | ru | null |
# 1C + офлайн карты на Android
Здравствуйте!
Продолжим знакомство с фреймворком «FBA Toolkit» и рассмотрим еще один пример разработки андроид-клиента для 1С. Наше приложение «Аудит торговой точки» будет загружать маршрут посещения из 1С и отображать его на карте. Используются офлайн карты на базе картографического сервиса OpenStreetMap.
Предполагается, что у вас уже установлены и настроены все необходимые инструменты разработчика. Если это не так, см. [предыдущую часть](http://habrahabr.ru/post/176371/). Фреймворк «FBA Toolkit» должен быть не ниже версии 1.03, обновите [конфигурацию 1С](http://profi1c.ru/products/fba_toolkit/fba-toolkit-byistryiy-start.html) и Android-проект [ru\_profi1c\_fba](https://xp-dev.com/svn/fba_toolkit_public/ru_profi1c_fba/) из SVN-репозитария.
#### Серверная часть (в базе 1С)
1. В информационной базе 1С создаем 2 справочника, которые будут выступать в роли источника данных для примера.
Реквизиты справочника «Торговые точки»:
* «Широта» и «Долгота» содержат координаты этой точки, число 10.6
* «Фото» ссылка на справочник «Хранилище дополнительной информации» — ссылка на основное изображение;
* все прочие реквизиты строкового типа.
Реквизиты справочника «Хранилище дополнительной информации»:
* «Объект» составного типа в т.ч содержит тип «СправочникСсылка.ТорговаяТочка», определяет объект которому принадлежит дополнительная информация. В мобильном приложении не используется.
* «Хранилище», тип «ХранилищеЗначения», содержит само изображение.
2. Так же добавлен план обмена «МобильноеПриложениеАудитТочки» в состав которого входят только эти два справочника, авто-регистрация изменений включена.
3. Справочники заполняем некоторой тестовой информацией, в этом примере это пиццерии в центре Москвы (данные взяты из открытых источников).
Для некоторых точек загружены изображения. Код сохранения значения в хранилище стандартный для 1С:
```
ДвоичныеДанные = Новый ДвоичныеДанные(ИмяФайла);
Хранилище = Новый ХранилищеЗначения(ДвоичныеДанные, Новый СжатиеДанных(9));
```
Форма элемента справочника «Хранилище дополнительной информации», «ИмяФайла» содержит путь к загружаемому изображению.
4. Создаем мобильное приложение «Аудит торговой точки». В дерево метаданных добавляем наши справочники.
Просто ради удобства, имена реквизитов и объектов из латиницы переведены на английский.
Схема обмена настроена таким образом, чтобы выгружать только измененные в 1С объекты:
* установлен флаг использования плана обмена «МобильноеПриложениеАудитТочки»
* при изменении любой «Торговой точки» в 1С она будет передана мобильному приложению;
* на справочник «Хранилище дополнительной информации» наложена дополнительная фильтрация: передавать измененную информацию только по торговым точкам. Это делается запросом:
```
ВЫБРАТЬ
ХранилищеДополнительнойИнформацииИзменения.Ссылка КАК Ссылка
ИЗ
Справочник.ХранилищеДополнительнойИнформации.Изменения КАК ХранилищеДополнительнойИнформацииИзменения
ГДЕ
ХранилищеДополнительнойИнформацииИзменения.Узел = &УзелОбмена
И ХранилищеДополнительнойИнформацииИзменения.Ссылка.Объект ССЫЛКА Справочник.ТорговыеТочки
```
где «УзелОбмена» это предопределенный параметр, в момент обмена будет содержать значение установленного узла для мобильного сотрудника (ниже покажем где это устанавливается).
5. Генерируем шаблон мобильного приложения Android. Стоимость и порядок приобретения лицензии описаны [здесь](http://profi1c.ru/fba-toolkit-price). Как внести полученные лицензионные данные в 1С написано [здесь](http://profi1c.ru/products/fba_toolkit/switch_to_commercial_version.html).
Можно так же воспользоваться тестовой лицензией:
client\_id: TEST-CLIENT-000
client\_name: test-client-name
client\_pwd: 31qX9OqZ\_V
lisence\_id: f7a42162-e27f-4246-a89b-b69c02387740
Только в этом случае не рекомендуется изменять имя пакета мобильного приложения: **ru.profi1c.samples.audit.salespoint**.
6. В справочник «Мобильные сотрудники» добавляем наше приложение для сотрудника, который используется для тестирования обмена. Обратите внимание на колонку «Узел обмена», это новый элемент нашего плана обмена.
Как правило, для каждого сотрудника создается свой узел обмена. В этом случае получается, что изменения данных в 1С будут автоматически регистрироваться для всех узлов (все мобильных сотрудников), а при обмене каждый мобильный клиент «заберет свою порцию данных».
Этот параметр может использоваться в запросах на выборку данных, как нашем случае со справочником «Хранилище дополнительной информации».
Также рекомендуется для каждого мобильного приложения создавать отдельный план обмена, чтобы не вносить путаницу.
Подготовительные работы в 1С завершены, для тестирования правил обмена можете воспользоваться обработкой «Тест обмена с мобильным приложением», подробнее [здесь](http://profi1c.ru/products/fba_toolkit/primer-3-zakazyi-pokupatelya-chast-1.html/2). В 1С больше ничего делать не надо, всю рутинную работу по организации обмена FBA берет на себя. Программист может сконцентрироваться на разработке мобильного приложения.
#### Мобильное приложение Android
1. Создаем новый проект на основании сгенерированого шаблона. Для этого в Eclipse необходимо выполнить импорт, как это сделать подробно описано [здесь](http://profi1c.ru/products/fba_toolkit/primer-1-zadachi-dlya-mobilnogo-sotrudnika-chast-1.html/2).
2. Займемся картой. В состав FBA включены вспомогательные классы, облегчающие новичку работу с офлайн картами [Mapsforge](http://code.google.com/p/mapsforge/). Один из таких классов – BaseRouteMapActivity, активити предназначенная для отображения точек маршрута и навигации по ним. Его и будем использовать.
2.1 Создаем свой класс, наследник от BaseRouteMapActivity:
**Показать**
```
public class MapsforgeRouteMap extends BaseRouteMapActivity {
/*
* На сколько должна изменится текущая позиция (в метрах) прежде чем будет
* получено новое значение координат
*/
public static int DEF_LOCATION_MIN_DISTANCE = 500;
/*
* Максимальное время, которое должно пройти, прежде чем пользователь
* получает обновление местоположения.
*/
public static long DEF_LOCATION_MIN_TIME = 5000 * 60;
//Москва, нулевой километр
private static final double DEFAULT_GEOPOINT_LAT = 55.755831;
private static final double DEFAULT_GEOPOINT_LNG = 37.617673;
//Файл карты
private static final String MAP_FILE = "ru_moscow.map";
private MapView mMapView;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_route_map);
init();
}
private void init() {
mMapView = (MapView) findViewById(R.id.mapView);
//Инициализация карты
onCreateMapView(mMapView);
}
@Override
public File getMapFile() {
return new File(getAppSettings().getBuckupDir(),MAP_FILE);
}
@Override
public GeoPoint getMapCenterPoint() {
return MapHelper.toGeoPoint(DEFAULT_GEOPOINT_LAT, DEFAULT_GEOPOINT_LNG);
}
@Override
public int getLocationMinDistance() {
return DEF_LOCATION_MIN_DISTANCE;
}
@Override
public long getLocationMinTime() {
return DEF_LOCATION_MIN_TIME;
}
@Override
public boolean showCurrentPosition() {
return true;
}
@Override
public boolean requestLocationUpdates() {
return true;
}
@Override
protected void onRouteItemSelect(RouteOverlayItem item) {
}
@Override
public void onLocationChanged(Location location) {
}
}
```
Отображать будем карту Москвы, которую необходимо поместить на эмулятор в каталог *mnt/sdcard/backup/<имя пакета>*. Этот каталог будет создан автоматически при первом запуска программы. Где взять файл карты или как создать самому, смотрите в конце статьи.
При запуске наша карта будет отцентрирована по координатам переданным в методе getMapCenterPoint(). Функция showCurrentPosition() должна возвращать true, если вы ходите отображать маркер с вашей текущей позицией.
Если методом requestLocationUpdates() включено отслеживание координат, то при изменении будет вызываться обработчик onLocationChanged. Настройки частоты обновления координат задаются через getLocationMinDistance() и getLocationMinTime(). По умолчанию используются оба провайдера (GPS и NETWORK) для получения координат, изменить можно в BaseMapActivity т.к исходный код открыт.
В макете activity\_route\_map.xml размещаем элемент карты:
```
```
В принципе, этого достаточно для отображения карты. Также на карте отображается маркер с текущей позицией и есть возможность обработать событие при изменении координат.
2.2 Добавление слоя с точками маршрута выполняется с помощью метода addRouteOverlay, в который передается список элементов List. T это тип доп. данных хранимых вместе с элементом, в вашем случае это CatalogSalesPoint. Подготовим список наших торговых точек:
**Показать**
```
private void initDummyRoute() throws SQLException {
//DAO для отображения картинки и для записи координат
mStorageDao = new CatalogAddInfoStorageDao(getConnectionSource());
mSalesPointDao = new CatalogSalesPointDao(getConnectionSource());
// Выбрать все торговые точки
CatalogSalesPointDao salePointDao = new CatalogSalesPointDao(getConnectionSource());
List lst = salePointDao.select();
// Список точек маршрута отображаемый на карте
routeItems = new ArrayList>();
// Для точек, у которых не установлены координаты
final double lng = DEFAULT\_GEOPOINT\_LNG;
double lat = DEFAULT\_GEOPOINT\_LAT;
int count = lst.size();
for (int i = 0; i < count; i++) {
CatalogSalesPoint salesPoint = lst.get(i);
boolean movable = (salesPoint.lat == 0 || salesPoint.lng == 0);
int resIdDrawable = R.drawable.fba\_map\_maker\_green;
GeoPoint geoPoint = new GeoPoint(salesPoint.lat, salesPoint.lng);
if (movable) {
resIdDrawable = R.drawable.fba\_map\_marker\_red;
lat -= 0.003f;
geoPoint = new GeoPoint(lat, lng);
}
//На маркере вывести порядковый номер
Drawable marker = MapHelper.makeNumberedMarker(this, resIdDrawable,i + 1);
RouteOverlayItem routePoint = new RouteOverlayItem(
geoPoint, marker, salesPoint);
routePoint.setMovable(movable);
routePoint.setOrdinal(i + 1);
routeItems.add(routePoint);
}
Drawable defaultMarker = getResources().getDrawable(R.drawable.fba\_map\_marker\_orange);
addRouteOverlay(mMapView, routeItems, defaultMarker);
}
```
и добавим вызов этого метода в init().
Здесь из локальной базы выбираются все элементы справочника «Торговые точки» и добавляются в коллекцию отображаемых элементов. Причем для точек, у которых установлены координаты в 1С, маркер будет зеленого цвета. Точки без координат размещаются по центру карты с маркером красного цвета. Пользователь может перемещать их по карте с целью уточнения координат.
2.3 Давайте добавим реакцию на клик по маркеру в обработчик onRouteItemSelect:
```
CatalogSalesPoint salesPoint = (CatalogSalesPoint) item.getData();
inflatePopup(salesPoint);
```
Поля класса и метод отображающий дополнительную информацию о торговой точке:
**Показать**
```
private ObjectView mSalesPointView, mFotoStorageView;
/*
* Имена реквизитов отображаемых в всплывающем окне (имена полей класса)
*/
private static String[] fields = new String[] {
CatalogSalesPoint.FIELD_NAME_DESCRIPTION,
CatalogSalesPoint.FIELD_NAME_ADRESS,
CatalogSalesPoint.FIELD_NAME_PHONE,
CatalogSalesPoint.FIELD_NAME_SITE
};
/*
* Идентификаторы view-элементов для отображения реквизитов
*/
private static int[] ids = new int[] { R.id.tvDescription, R.id.tvAdress,
R.id.tvPhone, R.id.tvSite};
/*
* Заполнить данные по торговой точке на всплывающем окне и отобразить его
*/
private void inflatePopup(CatalogSalesPoint salesPoint) throws SQLException {
if (CatalogSalesPoint.isEmpty(salesPoint.foto)) {
mFotoStorageView.setVisibility(View.GONE);
} else {
//Прочитать ссылку на фото
mStorageDao.refresh(salesPoint.foto);
mFotoStorageView.build(salesPoint.foto, getHelper(),
new String[] { CatalogAddInfoStorage.FIELD_NAME_STORAGE },
new int[] { R.id.ivFoto });
mFotoStorageView.setVisibility(View.VISIBLE);
}
mSalesPointView.build(salesPoint, getHelper(), fields, ids);
}
```
Для отображения всплывающего окна используется макет map\_popup.xml (разметка приведена частично):
```
```
На макете отображается информация по одной торговой точке, реквизиты «Наименование», «Адрес», «Сайт» и «Телефон» автоматически проецируются на TextView-элементы в *mSalesPointView.build(...)*.
Для отображения фото используется подчиненный объект ovFotoStorage с дочерним ImageView. Фото считывается из базы и проецируется на ImаgeView в методе *mFotoStorageView.build(...)*.
А так как в реквизите «Фото» хранится только ссылка на справочник «Хранилище дополнительной информации», ее необходимо предварительно считать методом *refresh*.
Инициализацию добавляем в метод в init()
```
mSalesPointView = (ObjectView) findViewById(R.id.ovSalesPoint);
mFotoStorageView = (ObjectView) findViewById(R.id.ovFotoStorage);
```
Макет map\_popup.xml можно установить как кастомный для Toast, но в этом примере он встроен в основной макет activity\_route\_map.xml:
**Показать**
```
```
Для управления видимостью используются методы:
**Показать**
```
/*
* Скрыть всплывающее окно
*/
private void closePopup(){
if(mSalesPointView.getVisibility() == View.VISIBLE){
mSalesPointView.setVisibility(View.GONE);
}
}
/*
* Показать всплывающее окно
*/
private void showPopup(){
if(mSalesPointView.getVisibility() != View.VISIBLE){
mSalesPointView.setVisibility(View.VISIBLE);
}
}
```
Скрывается всплывающее сообщение по клику на нем, а отображается при нажатии на маркер точки.
Приложение готово, запустите его на эмуляторе, настройте параметры авторизации (как в 1С) и выполните обмен с базой. Пример работы приложения:
Клик по номеру телефона откроет стандартную «звонилку», а по клику на ссылку будет запущен браузер. Такое поведение достигается простой установкой свойства *android:autoLink* для TextView.
Полный код примера доступен в SVN [хранилище](https://xp-dev.com/svn/fba_toolkit_public/samples/fbaSampleAuditPoint/). Дополнительно в нем показано как сохранить координаты у перемещенных точек и обновить маркер.
##### Где взять карты
Некоторые карты планируем размещать [на нашем сайте](http://profi1c.ru/fba-toolkit-maps-mapsforge), приоритет у городов (областей) непокрытых с достаточной детализацией на Google Maps и карт, подготовленных для клиентов FBA. Краткая инструкция по созданию файла карты приведена там же.
На этом все, с другими примерами вы можете ознакомиться на сайте <http://profi1c.ru>.
Надеюсь, мне удалось хоть чуть-чуть развеять миф о том, что разработка мобильных бизнес-приложений это «сложно, дорого и долго». | https://habr.com/ru/post/184978/ | null | ru | null |
# MonoDevelop на Nokia N900. Where is your God now?
Работает всё, что вообще может работать. Редактор, компиляция, отладчик, значение переменной по клику в отладчике. С диким скрипом и скрежетом даже дизайнер форм.
Пощупать сии ништяки у себя на мобилке можно добавив
`deb http_://archive.kebrum.com/n900/ all main`
В sources.list (надеюсь, я ничего не забыл при упаковке). Также понадобится подключить extras-testing и extras-devel. После чего набрать в консоле apt-get install monodevelop. Вся иерархия пакетов полностью соответствует таковой в Debian, за исключением 2 оптификационных, но они автоматом подтянутся по зависимостям.
Пока пакеты ставятся, забивая бесценное место в rootfs библиотеками из маэмовских репов (у меня-то всё в /opt, вы не подумайте!), предлагаю Вам почитать, как дошёл я до жизни такой.
Я хотел рассказать обо всём по-порядку, но для начала пятиминутка ненависти.
Хочу передать привет содомитам из Nokia, которые вместо нормального эмулятора своего девайса подсунули недоделанную старую версию qemu-arm, что сделало *невозможным* использование моновского компилятора, и, как следствие, сборки какого-либо управляемого кода посредством этого их SDK. Они подарили мне много весёлых часов.
Хочу передать привет разработчикам биндингов к gtk, которые соорудили генератор кода, который генерит нечто некомпилируемое (что превратило их сборку в кошмар из серии «не пытайтесь повторить это дома»), а так же считающим, что в гткшном диалоге в action area обязательно находится HButtonBox, хотя документация говорит, что там абстрактный контейнер (в результате чего GtkDialog.ArctionArea всегда было null). Они тоже подарили мне немало весёлых часов.
Так же хочу передать привет разрабочикам Mono.Addins, которые пишут вот такой код:
`string folder = args.Length > 2 ? args [2] : **null**;
if (**folder**.Length == 0) folder = null;`
На этом пятиминутку ненависти можно считать законченной. В конце концов они все хорошие люди, благодаря которым всё это вообще заработало.
Собственно, после написания [предыдущего поста](http://habrahabr.ru/blogs/DIY/116771/) я решил отказаться от правки debian/rules с целью переноса всего хлама в /opt, поскольку это ломало часть компонентов. Теперь оптификация производится предварительным созданием симлинков на нужные директории. Кстати, за счёт этого можно легко вычистить monoи всё с ним связанное, просто удалив пакет mono-opt-prepare. После сборки биндингов к гтк, и проверки работоспособности [того, ради чего всё затевалось](http://www.youtube.com/watch?v=7Gvd9oZcP0g) (кстати, софтина вообще без изменений исходника завелась, сейчас переделываю диалоги под размер экрана и управление пальцем), я решил проверить сборку в целом. Какая самая сложная программа на GTK#? Правильно, Monodevelop. Непосредственно после сборки всех зависимостей (часть пакетов была утянута непосредственно в бинарном виде с ports.ubuntu.com) я напоролся на следующую пакость:
И так практически со всеми диалогами. Поскольку сырцы биндингов уже были пропатчены в связи с багом с ActionArea, я не придумал ничего лучше чем спрятать от внешнего наблюдателя оригинальный VBox, а вместо него подсунуть другой, обёрнутый в ScrolledWindow. Полчаса шаманств и получился GtkDialog, адекватно подстраивающийся под размеры своего содержимого. Примерно вот так:
Что помешало нокиевским программистам сделать то же самое (учитывая, что диалог они и так переделали до состояния несовместимости с биндингами), а не ломать софт, заточенный под большие экраны, для меня остаётся загадкой. Если кто-то захочет таки достучаться до оригинального VBox-а, то это легко сделать просто перейдя по ссылкам на 2 уровня иерархии вверх.
Некоторую проблему представило из себя взаимодействие с отладчиком и компилятором, но это решилось посредством добавления ещё нескольких симлинков, хоть и потребовало копаться в исходнике.
Теперь ложка дёгтя. У меня не получилось отключить HILDON\_GTK\_INPUT\_MODE\_AUTOCAP через IMContext (для TextArea и Entry всё прекрасно, но MonoDevelop использует свой контрол для редактирования текста и работает с IMMultiContext напряму), так что придётся либо отключать автоподстановку заглавных букв глобально, либо печатать зажав шифт. Если кто-то владеет информацией по этому поводу, прошу поделиться.
Помимо перечисленного эта зараза почему-то не видит в списке сборок для подключения библиотеки, не относящиеся непосредственно к Mono. Это лечится добавлением оных по абсолютному пути. Это я попробую исправить, но ничего не обещаю.
И ещё. В нокиевские репы это, по всей видимости никогда не попадёт по той причине, что из-за особенностей процесса сборки (этот файл берём с эмуля, те 10 из скомпиленного под убунту, тут тормозим процесс сборки и подсовываем сгенерированный под той же убунтой исходник, правим линки, правим debian/control, etc) невозможно создать вменяемые пакеты исходного кода, а убедить их в безопасности бинарников весьма сложно. В прочем, если кто-то связан с этой тусовкой и решится помочь, буду рад.
Напоминаю, что теперь софт для N900 можно разрабатывать хоть в Visual Studio, если у кого-то с этим возникнут проблемы, обращайтесь, буду рад помочь.
**UPD:** выяснилось, что при отсутствии bash возникают проблемы с установкой. Если кто уже столкнулся, то лечится apt-get install bash. Сейчас пропишу его в зависимости.
**UPD2:** А ещё запустился Paint.NET:
Пакет зовётся paint-mono и уже есть в репозитории. | https://habr.com/ru/post/117149/ | null | ru | null |
# Получаем данные со счетчиков Меркурий 203.2Т по RS-485
Организовать удаленный сбор показаний с электросчетчиков — задача вроде не сложная, счетчики с каждым годом все умнее и умнее и должны сами все отправлять, ан нет, информация конечно есть, но она разрозненная. Производители оборудования видимо тоже хотят зарабатывать на продаже своего ПО. Пишу эту статью чтобы сэкономить время всем, у кого есть похожие задачи.
Начало
------
На предприятии нужно было автоматизировать сбор показаний с электросчетчиков, порядка двадцати штук. Сделать это требовалось быстро и максимально дешево. Поэтому приняли решение собирать данные с помощью уже развернутого Zabbix, а вот для подключения к счетчику потребовалось написать небольшой скрипт, об этом ниже. Так вышло, что сбор показаний, это лишь один из параметров, который нужно собирать, за остальные отвечает ПК с Debian на борту, поэтому не было сложности подключиться к счетчику через COM-порт. Конечно, для большинства, будет удобнее использовать локальную сеть и получить информацию с промышленного коммутатора или конвертера интерфейсов.
Из вариантов подключения также можно рассматривать оптопорт, правда потребуется приобретать дополнительный девайс, с другой стороны — не нужно снимать пломбу.
Клеммы для подключения к счетчику находятся под опломбированной крышкой.
Поэтому нам пришлось договариваться сетевой компанией о том что, нужно снимать пломбы, выполнять работы, заново пломбировать счетчики. Но в итоге, договоренности были достигнуты и можно было спокойно заниматься решением основной задачи.
Решение задачи
--------------
Как следует из [официальной документации.](http://www.incotexcom.ru/doc/M20x.rev2015.02.15.pdf)
Счетчик, принимает на вход строку байтов формата ADDR-CMD-CRC, а отдает ADDR-CMD-DATA-CRC, где:
* ADDR — Имя счетчика (для меркурий 203.2Т — совпадает с серийным номером)
* CMD — Код команда
* DATA — Данные, зависят от запроса
* CRC — 2х байтовый циклический избыточный код, вычисляемый по всем предшествующим байтам данного пакета. Из этого объяснения не понятно что записывать в поле контрольной суммы.
Дефис в последовательности не используется, здесь использован для разделения логических блоков.
Первым делом, подключимся к счетчику с помощью стандартной программы [konfigurator](http://www.incotexcom.ru/count_prog.htm) и, с помощью сниффера, посмотрим на передаваемые пакеты, выясним какую контрольную сумму нужно добавлять в конец. Ниже, строка полученная от счетчика.
Воспользовавшись [онлайн калькулятором CRC](https://www.lammertbies.nl/comm/info/crc-calculation.html) выясняем, что нужно вычислить CRC-16 (Modbus) с полиномом 0xA001.
### Немного Python
Ссылок на алгоритм вычисления достаточно, поэтому не буду останавливаться на нем. Для разработки я использовал Python 3
```
def crc16(data):
crc = 0xFFFF
l = len(data)
i = 0
while i < l:
j = 0
crc = crc ^ data[i]
while j < 8:
if (crc & 0x1):
mask = 0xA001
else:
mask = 0x00
crc = ((crc >> 1) & 0x7FFF) ^ mask
j += 1
i += 1
if crc < 0:
crc -= 256
result = data + chr(crc % 256).encode() + chr(crc // 256).encode('latin-1')
return result
```
Теперь попробуем получить от счетчика его серийный номер и проверить CRC. Понадобится установить модуль [pyserial](http://pyserial.readthedocs.io/en/latest/pyserial.html)
```
import serial
import struct
import time
sn = 26222790
# Открываем соединение
ser = serial.Serial('/dev/ttyUSB0', 9600, serial.EIGHTBITS, serial.PARITY_NONE, serial.STOPBITS_ONE)
print ('Connected:', ser.isOpen())
# \x2f - Команда для получения серийного номера
chunk = struct.pack('>L', int(sn))
chunk += b'\x2f'
chunk = crc16(chunk)
# Отправим данные на счетчик и получим информацию с него
ser.write(chunk)
time.sleep(1)
out = ser.read_all()
ser.close()
print ('Check CRC:', out[-2:] == crc16(out[:-2])[-2:])
print ('Result string:', ':'.join('{:02x}'.format(c) for c in out))
```
Отлично! Теперь получим значения для израсходованной энергии по первому и второму тарифам, на самом деле нам нужно изменить только поле команды и распарсить результат.
```
chunk += b'\x27'
t1 = ''.join('{:02x}'.format(c) for c in out[5:9])
t2 = ''.join('{:02x}'.format(c) for c in out[9:13])
print ('T1 =', float(t1)*0.01, '(кВт*ч)', 'T2 =', float(t2)*0.01, '(кВт*ч)')
```
Все работает. Конечный вариант скрипта выложил на [git](https://github.com/n0l/Mercury_remote). В перспективе, планирую добавить поддержку работы по локальной сети.
Для разработки использовался Адаптер USB -> COM «Меркурий-221», но можно напрямую подключать счетчик к COM-порту.
---
Ссылки:
Полезная информация по подключению счетчиков [находится тут](https://habr.com/post/315430/)
[Документация на официальном сайте](http://www.incotexcom.ru/doc/M20x.rev2015.02.15.pdf)
[Сайт техподдержки](http://incotex-support.blogspot.com/2016/05/blog-post.html)
Про CRC на [Википедии](https://ru.wikipedia.org/wiki/%D0%A6%D0%B8%D0%BA%D0%BB%D0%B8%D1%87%D0%B5%D1%81%D0%BA%D0%B8%D0%B9_%D0%B8%D0%B7%D0%B1%D1%8B%D1%82%D0%BE%D1%87%D0%BD%D1%8B%D0%B9_%D0%BA%D0%BE%D0%B4) | https://habr.com/ru/post/418209/ | null | ru | null |
# Разница между веб-сокетами и Socket.IO
Доброго времени суток, друзья!
Веб-сокеты и [Socket.IO](https://socket.io/), вероятно, являются двумя наиболее распространенными средствами коммуникации в режиме реального времени (далее — живое общение). Но чем они отличаются?
При построении приложения для живого общения наступает момент, когда необходимо выбрать средство для обмена данными между клиентом и сервером. Веб-сокеты и Socket.IO являются самыми популярными средствами живого общения в современном вебе. Какое из них выбрать? В чем разница между этими технологиями? Давайте выясним.
### Веб-сокеты
Говоря о веб-сокетах, мы имеем ввиду протокол веб-коммуникации, представляющий полнодуплексный канал коммуникации поверх простого TCP-соединения. Проще говоря, эта технология позволяет установить связь между клиентом и сервером с минимальными затратами, позволяя создавать приложения, использующие все преимущества живого общения.
Например, представьте, что вы создаете чат: вам необходимо получать и отправлять данные как можно быстрее, верно? С этим прекрасно справляются веб-сокеты! Вы можете открыть TCP-соединение и держать его открытым сколько потребуется.
Веб-сокеты появились в 2010 году в Google Chrome 4, первый RFC ([6455](https://tools.ietf.org/html/rfc6455)) опубликован в 2011.
Веб-сокеты используются в следующих случаях:
* Чаты
* Многопользовательские игры
* Совместное редактирование
* Социальные (новостные) ленты
* Приложения, работающие на основе местоположения
и т.д.
### Socket.IO
Socket.IO — библиотека JavaScript, основанная (написанная поверх) на веб-сокетах… и других технологиях. Она использует веб-сокеты, когда они доступны, или такие технологии, как Flash Socket, AJAX Long Polling, AJAX Multipart Stream, когда веб-сокеты недоступны. Легкой аналогией может служить сравнение Fetch API и Axios.
### Разница между веб-сокетами и Socket.IO
Главными преимуществами Socket.IO является следующее:
* В отличие от веб-сокетов, Socket.IO позволяет отправлять сообщения всем подключенным клиентам. Например, вы пишете чат и хотите уведомлять всех пользователей о подключении нового пользователя. Вы легко можете это реализовать с помощью одной операции. При использовании веб-сокетов, для реализации подобной задачи вам потребуется список подключенных клиентов и отправка сообщений по одному.
* В веб-сокетах сложно использовать проксирование и балансировщики нагрузки. Socket.IO поддерживает эти технологии из коробки.
* Как отмечалось ранее, Socket.IO поддерживает постепенную (изящную) деградацию.
* Socket.IO поддерживает автоматическое переподключение при разрыве соединения.
* С Socket.IO легче работать.
Может показаться, что Socket.IO — лучшее средство для живого общения. Однако существует несколько ситуаций, когда лучше использовать веб-сокеты.
Во-первых, веб-сокеты поддерживаются всеми современными браузерами. Поэтому вы редко нуждаетесь в поддержке других технологий, предоставляемой Socket.IO.
Если говорить о сетевом трафике, то веб-сокеты отправляют всего два запроса:
* GET для получения HTML страницы
* UPGRADE для соединения с веб-сокетами
Это позволяет установить соединение с сервером. А что насчет Socket.IO?
* GET для получения HTML страницы
* Клиентская библиотека Socket.IO ([207кб](https://bundlephobia.com/result?p=socket.io@2.3.0))
* Три long polling (длинные опросы) Ajax-запроса
* UPGRADE для соединения с веб-сокетами
В мире JS 207кб — это много. Какое нерациональное использование сетевого трафика!
В npm существует пакет [«websocket-vs-socket.io»](https://www.npmjs.com/package/websocket-vs-socket.io), который позволяет сравнить сетевой трафик этих технологий:
#### Сетевой трафик веб-сокетов:
#### Сетевой трафик Socket.IO:
Разница очевидна!
### Пишем код
#### Простой сервер на веб-сокетах
В нашей программе на Node.js мы создадим сервер, работающий на порту 3001. При каждом подключении клиента мы будем присваивать ему уникальный ID. При отправке сообщения клиентом мы будем уведомлять его об успехе: []:
```
const WebSocket = require('ws')
const UUID = require('uuid')
const wss = new WebSocket.Server({ port: 3001 })
wss.on('connection', ws => {
ws.id = UUID()
ws.on('message', message => {
ws.send(`[${ws.id}]: ${message}`)
})
})
```
Отлично! Но что если мы хотим рассылать сообщение каждому подключенному клиенту? Веб-сокеты не поддерживают рассылку по умолчанию. Это можно реализовать следующим образом:
```
const WebSocket = require("ws")
const UUID = require("uuid")
const wss = new WebSocket.Server({ port: 3001 })
function broadcast(clientId, message) {
wss.clients.forEach(client => {
if(client.readyState === WebSocket.OPEN) {
client.send(`[${clientId}]: ${message}`)
}
})
}
wss.on('conection', ws => {
ws.id = UUID()
ws.on('message', message => broadcast(ws.id, message))
})
```
Легко и просто! Как видите, WebSocket.Server хранит записи о каждом подключенном клиенте, поэтому мы можем сделать итерацию и отправить сообщение каждому. Вы можете протестировать код на [компьютере (MacOS)](https://websocket-client.com/) или в [браузере (Chrome)](https://chrome.google.com/webstore/detail/browser-websocket-client/mdmlhchldhfnfnkfmljgeinlffmdgkjo).
#### Простой сервер на Socket.IO
Это было не сложно. Может ли Socket.IO сделать это еще проще? Как нам написать такой же сервер на Socket.IO?
```
const io = require('socket.io')
const server = io.listen(3002)
server.on('connection', socket => {
socket.on('message', message => {
socket.emit(`[${socket.id}]: ${message}`)
socket.broadcast.emit(`[${socket.id}]: ${message}`)
})
})
```
Код получился почти наполовину короче! Как видите, метод «broadcast» не отправляет уведомление отправителю, поэтому мы вынуждены делать это вручную.
Существует проблема: код нельзя протестировать на обычном клиенте веб-сокетов. Это связано с тем, что, как отмечалось ранее, Socket.IO использует не чистые веб-сокеты, а множество технологий для поддержки всех возможных клиентов. Так как же нам проверить его работоспособность?
```
// head
// body
ioClient = io.connect('http://localhost:3002')
ioClient.on('connect', socket => {
ioClient.send('hello world')
ioClient.on('message', msg => console.log(msg))
})
```
Необходимо использовать специальный клиент. В приведенном примере мы загружаем его из CDN. Этот клиент позволяет нам провести быстрые (грязные) тесты в браузере.
Как видите, наши примеры не сильно отличаются. Однако, если говорить о совместимости, следует помнить о том, что Socket.IO работает с собственной библиотекой и его нельзя использовать в целях, не связанных с веб-разработкой. В тоже время веб-сокеты могут использоваться для решения широкого спектра задач, таких как P2P коммуникация, обмен данными между серверами в режиме реального времени и т.д.
### На заметку
Горизонтальное масштабирование. Допустим, ваш чат обрел популярность и вам необходимо добавить еще один сервер и балансировщик нагрузки для обработки запросов. Ну, если вы открываете соединение на «server 1», затем балансировщик переключает вас на «server 2», вы получите ошибку: «Error during WebSocket handshake: Unexpected response code: 400». Socket.IO решает эту проблему с помощью cookie (или с помощью маршрутизации соединений на основе исходных адресов), а у веб-сокетов не существует подобного механизма.
Производительность. Как отмечалось ранее, Socket.IO предоставляет несколько абстрактных уровней над транспортным уровнем веб-сокетов. Также здесь используется упаковывание данных в формат JSON, так что возможность отправлять на сервер (и наоборот) бинарные данные отсутствует. Если вам необходим такой функционал, придется «поколдовать» над кодом библиотеки с целью обеспечения нужного поведения. С веб-сокетами таких проблем не возникает.
### Так что же выбрать?
Решать вам.
Socket.IO облегчает жизнь, вам не нужно заботиться о проблемах, связанных с балансировкой нагрузки, разрывом соединений или рассылкой сообщений… но необходим ли вам такой функционал? Клиентская библиотека Socket.IO весит больше, чем пакеты React, Redux и React-Redux вместе взятые. Уверены ли вы, что не можете ограничиться веб-сокетами?
Еще одной важной вещью, о которой следует помнить, является то, что при использовании Socket.IO на стороне сервера, большая часть кода будет написана на абстракциях, предоставляемых этой библиотекой. Если у вас возникнет необходимость переписать Node.js-микросервисы на Go, Elixir, Java или другой язык программирования, вам придется переписывать почти всю логику. Например, для рассылки сообщений в Socket.IO используется метод «broadcast» (который в веб-сокетах реализуется вручную), поэтому при рефакторинге придется понять, как этот метод работает. В этом случае следует предпочесть веб-сокеты, поскольку их легче адаптировать.
Благодарю за внимание. | https://habr.com/ru/post/498996/ | null | ru | null |
# Once upon a time in Wasmwood или Как я реверсил игру на WASM
### Преамбула
Прошел уже месяц с того момента, как я попытал счастья в решении реверс челленджа, заключающегося в поиске пасхалок в игре скомпилированной в WASM, на платформе [root-me](https://www.root-me.org/). С тех пор я подумывал запостить это на хабр, но никак руки не доходили. К счастью, все же удалось перебороть себя. Статью я планирую написать так, будто челлендж еще не решен, т.е с воспроизведением всех умозаключений и рассуждений, которые имели место в процессе его решения.
### Суть челленджа
Описание челленджаТо есть в мире с 1000 npc есть только один, который может нам помочь. Ну-с, летс гет стартед, как говорится.
### Начало
Игра начинается со следующего сетапа
Попробуем повзаимодействовать с кем-нибудь
Заключаем, что ничего полезного этот npc нам не расскажет. Что ж, придется копать глубже - скачаем wasm-бинарник и исследуем его. В качестве инструмента исследования возьмем [wabt](https://github.com/WebAssembly/wabt) или WAsm Binary Toolkit. Посмотрим, что у нас там имеется.
Как можно заметить, инструментов здесь предостаточно, но нам понадобится только один, а именно wasm2js, конвертирующий wasm в js код. Конечный продукт пестрит нереальными комбинациями сложно написанного, обфусцированного js кода, состоящего из кучи непонятных функций, но в таком стоге сена мне удалось найти парочку интересных игл. Мой весьма скудный опыт разработки игр подсказывает, что где-то должен быть главный игровой цикл, где и происходит вся логика обновления позиции игрока, рендеринг мира, хендлинг эвентов и т.д. Такая функция в коде есть, и называется она, к моему величайшему удивлению, main\_loop.
```
function main_loop() {
var $2 = 0;
$2 = __stack_pointer - 16 | 0;
__stack_pointer = $2;
handle_events();
HEAP32[($2 + 12 | 0) >> 2] = clock() | 0;
HEAP32[($2 + 8 | 0) >> 2] = (HEAP32[($2 + 12 | 0) >> 2] | 0) - (HEAP32[(0 + 351648 | 0) >> 2] | 0) | 0;
HEAP32[(0 + 351648 | 0) >> 2] = HEAP32[($2 + 12 | 0) >> 2] | 0;
render_game(HEAP32[($2 + 8 | 0) >> 2] | 0 | 0);
SDL_RenderPresent(HEAP32[(0 + 315092 | 0) >> 2] | 0 | 0);
__stack_pointer = $2 + 16 | 0;
return;
}
```
Хмм, посмотрим: выделение стековой памяти под переменные, вызов функций. Думаю, что следующим на очереди у нас будет handle\_events.
```
function handle_events() {
var $20 = 0, $2 = 0, $90 = 0;
$2 = __stack_pointer - 64 | 0;
__stack_pointer = $2;
label$1 : {
label$2 : while (1) {
if (!(SDL_PollEvent($2 + 8 | 0 | 0) | 0)) {
break label$1
}
label$3 : {
if (!((HEAP32[($2 + 8 | 0) >> 2] | 0 | 0) == (768 | 0) & 1 | 0)) {
break label$3
}
label$4 : {
label$5 : {
if ((HEAPU8[(0 + 315112 | 0) >> 0] | 0) & 1 | 0) {
break label$5
}
$20 = HEAP32[($2 + 28 | 0) >> 2] | 0;
label$6 : {
label$7 : {
label$8 : {
if (($20 | 0) == (32 | 0)) {
break label$8
}
label$9 : {
label$10 : {
if (($20 | 0) == (97 | 0)) {
break label$10
}
if (($20 | 0) == (100 | 0)) {
break label$9
}
if (($20 | 0) == (113 | 0)) {
break label$10
}
label$11 : {
if (($20 | 0) == (115 | 0)) {
break label$11
}
label$12 : {
if (($20 | 0) == (119 | 0)) {
break label$12
}
if (($20 | 0) == (122 | 0)) {
break label$12
}
if (($20 | 0) == (1073741886 | 0)) {
break label$7
}
if (($20 | 0) == (1073741903 | 0)) {
break label$9
}
if (($20 | 0) == (1073741904 | 0)) {
break label$10
}
if (($20 | 0) == (1073741905 | 0)) {
break label$11
}
if (($20 | 0) != (1073741906 | 0)) {
break label$6
}
}
label$13 : {
if (!(HEAP32[(0 + 315136 | 0) >> 2] | 0)) {
break label$13
}
move(0 | 0, -1 | 0);
}
HEAP32[(0 + 315136 | 0) >> 2] = 3;
break label$6;
}
label$14 : {
if (!((HEAP32[(0 + 315136 | 0) >> 2] | 0 | 0) != (3 | 0) & 1 | 0)) {
break label$14
}
move(0 | 0, 1 | 0);
}
HEAP32[(0 + 315136 | 0) >> 2] = 0;
break label$6;
}
label$15 : {
if (!((HEAP32[(0 + 315136 | 0) >> 2] | 0 | 0) != (2 | 0) & 1 | 0)) {
break label$15
}
move(-1 | 0, 0 | 0);
}
HEAP32[(0 + 315136 | 0) >> 2] = 1;
break label$6;
}
label$16 : {
if (!((HEAP32[(0 + 315136 | 0) >> 2] | 0 | 0) != (1 | 0) & 1 | 0)) {
break label$16
}
move(1 | 0, 0 | 0);
}
HEAP32[(0 + 315136 | 0) >> 2] = 2;
break label$6;
}
interact();
break label$6;
}
emscripten_run_script(9447 | 0);
}
break label$4;
}
$90 = HEAP32[($2 + 28 | 0) >> 2] | 0;
label$17 : {
label$18 : {
label$19 : {
if (($90 | 0) == (32 | 0)) {
break label$19
}
if (($90 | 0) == (1073741886 | 0)) {
break label$18
}
break label$17;
}
HEAP8[(0 + 315112 | 0) >> 0] = 0;
break label$17;
}
emscripten_run_script(9447 | 0);
}
}
}
continue label$2;
};
}
__stack_pointer = $2 + 64 | 0;
return;
}
```
Этот код выглядит посложнее, но главную мысль уловить несложно. Каждую итерацию проверяется, какой эвент имеет место в данный момент, и на основе этого совершается желаемое действие. Из всех перечисленных действий меня больше всего интересует то, в котором вызывается функция interact.
```
function interact() {
var $2 = 0, $3 = 0, $4 = 0;
$2 = __stack_pointer - 16 | 0;
__stack_pointer = $2;
$3 = 0;
HEAP32[($2 + 12 | 0) >> 2] = $3;
$4 = HEAP32[($3 + 315136 | 0) >> 2] | 0;
label$1 : {
label$2 : {
switch ($4 | 0) {
case 3:
HEAP32[($2 + 12 | 0) >> 2] = get_entity_at(HEAP32[(0 + 315120 | 0) >> 2] | 0 | 0, (HEAP32[(0 + 315124 | 0) >> 2] | 0) - 1 | 0 | 0) | 0;
label$6 : {
if (!((HEAP32[($2 + 12 | 0) >> 2] | 0 | 0) != (0 | 0) & 1 | 0)) {
break label$6
}
HEAP32[((HEAP32[($2 + 12 | 0) >> 2] | 0) + 20 | 0) >> 2] = 0;
}
break label$1;
case 0:
HEAP32[($2 + 12 | 0) >> 2] = get_entity_at(HEAP32[(0 + 315120 | 0) >> 2] | 0 | 0, (HEAP32[(0 + 315124 | 0) >> 2] | 0) + 1 | 0 | 0) | 0;
label$7 : {
if (!((HEAP32[($2 + 12 | 0) >> 2] | 0 | 0) != (0 | 0) & 1 | 0)) {
break label$7
}
HEAP32[((HEAP32[($2 + 12 | 0) >> 2] | 0) + 20 | 0) >> 2] = 3;
}
break label$1;
case 2:
HEAP32[($2 + 12 | 0) >> 2] = get_entity_at((HEAP32[(0 + 315120 | 0) >> 2] | 0) + 1 | 0 | 0, HEAP32[(0 + 315124 | 0) >> 2] | 0 | 0) | 0;
label$8 : {
if (!((HEAP32[($2 + 12 | 0) >> 2] | 0 | 0) != (0 | 0) & 1 | 0)) {
break label$8
}
HEAP32[((HEAP32[($2 + 12 | 0) >> 2] | 0) + 20 | 0) >> 2] = 1;
}
break label$1;
case 1:
break label$2;
default:
break label$1;
};
}
HEAP32[($2 + 12 | 0) >> 2] = get_entity_at((HEAP32[(0 + 315120 | 0) >> 2] | 0) - 1 | 0 | 0, HEAP32[(0 + 315124 | 0) >> 2] | 0 | 0) | 0;
label$9 : {
if (!((HEAP32[($2 + 12 | 0) >> 2] | 0 | 0) != (0 | 0) & 1 | 0)) {
break label$9
}
HEAP32[((HEAP32[($2 + 12 | 0) >> 2] | 0) + 20 | 0) >> 2] = 2;
}
}
label$10 : {
if (!((HEAP32[($2 + 12 | 0) >> 2] | 0 | 0) != (0 | 0) & 1 | 0)) {
break label$10
}
show_quote(HEAP32[($2 + 12 | 0) >> 2] | 0 | 0);
}
__stack_pointer = $2 + 16 | 0;
return;
}
```
Строчка 7 демонстрирует доступ к полю какой-то структуры. Можно догадаться, что структура представляет собой стейт игрока, а поле - направление, в которое игрок смотрит в данный момент. На основании направления происходит доступ к npc путем вызова функции get\_entity\_at. Ну и в завершении вызывается функция show\_quote, в которую прокидывается npc в качестве аргумента. Но все же меня очень интересует функция show\_quote. Вдруг там и спрятан флаг.
```
function show_quote($0) {
$0 = $0 | 0;
var $3 = 0, $17 = 0, $39 = 0;
$3 = __stack_pointer - 48 | 0;
__stack_pointer = $3;
HEAP32[($3 + 44 | 0) >> 2] = $0;
HEAP32[($3 + 12 | 0) >> 2] = 0;
label$1 : {
label$2 : while (1) {
if (!(((HEAPU8[((HEAP32[($3 + 12 | 0) >> 2] | 0) + 9424 | 0) >> 0] | 0) & 255 | 0 | 0) != (0 & 255 | 0 | 0) & 1 | 0)) {
break label$1
}
$17 = 24;
HEAP8[(($3 + 16 | 0) + (HEAP32[($3 + 12 | 0) >> 2] | 0) | 0) >> 0] = (((HEAPU8[((HEAP32[($3 + 12 | 0) >> 2] | 0) + 9424 | 0) >> 0] | 0) << $17 | 0) >> $17 | 0) ^ ((((HEAP32[(HEAP32[($3 + 44 | 0) >> 2] | 0) >> 2] | 0) - 1 | 0) + (HEAP32[($3 + 12 | 0) >> 2] | 0) | 0 | 0) % (256 | 0) | 0) | 0;
HEAP32[($3 + 12 | 0) >> 2] = (HEAP32[($3 + 12 | 0) >> 2] | 0) + 1 | 0;
continue label$2;
};
}
HEAP8[($3 + 38 | 0) >> 0] = 0;
$39 = HEAP32[((HEAP32[($3 + 44 | 0) >> 2] | 0) + 12 | 0) >> 2] | 0;
HEAP32[$3 >> 2] = $3 + 16 | 0;
snprintf(315152 | 0, 300 | 0, $39 | 0, $3 | 0) | 0;
HEAP8[(0 + 315112 | 0) >> 0] = 1;
__stack_pointer = $3 + 48 | 0;
return;
}
```
Хмм, интересный цикл. В цикле вычисляется, по всей видимости, адрес строки, которую нужно показать. И все же нет смысла глядеть в статичный код, нужно что-нибудь динамическое в виде какого-нибудь дебаггера по типу cheat engine, но для браузера. Поиски натолкнули меня к интересному расширению под названием [Cetus](https://github.com/Qwokka/Cetus).
Посмотрю-ка я в раздел строк для начала.
Не, ничего примечательного. Придется пойти сложным путем - копать. Перейдем в раздел Memory View. Для начала я хочу подтвердить свою гипотезу о том, что по адресу 315136 располагается структура игрока. Сделаем так
Действительно, при перемещении игрока можно заметить меняющееся значение первого байта, что есть направление. Но мне все-таки интересно посмотреть на поведение игры во время взаимодействия с npc. В этот момент мне в голову приходит только один вопрос: есть ли какое-то уникальное свойство у npc, не меняющееся в течение всей игры? Конечно, позиция! Они ведь всегда статичны. Тогда если ввести хотя бы x координату, то можно и на структуру npc напороться.
Я ушел очень далеко, чтобы сузить пространство поиска. Попробуем найти что-нибудь в памяти со значением -546 (x-координата мадмуазель). Для этого я перейду в раздел Search.
Супер, только 2 ячейки памяти с таким значением. Путем перебора я быстро выяснил, что то, что мне нужно располагается по адресу 0x0004f2b8. Что ж, сходим туда.
Несложно заключить, что по адресу 0x0004f2bc располагается y-координата. Мне интересно, если есть что-нибудь до x-координаты. Вычтем 4 и посмотрим.
Хм, тут число 0x000000f6. Мне не совсем понятно, что оно значит, но предположим, что это какой-нибудь entityID по совместительству являющееся началом структуры. Анализируя функцию show\_quote я нашел фрагмент, вычисляющий адрес строки.
```
$39 = HEAP32[((HEAP32[($3 + 44 | 0) >> 2] | 0) + 12 | 0) >> 2] | 0;
```
Упростим строчку до
```
$39 = HEAP32[(0x0004f2b4 + 12)]
```
Вычислив эффективный адрес, можно поглядеть, что находится в этой ячейке.
Число 0x000020cc. Просто число или адрес какой-нибудь штуки? Я больше склоняюсь ко второму. Что ж, продолжим копать.
Бинго! Да это же наша строка! В этот момент передо мной предстает выбор:
A) Я бегу по всей карте и взаимодействую с каждым npc, которого вижу, до тех пор, пока не найду нужного
Б) Найду строку, хоть сколько-нибудь напоминающую строку с флагом, ну и на основании уже имеющихся знаний реверсну процесс.
Полагаю, что выбор очевиден, господа.
Для поисков флага пришлось использовать wasm-objdump с параметром -s, ну и греппать слово flag. Нашлась форматирующая строка "You found me! Your flag is %s". Далее остается только ввести это в Cetus и выяснить, что адресом строки является 0x00002588.
И вот почти весь пазл собран, но остается одна недостающая деталь - нам нужно найти позицию npc, который держит флаг. Для этого снова введем в строку поиска значение 0x00002588.
Лишь один результат - 0x00050b5c. Теперь лишь остается пойти в память и ввести туда значение 0x00050b5c - 12, так как изначально к началу структуры прибавлялось число 12. До флага осталось всего ничего, но мне хочется оставить это для тебя, дорогой читатель.
### Заключение
Конечно, мне не удалось воспроизвести полный ход мыслей во время решения этого челленджа, так как цепочка мыслей и действий очень велика по той причине, что на его решение я потратил 2 дня. Тот факт, что в то время я занимался исследованием самого формата WebAssembly, только увеличил дозу дофамина в 5x раз, когда мне удалось наконец-таки решить его. Ну и я очень рад, что появилась тема для первого поста на Хабре :) | https://habr.com/ru/post/707504/ | null | ru | null |
# Обход аутентификации и способы выполнения произвольного кода в ZABBIX
Источник:https://eternalhost.net/wp-content/uploads/2020/02/0-Sistema-Zabbix-.pngВ этой статье мы поговорим о некоторых атаках на систему мониторинга Zabbix и рассмотрим сценарии удаленного выполнения кода (RCE).
Zabbix- это свободная система мониторинга и отслеживания статусов разнообразных сервисов, серверов и сетевого оборудования. Рассказывать про всю функциональность Zabbix’а не имеет смысла, отметим лишь то, что есть серверная часть, которая собирает, обрабатывает и хранит данные, и агенты, которые располагаются на устройствах, с которых эти данные собираются.
Нередко на пентестах встречаются устаревшие версии Zabbix, или Zabbix с дефолтными или словарными паролями администраторов (а иногда и все вместе). В таких случаях Zabbix становится легкой добычей для пентестера.
Стоит отметить и новую уязвимость [CVE-2022-23131](https://nvd.nist.gov/vuln/detail/CVE-2022-23131), которая позволяет обойти аутентификацию, если используется SAML SSO. Уязвимость заключается в том, что в некоторых классах не вызывается метод проверки подписи *CEncryptedCookieSession::checkSign()*, в частности в классе *CCookieSession*, который отвечает за обработку файлов Cookie. Из-за этого значение cookie не верифицируется на сервере, а так как клиент может модифицировать cookie, то атакующий может спокойно его поменять. Это приводит к возможности обхода аутентификации, так как атакующему достаточно изменить значение поля *saml\_data[username\_attribute]* в Cookie-файле zabbix\_session. В этом поле нужно указать логин администратора, от имени которого нужно авторизоваться.
Часть кода ui/index\_sso.php, в котором отсутствует верификация cookie.
```
if (CSessionHelper::has('saml_data')) {
$saml_data = CSessionHelper::get('saml_data');
CWebUser::$data = API::getApiService('user')->loginByUsername($saml_data['username_attribute'],
(CAuthenticationHelper::get(CAuthenticationHelper::SAML_CASE_SENSITIVE) == ZBX_AUTH_CASE_SENSITIVE),
CAuthenticationHelper::get(CAuthenticationHelper::AUTHENTICATION_TYPE)
);
```
Так как в классе *CCookieSession* не вызывается метод проверки подписи, то мы успешно пройдем аутентификацию и получим доступ к панели администратора.
Предположим, что нам удалось каким-либо образом получить доступ к панели администратора Zabbix. Для того, чтобы выполнять системные команды на сервере и агентах, достаточно заглянуть в документацию, так как возможность выполнения команд на сервере и агентах заложена разработчиками в продукт. Разберем несколько кейсов с помощью которых можно выполнить системные команды. Отметим, что команды можно исполнять на агентах, только если установлен флаг *EnableRemoteCommands=1* в файле /etc/zabbix/zabbix\_agentd.conf. По умолчанию выставлено значение *EnableRemoteCommands=0.*
1. Выполнение команд через [scripts](https://www.zabbix.com/documentation/current/en/manual/web_interface/frontend_sections/administration/scripts)
Для выполнения команд вам необходима учетная запись с ролью Super Admin. В документации сказано, что в разделе *Administration* → *Scripts* определены глобальные скрипты, которые мы можем изменить или создать новые. Например, мы можем пропинговать или выполнить трассировку хостов.
Чтобы создать новый скрипт нажимаем Create script. В поле Commands прописываем команды, которые хотим исполнить, например, hostname и id. Выбираем, где мы хотим исполнять скрипт: на агенте или сервере. Сохраняем.
Для того, чтобы выполнить скрипт, заходим в раздел Monitoring → Latest data. Выбираем нужный хост и название созданного скрипта, далее в окне отобразится вывод команд.
2. Выполнение команд через [Items](https://www.zabbix.com/documentation/current/ru/manual/config/items/item)
Данный способ будет полезен в случае, если вы получили учетную запись с привилегиями Admin (стоит уточнить, что при получении УЗ Super Admin все перечисленные сценарии RCE будут работать, так как этот тип УЗ имеет максимальные привилегии). У такой учетной записи будет ограниченный доступ к панели администратора.
В таких условиях также можно будет выполнить команды на агентах, для этого переходим в раздел Configuration → Hosts → Items → Create Item
В поле Key указываем команду через ключ [system.run](https://www.zabbix.com/documentation/current/ru/manual/config/items/itemtypes/zabbix_agent). Сохраняем и команда автоматически будет выполнена на агенте.
 Сохраняем и проверяем подключение в nc.
3. Выполнение команд через [Actions](https://www.zabbix.com/documentation/current/ru/manual/config/notifications/action)
Данный способ также будет работать, если вы получили учетную запись с привилегиями Admin. В Zabbix есть функциональность с помощью которой можно выполнять команды в результате каких-либо событий. Чтобы создать событие, заходим в раздел Configuration→Actions→Event source→Discovery→Create action.
Задаем имя, выбираем тип операции Remote command, в поле Commands вводим полезную нагрузку, в поле Execute on указываем каким способом этот скрипт будет выполняться (Zabbix агентом, Zabbix сервером (прокси) или только Zabbix сервером).
 Сохраняем и проверяем nc.
4. Выполнение команд через jsonRPC
В старых версиях Zabbix’а (версии 2.2<3.03) уязвимо API, с помощью которого можно взаимодействовать с сервером и агентами через json-RPC. На гитхабе присутствует множество эксплойтов, для успешной эксплуатации нам необходимо знать учетные данные администратора Zabbix и [hostId](https://www.zabbix.com/documentation/3.2/en/manual/api/reference/host/get).
Чтобы определить hostId, необходимо зайти в Configuration → Hosts → Items и в GET-параметре увидим его значение.
 Указываем в эксплойте недостающие учетные данные и получаем RCE.
**Заключение**
Полученный низкопривилегированный доступ к системе может быть использован для дальнейшего продвижения по сети. На Windows системах Zabbix-агенты запущены с правами NT AUTHORITY\SYSTEM, что позволяет сразу получить высокие привилегии.
При написании данной статьи я сталкивался с описаниями различных кейсов компрометации внутренней информационной инфраструктуры с помощью Zabbix. В одной [статье](https://www.whiteoaksecurity.com/blog/take-over-situations-part-1-zabbix/) был описан случай, когда Zabbix-агент был установлен на контроллере домена, а панель администратора Zabbix была доступна с паролем по умолчанию. Вот, что значит получить доменного админа за пару минут 🙂.
На сегодня это все, в конце хотелось бы напомнить, что необходимо вовремя обновлять ПО и менять пароли, установленные по умолчанию, а также не использовать словарные пароли. | https://habr.com/ru/post/656829/ | null | ru | null |