text stringlengths 20 1.01M | url stringlengths 14 1.25k | dump stringlengths 9 15 ⌀ | lang stringclasses 4
values | source stringclasses 4
values |
|---|---|---|---|---|
# Чистим домашний интернет от очень назойливой рекламы (Ad's blocker для OpenWRT)
*Дело было вечером, делать было нечего...* © С. В. Михалков
*Навеяно публикацией [«Как я bind`ом вирусы искал…»](http://habrahabr.ru/post/221917/), а конкретно этой [веткой комментариев](http://habrahabr.ru/post/221917/#comment_7568287). Надеюсь, не поздно размещаю.*
Сидел я и думал, телевизор Samsung, WinPhone, *(а впоследствии может кофеварка и пылесос)* показывают суперназойливую рекламу, надо с этим чтото делать, и раз в WinPhone и телевизор*(кофеварку, пылесос)* плагина AdBlock нету, то он должен быть там где ходит их трафик, на роутере.
Оказалось ничего сложного тут нету, роутер у меня TP-Link 1043, с usb портом, флешка монтирована в /root, у кого флешки нет, можно использовать /tmp, замените пути.
Для начала научим стандартный dnsmasq работать с внешним host файлом.
В файле /etc/config/dhcp добавить строку:
```
в секции
config dnsmasq
list addnhosts '/root/hosts/adfree'
list addnhosts '/root/hosts/unchanged'
```
Файл */root/hosts/unchanged* я использую для добавления собственных hosts правил, или которых нет в adfree.
По пути /root/hosts/ создаем скриптик *upd-adfree.sh* который качает свежие списки adfree (ссылка которую использует android телефон) и модифицирует под вид hosts, затем перезагружает dnsmasq для того чтоб он прочитал новые файлы.
```
##adfree
wget http://winhelp2002.mvps.org/hosts.txt -O adfree-tmp
sed 's/^\(.*\).$/\1/' adfree-tmp > adfree
## dns restart to update
/etc/init.d/dnsmasq restart
```
И дать права на выполнение:
```
chmod +x /root/hosts/upd-adfree.sh
```
в файле /etc/crontabs/root добавить строку
`0 0 * * * /root/hosts/upd-adfree.sh`
Что означает запускать скрипт каждый день в 0:00.
Активировать cron:
```
/etc/init.d/cron enable
```
Собственно, всё. Конечно блокируется не всё, не сравнить с AdBlockPlus в десктопный браузерах, для этого надо проксю ставить, но и нагрузка небольшая идет.
Плюсы для меня: WinPhone не показывает рекламу в играх, девушке на компе не выскакивает видеореклама всяких *1000$ за сутки ничегонеделанья* с какого то форума, который не работает если видит в плагинах adblock, ютуб на телевизоре не орет рекламу на весь дом.
Минусы, обнаруженные мною: Некоторые сайты умеют определять adblock по размеру рекламных окон, такие будут возмущаться.
Ну и по традиции ошибки прошу писать в личные сообщения, *я их исправлю*. | https://habr.com/ru/post/263081/ | null | ru | null |
# Обеспечение качества кода в масштабных проектах
Когда осенью 2012 года я пришёл в Airbnb, то здесь мягко выражаясь, был некоторый разброд и шатание. Некоторое время назад компания начала расти и развиваться огромными темпами. В первую очередь это выражалось в объёмах трафика и транзакций. Чтобы справляться со всем этим, очень быстро увеличили и штат разработчиков. За год до моего прихода в группе было 16 человек, со мной было около 40, а сейчас уже свыше 130. И одной из главных проблем, вызванной всеми этими процессами, стало сохранение качества кода в стремительно увеличивающемся и усложняющемся проекте.
Оглядываясь назад, мне кажется, что это был переломный момент в истории нашей компании. Взрывное развитие стало причиной возникновения ряда технических и культурных вызовов для Airbnb, которые в большинстве своём пересекались друг с другом. Нам и раньше приходилось решать многочисленные трудные задачи, но в целом они были связаны с:
• масштабированием цельных приложений на Ruby on Rails, которые создавались безо всякого расчёта на последующую масштабируемость,
• и увеличением группы разработчиков для решения предыдущей задачи.
Сейчас уже понятно, что нам удалось справиться с многочисленными проблемами роста. И здесь я хотел бы рассказать о том, как мы переходили к написанию более удобного в сопровождении, более технологичного кода. И, как следствие, куда более пригодного к масштабированию.
Сейчас я работаю в группе, занимающейся разработкой модуля для [обработки платежей](https://www.airbnb.ru/jobs/departments/position/11422). Поэтому для нас качество кода, его устойчивость и удобство сопровождения имеют критически важное значение. Учитывая объём транзакций, недопустимы даже маленькие ошибки. За последний год мы проделали большую работу по выработке правил и методик, позволяющих писать код быстро и в то же время качественно. В первую очередь, речь идёт о об установлении и соблюдении при кодинге специфических стилей и условий, регулярной проверке кода коллегами (peer review) и тестировании.
#### Согласованность кода
Согласованность кода зависит от синтаксического стиля и соблюдения договорённостей и методик при написании. Вы читали и слышали об этом много раз, но всё же повторю: если вы можете открыть файл из своей кодовой базы и по стилю определить, кто из ваших коллег его написал, то это [очень плохой знак](https://github.com/airbnb/javascript/issues/102). На нашей работе крайне благоприятно сказалась выработка внутренних стандартов кодинга и соблюдение их всеми членами команды.
В общем смысле, компьютерный код потребляется двумя классами сущностей: машинами и людьми. Машинам всё-равно, как выглядит код, лишь бы он компилировался без проблем. А вот разработчикам не всё-равно. Если у вас в коллективе применяются различные стили и подходы к написанию и решению проблем в кодовой базе, то это приводит к излишней когнитивной нагрузке на всех участников, и длительному вниканию в код, созданный не тобой самим. Если же все члены группы пишут код в более-менее схожей манере, то существенно упрощается дебаггинг, гораздо легче становится поддерживать чужой код. Я не имею в виду, что вы должны делать выбор в пользу каких-то решений в угоду читабельности или простоты кода, но есть достаточно способов унификации процесса кодинга всеми членами команды.
У себя в Airbnb мы улучшали согласованность кода в течение двух лет. Сначала мы разработали руководство по стилю (было несколько версий этого руководства). Самые детальные руководства по [JavaScript](https://github.com/airbnb/javascript) и [Ruby](https://github.com/airbnb/ruby), также есть по [RSpec](http://en.wikipedia.org/wiki/RSpec), дизайну API, проектированию услуг и т.д. Несмотря на то, что эти руководства основаны на наших специфических требованиях и условиях, многие из них теперь используются как другими коллективами, так и одиночным разработчиками. Конечно, потенциальная польза этих руководств зависит от типа приложения, над которым вы работаете, но если вы разрабатываете на JavaScript или Ruby, то рекомендую в любом случае ознакомиться с ними. Хотя бы для вдохновения.
Некоторые правила приняты нами исключительно произвольно. Например, по отступам (табуляция и пробел), или на какой строке располагать открывающую фигурную скобку. Эти и прочие моменты — дело вкуса. Тут важно, чтобы правила соблюдались всеми причастными лицами. С другой стороны, в ряде случаев возможны варианты.
Возьмём длину строки. Мы предпочитаем делать строки короткими и наглядными. Короткие строки не только более читабельны, но и позволяют задавать операторы в более простой форме (особенно, когда они используются с описательными именами переменных). Методы, состоящие из серий коротких простых операторов, легче для восприятия и модифицирования. Даже [диффы](https://ru.wikipedia.org/wiki/Diff) в результате точнее показывают, что поменялось между коммитами. А поскольку мы пишем тестопригодный код, содержащий небольшие, лаконичные методы, то это подталкивает к созданию очень «чистой», модульной и лёгкой для понимания кодовой базы.
Рассмотрим пример:
```
usernames = Users.where(:status => 1, :deleted => false).map{ |u| u.first_name.downcase }.reject{ |n| n == ‘john’ }.map{ |n| n.titleize }
```
Допустим, нам нужно поменять регистр. Дифф покажет нечто подобное:
```
- usernames = Users.where(:status => 1, :deleted => false).map{ |u| u.first_name.downcase }.reject{ |n| n == ‘john’ }.map{ |n| n.titleize }
+ usernames = Users.where(:status => 1, :deleted => false).map{ |u| u.first_name.upcase }.reject{ |n| n == ‘JOHN’ }.map{ |n| n.titleize }
```
Трудно сказать навскидку, что именно поменялось, не пропарсив строку у себя в голове. А если бы код был изначально написан так:
```
users = Users.where(:status => 1, :deleted => false)
usernames = users.
map{ |user| user.first_name.downcase }.
reject{ |name| name == ‘john’ }.
map{ |name| name.titleize }
```
То разница в диффе была бы куда нагляднее:
```
users = Users.where(:status => 1, :deleted => false)
usernames = users.
- map{ |user| user.first_name.downcase }.
- reject{ |name| name == ‘john’ }.
+ map{ |user| user.first_name.upcase }.
+ reject{ |name| name == ‘JOHN’ }.
map{ |name| name.titleize }
```
Забавно, но изначально те из нас, кто продвигать такой подход, поначалу столкнулись с сопротивлением коллег. Пришлось проявить настойчивость, и в результате это вошло у всех нас в привычку — делать короткие строки. Совсем экстремальные примеры на эту тему можно увидеть в руководствах [Joint Strike Fighter C++](http://www.stroustrup.com/JSF-AV-rules.pdf) и [JPL C Coding](http://lars-lab.jpl.nasa.gov/JPL_Coding_Standard_C.pdf). Очевидно, что эти стандарты избыточны для большинства потребительских веб-приложений, поэтому всегда соотносите уровень проекта и цели, которых хотите достичь соблюдением тех или иных правил. Важно соблюдать баланс.
Как я упоминал, мы создали руководства также для разработки API и сервисов. Несмотря на то, что заранее не всегда удаётся однозначно прописывать подобные вещи, консолидация общих знаний команды в единый документ оказала неоценимую пользу.
#### Проверка кода коллегами
Регулярный аудит кода своих коллег стал вторым краеугольным камнем повышения согласованности кода. Самое главное преимущество этого процесса в том, что он позволяет быстро и эффективно обнаруживать всевозможные баги до того, как они попадут в очередной релиз. Но есть в перекрёстном аудите и множество других мелких положительных моментов. В течение последнего года мы проводим аудит для каждого внесённого в код изменения.
Мы стараемся вовлекать в аудит всех, кто так или иначе причастен к данной части кода или функционала. В результате по наиболее нетривиальным pull request возникает как минимум одно-два независимых обсуждения. Иногда процесс разбора заходит так далеко, что некоторым приходится изучать ранее неизвестные для себя вещи (например, процессинг кредитных карт, внутреннюю организацию баз данных, криптографию и т.д.). Если изменение в коде затрагивает какой-то большой важный вопрос, то мы создаём соответствующие рекомендации и документацию. Хочу подчеркнуть, что при рецензировании у нас не допускается апеллирование к своему статусу или должности. Ценится вклад любого члена команды, и в бой выкатываются наилучшие решения. Всё это является и хорошей школой для новичков, к слову говоря.
Важно помнить, что само по себе наличие рекомендаций не означает, что им будут следовать (или хотя бы читать), или что они подходят на все случаи жизни. Зато рецензирование не только очень эффективно с точки зрения взаимопомощи, но и является прекрасным способом узнать или научить кого-то искусству программирования, что затруднительно сделать с помощью обычных учебников. И когда люди многому учатся на работе, это способствует их вовлечению и улучшает качество труда.
Вот пример ситуации, когда главную роль играет не стиль кодинга, а мудрый подход:
```
rus_users = User.active.select{ |u| ‘RUS’ == u.country }
puts “There are #{rus_users.length} RUS users today”
```
и
```
rus_users = User.active.where(:country => ‘RUS’)
puts “There are #{rus_users.count} RUS users today”
```
Первый вариант более ресурсоёмок, и при больших объёмах данных может привести к катастрофическому падению производительности. Добавление `select` к объекту `User.active` означает, что Rails обратится к MySQL, вызовет и инстанцирует всех активных пользователей, положит их в массив, итерирует его и выберет пользователей, чья страна соответствует RUS. И всё это лишь для того, чтобы посчитать их.
Во втором примере мы тоже начинаем с объекта `User.active`, но затем применяем фильтр where. Первая строка не инициирует какие-либо запросы к базе данных. Когда во второй строке, когда мы запрашиваем счётчик, Rails лишь делает запрос `SELECT COUNT(*)` и не заморачивается вызовом строк или инстанцированием моделей.
Вот ещё пример:
плохо:
```
amount = Payout.
where(:successful => true).
where(‘DATE(timestamp) = ?’, Date.today).
inject(0) { |sum, p| sum += p.amount }
```
хорошо:
```
amount = Payout.
where(:successful => true).
where(‘DATE(timestamp) = ?’, Date.today).
sum(:amount)
```
В первом примере мы ограничиваем область поиска одним днём, но даже в этом случае нужно вызвать и инстанцировать большое количество объектов всего лишь для суммирования по одному полю. Во втором примере суммированием во время поиска занимается MySQL, который потом просто возвращает нужное нам значение. В целом это не создаёт дополнительной нагрузки на MySQL, мы не генерируем ненужный сетевой трафик и избегаем потенциально огромных вычислений в Ruby.
Приведённые примеры демонстрируют, как мы улучшаем отзывчивость нашего сайта и даже предотвращаем его падения. Рецензирование хорошо ещё и тем, что, обсуждая какую-то конкретную часть кода, сотрудники периодически поднимают самые разные темы, вроде структуры баз данных или генерации финансовых отчётов. То есть вокруг кода постоянно возникают живые и продуктивные диалоги, в ходе которых мы учимся сами и обучаем других.
#### Тестирование
Я не буду углубляться в этот вопрос, об этом очень хорошо написано в [одном из постов](http://nerds.airbnb.com/testing-at-airbnb/) нашего блога. Скажу лишь (и вряд ли это будет для вас чем-то новым), что тестирование невероятно важный процесс с точки зрения обеспечения высокого качества кода, удобного в сопровождении. Однако дело не в максимальном охвате кода тестами, главное заключается в создании культуры тестирования, чтобы это стало условным рефлексом у каждого члена команды. Когда в привычку входит написание тестов, то и создание тестопригодного кода также превращается в привычку.
#### Заключение
Подведу итоги всему сказанному.
Все члены профессиональной команды разработчиков, какого бы размера она не была, должны писать код в одном, заранее утверждённом стиле. Это помогает широко использовать удачные подходы и методики, облегчает сопровождение и обслуживание кода другими людьми. Лучшим началом будет создание руководств по стилю кодинга. Даже обманчиво простые и очевидные вещи могут сильно влиять на качество кода, его устойчивость и простоту рефакторинга.
Необходимо активно и конструктивно рецензировать код друг друга. Как минимум один человек, помимо автора, должен просмотреть все диффы. Доброжелательное внесение предложений и их проверка кода является залогом сплочения коллектива и роста профессионального уровня. Это помогает новичкам быстрее и полнее учиться, обретать полезные навыки и привычки. В конце концов, это может уберечь ваше приложение от серьёзного падения.
Важно развивать сильную культуру тестирования, не идти в этом на компромиссы или «срезать дорогу». Чем больше мы тестируем, тем больше это превращается в привычку. В результате можно даже полюбить этот процесс. | https://habr.com/ru/post/252125/ | null | ru | null |
# Тонкость определения EIGRP Feasible Distance
EIGRP – это дистанционно-векторный протокол маршрутизации, изначально разработанный Cisco. Одним из ключевых отличий от предшественника, IGRP, является использование DUAL – алгоритма, который позволяет исключить появление постоянных петель маршрутизации в топологии. Однако найти корректное определение одного из основных параметров DUAL, feasible distance (FD), оказывается подчас непростой задачей. Обратимся к [определению на официальном сайте](https://www.cisco.com/c/en/us/support/docs/ip/enhanced-interior-gateway-routing-protocol-eigrp/16406-eigrp-toc.html#anc7)):
> *“Feasible distance is the best metric along a path to a destination network, including the metric to the neighbor advertising that path.“*
>
> Перевод: feasible distance – это наилучшее значение метрики до сети назначения, включающее значение метрики до соседа, который анонсирует соответствующий маршрут.
>
>
Такое определение справедливо для большинства случаев, но, к сожалению, далеко не для всех. Несмотря на то, что корректное определение можно найти на просторах интернета, попробуем выяснить, что именно не так с определением выше. Ниже лабораторная схема:
На каждом из маршрутизаторов настроен соответствующий loopback (например, на R1 – с адресом 1.1.1.1/32). В сети, очевидно, используется EIGRP в качестве протокола маршрутизации без каких-либо изысков в настройке:
```
R3#sho run | section router eigrp
router eigrp 1
network 0.0.0.0
```
В рамках данной статьи основной интерес представляет маршрут до 3.3.3.3/32 с точки зрения R1:
```
R1#deb eigrp fsm
EIGRP Finite State Machine debugging is on
R1#sho ip eigrp topology 3.3.3.3/32
EIGRP-IPv4 Topology Entry for AS(1)/ID(1.1.1.1) for 3.3.3.3/32
State is Passive, Query origin flag is 1, 1 Successor(s), FD is 158720
Descriptor Blocks:
192.168.12.2 (FastEthernet0/0), from 192.168.12.2, Send flag is 0x0
Composite metric is (158720/156160), route is Internal
Vector metric:
Minimum bandwidth is 100000 Kbit
Total delay is 5200 microseconds
Reliability is 255/255
Load is 1/255
Minimum MTU is 1500
Hop count is 2
Originating router is 3.3.3.3
```
По умолчанию существуют [2 способа](https://www.cisco.com/c/en/us/support/docs/ip/enhanced-interior-gateway-routing-protocol-eigrp/16406-eigrp-toc.html#anc6) повлиять на значение метрики EIGRP: изменить пропускную способность канала или же его задержку. В нашем случае изменение пропускной способности позволяет получить более предсказуемые результаты. Изменим метрику соединения между R2 и R3:
```
R2(config-if)#delay 100
```
Как и следовало ожидать, R1 теряет единственный маршрут до 3.3.3.3/32 и переводит префикс в состояние Active:
```
R1#
*Mar 2 20:17:07.655: EIGRP-IPv4(1): rcvupdate: 3.3.3.3/32 via 192.168.12.2 metric 181760/179200 on tid 0
*Mar 2 20:17:07.659: EIGRP-IPv4(1): Find FS for dest 3.3.3.3/32. FD is 158720, RD is 158720 on tid 0
*Mar 2 20:17:07.659: EIGRP-IPv4(1): 192.168.12.2 metric 181760/179200 not found Dmin is 181760
*Mar 2 20:17:07.659: DUAL: AS(1) Peer total 1 stub 0 template 1 for tid 0
*Mar 2 20:17:07.659: DUAL: AS(1) Dest 3.3.3.3/32 entering active state for tid 0.
*Mar 2 20:17:07.659: EIGRP-IPv4(1): Set reply-status table. Count is 1.
*Mar 2 20:17:07.659: EIGRP-IPv4(1): Not doing split horizon
*Mar 2 20:17:07.759: EIGRP-IPv4(1): rcvreply: 3.3.3.3/32 via 192.168.12.2 metric 181760/179200 for tid 0
*Mar 2 20:17:07.759: EIGRP-IPv4(1): reply count is 1
*Mar 2 20:17:07.759: DUAL: AS(1) Clearing handle 0, count now 0
*Mar 2 20:17:07.759: DUAL: AS(1) Freeing reply status table
*Mar 2 20:17:07.759: EIGRP-IPv4(1): Find FS for dest 3.3.3.3/32. FD is 72057594037927935, RD is 181760 on tid 0 found
*Mar 2 20:17:07.759: DUAL: AS(1) RT installed 3.3.3.3/32 via 192.168.12.2
```
Значение FD также изменилось – теперь оно соответствует значению метрики до 3.3.3.3/32:
```
R1#sho ip eigrp topology 3.3.3.3/32
EIGRP-IPv4 Topology Entry for AS(1)/ID(1.1.1.1) for 3.3.3.3/32
State is Passive, Query origin flag is 1, 1 Successor(s), FD is 181760
Descriptor Blocks:
192.168.12.2 (FastEthernet0/0), from 192.168.12.2, Send flag is 0x0
Composite metric is (181760/179200), route is Internal
Vector metric:
Minimum bandwidth is 100000 Kbit
Total delay is 6100 microseconds
Reliability is 255/255
Load is 1/255
Minimum MTU is 1500
Hop count is 2
Originating router is 3.3.3.3
```
Попробуем теперь другое значение, предварительно сбросив предыдущие изменения. Задержка для интерфейса f0/1 на R2:
```
R2#sho int f0/1
FastEthernet0/1 is up, line protocol is up
Hardware is i82543 (Livengood), address is ca02.0ebd.0006 (bia ca02.0ebd.0006)
Internet address is 192.168.23.2/24
MTU 1500 bytes, BW 100000 Kbit/sec, DLY 100 usec,
```
В прошлый раз мы назначили задержку, равную 1000 мкс (значение указывает в десятках микросекунд), что значительно больше значения по умолчанию. Теперь используем минимально настраиваемое значение в 110 мкс:
```
R2(config-if)#delay ?
<1-16777215> Throughput delay (tens of microseconds)
R2(config-if)#delay 11
```
Известен небольшой трюк, позволяющий не ошибиться с единицами измерения значений в командах: перед вводом значения символ ‘?’ вызывает контекстную подсказку, которая среди прочего указывает и ожидаемые единицы измерения; такая привычка подчас экономит массу времени, исключая ошибки по невнимательности (в конце концов десятки микросекунд – не самая очевидная единица измерения на мой взгляд). Проверим, что происходит в этот момент на R1:
```
R1#
*Mar 2 20:25:40.227: EIGRP-IPv4(1): rcvupdate: 3.3.3.3/32 via 192.168.12.2 metric 158976/156416 on tid 0
*Mar 2 20:25:40.231: EIGRP-IPv4(1): Find FS for dest 3.3.3.3/32. FD is 158720, RD is 158720 on tid 0
*Mar 2 20:25:40.231: EIGRP-IPv4(1): 192.168.12.2 metric 158976/156416 found Dmin is 158976
*Mar 2 20:25:40.239: DUAL: AS(1) RT installed 3.3.3.3/32 via 192.168.12.2
```
Отладочный вывод в этот раз существенно меньше. Что насчёт значения FD?
```
R1#sho ip eigrp topology 3.3.3.3/32
EIGRP-IPv4 Topology Entry for AS(1)/ID(1.1.1.1) for 3.3.3.3/32
State is Passive, Query origin flag is 1, 1 Successor(s), FD is 158720
Descriptor Blocks:
192.168.12.2 (FastEthernet0/0), from 192.168.12.2, Send flag is 0x0
Composite metric is (158976/156416), route is Internal
Vector metric:
Minimum bandwidth is 100000 Kbit
Total delay is 5210 microseconds
Reliability is 255/255
Load is 1/255
Minimum MTU is 1500
Hop count is 2
Originating router is 3.3.3.3
```
FD не совпадает с метрикой! В чём же соль? Внимательный читатель мог заметить разницу между рассматриваемыми случаями помимо разных значений задержек. Рассмотрим, что происходило после изменения метрики щаг за шагом:
| | | |
| --- | --- | --- |
| | **Delay 1100** | **Delay 110** |
| **Шаг 1** | R1 получает обновление о 3.3.3.3/32 |
| **Шаг 2** | R1 ищет feasible successor for 3.3.3.3/32 |
| **Шаг 3** | R1 не удалось найти FS, что приводит к запуску DUAL | R1 находит FS и устанавливает маршрут в таблицу маршрутизации |
| **Шаг 4** | По завершении DUAL R1 выбирает наилучший маршрут и устанавливает его в таблицу маршрутизации | |
Ключевое отличие заключается в запуске R1 процесса DUAL. Большая задержка на R2 (100) изменяет метрику таким образом, что результирующий маршрут не удовлетворяет условию feasibility condition, что, в свою очередь, вынуждает R1 инициировать DUAL. Малое же изменение задержки позволяет префиксу соответствовать feasibility condition (изменение задержки меньше задержки канала R1-R2), что даёт возможность избежать времязатратного DUAL. Отладочный вывод включает в себя значение FD, используемое для поиска feasible successor в определённый момент; значение FD после окончания DUAL равно бесконечности. Получается, что FD – исторически минимальное значение метрики; оно сбрасывается, как только маршрут переходит в состояние Active.
В обсуждениях Cisco Community можно найти [точное определение FD:](https://community.cisco.com/t5/routing/definition-of-feasible-distance-in-eigrp-convergence/td-p/2684769)
> *“Feasible Distance is the lowest distance to the destination experienced since the last time the route went from Active to Passive state”*
>
> Перевод: FD – это минимальное значение метрики до сети назначения с момента последнего перехода префикса из состояния Active в Passive.
>
>
Хотя практическая польза этого знания может показаться несущественной, наличие строгих определений позволяет избежать разночтений, что положительно влияет на понимание используемой технологии.
Помогали редактировать статью: Анастасия Куралёва, Максим Климанов. | https://habr.com/ru/post/546022/ | null | ru | null |
# Функции в скриптах Роутер ОС Микротик. Интересные решения и недокументированные возможности
Роутер ОС Микротик, как известно, имеет мощнейший LUA-подобный встроенный скриптовый язык, позволяющий осуществлять исполнение сценариев, в том числе при наступлении каких-либо событий в сети или по расписанию. Скрипты могут состоять из одной строки кода или иметь внушительные размеры, при передаче управления друг другу формируя сложные программы. Встроенный скриптовый язык существенно расширяет возможности системы, практически не ограничивая полет фантазии программиста. Существующее [официальное руководство](https://wiki.mikrotik.com/wiki/Manual:Scripting) по скриптам написано кратко и, разумеется, не может охватить все особенности программирования для Роутер ОС.
В этой статье, не претендующей на полное руководство к разделу, мы рассмотрим одну из интересных и важных рубрик «скриптинга», а именно — функции.
Перед прочтением статьи, пользователям, начинающим изучать скрипты, рекомендую ознакомиться с официальным руководством Микротик по скриптам по ссылке выше, либо с его переводом (например, [здесь](https://blog.telecom-sales.ru/napisanie-skriptov-dlya-routeros)). Следует знать типы переменных в скриптах Микротик, иметь понятие об областях видимости, окружении переменных и т.д… Также будет весьма полезна статья [habr.com/ru/post/270719](https://habr.com/ru/post/270719/), в которой автор подробно разбирает типы переменных LUA Микротик и варианты их объявления и использования.
Вспомним также, что в языках программирования все команды можно разделить на две основные группы – процедуры и функции. В отличие от процедур функции не только позволяют исполнить встроенный код, но также могут использовать переданные им параметры (аргументы) и вернуть результат (в виде переменных или массивов). Функции обычно используются там, где есть необходимость повторно вызывать одни и те же фрагменты кода, чтобы не повторять их текст в листинге скрипта.
До версии Роутер ОС 6.2 функции в Микротик не были доступны напрямую, однако можно было использовать возможности команды :parse, как обходной способ для создания функций.
Например:
```
:global myFunc [:parse ":log info Goodbay!"];
$myFunc;
```
Или можно определить функцию из текста существующего скрипта:
```
# добавляем скрипт в репозиторий (если его там ещё нет)
/system script add name=myScript source=":put \"Hello world !\""
# парсим скрипт и присваиваем его текст переменной, исполняем код:
:local myFunc [:parse [/system script get myScript source]]
$myFunc
```
Здесь я также приведу пример небольшого, изящно написанного, скрипта, почерпнутого мной где-то на просторах Интернет и позволяющего создать функции из всех скриптов репозитория, имена которых начинаются в данном примере на «Function.»:
```
:local fnArray;
:foreach f in=[/system script find where name~"^Function.*"] do={:set fnArray ($fnArray.",".[/system script get $f name])};
:set fnArray [:toarray $fnArray];
:foreach f in=$fnArray do={:exec script=":global \"$f\" [:parse [/system script get $f source]]"; /log info ("Defined function ".$f);};
```
В этом скрипте, сначала производится поиск всех скриптов репозитория роутера, имена которых соответствуют требованиям поиска и заполнение ими переменной $fnArray. Затем переменная fnArray преобразуется в массив данных, а в последней строке пробегая по элементам массива циклом :foreach скрипты помещаются в переменные окружения и становятся функциями.
Позднее, начиная с версии 6.2, синтаксис был доработан и появилась возможность передачи функциям параметров, а также реализован возврат из функций. Соответствующие примеры приведены в официальном руководстве. Я же приведу здесь в качестве практического примера простую функцию FuncPing, позволяющую определить доступность устройства с указанным адресом в сети:
```
#------ FuncPing-------#
# Функция проверки доступности устройства в сети методом пинга
# в именованном параметре PingAdr следует передать пингуемый IP-адрес
# при этом IP-адрес может быть "чистым"
# или с указанием порта через двоеточие (при пинге функция отсекает порт)
#
# ответ функции возвращается в виде:
# "done" - устройство доступно в сети
# "ERROR: device not responded" - устройство не доступно
:global FuncPing do={
:local Hadr;
:if ([:find $PingAdr ":"]>0) do={:set Hadr [:pick $PingAdr 0 [:find $PingAdr ":"]];} else={
:set Hadr $PingAdr}
:local PingCount
:if ([:typeof $Count]="nothing") do={:set PingCount 3} else={:set PingCount $Count}
:local Result [/ping $Hadr count=$PingCount];
:local PingAnswer;
:local MainIfInetOk false;
:set MainIfInetOk ((3*$Result) >= (2 * $PingCount))
:put "MainIfInetOk=$MainIfInetOk"
if (!$MainIfInetOk) do={:set PingAnswer "ERROR: device not responded"}
if ($MainIfInetOk) do={:set PingAnswer "done"}
:return $PingAnswer;
}
:log info [$FuncPing PingAdr="192.168.0.7" Count=5]
```
В данном случае функция декларируется как глобальная переменная в окружении FuncPing, которой присваивается код функции, помещенный между do={}.
Функции, определённые как глобальные переменные, становятся доступны для всех скриптов репозитория, терминала и Планировщика роутера. Определенные как локальные, функции ограничены областью видимости скрипта.
В функциях Микротик можно передавать параметры двух типов: позиционные и именованные, а также их сочетание.
В примере, приведенном выше, осуществляется передача именованных параметров-аргументов PingAdr, который должен содержать адрес пингуемого функцией устройства в сети, и Count, содержащего количество «пингов» для проверки. В случае передачи функции именованных параметров, их положение в строке вызова не имеет значения (можно менять местами).
Обратите внимание на строку кода функции:
```
:if ([:typeof $Count]="nothing") do={:set PingCount 3} else={:set PingCount $Count}
```
Здесь осуществляется проверка параметра Count (число пингов). Если $Count=«nothing» (т.е. не был задан), устанавливается значение $PingCount=3, если же $Count передан в функцию, то $PingCount принимает значение $Count.
Когда нам нужно определить доступность устройства в сети, вызываем функцию FuncPing, определенную как глобальная переменная, не забыв предварительно продекларировать (объявить) её в коде своего скрипта, иначе он не сможет её выполнить. Чтобы функция была исполнена следует подставить символ «$» перед её именем, для наглядности вся конструкция может быть заключена в квадратные скобки (не обязательно), дополнительно обозначающие необходимость исполнить действие внутри:
```
:global FuncPing
:local Result [$FuncPing PingAdr=«192.168.0.1» PingCount=5]
:put $Result
```
Результат работы функция возвращает из своего кода оператором :return (в нашем примере :return $PingAnswer). Из функции возвращено может быть одно значение переменной любого типа или массив переменных.
Пока, всё изложенное выше, общеизвестно, и лишь уточняет некоторые детали. Пойдём дальше в нашем изучении функций. Следует понимать, что функция в скриптах Микротик «с точки зрения» скриптового языка по конструкции напоминает ни что иное как массив. Такая конструкция удобна как для передачи параметров, так и для возврата результатов.
Это положение может быть доказано, например, следующим. Я условно называю это выражением function knows its name (функция знает своё имя).
Заключается этот эффект в том, что вне зависимости передавали ли функции аргументы или нет (в том числе строковые, позиционные или смешанные), при вызове функции всегда имеется параметр $0, который содержит имя нашей функции (вероятно он служит как какой-то внутренний указатель в скриптах Микротик).
Таким образом, получается, что функция – это смешанный массив, содержащий как позиционные ($0), так и именованные аргументы (ключевые и/или нумерованные элементы массива – аргументы функции).
«Узнать своё имя» функция может следующим образом (берем $0 и отсекаем у него первый символ, это всегда «$»):
```
:global FuncName do={:return [:pick $0 1 [:len $0]]}
:log info [$FuncName]
```
Этот трюк можно использовать для нескольких целей: для печати в лог роутера событий, осуществляемых в функции, в том числе в подпрограммах обработки ошибок, сокращая текст надписей.
Кроме, того данный эффект позволяет избежать столкновения с одной ошибкой, допущенной разработчиками Микротик и изученной мной на собственном опыте.
А именно, по неизвестным причинам, при вызове любой функции дважды подряд с заключением вызова в квадратные скобки, вызываемая функция в скриптах выполняется трижды. С чем связана такая ошибка мне не известно. При этом в службе техподдержки Микротик знают о существовании этой ошибки, но до сих пор не спешат, так же по неизвестным причинам, её исправлять.
Наглядно проиллюстрировать «ошибку третьего вызова» можно следующим образом:
```
[$FuncPing PingAdr=«192.168.0.1» PingCount=5]
[$FuncPing PingAdr=«192.168.0.7» PingCount=2]
```
Здесь функция вызвана подряд дважды, а будет исполнена трижды, ошибочно повторяя именно второй вызов. Начиная с третьего раза ошибка не повторяется (последующие вызовы осуществляются корректно).
Для избежания этой ошибки, при необходимости обращения к функции дважды подряд, следует либо вызывать функции без заключения конструкции в квадратные скобки:
```
$FuncPing PingAdr=«192.168.0.1» PingCount=5
$FuncPing PingAdr=«192.168.0.7» PingCount=2
```
либо как-то блокировать лишний вызов … но как это сделать?
К счастью, как оказалось, ошибочный третий вызов функции производится без передачи функции параметра $0 (имени функции). Да, да по какой-то причине при этом ошибочном вызове $0 пуст. Это позволяет реализовать программную страховку от ошибочного выполнения внутри самой функции. Сделаем это так, допустим есть функция:
```
:global myFunc do={:log info "Hello world !"}
```
Если мы попросим выполнить её дважды:
```
[$myFunc]; [$myFunc]
```
Как мы уже выяснили она будет выполнена трижды.
Добавление в функцию проверки на наличие имени в $0 устраняет проблему:
```
:global myFunc do={
:if ([$len $0]!=0) do={
:log info "Hello world !"}
}
```
Если имеется проверка на $0, то при ошибочном третьем запуске тело кода функции будет просто проигнорировано (не будет исполнено). Эта проверка осуществляется строкой проверки на условие :if ([$len $0]!=0) do={ }.
К сожалению, пока эта ошибка не исправлена разработчиками Микротик. Для корректной работы такую проверку следует вставлять в каждую пользовательскую функцию, либо не использовать в конструкциях квадратные скобки. Это одинаково справедливо для функций, объявленных как глобальные переменные, так и для «локальных» функций.
Отдельно стоит остановиться на обработке ошибок в функциях. Не секрет, что при выполнении функций, как и обычных скриптов, могут возникать ошибки, приводящие к остановке работы. Это весьма не желательно, так как не позволяет полностью «автоматизировать» процесс. Разработчики Рос внесли возможность организации обработки ошибок, позволяющий избежать остановки выполнения сценариев при возникновении подобных ситуаций.
Обработка ошибок организуется командами do { контролируемое действие } on-error={ действие при ошибке }. В обработчик ошибок имеет смысл «заворачивать» команды, при исполнении которых есть риск ошибочного завершения, например действие команд :fetch, :resolve и т.п… Всё это справедливо и для функций. Внутри функций, я также делаю проверки на корректность переданных аргументов.
В качестве примера демонстрации обработки ошибок, приведу «старую» свою функцию FuncMail, написанную ещё в 2017 году, и служащую для отправки сообщений на почту. Функция имеет два именованных параметра: Mailtext (должен содержать текст пересылаемого сообщения) и Email (должен содержать адрес получателя):
```
#------------- FuncMail-----------------#
# Функция отправки почты
# by Sergej Serkov 24.12.17
#---------------------------------------#
# Применение:
# [$FuncMail Email="user@mail.ru" Mailtext="test letter"]
# В качестве параметра функции в Mailtext нужно передать текст сообщения на почту
# отправка почты идет на ящик, указанный в параметре Email
# для корректной работы функции почтовый сервис Router OS /tool email должен быть настроен верно по умолчанию
:global FuncMail do={
:local smtpserv [:resolve [/tool e-mail get address]];
:local Eaccount [/tool e-mail get user];
:local pass [/tool e-mail get password];
:local Eport [/tool e-mail get port];
:local Etls "yes"; # если не используется установить в "no"
:if (([:len $Email]!=0) and ([:len $Mailtext]!=0)) do={
:log info " "; :log warning "FuncMail start mail sending ... to e-mail: $Email";
do {[/tool e-mail send from="<$Eaccount>" to=$Email server=$smtpserv \
port=$Eport user=$Eaccount password=$pass start-tls=$Etls subject=("from FuncMail Router $[/system identity get name]") \
body=$Mailtext;];
} on-error={:log info ""; :log error ("Call ERROR function $0 ERROR e-mail send");
:return "ERROR: <$0 e-mail send>"}
:log warning "Mail send"; :log info " "; :return "OK: "
} else={:log error ("Call ERROR function $0 Email or Mailtext parametrs no defined"); :return ("ERROR: $0 < necessary parameters are not set >")}
}
:log info [$FuncMail Mailtext="Привет !" Email="user@mail.ru"]
```
Заметьте, обработка ошибок сделана для команды отправки почты /tool e-mail send, но не сделана для :resolve smtp сервера (для данного примера). Также сделана обработка ошибки при вызове функции без параметров:
```
:if (([:len $Email]!=0) and ([:len $Mailtext!]=0)) do={} else={:log error ("Call ERROR function $0 Email or Mailtext parametrs no defined"); :return ("ERROR: $0 < necessary parameters are not set >")}
```
Возврат из функции не всегда нужен, однако функции тем и хороши, что могут посредством переменных различных типов возвращать результаты своей работы. При этом можно возвращать из функций «логические» (булевые) переменные, такие как «thrue» и «false», числовые и строковые переменные, переменные других типов (при необходимости), а также массивы данных. Возврат из функции прекращает её работу и осуществляется командой :return.
Например:
```
:global cuDte do={:return ([/system clock get date]." ".[/system clock get time]);}
:log info [$cuDte]
```
В этом примере функция возвратит полученные конкатенацией системные дату и время в виде единой строки. А в примере ниже возврат осуществляется в виде массива элементов (первый элемент дата, второй – время)
```
:global cuDte do={:return [:toarray {[/system clock get date]; [/system clock get time]}] }
:local DateTime [$cuDte]
:log info $DateTime
:log info [:typeof $DateTime]
```
По индексам массива можно получить каждый (нужный) элементы массива (помним, что индекс первого элемента массива равен 0, второго 1 и т.д…
```
:log info ($DateTime->0)
:log info ($DateTime->1)
```
Можно тоже самое сделать с созданием ключевого массива (каждый элемент имеет имя (ключ), но описание работы с массивами выходит за рамки данной статьи и достойно отдельного рассмотрения.
Когда надобность в функции отпадает её можно удалить. Локальные функции не требуют удаления, так как удаляются системой при выходе скрипта из области видимости (либо по завершению работы). Функции, объявленные как глобальные переменные могут быть удалены из окружения присвоением пустого значения командой :set.
```
:set cuDte
```
или
```
:set сuDte (:nothing);
```
Формально можно также удалить переменную из окружения системной командой удаления:
```
/system script environment remove [find name="cuDte"]
```
Обнулить (очиcтить значение), как уже ясно из вышеизложенного, можно декларированием с присвоением пустого действия так:
```
:global cuDte []
```
Также напомню важную рекомендацию из официальной документации Wiki по скриптам относительно функций, которую следует всегда иметь ввиду:
«Если функция содержит глобально определённую переменную с именем совпадающим с именем передаваемого именного параметра, то глобально определённая переменная будет проигнорирована для совместимости со старыми версиями. Эта возможность может быть изменена в будущих версиях. Избегайте использование параметров с теми же именами, что и глобальные переменные.»
Пример:
```
:global my2 "123"
:global myFunc do={ :global my2; :put $my2; :set my2 "lala"; :put $my2 }
$myFunc my2=1234
:put «global value $my2»
```
Вывод:
1234
lala
global value 123
Любая функция может в свою очередь вызывать другие функции. Чтобы это работало, вызываемые функции должны быть продекларированы в коде той функции, которая их вызывает (пример из Wiki):
```
:global funcA do={ :return 5 }
:global funcB do={
:global funcA;
:return ([$funcA] + 4)
}
:put [$funcB]
```
Вывод:
9
В Роутер ОС Микротик поддерживается рекурсивный вызов функций. То есть функция может вызывать саму себя! Это бывает нужно в случаях, когда необходимо повторять ту или иную часть кода с различными значениями входных параметров. Рекурсивные функции фактически формируют циклы и наиболее эффективны при обработке сложных данных, которые слишком сложны, чтобы пройтись по ним с помощью обычных циклов языка, задаваемых командами :for, :foreach или :while. Для работы рекурсии в теле функции она должна декларировать сама себя.
Простой пример рекурсивного вызова функции:
```
:global CountDown do={
:global CountDown;
:if ($1>0) do={:log warning $1; :set $1 ($1-1);[$CountDown $1];}
:return "end"
}
:log info [$CountDown 5]
```
Вывод:
5
4
3
2
1
end
Заметьте, что обращаемся мы к функции один раз (:log info [$CountDown 5]), а выполняет она сама себя пока не исчерпает данные по условию (6 раз).
При наличии сложных данных рекурсивные функции работают эффективнее и быстрее циклов, при простых – наоборот. С рекурсивными функциями следует быть осторожными, так как при неправильном рекурсивном вызове может получится формирование бесконечного цикла и, как следствие, переполнение стека данными с аварийным завершением работы (чаще всего происходит перезагрузка роутера, как при исполнении /system reboot).
Более сложный пример необходимости использовании рекурсивного вызова функций в скриптах Микротик можно видеть, например, [здесь](https://github.com/Winand/mikrotik-json-parser).
Автором был создан великолепный парсер данных из формата JSON в многомерный ассоциативный массив. В функции $fJParsePrint, из набора парсера, можно видеть в коде функции рекурсивный вызов, который передает внутрь функции текущий уровень вложения и элемент-подмассив, таким образом осуществляется обход всего дерева массивов в переменной $JParseOut (подробнее в [статье](https://habr.com/ru/post/337978)).
В той же статье можно видеть недокументированную команду :any, ювелирно использованную автором парсера для исключение повторного развертывания функций при вызове, что ускоряет работу системы. При объявлении каждой из функций сначала производится проверка на её «не пустость» командой :any. Если переменная (она же функция) пуста – требуется её определение (наполнение кодом), если же не пуста, соответственно она уже содержит код и её переопределение не требуется. В качестве примера короткой, но мощной функции, для демонстрации работы :any, в указанной статье можно видеть функцию fByteToEscapeChar, «налету» преобразующей позиционный параметр $1 (байтовое число) в строковый символ, т.е. осуществляющей преобразование кода ASCII в символ.
```
:global fByteToEscapeChar
:if (!any $fByteToEscapeChar) do={ :global fByteToEscapeChar do={
:return [[:parse "(\"\\$[:pick "0123456789ABCDEF" (($1 >> 4) & 0xF)]$[:pick "0123456789ABCDEF" ($1 & 0xF)]\")"]]
}}
```
От себя добавлю интересную находку. Когда я проверил какой тип у параметра функции $0, то получил вот что:
```
:global myFunc do={:log info $0; log info [:typeof $0]}
$myFunc
```
Вывод:
$myFunc
lookup
То есть параметр $0 (тот, что содержит имя функции как мы выяснили выше) имеет некий тип «lookup», о котором нет ни слова в официальном руководстве Рос Микротик! Запомним это и посмотрим как это можно использовать (будет обсуждено далее).
Одним из интересных разделов в теме функции Роутер Ос является создание функций в массиве. Да, да, такое возможно! Действительно, раз функции можно создавать внутри переменных, почему нельзя было бы определять функции, как элементы массива?
Не скрою, данная идея не моя и была случайно почерпнута в одном из топиков официального форума Микротик [здесь](https://forum.mikrotik.com/viewtopic.php?t=181142).
При этом по данной теме очень мало информации и примеров.
Перескажу содержание топика автора со своими комментариями ниже:
Функции могут принимать параметры, которые могут быть позиционными или именованными (это мы уже знаем). Позиционные начинаются с $1 для первого параметра функции. Поскольку функция может быть элементом массива, она также может принимать параметры, как и глобальная (или локальная) функция. Все это работает нормально (при правильном использовании).
Мы уже знаем, что функция knows its name (знает своё имя). Наглядный пример ниже демонстрирует как имя функции и параметр $1 формируют предложение:
```
:global hello
:set hello do={:log info ("$[pick $0 1 [:len $0]]". " $1")}
$hello world
```
Вывод:
hello world
Функцию массив можно задать следующим образом. Сначала создаём пустой массив:
```
:global fnArray [:toarray ""]
```
Затем, наполняем его функциями, индексированными, например, по ключевым элементам:
```
:global fnArray [toarray ""]
:set ($fnArray->"hello") do={:log info "hello $1 "}
:set ($fnArray->"good by") do={:log info "good by $1 "}
```
Вызовем первую функцию:
```
[($fnArray->"hello") world]
```
Вывод:
hello
Функция должна была вывести hello world, а вместо этого выводит hello. Почему так происходит?
Всё дело в том, что параметр world, передается функции не как первый позиционный параметр $1, а как нулевой — $0, а параметр $1 получается нами вовсе не определен.
Правильно будет написать так:
```
:set ($fnArray->"hello") do={:log info "hello $0 "}
[($fnArray->"hello") world]
```
Тогда world становится $0 параметром и функция выводит:
hello world
Далее цитирую источник:
" … С несколькими параметрами то, что было бы $2 в функции с глобальной областью действия, равно $1, когда функция определена в массиве. По сути, является ли первый аргумент $0 или $1, зависит от того, где он находится. Даже примешивание именованного параметра все еще работает, позиционные аргументы просто сдвигаются на единицу, а аргументы ключ=значение работают везде, как обычно.
Возможно, что это ошибка, но более тонкая. Но я вижу логику: функция массива больше похожа на анонимную функцию — это термины CS, а глобальная функция — это команда (команды имеют имя, имя — это аргумент), поэтому первый аргумент, известный функции, всегда равен $0, что может быть его имя, если таковое имеется…
… Таким образом используйте $0, когда функция определена в массиве."
В заключение этого небольшого обзора по функциям скриптов Микротик в качестве бонуса, приведу свою универсальную функцию массив, FuncAS (Function Active Sender), осуществляющую отправку сообщений в мессенджер Телеграмм, в виде SMS через модем роутера, SMS через API сервиса sms.ru, SMS через шлюз устройств Laurent5G, Netping и на почту.
Функция FuncAS представляет собой смешанный массив, имеющий девять элементов: $0, translite, telegram, sms, smsAPI, smsLT, smsNP, email, all. Элемент all стоит последним и производит вызов всех элементов, отправляя сообщения сразу на все «пункты приема». Благодаря работе над этой функцией, выяснилась ещё одна интересная особенность функций, определенных как массив. Если вызвать не один из элементов такой функции, а как обычно функцию «целиком» (без ключей) будет произведено выполнение последнего элемента массива-функции. Этой особенностью я и воспользовался разместив на последнем месте элемент с ключом «all». Заметьте, что элемент функции «translate» не является компонентом отправки, как другие элементы, а используется частью из них для транслитерации русскоязычных сообщений как подпрограмма.
Функция полностью корректно работает при отправке сообщений на английском языке и/или русском языке с аргументом «translite» и, с учётом ограничения длины сообщения, поддерживает спец. символы \$@!#%'()\*+,-./:;<=>?[]^\_`{|}~ Для Телеграмм, API sms.ru и большинства почтовых клиентов (проверено для mail.ru, yandex.ru и gmail.com) есть поддержка национального (русского) текста. Для Телеграмм (опционально при указании $1=«translite») и отправке SMS через модемы, работает транслитерация русских символов в латинские. В работе функции использованы, написанные мной ранее конвертеры строки (приведены и описаны в статьях Хабра [habr.com/ru/post/518534](https://habr.com/ru/post/518534) и [habr.com/ru/post/519406](https://habr.com/ru/post/519406)).
Функция поддерживает отправку сообщений через модем, подключенный к роутеру (usb или pci-e), а также через многофункциональные интернет-контроллеры компаний [KernelChip](https://kernelchip.ru) (Laurent-5G) и [Алентис-Электроникс](https://netping.ru) (устройства Netping, имеющие модем).
Для работы функции на роутере должны быть сконфигурированы /tool sms и /tool e-mail. При использовании ключа «telegram» должны быть определены global Emoji (Emoji роутера, по желанию), заданы ID Вашего Телеграм-бота и чата (глобальные переменные botID и myChatID). При использовании сервиса [sms.ru](http://sms.ru) (ключ «smsAPI») должна быть определена global apikey (ключ аккаунта пользователя на sms.ru). При пересылке сообщения через модем модуля Laurent-5G (ключ smsLT) должны быть определены глобальные переменный Ladr (адрес Laurent-5G в локальной сети) и Lpassword (пароль для авторизации при http get-запросах к модулю). При использовании ключа «smsNP» должны быть определены global NPadr (адрес шлюза Netping в сети), NPuser (login), NPpass (пароль) авторизации.
Выбор номера телефона получателя при всех вариантах отправок sms осуществляется в порядке $1 (из параметра функции) -> $ADMINPHONE (global var) -> first [/tool sms get allowed-number] по алгоритму «если не указан, то следующий». Для smsLT вместо $ADMINPHONE номер телефона берется из первой ячейки базы данных телефонных номеров модуля. Номера телефонов следует указывать в международном формате (+7десятизначный номер), поддерживается отправка sms только по России (+7). Выбор почтового адреса получателя при отправке e-mail осуществляется аналогично в порядке $1 -> $ADMINMAIL (global var).
Ещё раз обратим внимание, что в отличие от обычных функций, которые в $0 хранят своё имя, первый параметр функции массива будет $0, второй $1 и т.д...., что учитывается в коде элементов функции. Вызов функции без ключа, в виде [$FuncAS «you mesage»] вызывает последовательную работу всех элементов функции и равноценен записи [($FuncAS->«all») «you mesage»].
**Собственно код функции FuncAS под катом**
```
#--------------------------------------------------------------------------------------------
# FuncAS version 1.4 by Sertik (Serkov S.V.) 09/01/2022
#--------------------------------------------------------------------------------------------
# полностью корректно работает при отправке сообщений на английском языке и/или русском языке с опцией "translite" и с учётом ограничения длины сообщения
# поддерживает спец. символы \$@!#%'()*+,-./:;<=>?[]^_`{|}~ (не для всех вариантов отправок)
;
# Usage: [($FuncAS->"telegram") "you mesage"]
# [($FuncAS->"sms") "you mesage" "phone number"]
# [($FuncAS->"sms") "you mesage" (phone number get from ADMINPHONE or first [/tool sms get allowed-number];
# [($FuncAS->"smsAPI") "you mesage" "phonenumber"]
# [($FuncAS->"smsAPI") "you mesage" (phone number get from ADMINPHONE or or first [/tool sms get allowed-number];
# [($FuncAS->"smsNP") ("привет text H"."\\"."\$"." @!#%'()*+,-./:;<=>?[]^_`{|}~") "+79104797703"]
# [($FuncAS->"smsLT") ("good by world") 2]
# [($FuncAS->"email") "you mesage" "e-mail"]
# [($FuncAS->"email") "you mesage"] (e-mail get from $ADMINMAIL)
# [($FuncAS->"all") "you mesage"] (e-mail get from $ADMINMAIL)
# [$FuncAS "you mesage"] = [($FuncAS->"all") "you mesage"] (execute last key)
# see also the examples at the end of the function code !
# defining global users variables:
:global Emoji; # :global Emoji "%E2%9B%BA"
:global botID; # :global botID "botXXXXXXXXXX:XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX";
:global myChatID; #:global myChatID "XXXXXXXXX";
:global ADMINPHONE; #:global ADMINPHONE "+7910777777"
:global ADMINMAIL; # :global ADMINMAIL user@mail.ru
:global Ladr; # :global Ladr 192.168.0.10
:global Lpass; # :global Lpass Laurent5G password
:global NPadr; # :global NPadr 192.168.0.10:8080
:global NPuser; # :global NPuser Sertik
:global NPpass; # :global NPpass NPpassword
:global apikey; # :global apikey ХХХХХХХХ-ХХХХ-ХХХХ-ХХХХ-ХХХХХХХХХХХХ
:global FuncAS [:toarray ""]
# function transliteration
# string for transliteration is set in the parametr name "string"
:set ($FuncAS->"translite") do={
# table of the codes of Russian letters translite
:local rsimv [:toarray {"А"="A"; "Б"="B"; "В"="V"; "Г"="G"; "Д"="D"; "Е"="E"; "Ж"="ZH"; "З"="Z"; "И"="I"; "Й"="J"; "К"="K"; "Л"="L"; "М"="M"; "Н"="N"; "О"="O"; "П"="P"; "Р"="R"; "С"="S"; "Т"="T"; "У"="U"; "Ф"="F"; "Х"="KH"; "Ц"="C"; "Ч"="CH"; "Ш"="SH"; "Щ"="SCH"; "Ъ"="``"; "Ы"="Y`"; "Ь"="`"; "Э"="E`"; "Ю"="JU"; "Я"="YA"; "а"="a"; "б"="b"; "в"="v"; "г"="g"; "д"="d"; "е"="e"; "ж"="zh"; "з"="z"; "и"="i"; "й"="j"; "к"="k"; "л"="l"; "м"="m"; "н"="n"; "о"="o"; "п"="p"; "р"="r"; "с"="s"; "т"="t"; "у"="u"; "ф"="f"; "х"="kh"; "ц"="c"; "ч"="ch"; "ш"="sh"; "щ"="sch"; "ъ"="``"; "ы"="y`"; "ь"="`"; "э"="e`"; "ю"="ju"; "я"="ya"; "Ё"="Yo"; "ё"="yo"; "№"="#"}]
# encoding of the symbols and аssembly line
:local StrTele ""; :local code "";
:for i from=0 to=([:len $string]-1) do={:local keys [:pick $string $i (1+$i)];
:local key ($rsimv->$keys); if ([:len $key]!=0) do={:set $code ($rsimv->$keys);} else={:set $code $keys};
:if (($keys="Ь") and ([:pick $string ($i+1) (2+$i)]="Е")) do={:set $code "I"; :set $i ($i+1)}
:if (($keys="ь") and ([:pick $string ($i+1) (2+$i)]="е")) do={:set $code "i"; :set $i ($i+1)}
:if (($keys="Ь") and ([:pick $string ($i+1) (2+$i)]="е")) do={:set $code "I"; :set $i ($i+1)}
:if (($keys="ь") and ([:pick $string ($i+1) (2+$i)]="Е")) do={:set $code "i"; :set $i ($i+1)}
:if (($keys="Ы") and ([:pick $string ($i+1) (2+$i)]="Й")) do={:set $code "I"; :set $i ($i+1)}
:if (($keys="ы") and ([:pick $string ($i+1) (2+$i)]="й")) do={:set $code "i"; :set $i ($i+1)}
:if (($keys="ы") and ([:pick $string ($i+1) (2+$i)]="Й")) do={:set $code "i"; :set $i ($i+1)}
:if (($keys="Ы") and ([:pick $string ($i+1) (2+$i)]="й")) do={:set $code "I"; :set $i ($i+1)}
:set $StrTele ("$StrTele"."$code")}
:return $StrTele
}
# part to Telegram
:set ($FuncAS->"telegram") do={
:if ([:len $0]!=0) do={
:global Emoji
:global botID;
:global myChatID;
:if (([:len $botID]=0) or ([:len $myChatID]=0)) do={:log error "ERROR FuncAs telegram chatbotID not found"; :return "ERROR telegram"}
:if ((any $1) && ($1="translite")) do={
:global FuncAS
:set $0 [($FuncAS->"translite") string=$0]
}
# bypassing the transmission of special characters and symbol "H"
:local output $0
:local cp1251 [:toarray {"\20";"\01";"\02";"\03";"\04";"\05";"\06";"\07";"\08";"\09";"\0A";"\0B";"\0C";"\0D";"\0E";"\0F"; \
"\10";"\11";"\12";"\13";"\14";"\15";"\16";"\17";"\18";"\19";"\1A";"\1B";"\1C";"\1D";"\1E";"\1F"; \
"\21";"\22";"\23";"\24";"\25";"\26";"\27";"\28";"\29";"\2A";"\2B";"\2C";"\2D";"\2E";"\2F";"\3A"; \
"\3B";"\3C";"\3D";"\3E";"\3F";"\40";"\5B";"\5C";"\5D";"\5E";"\5F";"\60";"\7B";"\7C";"\7D";"\7E"; \
"\C0";"\C1";"\C2";"\C3";"\C4";"\C5";"\C7";"\C7";"\C8";"\C9";"\CA";"\CB";"\CC";"\CD";"\CE";"\CF"; \
"\D0";"\D1";"\D2";"\D3";"\D4";"\D5";"\D6";"\D7";"\D8";"\D9";"\DA";"\DB";"\DC";"\DD";"\DE";"\DF"; \
"\E0";"\E1";"\E2";"\E3";"\E4";"\E5";"\E6";"\E7";"\E8";"\E9";"\EA";"\EB";"\EC";"\ED";"\EE";"\EF"; \
"\F0";"\F1";"\F2";"\F3";"\F4";"\F5";"\F6";"\F7";"\F8";"\F9";"\FA";"\FB";"\FC";"\FD";"\FE";"\FF"; \
"\A8";"\B8";"\B9";"\48"}];
:local utf8 [:toarray {"0020";"0020";"0020";"0020";"0020";"0020";"0020";"0020";"0020";"0020";"000A";"0020";"0020";"000D";"0020";"0020"; \ "0020";"0020";"0020";"0020";"0020";"0020";"0020";"0020";"0020";"0020";"0020";"0020";"0020";"0020";"0020";"0020"; \
"0021";"0022";"0023";"0024";"0025";"0026";"0027";"0028";"0029";"002A";"002B";"002C";"002D";"002E";"002F";"003A"; \ "003B";"003C";"003D";"003E";"003F";"0040";"005B";"005C";"005D";"005E";"005F";"0060";"007B";"007C";"007D";"007E"; \ "D090";"D091";"D092";"D093";"D094";"D095";"D096";"D097";"D098";"D099";"D09A";"D09B";"D09C";"D09D";"D09E";"D09F"; \ "D0A0";"D0A1";"D0A2";"D0A3";"D0A4";"D0A5";"D0A6";"D0A7";"D0A8";"D0A9";"D0AA";"D0AB";"D0AC";"D0AD";"D0AE";"D0AF"; \ "D0B0";"D0B1";"D0B2";"D0B3";"D0B4";"D0B5";"D0B6";"D0B7";"D0B8";"D0B9";"D0BA";"D0BB";"D0BC";"D0BD";"D0BE";"D0BF"; \ "D180";"D181";"D182";"D183";"D184";"D185";"D186";"D187";"D188";"D189";"D18A";"D18B";"D18C";"D18D";"D18E";"D18F"; \
"D001";"D191";"2116";"0048"}];
:local convStr ""; :local code "";
:for i from=0 to=([:len $output]-1) do={
:local symb [:pick $output $i ($i+1)];
:local idx [:find $cp1251 $symb];
:local key ($utf8->$idx);
:if ([:len $key] != 0) do={
:set $code ("%$[:pick ($key) 0 2]%$[:pick ($key) 2 4]");
:if ([pick $code 0 3] = "%00") do={ :set $code ([:pick $code 3 6]); }
} else={ :set code ($symb); };
:set $convStr ($convStr.$code);
}
:set $0 $convStr
:log info ""; :log warning "FuncAs start telegram sending ...";
:do {
[/tool fetch url="https://api.telegram.org/$botID/sendmessage\?chat_id=$myChatID&text=$Emoji $0" keep-result=no;]
} on-error={:log error "ERROR FuncAs telegram send"; :return "ERROR telegram"}
:log warning "FuncAs message to telegram send"; :log info "";
:return "done telegram"
} else={:log error "ERROR FuncAs telegram send but no message text"; :return "ERROR telegram" }
}
# part to sms from modem router`s
:set ($FuncAS->"sms") do={
:if ([:len $0]!=0) do={
:local SMSdevice [/tool sms get port];
:local NumPhone
:global ADMINPHONE;
:if ([:len $1]!=0) do={:set NumPhone $1} \
else={
:if ([:len $ADMINPHONE]!=0) do={:set NumPhone $ADMINPHONE} \
else={
:local NumSMS [/tool sms get allowed-number];
:if ([:len $NumSMS]!=0) do={:set NumPhone ($NumSMS->0)} \
else={:log error "ERROR FuncAs sms phone number not found"; :return "ERROR sms"}
}}
# must be performed translite
:global FuncAS
:set $0 [($FuncAS->"translite") string=$0]
:log info ""; :log warning "FuncAS start sms sending to $NumPhone";
:do {
[/tool sms send $SMSdevice phone=$NumPhone message=$0];
} on-error={:log error "ERROR FuncAs sms send"; :return "ERROR sms"}
:log warning "FuncAs sms sent via modem"; :log info "";
:return "done sms"
} else={:log error "ERROR FuncAs sms send but no message text"; :return "ERROR sms" }
}
# part to sms from API sms.ru
# must be configured global variable $apikey for sms.ru user
;
:set ($FuncAS->"smsAPI") do={
:if ([:len $0]!=0) do={
:local SMSanswer;
:global apikey;
:if ([:len $apikey]!=0) do={
:local NumPhone
:global ADMINPHONE;
:if ([:len $1]!=0) do={:set NumPhone $1} \
else={
:if ([:len $ADMINPHONE]!=0) do={:set NumPhone $ADMINPHONE} \
else={
:local NumSMS [/tool sms get allowed-number];
:if ([:len $NumSMS]!=0) do={:set NumPhone ($NumSMS->0)} \
else={:log error "ERROR FuncAs smsAPI phone number not found"; :return "ERROR smsAPI"}
}}
:log info ""; :log warning "FuncAS start smsAPI sending to $NumPhone";
:do {
:set SMSanswer [/tool fetch url=("https://sms.ru/sms/send\?api_id="."$apikey") mode=https http-method=post http-data=("&to="."$NumPhone"."&msg="."$0"."&json=1") as-value output=user];
} on-error={:log error "ERROR FuncAs smsAPI fetch send"; :return "ERROR smsAPI"}
:if (($SMSanswer->"status")="finished") do={
:local ans;
:if ([find ($SMSanswer->"data") "ERROR"]>0) do={:set ans "ERROR smsAPI"; :log error "ERROR FuncAs smsAPI send"; :log info "";} else={:set ans "done smsAPI"; :log warning "FuncAs sms sent via API sms.ru"; :log info "";}
:return $ans;
} else={:log error "ERROR FuncAs smsAPI fetch to sms.ru"; :return "ERROR smsAPI"}
} else={:log error "ERROR FuncAs smsAPI apikey not defined"; :return "ERROR smsAPI"}
} else={:log error "ERROR FuncAs smsAPI send but no message text"; :return "ERROR smsAPI" }
}
# part to sms from Laurent-5G module
# must be configured Ladr, Lpass
:set ($FuncAS->"smsLT") do={
:if ([:len $0]!=0) do={
:local Lanswer;
:global Ladr
:global Lport
:global Lpass
:local Sport
:if (([:len $Ladr]!=0) && ([:len $Lpass]!=0)) do={
:if ([:len $0]!=0) do={
:if ([:len $1]=0) do={:set $1 "1"}
:if ([:len $Lport]=0) do={:set Sport "80";} else={:set Sport $Lport;}
# must be performed translite
:global FuncAS
:set $0 [($FuncAS->"translite") string=$0]
# replacing a space in a line with a sign "+"
# for normal space sending
:local string $0
:local StrTele
:for i from=0 to=([:len $string]-1) do={:local keys [:pick $string $i (1+$i)];
# \2B="+" or you can use \5F ("_")
:if ($keys=" ") do={:set $code "\2B";} else={:set $code $keys};
:set $StrTele ("$StrTele"."$code")}
:set $0 $StrTele;
:log info ""; :log warning "FuncAS start sms from Laurent getway sending to $1 database cell";
:local StrFetchLaurent; :set StrFetchLaurent ("http://"."$Ladr".":"."$Sport"."/cmd.cgi?psw=$Lpass&cmd=SMS,"."SND".","."$1,"."C,"."$0");
do {
:set Lanswer ([/tool fetch url=$StrFetchLaurent mode=http as-value output=user]->"data");
} on-error={: log info ""; :log error ("Call ERROR function <$0> ERROR fetch command");
:local Lanswer "ERROR $0 command ROS "; : log info ""; :return $Lanswer}
:if ($Lanswer="#SMS,SND,OK\0D\0A") do={:log warning "FuncAs sms sent via Laurent getway"; :log info ""; :return "done smsLT";} else={
:if ($Lanswer="#ERR,NO\_FREE\_PLACE\0D\0A") do={:log info ""; :log error ("ERROR function FuncAS smsLT but no free place");
:log info ""; :return "ERROR FuncAS smsLT no free place"}
:if ($Lanswer="#ERR,BAD\_PHN\0D\0A") do={:log info ""; :log error ("ERROR function FuncAS smsLT but invalid phone number");
:log info ""; return "ERROR FuncAS smsLT bad phone number"}
:return "ERROR smsLT unknown"}
} else={:log info ""; :log error "ERROR FuncAs smsLT parametrs no defined"; :return "ERROR smsLT"}
} else={:log info ""; :log error "ERROR FuncAS smsLT Ladr or Lpass not defined"; :return "ERROR smsLT"}
}
}
# part to sms from Netping device modem (as getway)
# [$FuncNPsendSMS "you text in utf8" "+7phonenumber"]
# должны быть определены NPadr, NPuser, NPpass
:set ($FuncAS->"smsNP") do={
:if ([:len $0]!=0) do={
:global NPadr; :global NPuser; :global NPpass;
:if (([:len $NPadr]!=0) && ([:len $NPuser]!=0) && ([:len $NPpass]!=0)) do={
:local NPanswer;
:local NumPhone
:global ADMINPHONE;
:if ([:len $1]!=0) do={:set NumPhone $1} \
else={
:if ([:len $ADMINPHONE]!=0) do={:set NumPhone $ADMINPHONE} \
else={
:local NumSMS [/tool sms get allowed-number];
:if ([:len $NumSMS]!=0) do={:set NumPhone ($NumSMS->0)} \
else={:log error "ERROR FuncAs smsNP phone number not found"; :return "ERROR smsAPI"}
}}
:if ([:pick $NumPhone 0 2]="+7") do={
# must be performed translite
:global FuncAS
:set $0 [($FuncAS->"translite") string=$0]
:log info ""; :log warning "FuncAS start sms from Netping getway sending to $NumPhone";
:do {
:set NPanswer [/tool fetch url=("http://"."$NPadr"."/sendsms.cgi\?utf8") mode=http http-method=post http-data=("["."$NumPhone"."]"." "."$0") user=$NPuser password=$NPpass as-value output=user];
} on-error={:log error "ERROR FuncAs smsNP fetch send"; :return "ERROR smsNP"}
:if (($NPanswer->"status")="finished") do={:log warning "FuncAs sms sent via Netping getway"; :log info "";
:set NPanswer ($NPanswer->"data");
:if ([:find $NPanswer "ok"]) do={:return "done smsNP"} else={:return "ERROR smsNP"}
} else={ :return "ERROR smsNP"}
} else={:log error "ERROR FuncAs smsNP invalid phone number format"; :return "ERROR smsNP"}
} else={:log error "ERROR FuncAs smsNP NPadr or NPuser or NPpass not defined"; :return "ERROR smsNP"}
} else={:log error "ERROR FuncAs smsNP send but no message text"; :return "ERROR smsNP" }
}
# part to e-mail
:set ($FuncAS->"email") do={
:if ([:len $0]!=0) do={
:global ADMINMAIL;
:if (([:len $1]=0) && ([:len $ADMINMAIL]=0)) do={:log error "ERROR FuncAs email send E-mail address not found"; :return "ERROR email"}
:if ([:len $1]!=0) do={} else={:set $1 $ADMINMAIL}
:local smtpserv
:do {
:set smtpserv [:resolve [/tool e-mail get address]];} on-error={:log error "ERROR FuncAs email no resolve email server"; :return "ERROR email"}
:local Eaccount [/tool e-mail get user];
:local pass [/tool e-mail get password];
:local Eport [/tool e-mail get port];
:local Etls "yes"; # если не используется установить в "no";
:log info " "; :log warning ("FuncAS start mail sending ... to e-mail: $1");
:do {
[/tool e-mail send from="<$Eaccount>" to=$1 server=$smtpserv \
port=$Eport user=$Eaccount password=$pass start-tls=$Etls subject=("from FuncAS Router $[/system identity get name]") body=$0;];
} on-error={:log error "ERROR FuncAs email send"; :return "ERROR email"}
:local sendit 60
:while ($sendit > 0) do={:delay 1s; :set $sendit ($sendit - 1)
:if (([tool e-mail get last-status] = "succeeded") or ([tool e-mail get last-status] = "failed")) do={:set $sendit 0}}
:if ([tool e-mail get last-status] = "succeeded") do={:log warning "FuncAs message to email send"; :log info ""; :return "done email"} \
else={:log error "ERROR FuncAs email send"; :return "ERROR email"}
} else={:log error "ERROR FuncAs email send but no message text"; :return "ERROR email" }
}
# part to all send channels (a psevdo recursive call is used !)
# must be the last to bypass the $0 <-->$1 effect
:set ($FuncAS->"all") do={
:if ([:len $0]!=0) do={
:global FuncAS;
:global ADMINMAIL;
:local T
:local E
:local MDsms
:local APIsms
:local LTsms
:local NPsms
# bypass when calling a function without keys !
:if ([:typeof $0]="lookup") do={:set $0 $1; :if ((any $2) && ($2="translite")) do={:set $1 $2}}
:set T [($FuncAS->"telegram") $0 $1]
:set E [($FuncAS->"email") $0 $ADMINMAIL]
:set MDsms [($FuncAS->"sms") $0]
:set APIsms [($FuncAS->"smsAPI") $0]
:set LTsms [($FuncAS->"smsLT") $0]
:set NPsms [($FuncAS->"smsNP") $0]
:return [:toarray {$T;$E;$MDsms; $APIsms; $LTsms; $NPsms}]
} else={:log error "ERROR FuncAs all but no message text"; :return "ERROR common sending" }
}
# -------------------------------------------------------------------
# examples call:
# -------------------------------------------------------------------
# :global FuncAS
# :log info [($FuncAS->"telegram") ("Router "."$[/system identity get name]"." test function FuncAS to Telegram Hello тест функции FuncAS для Телеграмм")]
# :log info [($FuncAS->"telegram") ("Router "."$[/system identity get name]"." test function FuncAS to Telegram Hello тест функции FuncAS для Телеграмм") "translite"]
# :log info [($FuncAS->"email") ("Router "."$[/system identity get name]"." test FuncAS to e-mail проверка") "user@gmail.com"]
# :log info [($FuncAS->"email") ("Router "."$[/system identity get name]"." test FuncAS to e-mail")]
# :log info [($FuncAS->"sms") ("Router "."$[/system identity get name]"." test function FuncAS test to SMS Привет !")]
# :log info [($FuncAS->"all") ("Router "."$[/system identity get name]"." test function FuncAS all channels")]
# exception support for Telegram
# :log info [($FuncAS->"telegram") ("text H"."\\"."\$"." @!#%'()\*+,-./:;<=>?[]^\_`{|}~")]
# :log info [($FuncAS->"smsAPI") "Verify for Sertik" "+79107777777"]
# :log info [($FuncAS->"smsAPI")]
# :log info [($FuncAS->"smsAPI") "смс от Микротик to you" "+79654123794"]
# exception transliteration for Telegram and send SMS modem
# :log info [($FuncAS->"smsNP") ("привет text H"."\\"."\$"." @!#%'()\*+,-./:;<=>?[]^\_`{|}~") "+79657777777"]
# :log info [($FuncAS->"telegram") ("Router "."$[/system identity get name]"." Привет админ ! С новым годом тебя ...") "translite"]
# :log info [$FuncAS "С новым годом !"]
# :log info [$FuncAS "С новым годом !" "translite"]
# :log info [($FuncAS->"smsLT") ("good by world") 2]
# :log info [($FuncAS->"smsLT") ("привет text H"."\\"."\$"." @!#%'()\*+,-./:;<=>?[]^\_`{|}~") 2]
# :log info [$FuncAS "good by world" sv\_device@mail.ru]
# :log info [($FuncAS->"all") ("good by world до свидания мир") "translite"]
```
Основные аспекты работы функции отмечены в комментариях к коду. Функция объединяет шесть вариантов отправки сообщений посредством различных служб и устройств и способна работать как частично (отправляя сообщение по какому-либо одному каналу) так и полностью по всем последовательно. Служит наглядным примером того, как можно создавать функции в массивах. Вероятно, можно такое проделать и в многомерном массиве, однако ввиду усложнений синтаксиса вряд ли это необходимо.
Из вышесказанного следует также, что в функции-массиве можно разместить как «подфункции» так и данные.
Обратите внимание на последнюю часть функции под ключом ($FuncAS->«all»). Помня про lookup мы проверяем откуда вызвана данная часть функции: как элемент массива по ключу «all» или как обычная целая функция $FuncAS в этой строке кода:
```
:if ([:typeof $0]="lookup") do={:set $0 $1; :if ((any $2) && ($2="translite")) do={:set $1 $2}}
```
Если функция вызвана без ключа, то осуществляется «передвижка» аргументов: $1 «передвигается» в $0, а $2, когда это нужно для работы блока транслитерации, становится $1.
Разумеется можно «разобрать» функцию массив на более привычные нам, отдельные функции, и использовать каждую со своим именем, однако объединение в функцию-массив тематически однообразных подфункций представляется удобным и логичным решением.
С 2017 года мной были созданы и собраны около 200 функций самого разного назначения, многие из которых ежедневно помогают мне в работе над скриптами Роутер ОС. Конечной целью было бы создание сайта-библиотеки скриптов и функций, которым могли бы пользоваться все желающие. В настоящее время можно обсуждать всё, что связано со скриптовыми функциями на русскоязычном форуме Микротик по [ссылке](https://forummikrotik.ru/viewforum.php?f=14).
Еще очень полезная и глубокая статья про функции в скриптах Микротик для продвинутых пользователей и программистов опубликована [здесь](https://habr.com/ru/post/650795/).
Надеюсь, моя статья будет полезной пользователям изучающим скрипты Роутер ОС Микротик. Всем желаю удачи в изучении скриптов и успехов в программировании.
© Серков Сергей Владимирович 2022 (Sertik) | https://habr.com/ru/post/646663/ | null | ru | null |
# Статические Generic таблицы
Всем нам часто приходится сталкиваться со статическими таблицами, они могут являться настройками нашего приложения, экранами авторизации, экранами «о нас» и многими другими. Но часто начинающие разработчики не применяют никакие паттерны разработки подобных таблиц и пишут все в одном классе немасштабируемую, негибкую систему.
О том, как я решаю данную проблему — под катом.
#### О чем речь?
Прежде чем решать проблему статических таблиц — стоит понять что это такое. Статические таблицы — это таблицы, где у вас уже известны количество строк и контент, который в них находится. Примеры подобных таблиц ниже.
#### Проблема
Для начала стоит определить проблему: почему мы не можем просто создать ViewController, который будет являться UITableViewDelegate и UITableViewDatasource и просто описать все нужные ячейки? Как минимум — тут возникают 5 проблем с нашей таблицей:
1. Трудно масштабируемая
2. Зависит от индексов
3. Не гибкая
4. Отсутвие переиспользования
5. Требует много кода для инициализации
#### Решение
Метод решения проблемы основан на следующем фундаменте:
1. Вынос отвественности конфигурации таблицы в отдельный класс (**Constructor**)
2. Своя обертка над **UITableViewDelegate** и **UITableViewDataSource**
3. Подключение ячеек к кастомным протоколам для переиспользования
4. Создание своих моделей данных для каждой таблицы
Сначала я хочу показать, как это используется на практике — затем покажу как это все реализовано под капотом.
#### Реализация
Задача — создать таблицу с двумя текстовыми ячейками и между ними одна пустая.
Первым делом я создал обычный **TextTableViewCell** с **UILabel**.
Далее, к каждому UIViewController со статической таблицей нужен свой Constructor, давайте его создадим:
```
class ViewControllerConstructor: StaticConstructorContainer {
typealias ModelType = <#type#>
}
```
Когда мы наследовали его от **StaticConstructorContainer**, первым делом Generic протокол требует от нас тип модели (**ModelType**) — это тип модели ячейки, который мы тоже должны создать, давайте сделаем это.
Я для этого использую enum, так как это больше подходит для наших задач и тут начинается самое интересное. Мы будем наполнять контентом нашу таблицу с помощью протоколов, таких как: *Titled, Subtitled, Colored, Fonted* и так далее. Как вы можете догадаться — эти протоколы отвечают за отображение текста. Допустим, протокол Titled требует **title: String?**, и если наша ячейка поддерживает отображения **title**, он ее заполнит. Давайте посмотрим как это выглядит:
```
protocol Fonted {
var font: UIFont? { get }
}
protocol FontedConfigurable {
func configure(by model: Fonted)
}
protocol Titled {
var title: String? { get }
}
protocol TitledConfigurable {
func configure(by model: Titled)
}
protocol Subtitled {
var subtitle: String? { get }
}
protocol SubtitledConfigurable {
func configure(by model: Subtitled)
}
protocol Imaged {
var image: UIImage? { get }
}
protocol ImagedConfigurable {
func configure(by model: Imaged)
}
```
Соотвественно, здесь представлено только малая часть подобных протоколов, вы можете создавать и сами, как видите — это очень просто. Напоминаю, что мы создаем их 1 раз для 1 цели и потом забываем их и спокойно используем.
Наша ячейка (*с текстом*) поддерживает по сути следующие вещи: Шрифт текста, сам текст, цвет текста, цвет background'a ячейки и вообще любые вещи, приходящие вам на ум.
Нам понадобится пока что только **title**. Поэтому мы наследуем нашу модель от Titled. Внутри модели в case мы указываем какие типы ячеек у нас будут.
```
enum CellModel: Titled {
case firstText
case emptyMiddle
case secondText
var title: String? {
switch self {
case .firstText: return "Я - первый"
case .secondText: return "Я - второй"
default: return nil
}
}
}
```
Так как в средней (пустой ячейке) никакого label нет, то можно вернуть nil.
C ячейкой закончили и можно ее вставить в наш конструктор.
```
class ViewControllerConstructor: StaticConstructorContainer {
typealias ModelType = CellModel
var models: [CellModel] // Здесь мы должны выставить порядок и количество ячеек, отображаемых в коде
func cellType(for model: CellModel) -> Self.StaticTableViewCellClass.Type {
// здесь мы должны вернуть тип ячейки, которая принадлежит модели
}
func configure(cell: UITableViewCell, by model: CellModel) {
// Здесь мы можем конфигурировать ячейку вручную, если это необходимо, но можно оставить это пустым
}
func itemSelected(item: CellModel) {
// аналог didSelect, не завязанный на индексах
}
}
```
И по сути, это весь наш код. Можно сказать, что наша таблица готова. Давайте заполним данные и посмотрим что произойдет.
Ах да, чуть не забыл. Нужно наследовать нашу ячейку от протокола TitledConfigurable, чтобы она могла вставить в себя title. Ячейки поддерживают и динамичную высоту тоже.
```
extension TextTableViewCell: TitledConfigurable {
func configure(by model: Titled) {
label.text = model.title
}
}
```
Как выглядит заполненный конструктор:
```
class ViewControllerConstructor: StaticConstructorContainer {
typealias ModelType = CellModel
var models: [CellModel] = [.firstText, .emptyMiddle, .secondText]
func cellType(for model: CellModel) -> StaticTableViewCellClass.Type {
switch model {
case .emptyMiddle: return EmptyTableViewCell.self
case .firstText, .secondText: return TextTableViewCell.self
}
}
func configure(cell: UITableViewCell, by model: CellModel) {
cell.selectionStyle = .none
}
func itemSelected(item: CellModel) {
switch item {
case .emptyMiddle: print("Нажата средняя ячейка")
default: print("Нажата другая ячейка...")
}
}
}
```
Выглядит довольно компактным, не так ли?
Собственно, последнее что нам осталось сделать, это подключить это все во ViewController'e:
```
class ViewController: UIViewController {
private let tableView: UITableView = {
let tableView = UITableView()
return tableView
}()
private let constructor = ViewControllerConstructor()
private lazy var delegateDataSource = constructor.delegateDataSource()
override func viewDidLoad() {
super.viewDidLoad()
constructor.setup(at: tableView, dataSource: delegateDataSource)
}
}
```
Все готово, мы должны вынести **delegateDataSource** как отдельный проперти в наш класс, чтобы weak ссылка не разорвалась внутри какой-то функции.
Можем запускать и тестировать:
Как видите, все работает.
Теперь давайте подведем итоги и поймем чего мы добились:
1. Если мы создадим новую ячейку и захотим подменить текущую на нее, то это мы делаем путем изменения одной переменной. У нас очень гибкая система таблицы
2. Мы переиспользуем все ячейки. Чем больше ячеек вы подвязываете на эту таблицу, тем легче и проще с этим работать. Отлично подходит для больших проектов.
3. Мы снизили количество кода для создания таблицы. И нам придётся писать его еще меньше, когда у нас будет много протоколов и статических ячеек в проекте.
4. Мы вынесли построение статических таблиц из **UIViewController** в **Constructor**
5. Мы перестали зависеть от индексов, мы можем спокойно менять местами ячейки в массиве и логика при этом не поломается.
Код на тестовый проект в конце статьи.
#### Как это работает изнутри?
Как работают протоколы мы уже обсудили. Теперь надо понять как работает весь конструктор и его сопуствующие классы.
Начнем с самого конструктора:
```
protocol StaticConstructorContainer {
associatedtype ModelType
var models: [ModelType] { get }
func cellType(for model: ModelType) -> StaticTableViewCellClass.Type
func configure(cell: UITableViewCell, by model: ModelType)
func itemSelected(item: ModelType)
}
```
Это обычный протокол, который требует уже знакомые нам функции.
Более интересен его **extension**:
```
extension StaticConstructorContainer {
typealias StaticTableViewCellClass = StaticCell & NibLoadable
func delegateDataSource() -> StaticDataSourceDelegate {
return StaticDataSourceDelegate.init(container: self)
}
func setup(at tableView: UITableView, dataSource: StaticDataSourceDelegate) {
models.forEach { (model) in
let type = cellType(for: model)
tableView.register(type.nib, forCellReuseIdentifier: type.name)
}
tableView.delegate = dataSource
tableView.dataSource = dataSource
dataSource.tableView = tableView
}
}
```
Функция *setup*, которую мы вызывали в нашем ViewController регистрирует все ячейки для нас и делегирует **dataSource** и **delegate**.
А ***delegateDataSource()*** создает для нас обертку **UITableViewDataSource** и **UITableViewDelegate**. Давайте рассмотрим его:
```
class StaticDataSourceDelegate: NSObject, UITableViewDelegate, UITableViewDataSource {
private let container: Container
weak var tableView: UITableView?
init(container: Container) {
self.container = container
}
func reload() {
tableView?.reloadData()
}
func tableView(\_ tableView: UITableView, estimatedHeightForRowAt indexPath: IndexPath) -> CGFloat {
let type = container.cellType(for: container.models[indexPath.row])
return type.estimatedHeight ?? type.height
}
func tableView(\_ tableView: UITableView, heightForRowAt indexPath: IndexPath) -> CGFloat {
let type = container.cellType(for: container.models[indexPath.row])
return type.height
}
func tableView(\_ tableView: UITableView, numberOfRowsInSection section: Int) -> Int {
return container.models.count
}
func tableView(\_ tableView: UITableView, cellForRowAt indexPath: IndexPath) -> UITableViewCell {
let model = container.models[indexPath.row]
let type = container.cellType(for: model)
let cell = tableView.dequeueReusableCell(withIdentifier: type.name, for: indexPath)
if let typedCell = cell as? TitledConfigurable, let titled = model as? Titled {
typedCell.configure(by: titled)
}
if let typedCell = cell as? SubtitledConfigurable, let subtitle = model as? Subtitled {
typedCell.configure(by: subtitle)
}
if let typedCell = cell as? ImagedConfigurable, let imaged = model as? Imaged {
typedCell.configure(by: imaged)
}
container.configure(cell: cell, by: model)
return cell
}
func tableView(\_ tableView: UITableView, didSelectRowAt indexPath: IndexPath) {
let model = container.models[indexPath.row]
container.itemSelected(item: model)
}
}
```
Думаю, к функциям **heightForRowAt**, **numberOfRowsInSection**, **didSelectRowAt** вопросов нет, они всего лишь реализуют понятный функционал. Самый интересный здесь метод — **cellForRowAt**.
В нем мы реализуем не самую красивую логику. Мы вынуждены каждый новый протокол к ячейкам прописывать здесь, но мы это делаем один раз — поэтому это не так уж и страшно. Если модель соотвествует протоколу, как и наша ячейка, то сконфигурируем ее. Если у кого-то есть идеи, как это автоматизировать — буду рад выслушать в комментариях.
На этом логика заканчивается. Я не затрагивал сторонние утилитарные классы в этой системе, [полностью с кодом вы можете ознакомиться по ссылке](https://github.com/Hadevs/static-generic-tableview).
Спасибо за внимание! | https://habr.com/ru/post/439016/ | null | ru | null |
# Опыт перевода большого проекта с Flow на TypeScript
JavaScript – это один из языков с динамической типизацией. Такие языки удобны для быстрой разработки приложений, но когда несколько команд берутся за разработку одного большого проекта, лучше с самого начала выбрать один из инструментов для проверки типов.
Можно начать разрабатывать код на TypeScript или включить в проект Flow. TypeScript – это компилируемая версия JavaScript, разработанная компанией Microsoft. Flow, в отличие от TypeScript, это не язык, а инструмент, который позволяет анализировать код и проверять типы. В сети можно найти множество статей и видео об этих подходах, а также руководство по тому, как начать использовать типизацию. В этой статье мы бы хотели рассказать, почему нам не подошел Flow, и как мы начали переходить на Typescript.
Немного истории
---------------
В 2016 году мы начали разрабатывать веб-клиент на базе React/Redux для нашей ECM системы. Для проверки типизации был выбран Flow по следующим причинам:
1. React и Flow – это продукты одной компании Facebook.
2. Flow более активно развивался.
3. Flow легко интегрируется в проект.
Но проект рос, количество команд-разработки увеличилось, и проявился ряд проблем при использовании Flow:
1. Фоновый режим проверки типов Flow использовал слишком много ресурсов ПК. В результате некоторые разработчики отключали его и запускали проверку по необходимости.
2. Возникали ситуации, когда для приведения кода в соответствие с Flow тратилось столько же времени, сколько и на написание самого кода.
3. В проекте стал появляться код, необходимый только для прохождения проверки Flow. Например, двойная проверка на null:
```
foo() {
if (this.activeFormContainer == null) {
return;
}
// to do something
if (this.activeFormContainer != null) // only for Flow
this.activeFormContainer.style.minWidth = '100px';
}
```
4. Большинство разработчиков использовало редактор кода Visual Studio Code, в котором у Flow не такая хорошая поддержка, как у TypeScript. Во время разработки не всегда срабатывало автодополнение (IntelliSense), а также нестабильно работала навигация по коду. Хотелось бы иметь такое же удобство разработки, как при написании на С# в Visual Studio.
У некоторых разработчиков появилась идея попробовать перейти на TypeScript. Для того чтобы проверить идею перехода и убедить руководство, решили попробовать прототип.
Прототип
--------
На прототипах мы хотели проверить две идеи:
1. Попробовать перевести весь проект целиком.
2. Настроить проект так, чтобы можно было использовать параллельно и Flow, и Typescript.
Для первой идеи нужна была утилита, которая сконвертировала бы все файлы проекта. В сети нашли одну из таких. Судя по описанию, она смогла бы перевести большую часть, но часть изменений пришлось бы править самим, либо дописать саму утилиту. Нам удалось сконвертировать тестовый проект с небольшим количеством файлов. Реальный же проект скомпилировать так и не удалось, пришлось бы править слишком большое количество файлов. Решили не продолжать в этом направлении, так как:
1. Доделывать предстояло еще много! И пока мы будем дорабатывать проект, остальные команды будут продолжать разрабатывать новую функциональность, править баги, писать тесты. К тому же пришлось бы потратить немало времени для слияния файлов.
2. Даже если бы мы перевели таким способом проект, то какой объем работы пришлось бы проделать нашим тестировщикам!
Хотя мы и отказались от этого варианта, на нем мы получили полезный опыт. Стал ясен примерный объем работ, который нужно проделать для перевода каждого файла. Вот как примерно выглядит перевод простого React-компонента.
[](https://habrastorage.org/webt/xa/d8/h1/xad8h1wgyhpfy1jydrgxmuqy1ga.jpeg)
Как видно, изменений не так много. В основном, они заключаются в следующем:
* убрать //@flow;
* заменить type на более привычный interface;
* добавить модификаторы доступа;
* заменить типы на типы из ts-библиотек (из примера на картинке: обработчики событий и сами события).
Реализация по второй идее позволила бы продолжить разработку, но уже на TypeScript, и в фоновом режиме потихоньку переводить существующую кодовую базу. Это давало ряд преимуществ:
1. Легко переводить, без страха что-то упустить.
2. Легко тестировать.
3. Легко сливать изменения.
Но было не до конца ясно, можно ли настроить проект для работы с двумя видами типизации параллельно. Поиск в интернете ни к чему конкретному не привел, поэтому стали разбираться сами. В теории, анализатор Flow проверяет только файлы с расширением js/jsx и содержащие комментарий:
```
//@flow
или
/* @flow */
```
Для компилятора TypeScript файлы должны иметь расширение ts/tsx. Из чего следует, что оба подхода к типизации должны работать одновременно и не мешать друг другу. На основании этого мы настроили окружение проекта. Используя опыт от первого прототипа, перевели пару файлов. Скомпилировали проект, запустили клиент — всё заработало как раньше!
Зеленый свет
------------
И вот в один прекрасный день — день планирования спринта, у нашей команды в бэклоге появляется User Story “Начать переход на TypeScript”, с следующим перечнем работ:
1. Настроить webpack.
2. Настроить tslint.
3. Настроить тестовое окружение.
4. Перевести файлы на TypeScript.
### Настройка webpack
Первым делом нужно научить webpack обрабатывать файлы с расширением ts/tsx. Для этого добавили правило в секцию rules конфигурационного файла. Изначально использовался ts-loader:
```
// webpack.config.js
const rules = [
...
{
test: /\.(ts|tsx)?$/,
loader: 'ts-loader',
options: {
transpileOnly: true
}
}
];
```
Чтобы ускорить сборку, отключили проверку типов: `transpileOnly: true`, т.к. IDE и так указывает на ошибки во время написания кода.
Но когда приступили к переводу наших Redux-экшенов, стало ясно, что для их работы необходим плагин [babel-plugin-transform-class-display-name](https://www.npmjs.com/package/babel-plugin-transform-class-display-name). Этот плагин добавляет всем классам статическое свойство displayName. Экшены после перевода стали обрабатываться только ts-loader, а это не позволило применить к ним плагины babel. В результате, мы отказались от ts-loader и расширили существующее правило для js/jsx, добавив [babel](https://habr.com/ru/users/babel/)/preset-typescript:
```
// webpack.config.js
const rules = [
{
test: /\.(ts|tsx|js|jsx)?$/,
exclude: /node_modules|lib/,
loader: 'babel-loader?cacheDirectory=true'
},
...
];
```
```
// .babelrc.js
const presets = [
[
"@babel/preset-env",
{
"modules": !isTest ? false : 'commonjs',
"useBuiltIns": false
}
],
"@babel/typescript",
"@babel/preset-react",
];
```
Для правильной работы компилятора TypeScript нужно добавить конфигурационный файл tsconfig.json, он был взят из документации.
### Настройка Tslint
Написанный с использованием Flow код дополнительно проверялся с помощью eslint. Для TypeScript есть его аналог — tslint. Изначально хотелось все правила из eslint перенести в tslint. Была попытка синхронизации правил через плагин tslint-eslint-rules, но большинство правил не поддерживается. Также есть возможность использовать eslint для проверки ts-файлов с помощью typescript-eslint-parser. Но, к сожалению, к eslint-у можно подключить только один парсер. Если использовать только ts-parser для всех видов файлов, появляется много непонятных ошибок как в js-файлах, так и в ts. В результате, использовали рекомендуемый набор правил, расширенный под наши требования:
```
// tslint.json
"extends": ["tslint:recommended", "tslint-react"]
```
### Перевод файла на TypeScript
Теперь все готово, и можно приступать к переводу файлов. Для начала решили перевести небольшой React-компонент, который используется по всему проекту. Выбор пал на компонент “Кнопка”.
В процессе перевода столкнулись с проблемой: не все сторонние библиотеки имеют типизацию TypeScript, например, bem-cn-lite. На ресурсе [TypeSearch](https://microsoft.github.io/TypeSearch/) от Microsoft библиотеку типов для нее найти не удалось. почти для всех необходимых библиотек мы нашли и подключили ts-библиотеки типов. Одним из решений было подключение через require:
```
const b = require(‘bem-cn-lite’);
```
Но при этом проблема с отсутствием типов не решилась. Поэтому мы сгенерировали «заглушку» для типов самостоятельно, воспользовавшись утилитой [dts-gen](https://www.npmjs.com/package/dts-gen-sandbox):
```
dts-gen -m bem-cn-lite
```
Утилита сгенерировала файл с расширением \*.d.ts. Файл поместили в папку @types и настроили tsconfig.json:
```
// tsconfig.json
"typeRoots": [
"./@types",
"./node_modules/@types"
]
```
Далее, по аналогии с прототипом, мы перевели компонент. Скомпилировали проект, запустили клиент — всё заработало! Но сломались тесты.
### Настройка тестового окружения
Для тестирования приложения мы используем Storybook и Mocha.
Storybook используется для визуального регрессионного тестирования ([статья](https://habr.com/ru/post/454464/)). Как и сам проект, он собирается с помощью webpack и имеет свой конфигурационный файл. Поэтому для работы с ts/tsx-файлами его нужно было сконфигурировать по аналогии с конфигурацией самого проекта.
Пока мы использовали ts-loader для сборки проекта, у нас перестали запускаться тесты Mocha. Для решения этой проблемы в тестовое окружение необходимо добавить ts-node:
```
// mocha.opts
--require @babel/polyfill
--require @babel/register
--require test/index.js
--require tsconfig-paths/register
--require ts-node/register/transpile-only
--recursive
--reporter mochawesome
--reporter-options reportDir=../../bin/TestResults,reportName=js-test-results,inlineAssets=true
--exit
```
Но после перехода на Babel от этого можно было избавиться.
Проблемы
--------
В процессе перевода мы столкнулись с большим количеством проблем различной степени сложности. В основном они были связаны с отсутствием у нас опыта работы с TypeScript. Вот несколько из них:
1. Импорт компонентов/функций из разных типов файлов.
2. Перевод компонентов высшего порядка.
3. Потеря истории изменений.
### Импорт компонентов/функций из разных типов файлов
При использовании компонентов/функций из разных типов файлов появилась необходимость указывать расширение файла:
```
import { foo } from ‘./utils.ts’
```
Избавиться от этого позволяет добавление допустимых расширений в конфигурационные файлы webpack и eslint:
```
// webpack.config.js
resolve: {
…
extensions: [ '.tsx', '.ts', '.js' ]
}
```
```
// .eslintrc.js
"import/resolver": {
"node": {
"extensions": [
".js",
".jsx",
".ts",
".tsx",
".json"
]
}
}
```
### Перевод компонентов высшего порядка
Из всех типов файлов больше всего проблем вызвал перевод компонентов высшего порядка (Higher-Order Component, HOC). Это функция, которая на вход принимает компонент и возвращает новый компонент. Применяется в основном для повторного использования логики, например, это может быть функция, добавляющая возможность выделять элементы:
```
const MyComponentWithSeletedItem = withSelectedItem(MyComponent);
```
Или наиболее известная connect, из библиотеки Redux. Типизация таких функций не тривиальная и требует подключения дополнительной библиотеки для работы с типами. Подробно описывать процесс перевода не буду, так как в сети можно найти много руководств на эту тему. Если вкратце, то проблема заключается в том, что такая функция – абстрактная: на вход может принять любой компонент, с любым набором свойств. Это может быть компонент «Кнопка» со свойствами title и onClick или компонент «Картинка» со свойствами alt и imgUrl. Набор этих свойств нам заранее не известен, известны лишь те свойства, которые добавляет сама функция. Для того, чтобы компилятор TypeScript не ругался при использовании компонентов, полученных с помощью таких функций, нужно «вырезать» свойства, которые добавляет функция из возвращаемого типа.
Для этого нужно:
1. Вынести в интерфейс эти свойства:
```
interface IWithSelectItem {
selectedItem: number;
handleSelectedItemChange: (id: number) => void;
}
```
2. Удалить все свойства, которые входят в интерфейс IWithSelectItem из интерфейса компонента. Для этого можно воспользоваться операцией Diff из библиотеки [utility-types](https://github.com/piotrwitek/utility-types).
```
React.ComponentType>
```
### Потеря истории изменений
Для работы с исходниками, например, выполнение code review, мы используем Team Foundation Server. При переводе файлов мы столкнулись с одной неприятной особенностью. В пул реквестах вместо одного измененного файла появляется два:
* удаленный – старая версия файла;
* созданный – новая версия.
Такое поведение наблюдается, если изменений в файле много (similarity < 50%), например для небольших по объему файлов. Для решения этой проблемы пробовали использовать:
* команду git mv;
* выполнять два коммита: первый – это изменение расширения файла, второй — с непосредственными исправлениями.
Но, к сожалению, оба подхода нам так и не помогли.
Итоги
-----
Использовать Flow или же TypeScript — решает каждый для себя сам, оба подхода имеют свои плюсы и минусы. Мы для себя выбрали TypeScript. И на своем опыте убедились: если вы выбрали один из подходов и вдруг осознали, даже спустя три года, что он вам не подходит, то всегда можно его поменять. А для более гладкого перехода можно настроить проект, как и мы, на параллельную работу.
На момент написания статьи мы еще не полностью перешли на TypeScript, но основную часть — «ядро» проекта – мы уже переписали. В кодовой базе можно найти примеры перевода всех видов файлов, начиная от простого react-компонента и заканчивая компонентами высшего порядка. Также было проведено обучение среди всех команд разработчиков, и теперь каждая команда в рамках своей задачи на тех долг переводит часть проекта.
Мы планируем завершить переход до конца года, перевести тесты и storybook, и, возможно даже написать несколько своих tslint-правил.
По личным ощущениям могу сказать, что разработка стала занимать меньше времени, проверка типов делается на лету, при этом не нагружая систему, а сообщения об ошибках лично для меня стали более понятными. | https://habr.com/ru/post/462055/ | null | ru | null |
# STM32. Про синус
Вместо вступления
-----------------
В статье алгоритмическая оптимизация функции sin() для бюджетных микроконтроллеров stm32, повышающая производительность в 10 и более раз.
Тригонометрические функции, характеризующиеся высоким потреблением процессорного времени, могут негативно влиять на выбор бюджетных микроконтроллеров ( без модуля FPU ) для задач, где важна скорость счёта, например, контроль пространственного положения.
Библиотечные тригонометрические функции с двойной точностью в два раза медленнее, чем с одинарной. Это досадный факт.
На иллюстрации время работы «sin()» и «sinf()», измеренное в тактах CPU, на диапазоне [-420° .. +420°] с шагом 5°, плюс слабый шум.
Производительность библиотечных «sin()» и «sinf()» высока вблизи точки «0» и снижается в два раза пропорционально модулю аргумента.
Возникает потребность считать тригонометрию несколько быстрее, без FPU, но допуская худшую точность:
* у аргумента — в пределах чувствительности доступных электронных датчиков положения, например, LSM6DSO;
* у результата — в пределах точности доступных шаговых двигателей и сервомашин, например, HS-5082MG.
Требования к алгоритму
----------------------
1. Требования к исходному коду:
a) Исходный код без интеллектуального балласта третьих лиц;
b) Самодостаточный компилируемый модуль на основе стандартных библиотек;
c) Кросс-платформенность — отсутствие вставок на ассемблере.
2. Требования к исполняемому коду:
a) Ограниченный объём бинарного кода — чем меньше, тем лучше;
b) Ограниченный объём статических и динамических данных — чем меньше, тем лучше.
3. Требования к интерфейсу (привычный):
a) float sint( float x );
b) float cost( float x ).
4. Требования к аргументу:
a) Объектная сущность: геометрический плоский угол;
b) Единица измерения: угловой градус в десятичном виде: 1,0 °;
c) Точность измерения: +/- 0,05 °;
d) Рабочий диапазон: +/- 5400 °;
e) Тип данных: float, согласно IEEE 754.
5. Требование к результату:
a) Объектная сущность: тригонометрические функции «sin» и «cos»;
b) Точность счёта: +/- 0,005;
c) Тип данных: float, согласно IEEE 754.
#### Применяемая методика
Сравнительный анализ способов приближения тригонометрических функций за границами настоящей публикации.
Применяемый метод считает синус плоского угла в рабочем диапазоне от 0 до ½π.
Синусы углов за пределами рабочего диапазона находятся через осевую симметрию применительно к результату из рабочего диапазона.
Вычисление синуса угла в рабочем диапазоне заменяется поиском точки на куске одномерного сплайна:
В некоторых условиях сплайн и синус демонстрируют схожее поведение.
Аппроксимирующий сплайн представляется формой Безье. Точка сплайна вычисляется геометрически, редуцированным методом де Кастельжо.
Алгоритм оптимизируется на соответствие функции синус.
Косинус считается как синус, сдвинутый по фазе на 1½ π.
Достигнутый результат
---------------------
Характеристики бинарного кода на платформе Cortex M0:
* размер бинарного кода — 168 байт;
* размер стека — 40 байт (локальные переменные — 24 байта);
* статическая и динамическая память — без надобности.
Результат с тремя точными знаками после запятой и гарантированной ошибкой в четвёртом знаке — | 0,0003 |.
Скорость работы вновь созданной функции на платформе Cortex M0 превосходит библиотечные «sin» и «sinf» в 10 и более раз.
У алгоритма есть опции, выбираемые через условную компиляцию:
* медленный счёт — гарантирует ошибку |0,0003| и менее;
* быстрый счёт — даёт преимущество в ~20 тактов на Cortex M0, ухудшая ошибку до |0,0004|.
Преимущество в 15-25 тактов ( ~1us ) — это существенный прирост производительности для бюджетных контроллеров на малых частотах.
На платформе Cortex M4 быстрый метод счёта даёт сомнительное преимущество в 3-5 тактов, соразмерное погрешности измерения, и ухудшение точности до |0,0004|.
В целом, тестирование алгоритма на Cortex M4 показало приемлемый результат с малым превосходством по скорости библиотечной функции «sinf», оптимизированной под имеющийся FPU.
На графике отсутствует функция «sin» [ double sin ( double x ) ], показывающая худшее на десятичный порядок время.
На платформе Cortex M4 каждый вызов «sin» [ double sin ( double x ) ] забирает порядка 2500 тактов.
Итоговый алгоритм допускает аргумент в угловых градусах и в радианах.
Выбор единицы измерения аргумента осуществляется через условную компиляцию.
Вместо заключения
-----------------
Алгоритм соответствует техническим требованиям, показывая удовлетворительную скорость и ожидаемую точность счёта.
Есть некоторый потенциал для улучшения характеристик алгоритма. С практической точки зрения этот потенциал целесообразно отложить в будущее.
Прикладная библиотека
---------------------
Файл заголовок
```
/******************************************************************************
* File: cosint.h Created on 31 мар. 2022 г.
*
* Copyright (c) 2022, "Nikolay E. Garbuz"
\*
\* This program is free software: you can redistribute it and/or modify
\* it under the terms of the GNU General Public License version 3 as
\* published by the Free Software Foundation.
\*
\* This program is distributed in the hope that it will be useful,
\* but WITHOUT ANY WARRANTY; without even the implied warranty of
\* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
\* GNU General Public License for more details.
\*
\* You should have received a copy of the GNU General Public License
\* along with this program. If not, see .
\*
\* Authored by "Nikolay E. Garbuz"
\* Modified by
\*
\* TAB Size .EQ 4
\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*/
#ifndef \_COSINT\_H\_
#define \_COSINT\_H\_
#ifdef \_\_cplusplus
extern "C"
{
#endif
//\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*
//---------------- module interface ------------------------
/\*\*
\* @brief Fast sine function for approximate calculations
\* @param Geometric angle between -5400.00 and 5400.00 degrees
\* with two correct numbers after the decimal separator
\* @retval Sine with three correct numbers after the decimal separator
\*/
float sint( float x );
/\*\*
\* @brief Fast cosine function for approximate calculations
\* @param Geometric angle between -5400.00 and 5400.00 degrees
\* with two correct numbers after the decimal separator
\* @retval Cosine with three correct numbers after the decimal separator
\*/
float cost( float x );
//\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*
//---------------- module options --\_\_----------------------
/\*
\* The [COSINT\_RAD] directive sets the angle units.
\* By default, module functions take a parameter measured in degrees.
\*
\* Remove or comment out the [#undef COSINT\_RAD] line
\* to switch the interface [cosint] from degrees to radiant.
\*/
#define COSINT\_RAD
#undef COSINT\_RAD
/\*
\* The [COSINT\_FAST] directive defines the linear proportion method.
\* The default is the slow method with a maximum error modulus is |0.0003|.
\*
\* Remove or comment out the [#undef COSINT\_FAST] line to switch module [cosint] to fast mode.
\* About ~1.6% speedup, maximum error modulus is 0.0004
\*/
#define COSINT\_FAST
#undef COSINT\_FAST
#ifdef \_\_cplusplus
}
#endif
#endif /\* \_COSINT\_H\_ \*/
```
Исходный код
```
/******************************************************************************
* File: cosint.c Created on 31 мар. 2022 г.
*
* Copyright (c) 2022, "Nikolay E. Garbuz"
\*
\* This program is free software: you can redistribute it and/or modify
\* it under the terms of the GNU General Public License version 3 as
\* published by the Free Software Foundation.
\*
\* This program is distributed in the hope that it will be useful,
\* but WITHOUT ANY WARRANTY; without even the implied warranty of
\* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
\* GNU General Public License for more details.
\*
\* You should have received a copy of the GNU General Public License
\* along with this program. If not, see .
\*
\* Authored by "Nikolay E. Garbuz"
\* Modified by
\*
\* TAB Size .EQ 4
\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*/
#pragma GCC push\_options
#pragma GCC optimize ("O3")
#include "cosint.h"
#include
//\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*
//---------------- module implementation -------------------
typedef enum
{
coname = -1, siname
} EFName;
inline float cosint( float x, EFName fn );
//---------------- exported module functions ---------------
float sint( float x )
{
return cosint( x, siname );
}
float cost( float x )
{
return cosint( x, coname );
}
//\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*
//------------- helper data and function -------------------
#ifndef M\_PI
# define M\_PI 3.14159265358979323846 /\* pi \*/
#endif
#ifdef COSINT\_RAD
# define R\_UNIT M\_PI
#else
# define R\_UNIT 180.
#endif
#define R\_TU ( R\_UNIT / 2. ) // The real measure unit in use
#define M\_PRC 0x0A // The precision of calculations
#define M\_MAX 0x1F // The bit range of calculations
#define M\_DAT ( M\_MAX >> 1 ) // The bit range of a data
#define M\_SGN 0x02 // The sign mask for a result of calculations
#define M\_QTR 0x01 // The mask of a circle quarter
#define M\_ASQ ( M\_SGN | M\_QTR ) // The mask of common characteristics for the angular data
#define M\_ADV ( 1 << M\_DAT ) // The allowed data value
#define M\_ADM ( M\_ADV - 1 ) // The mask of allowed data value
#define M\_MTR (int32\_t)( ( M\_ADV << M\_PRC ) / R\_TU )
// Slow and precise, maximum error modulus is |0.0003|
#define DO\_SLOW( t, pw, A, B ) ( ( ( t \* ( B - A ) + ( ( 1 << pw ) - 1 ) ) >> pw ) + A )
// Fast and rough, about ~1.6% speedup, maximum error modulus is |0.0004|
#define DO\_FAST( t, pw, A, B ) ( ( ( t \* ( B - A ) ) >> pw ) + A )
#ifdef COSINT\_FAST
# define LN\_ DO\_FAST
#else
# define LN\_ DO\_SLOW
#endif
// Control data for the spline
#define Ax 0x0000
#define Bx 0x320B
#define Cx 0x655D
#define Dx 0x8000
// helper function
float cosint( float x, EFName fn )
{
int32\_t sq, tm;
int32\_t A, B, C, D;
// Converting from real to integer
tm = M\_MTR;
tm \*= x;
tm = tm >> M\_PRC;
// Choosing a function via a phase shift by it name
tm += fn & ( M\_ADM );
// Extracting a quarter of the angle and a sign of the result
sq = ( tm >> M\_DAT ) & M\_ASQ;
// Removing periods and reverse from the angle value
// Transforming the angle value to the first quarter
if ( sq & M\_QTR )
tm = ( tm & M\_ADM ) ^ M\_ADM;
else
tm &= M\_ADM;
// Calculating a result thru a line proportion
A = Dx;
B = LN\_( tm, M\_DAT, Cx, Dx );
C = LN\_( tm, M\_DAT, Bx, Cx );
D = LN\_( tm, M\_DAT, Ax, Bx );
A = LN\_( tm, M\_DAT, B, A );
B = LN\_( tm, M\_DAT, C, B );
C = LN\_( tm, M\_DAT, D, C );
A = LN\_( tm, M\_DAT, B, A );
B = LN\_( tm, M\_DAT, C, B );
A = LN\_( tm, M\_DAT, B, A );
// Correcting a numeric sign of the result
x = ( sq & M\_SGN ) ? -A : A;
// Converting from integer to real and return
x /= M\_ADV;
return x;
}
#pragma GCC pop\_options
``` | https://habr.com/ru/post/659089/ | null | ru | null |
# Google Chrome и Microsoft Edge планируют круто расширить возможности копипаста
[](https://habr.com/ru/company/ruvds/news/t/567618/)
Копирование контента из интернета вскоре станет намного более гибким благодаря ряду новых API, разрабатываемых Google и Microsoft для их браузеров. После внедрения этих API пользователи [Edge и Chrome](https://hothardware.com/news/microsoft-edge-browser-to-mirror-google-chromes-accelerated-4-week-release-cycle) смогут копировать контент из более широкого спектра исходных форматов, включая `.docx`.
В этом процессе задействован набор Pickle Clipboard API. В текущих условиях пользователи указанных браузеров могут копировать содержимое только из ограниченного списка типов файлов, таких как .jpg и .png. Однако в ближайшем будущем это изменится.
Как сообщается в описании Google Chromium на GitHub, Pickle Clipboard API расширят возможности копипаста, включив в них нестандартные веб-форматы.
> Pickle Clipboard API позволяет сайтам считывать/записывать произвольные неочищенные полезные нагрузки при помощи стандартизированного формата сериализации, а также считывать/записывать ограниченное подмножество специализированных форматов операционных систем (для поддержки устаревших приложений). Имя формата буфера обмена видоизменяется браузером стандартизированным способом, указывающим, что контент поступает из интернета. Это позволяет приложениям соглашаться на прием неочищенного содержимого. — говорится в описании.
[Сопроводительная страница GitHub](https://github.com/dway123/clipboard-pickling/blob/main/explainer.md#pickling-for-async-clipboard-api) по Pickle Clipboard API отмечает, что существующая Веб-платформа располагает API, который поддерживает только наиболее популярные стандартизированные форматов данных, пренебрегая «длинным хвостом специализированных», в особенности пользовательских, не стандартизированных веб-форматов. К ним относятся `TIFF`, формат файлов объемных изображений, и проприетарные форматы вроде `.docx`.
Одним из главных выигрышей для разработчиков станет возможность использования сериализованных форматов для реализации в веб-приложениях поддержки специфичных для сторонних приложений видов данных. К примеру, копирование внутри или между Документами Google и Таблицами Google, а также продуктами Office 365 – Word и Excel. Разработчики же, у которых есть нативная и веб-версия приложения (например, SketchUp), смогут реализовать копирование между этими версиями.
> Существующее перекодирование, предоставляемое Async Clipboard API, по-прежнему рекомендуется для случаев, требующих использования только общих типов. При этом оно проще в использовании, поскольку такие типы стандартизированы и широко совместимы. Тем не менее сериализация позволяет отвечать нуждам приложений, имеющих более специфичные или сложные требования к буферу обмена. — говорится на странице GitHub.
Согласно ряду патчей для кода Chromium, подмеченным порталом WindowsLatest, в Microsoft [работают над пользовательскими форматами буфера обмена](https://www.windowslatest.com/2021/07/12/microsoft-google-chromium-copy-and-paste-clipboard-upgrade/), один из которых предназначен для флага среды выполнения, добавляющего в Async Clipboard API пользовательские форматы буфера обмена.
Пока неясно, сколько времени займет реализация, а также то, появятся ли расширенные возможности копипаста до [дебюта Windows 11](https://hothardware.com/news/microsoft-confirms-windows-11-free-upgrades-reveals-system-requirements) в текущем году.
Перевод новости Paul Lilly — [Google Chrome And Microsoft Edge Will Bring Cool New Innovations To Copy-And-Paste](https://hothardware.com/news/google-chrome-microsoft-edge-cool-innovations-copy-paste)
[](http://ruvds.com/ru-rub?utm_source=habr&utm_medium=article&utm_campaign=Bright_Translate&utm_content=google_chrome_i_microsoft_edge_planiruyut_kruto_rasshirit_vozmozhnosti_kopipasta) | https://habr.com/ru/post/567618/ | null | ru | null |
# Создание капчи только своими руками
Вот на днях решил, что на страницу регистрации в срочном порядке нужно ставить капчу, боты на столько обнаглели, что без неё там хорошо себя чувствуют и зовут ещё больше ботов.
По запросу в поисковике *«Скрипт капчи»*, выпадает столько готовых вариантов — что грех жаловаться, но все они мне не подходят — одни слишком страшные, другие через-чур мудренные.
Решено! Делаем капчу своими руками. Тема конечно избита, но процессом работы поделюсь.
От капчи я жду в первую очередь эргономику, сайт у меня цветастый и капча должна быть соответствующей.
На белом фоне рисовать цифры не по мне, поэтому делаем прямоугольник и заполняем его разными закорючками.
Размер фона в 3 раза больше чем размер будующей капчи т.к. в процессе генерации картинки, этот фон будет рандомно менять своё положение — делая каждую капчу уникальной.
Теперь нужны цифры. В предложенных мне вариантах скриптов — которые генерируют капчу, цифры рисовались текстом — менялся их цвет и размер.
Я же пошел другим путем и нарисовал 30 разных цифр — 3-мя различными шрифтами и закрасил их градиентом в цвета сайта.
Сохранив каждую цифру в отдельный файл и установив им размер height:22px; начинаю кодить:
Капча будет состоять из 6-ти цифр поэтому. Цифры присваиваются рандомно.
```
$pic1 = rand(1, 30);
$pic2 = rand(1, 30);
$pic3 = rand(1, 30);
$pic4 = rand(1, 30);
$pic5 = rand(1, 30);
$pic6 = rand(1, 30);
```
Для каждой переменной берется рандомно цифра от 1 до 30, максимальный порог — это количество файлов с цифрами (каждый файл подписан от 0.png до 30.png). Т.к цифры сохраненны в правильном порядке, то узнать какая из них нарисована в файле можно определив последнюю цифру из названия файла:
```
$pic1_value = substr($pic1, strlen($pic1)-1, 1);
$pic2_value = substr($pic2, strlen($pic2)-1, 1);
$pic3_value = substr($pic3, strlen($pic3)-1, 1);
$pic4_value = substr($pic4, strlen($pic4)-1, 1);
$pic5_value = substr($pic5, strlen($pic5)-1, 1);
$pic6_value = substr($pic6, strlen($pic6)-1, 1);
```
Т.е цифра 2 может храниться в файле 2.png, 12.png, 22.png и т.д.
Обязательно запомним код капчи и запишем его в сессию.
```
session_start();
$_SESSION['captha'] = "{$pic1_value}{$pic2_value}{$pic3_value}{$pic4_value}{$pic5_value}{$pic6_value}";
```
Теперь когда нам известны цифры — нам нужно их нарисовать на картинке размером 112x38px;
```
$dest = imagecreatetruecolor(112,38); # Сюда мы и будем рисовать
$back = imagecreatefromjpeg("../../pic/captha/back.jpg"); # Задний фон
```
Открываем также нужные нам цифры:
```
$var1 = imagecreatefrompng("../../pic/captha/{$pic1}.png");
$var2 = imagecreatefrompng("../../pic/captha/{$pic2}.png");
$var3 = imagecreatefrompng("../../pic/captha/{$pic3}.png");
$var4 = imagecreatefrompng("../../pic/captha/{$pic4}.png");
$var5 = imagecreatefrompng("../../pic/captha/{$pic5}.png");
$var6 = imagecreatefrompng("../../pic/captha/{$pic6}.png");
```
Задний фон рандомно двигаем по горизонтали и вертикали таким образом чтобы фон не выходил за рамки капчи.
```
imagecopyresampled($dest, $back, 0, 0, rand(0, 224), rand(0, 106), 112, 38, 112, 38);
```
Сами цифры мы тоже копируем в капчу — рандомно изменяя позицию по вертикали и горизонтали, а также размер цифры максимум на 4px.
```
imagecopyresampled ($dest, $var1, rand(0, 6), rand(2, 10), 0, 0, imagesx($var1) - rand(0, 4), imagesy($var1) - rand(0, 4), imagesx($var1), imagesy($var1));
imagecopyresampled ($dest, $var2, rand(18, 24), rand(2, 10), 0, 0, imagesx($var2) - rand(0, 4), imagesy($var2) - rand(0, 4), imagesx($var2), imagesy($var2));
imagecopyresampled ($dest, $var3, rand(36, 42), rand(2, 10), 0, 0, imagesx($var3) - rand(0, 4), imagesy($var3) - rand(0, 4), imagesx($var3), imagesy($var3));
imagecopyresampled ($dest, $var4, rand(54, 60), rand(2, 10), 0, 0, imagesx($var4) - rand(0, 4), imagesy($var4) - rand(0, 4), imagesx($var4), imagesy($var4));
imagecopyresampled ($dest, $var5, rand(72, 78), rand(2, 10), 0, 0, imagesx($var5) - rand(0, 4), imagesy($var5) - rand(0, 4), imagesx($var5), imagesy($var5));
imagecopyresampled ($dest, $var6, rand(90, 96), rand(2, 10), 0, 0, imagesx($var6) - rand(0, 4), imagesy($var6) - rand(0, 4), imagesx($var6), imagesy($var6));
```
В принципе всё готово осталось только установить в начале php файла нужный заголовок:
```
header('Content-type: image/jpeg');
```
И вывести нарисованную капчу в браузер:
```
imagejpeg($dest);
```
Ну и разумеется не забыть очистить буфер:
```
imagedestroy($back);
imagedestroy($dest);
imagedestroy($var1);
imagedestroy($var2);
imagedestroy($var3);
imagedestroy($var4);
imagedestroy($var5);
imagedestroy($var6);
```
Сохраняем, проверяем.
Ставим в нужное место на сайте.
Если введенный код
```
!= $_SESSION['captha']
```
— то выводим соответствующую ошибку.
По мере необходимости в папку с капчей можно будет скопировать дополнительные цифры а максимальный порог в строках:
`$pic1 = rand(1, 30);` — увеличить.
На этом наша самоджельная улучшенная и простая капча, готова. Спасибо за внимание и не судите строга. Если кому то понравится пример, пользуйтесь на здоровье. | https://habr.com/ru/post/164733/ | null | ru | null |
# Настоящий веб-сайт на Common Lisp за 9 шагов
Введение
--------
Эта вводная статья предназначена для желающих попробовать применить Common Lisp в задачах веб-программирования. Я не буду останавливаться на преимуществах этого языка, за меня это сделал [ababo](http://habrahabr.ru/users/ababo/) в своем вводном посте [Разработка web-приложений на языке Common Lisp (часть первая)](http://habrahabr.ru/blogs/webdev/104349/)
Я занимаюсь вопросами разработки веб-приложений на Common Lisp немногим более года и сделал на Common Lisp крупный интернет-магазин, что, как мне кажется, предупредит возражения тех, кто считает, что лисп бесполезен для коммерческого применения.
Сегодня моя задача — рассказать в подробностях о применяемом мной способе развертывания всей необходимой инфраструктуры. Используя эту статью как пошаговое руководство внимательный читатель сможет развернуть свой собственный сайт на лиспе.
Возможно мои подходы не идеальны — в таком случае я буду рад конструктивной критике — пожалуйста, не стесняйтесь если вам что-то не нравится — одной из целей написания этой статьи было исправление собственных ошибок.
Для тех, кто любит проматывать скучные процедуры установки — в конце статьи размещена небольшая вкусность, которая, возможно, расширит ваш взгляд на веб-программирование, если до этого момента вы не имели дела с лиспом. Ищите по ключевым словам SLIME и SWANK :)
Установка последней версии SBCL
--------------------------------
Я использую SBCL как наиболее удобную, распространенную и свободную реализацию Common Lisp, тесно интергрированную со средой Emacs, обеспечивающей удобную и комфортную работу. В репозиториях, как правило, находится не самая последняя версия SBCL, поэтому вы можете скомпилировать его из сорцов или установить бинарник для вашей архитектуры. Последнее тривиально, поэтому в этой статье я опишу компиляцию из исходников.
Чтобы скомпилировать свежий SBCL можно воспользоваться старым, который мы тут же поставим, используя пакетный менеджер:
```
$ apt-get install sbcl
```
Исходники SBCL можно получить тут: [sbcl.sourceforge.net/platform-table.html](http://sbcl.sourceforge.net/platform-table.html)
```
# Скачиваем
$ wget http://downloads.sourceforge.net/project/sbcl/sbcl/1.0.45/sbcl-1.0.45-source.tar.bz2
# Распаковывываем архив:
$ bzip2 -cd sbcl-1.0.45.tar.bz2 | tar xvf -
# Заходим внутрь каталога и компилим
$ cd sbcl-1.0.45/
$ sh make.sh
# Удаляем старый SBCL поставленный из репозиториев
$ apt-get remove sbcl
# Устанавливаем скомпилированный sbcl
$ sh install.sh
# Проверяем, все ли в порядке:
$ sbcl
This is SBCL 1.0.45, an implementation of ANSI Common Lisp.
More information about SBCL is available at .
SBCL is free software, provided as is, with absolutely no warranty.
It is mostly in the public domain; some portions are provided under
BSD-style licenses. See the CREDITS and COPYING files in the
distribution for more information.
*
```
Поздравляю, теперь у вас есть свежая версия sbcl. В данный момент я разворачиваю его вместе с вами на своем сервере, чтобы избежать возможных неточностей и в конце статьи вы сможете убедиться в том, что по крайней мере у меня все заработало. Ну, будем надеяться, что это будет так :)
Ставим quicklisp
----------------
Для управления библиотеками наиболее часто используются два пакетных менеджера — ASDF и QuickLisp. Последний гораздо более дружелюбен, а первый уже предустановлен вместе с SBCL, поэтому сейчас мы установим себе QuickLisp. На [quicklisp.org](http://quicklisp.org) размещена все вводная информация, поэтому я не буду повторяться и мы перейдем сразу к установке:
```
$ wget http://beta.quicklisp.org/quicklisp.lisp
$ sbcl --load quicklisp.lisp
* (quicklisp-quickstart:install)
* (ql:add-to-init-file)
```
Ставим hunchentoot
------------------
Теперь, когда у нас есть библиотечный менеджер, мы устанавливаем
веб-сервер hunchentoot, вместе со всеми его зависимостями одной командой:
```
* (ql:quickload 'hunchentoot)
```
Ставим swank и slime на сервер
------------------------------
> «И даже более впечатляющий пример удаленной отладки произошел в миссии NASA «Deep Space 1» в 1998 году. Через полгода после запуска космического корабля, небольшой код на Lisp должен был управлять космическим кораблем в течении двух дней для проведения серии экспериментов. Однако, неуловимое состояние гонки (race condition) в коде не было выявлено при тестировании на земле и было обнаружено уже в космосе. Когда ошибка была выявлена в космосе (100 миллионов миль от Земли) команда смогла произвести диагностику и исправление работающего кода, что позволило завершить эксперимент. Один из программистов сказал об этом следующее:
>
>
>
> — Отладка программы, работающей на оборудовании стоимостью 100 миллионов долларов, которая находится в 100 миллионах миль от вас, является интересным опытом. REPL, работающий на космическом корабле, предоставляет бесценные возможности в нахождении и устранении проблем.»
>
>
Я услышал об этом инциденте задолго до того как стал заниматься лиспом сам, и честно говоря воспринял это как байку, которой уже не суждено повториться в наш современный мир многомегабайтных исполняемых файлов и не менее тяжеловесных динамически связываемых библиотек. Однако познакомившись с возможностями удаленного управления лисп-образом я убедился в том, что это ничуть не сложнее чем работать с кодом у себя на машине. И никаких инкрементальных сборок, длительной компиляции или закачек скриптов через ftp — с помощью slime я подключаюсь к работающей системе и могу видеть и менять практически все, например реализовать горячую замену кода, или проинспектировать любой объект, функцию или макрос используя мощные средства интроспекции.
Как это работает? — спросите вы. Внутри лисп образа на удаленном сервере работает SWANK — специальная библиотека, предоставляющая собой бэкэнд, который предоставляет доступ ко всем рычагам управления лисп образом. SWANK написан на Common Lisp и общается со SLIME по довольно простому текстовому протоколу.
В моем Emacs-e работает SLIME, написанный на Emacs Lisp, который позволяет мне в момент редактирования файла с кодом отправлять команды, куски кода, определения объектов и структур удаленному образу Common Lisp. Таким образом, вы можете даже вообще не иметь копии исходного кода на удаленном сервере — и в этом случае никакой злоумышленник не сможет изменить его там, например чтобы обеспечить себе backdoor.
А учитывая развитые средства для кодогенерации, которыми отличается лисп, можно вообще не иметь практически никакого кода — пусть он сам будет генерироваться по данным — лучше самурая, который не сражается, может быть только программист, который не пишет код… Хм, что-то я тут увлекся, вернемся к установке :)
Итак, если у вас есть удаленный сервер, как у меня — вы можете ставить SWANK на него, а SLIME — на свою рабочую машину. Или
поставить и то и другое и туда и туда — главное потом не перепутать. Устанавливаем SWANK:
```
$ sbcl
* (ql:quickload 'swank)
```
… и SLIME
```
$ wget http://common-lisp.net/project/slime/snapshots/slime-current.tgz
$ tar xvzf slime-current.tgz
$ cd slime-2011-01-06/
```
Внимательно читаем README в этом каталоге и добавляем в свой
~/.emacs/init.el следующий код, следя за правильным указанием путей
```
;; SBCL
(setq inferior-lisp-program "/opt/sbcl/bin/sbcl") ; your Lisp system
(setq slime-lisp-implementations '((sbcl ("sbcl"))))
(setq slime-startup-animation nil)
;; SLIME
(add-to-list 'load-path "~/.emacs.d/slime") ;; Путь к slime
(require 'slime)
(setq slime-net-coding-system 'utf-8-unix)
(slime-setup '(slime-fancy))
(setq slime-enable-evaluate-in-emacs t)
```
Ставим screen
-------------
Поскольку мои сервера никогда не падают (ну да :) — я использую screen, чтобы держать вечно запущенную копию SBCL, хотя, насколько мне известно, существуют и более лучшие практики (о которых компетентные читатели, несомненно, напомнят в комментариях)
Если он у вас еще не стоит — самое время поставить:
```
$ apt-get install screen
```
Запускаем sbcl в screen на сервере и стартуем swank-сервер на 4005 порту
------------------------------------------------------------------------
```
$ screen -S sbcl
$ sbcl
* (require 'asdf)
* (asdf:oos 'asdf:load-op 'swank)
* (setq swank:*use-dedicated-output-stream* nil)
* (swank:create-server :coding-system "utf-8-unix" :dont-close t :port 4005)
```
Подключаемся из Emacs-a запущенного на своей машине к лисп-образу на сервере
----------------------------------------------------------------------------
В терминале прокидываем до хоста ssh-туннель
```
ssh -2 -N -f -L 4005:localhost:4005 user@host.tld
```
В Emacs-е подключаемся через этот туннель
```
M-x slime-connect
127.0.0.1
4005
```
Или, если у вас сервером является ваша домашняя машина — ничего прокидывать и поднимать SWANK не нужно — просто наберите в Emacs-e:
```
M-x slime
```
Запускаем web-server hunchentoot на 4242 порту
----------------------------------------------
Теперь мы готовы поднять веб-сервер hunchentoot. Я поднимаю его на 4242 порту и использую nginx как прокси. Также nginx отдает статику и делает еще ряд вещей, для которых он предназначен как нельзя лучше.
Конфиг nginx для наших тестовых целей может быть очень простым:
```
server {
listen 80;
server_name localhost;
location / {
proxy_pass http://localhost:4242;
proxy_redirect off;
}
}
```
Нижеследующий код, за авторством [archimag](http://habrahabr.ru/users/archimag/)-a создает специальный класс, который позволяет при возникновении ошибки на удаленном сервере сразу же пробросить эту ошибку вместе со стек-трейсом вам в уютненький emacs, где вы сможете с ней разобраться как следует. Таким образом, если вы подключены к серверу, где работает ваш сайт — вы будете всегда осведомлены о возникающих ошибках в момент их появления, в отличии от ряда других языков, используемых в веб-программировании.
Если же ошибок возникает слишком много, например на ошибочную странцицу постоянно заходят посетители — вы можете просто изменить значение \*catch-errors-p\* чтобы без помех разобраться из-за чего возникают уже пришедшие вам ошибки.
```
(defparameter *catch-errors-p* nil)
(defclass debuggable-acceptor (hunchentoot:acceptor) ())
(defmethod hunchentoot:acceptor-request-dispatcher ((acceptor debuggable-acceptor))
(if *catch-errors-p*
(call-next-method)
(let ((dispatcher (handler-bind ((error #'invoke-debugger))
(call-next-method))))
(lambda (request)
(handler-bind ((error #'invoke-debugger))
(funcall dispatcher request))))))
(defun request-dispatcher (request)
"Hello!")
(defparameter *debuggable-acceptor* (make-instance 'debuggable-acceptor
:request-dispatcher 'request-dispatcher
:port 4242))
(hunchentoot:start *debuggable-acceptor*)
(setf hunchentoot:*handle-http-errors-p* nil)
```
Функция request-dispatcher вызывается при каждом входящем запросе и в нашем случае просто возвращает «Hello!» — о ее расширении мы поговорим в следующей статье.
Если вы дочитали до этого места ~~надо поставить вам бутылку
пива~~, да еще и подняли у себя тестовый сайт на лиспе — я вам
завидую! Знакомство с лиспом подарило мне почти полтора года
наслаждения этим удивительным языком — и у вас в этом отношении все
впереди. Happy hacking! | https://habr.com/ru/post/111365/ | null | ru | null |
# Популярный плагин для WordPress содержит в себе бэкдор
Специалисты в области информационной безопасности нашли бэкдор в плагине для [WordPress](https://wordpress.org/plugins/custom-content-type-manager/), который вносил изменения в основные файлы платформы с целью дальнейшей авторизации и кражи пользовательских данных.
Первые признаки наличия бэкдора были замечены сотрудниками компании Sucuri, работающей в области обеспечения информационной безопасности web-сайтов. Один из их клиентов заметил файл со странным названием (auto-update.php), не существовавший до недавнего обновления плагина.
Речь идёт о [Custom Content Type Manager (CCTM)](https://wordpress.org/plugins/custom-content-type-manager/), популярном плагине для WordPress, предназначенном для создания произвольного типа постов. CCTM был доступен в директории плагинов на сайте WordPress в течение трёх лет и собрал себе довольно большую аудиторию – он установлен на более чем 10000 сайтов.
#### Версия 0.9.8.8 плагина Custom Content Type Manager содержит в себе вредоносный код
Плагин, выглядевший заброшенным последние 10 месяцев, за последние две недели загадочным образом изменил своего владельца, что сразу повлекло за собой создание и выпуск новой версии, за авторством его нового разработчика с никнеймом Wooranker. Но новая версия содержала лишь вредоносные обновления:
* Был добавлен файл auto-update.php, способный загружать файлы с удалённого сервера на заражённый сайт.
* Wooranker добавил файл CCTM\_Communicator.php, который работал в паре со старым, ранее безопасным файлом данного плагина. Целью этих двух файлов было оповещение Wooranker'a о появлении недавно заражённых сайтов при помощи пинга к его серверу.
* Помимо сбора информации на заражённом сайте, новая версия CCTM перехватывала логины и пароли пользователей при помощи WordPress, отправляя эти данные в зашифрованном виде на wordpresscore.com.
Модификации были выпущены как обновление 0.9.8.8 для Custom Content Type Manager, что позволило им легко распространиться при помощи включенной функции авто-обновления на сайтах или при установке самими пользователями.
Sucuri сообщает, что после получения украденных данных Wooranker пытался их использовать. Он вручную попробовал авторизоваться на одном из заражённых сайтов, но безуспешно, так как его владелец изменил URL на нестандартную ссылку. После неудачи Wooranker быстро сменил тактику. Он использовал бэкдор файла `auto-update.php` и вынуждал сайт жертвы закачивать и устанавливать файл `c.php`, который, в свою очередь, создавал другой файл: `wp-options.php` (WordPress использует `wp-settings.php`). Созданный файл должен был изменить основные файлы WordPress: `wp-login.php`, `wp-admin/user-new.php`, и `wp-admin/user-edit.php`.
Эти изменения позволяли хакеру контролировать действия пользователей над аккаунтами: создание, редактирование и их изменение, что позволяло перехватывать данные до их шифрования и красть полученную информацию.
#### Раскрыл ли хакер свою личность?
На случай, если возможностей файла `CCTM_Communicator.php` становилось недостаточно, Wooranker создал собственный аналитический код на JavaScript, который загружался через плагин CCTM как поддельная версия jQuery.
Этот файл передавал информацию о новых заражённых сайтах на домен `donutjs.com`. В дальнейшем команда Sucuri вычислила, что все использованные в этой атаке домены принадлежали человеку под именем Вишнудат Мангилипуди, проживающем в Индии, городе Андрха-Прадеш, но его данные также могли быть украдены и маловероятно, что он — наш хакер.
Хоть и Sucuri не первыми заметили странное поведение плагина, но, в отличие от его пользователей, они поняли, что файл auto-update.php является бэкдором, а не простой уязвимостью в безопасности плагина.
Администраторы WordPress с установленным CCTM должны немедленно удалить его и откатить основные файлы WordPress до их стандартных версий. Если же приложение CCTM вам необходимо, то используйте его последнюю стабильную версию 0.9.8.6 (версия 0.9.8.7 имеет уязвимости).
Также обратите внимание на то, что уже вышла версия 0.9.8.9 CCTM, не содержащая в себе вредоносного кода и идентичная версии 0.9.8.6.
[Источник](http://news.softpedia.com/news/popular-wordpress-plugin-comes-with-a-backdoor-steals-site-admin-credentials-501383.shtml) | https://habr.com/ru/post/279539/ | null | ru | null |
# Драйвер внешнего оборудования для 1С на примере фискального регистратора Мария-301МТМ
При реализации проектов на 1С зачастую приходится сталкиваться с разного рода устройствами и их сопряжением. Покуда будут существовать устройства на древним RS232 будет необходимость во внешних компонентах такого рода. Как правило с устройством идет документация, которая нередко содержит систему команд и некий драйвер который распространяется «так как есть». Очень часто драйвера «так как они есть» оставляют ожидать лучшего. Я предлагаю немного окунутся в системное программирование и решить для себя сей вопрос раз и навсегда.
Прекрасная [статья](http://habrahabr.ru/post/191014/) содержит пример и достаточное описание что к чему, что где менять. Пример компилируется. Для быстрого старта замечательная статья. Подобный пример свободно распространяется фирмой 1С и валяется в куче хлама на [диске ИТС](http://its.1c.ru/db/metodtorg#content:3221:hdoc). Много раз мелькало в глазах но было заложено на дальнюю полку с ярлыком «обязательно изучить».
Для простоты внешнюю компоненту далее по тексту буду называть драйвером.
**1. Отказ от OLE32 в пользу Native API.**
Тяжелые воспоминания об регистрации OLE32 компонент, и ужас их регистрации под Windows 7, натолкнул на соображение, что драйвер должен поддерживать Native API. Регистрация такой внешней компоненты выглядит:
```
ПодключитьВнешнююКомпоненту(ИмяФайлаДравера, "prn", ТипВнешнейКомпоненты.Native);
ДемоКомп = Новый("AddIn.prn.Maria2");
```
При этом предварительно никаких действий типа regsvr32. Да и на сколько мне известно, OLE32 ужа давно не флагманская технология Microsoft.
**2. Хранение самого драйвера в составе обработки или конфигурации.**
Файл драйвера вставляем в макет 1С как двоичные данные и по надобности распаковываем его в временный каталог пользователя.
```
Макет = ПолучитьОбщийМакет("Драйвер");
ИмяФайлаДравера = КаталогВременныхФайлов() + "AddInNewMaria.dll";
Макет.Записать(ИмяФайлаДравера);
ПодключитьВнешнююКомпоненту(ИмяФайлаДравера, "prn", ТипВнешнейКомпоненты.Native);
ДемоКомп = Новый("AddIn.prn.Maria2");
```
**3. Реализация интерфейса драйвера. Вынос логики команд на сторону 1С.**
Первоначально при написании драйвера, была использована идеология существующих драйверов. ДемоКомп.СделайЧтото(МногоРаз).
```
ДемоКомп.NullCheck();
ДемоКомп.CancelCheck();
```
По-сути был повторен драйвер, разумеется без ограничений наложенных производителем. Но сия наследственность оказалась мучительной и пагубной. Раз в пол года возникает необходимость добавления каких-то команд, изменении существующих.
Был написан универсальный [драйвер RS232 порта для 1С](https://github.com/tarasii/1c_rs232). Он был протестирован usb-модемом Huawei-1550 и с Марией. Для этого драйвера необходимо переписать сервис обработку для 1С.
После очередного «усовершенствования» родилась идея выноса логики команд на сторону 1С. Драйвер занимается только реализацией транспортного протокола. Системные программисты ликуют. Теперь команда драйвера выглядит:
```
ДемоКомп.Команда("NULL"); //печать нулевого чека
```
И да на радость каждому программисту 1С Native API дает возможность вызывать функции по-русски (русские псевдонимы функций).
4. Запись протокола обмена.
Для записи в файл maria.log в каталог временных файлов пользователя команд и реакций на них необходимо:
```
ДемоКомп = Новый("AddIn.prn.Maria2");
ДемоКомп.Логирование();
```
В файле пишется время и вид события: с — команда; а — ответ; u — соединение; t — количество циклов для получения ответа; e — ошибка.
```
[20150210205009]t: 1 8
[20150210205009]u:эREADYю
[20150210205009]c:эSYNCю
[20150210205009]t: 1 29
[20150210205009]a:эWAITюэSYNCюэDONEюэREADYю
[20150210205009]c:эCNALю
[20150210205009]t: 1 141
[20150210205009]a:эWAITюэCNAL2013120510200020150210200500000000000000000000000000000000000000000000000000000000000000000000000020131205800000uюэDONEюэREADYю
[20150210205009]c:эUPAS1111111111‘в ¦Ґаю
[20150210205009]t: 1 22
[20150210205009]a:эWAITюэDONEюэREADYю
[20150210205009]c:эNREPю
[20150210205012]t: 18 52
[20150210205012]a:эWAITюэNREP5100 юэPRNюэSOFTREGIST юэDONEюэREADYю
[20150210205012]e:35
```
Вот минимальный набор необходимого чтоб «заработало». Теперь немного о будущем:
**5. Другие устройства такого класса.**
По задумке не сложно заменить транспортный протокол Марии на протокол например ИКС-а. Можно было б говорить о семействе драйверов. Сам скелет основных необходимых функций готов.
**6. Внешние события.**
В процедурах реализации транспортного протокола стоит перейти на threads, а сигнализацию о завершении работы команды делать внешним событием. Хочу сделать именно так, но немножко чего-то не хватает: времени или знаний или того и другого. И рок «уже работает так», " работает не трогай" немного охлаждает пыл порыва.
**7. Совместная работа.**
В планах написание простого web-сервиса, который бы принимал команды, организовывал очередь команд и перенаправлял их на устройство. Сервисная обработка в таком случае будет выглядеть аналогично, команды не поменяются. Изменится только инициализация объекта.
[Ссылка на проект на github](https://github.com/tarasii/Maria301dllfor1C)
Проект состоит из проекта Visual Studio, демонстрации команд на 1С (в модуле управляемого приложения) и сервис обработки для 1С. | https://habr.com/ru/post/250341/ | null | ru | null |
# Имитируем управление устройствами с помощью акторов
Корни [SObjectizer](https://habrahabr.ru/post/304386/) берут свое начало в теме автоматизированных систем управления технологическими процессами (АСУТП). Но использовали мы SObjectizer в далеких от АСУТП областях. Поэтому иногда возникает ностальгия из категории «эх, давно не брал в руки шашек...» Однажды из-за этого в составе SObjectizer появился один из самых объемных примеров — [machine\_control](https://sourceforge.net/p/sobjectizer/repo/HEAD/tree/tags/so_5/5.5.19.2/dev/sample/so_5/machine_control/main.cpp). Уж очень тогда захотелось «тряхнуть стариной», смоделировать задачку управления оборудованием на современном SObjectizer-е. Ну и под шумок запихнуть в пример разные вкусные фичи SObjectizer-а вроде фильтров доставки, шаблонных агентов и диспетчера с поддержкой приоритетов. Сегодня попробуем рассказать и показать, как это все работает.
Photo [by Mike Boening](https://www.flickr.com/photos/memoriesbymike/30346870663/)
Что мы моделируем?
==================
Предположим, что мы имеем дело с какой-то машиной или со станком на производстве, у которого внутри есть двигатель. Ну, скажем, привод ленты конвейера. Или это насос, качающий воду. Не суть важно. Важно то, что когда двигатель работает, он нагревается. А когда он нагревается, его нужно охлаждать. Поэтому рядом с двигателем установлен охлаждающий вентилятор. Этот вентилятор нужно включить, если двигатель разогрелся свыше 70 градусов. Вентилятор следует выключить, если в результате охлаждения двигатель остыл до 50 градусов. Если же двигатель, не смотря на охлаждение, продолжает нагреваться и его температура достигает 95 градусов, то двигатель вовсе нужно выключить и подождать, пока он не остынет до 50 градусов.
Естественно, что нам бы хотелось видеть, как все это происходит в динамике. Нам нужно видеть работает ли сейчас двигатель, какова температура у двигателя, включен ли охлаждающий вентилятор. Для этого в реализации machine\_control мы используем простую периодическую печать всей этой информации на консоль.
Ну и для того, чтобы нам было интереснее, сделаем работу не с одним двигателем, а с несколькими. Все они работают одинаковым образом, но их свойства отличаются. Какой-то из них нагревается быстрее, какой-то медленнее. Поэтому если наблюдать за работой, скажем, четырех двигателей, то будет казаться, что каждый из них живет своей жизнью.
Поехали!
========
Пара общих слов о выбранном решении
-----------------------------------
Понятно, что любую задачу можно решить несколькими способами. Описываемый ниже способ всего лишь один из возможных. Его выбрали не столько из-за соображений простоты и практичности, сколько из-за возможности продемонстрировать разные фичи SObjectizer-а. Поэтому лучше относиться к последующему тексту как к демонстрации. Тем более, что в продакшен все будет гораздо серьезнее и страшнее ;)
Как именно работает пример?
---------------------------
Есть несколько агентов-машин, есть специальный общий почтовый ящик. Агенты-машины время от времени посылают в этот общий почтовый ящик сообщения о своем текущем статусе.
Из общего почтового ящика сообщения о статусе агента-машины попадают к двум совершенно разным агентам. Первый из них, total\_status\_dashboard, собирает информацию о статусах агентов-машин и периодически отображает информацию о происходящем на стандартный поток вывода. Благодаря чему запустив пример мы видим приблизительно вот такую картинку:
Второй агент — это statuses\_analyser. Он получает информацию о статусах для того, чтобы контролировать происходящее с машинами и определять моменты, когда какой-то из машин требуется внешнее воздействие. Когда воздействие требуется, агент statuses\_analyser отсылает еще одно сообщение в этот же общий почтовый ящик. На это сообщения реагируют агенты machine\_controller. Они уже решают какое именно управляющее воздействие должно быть применено к конкретной машине и отсылают соответствующее сообщение напрямую соответствующему агенту-машине.
Вот, собственно, и все. Остальные моменты в деталях постараемся рассмотреть ниже по тексту.
Агент a\_machine\_t
-------------------
Начнем разбор реализации нашего примера «от печки», т.е. от самой машины с двигателем и охлаждающим вентилятором. В реальной жизни у нас было бы какое-то настоящее «железо», к которому были бы подключены какие-то датчики и управляторы. И со всей этой кухней нужно было бы работать из программы через тот или иной интерфейс, а может быть и через несколько разных интерфейсов.
Но у нас вымышленный пример, поэтому нам не нужно опрашивать никаких портов и считывать данные с реального оборудования. Нам нужно что-то изображающее из себя работающую машину. Для этого у нас есть агент a\_machine\_t, который:
* периодически выдает во внешний мир информацию о своем состоянии, как то: работает ли двигатель, работает ли вентилятор, какова текущая температура двигателя;
* принимает команды на включение/выключение двигателя и выполняет их;
* принимает команды на включение/выключение вентилятора и выполняет их.
Не смотря на то, что данный агент занимается имитацией, в свое время, в задачах АСУТП, доводилось использовать похожую логику. Агент по событию таймера обращался через некоторый интерфейс к оборудованию и собирал информацию с датчиков. После чего преобразовывал снятую информацию в нужный вид и отсылал ее тем, кто мог эту информацию должным образом обработать.
Посмотрим на то, как выглядит этот самый агент a\_machine\_t, но сперва введем несколько определений, которые нам понадобятся в реализации a\_machine\_t:
```
// Специальный тип для обозначения состояния двигателя.
enum class engine_state_t { on, off };
// Специальный тип для обозначения состояния вентилятора.
enum class cooler_state_t { on, off };
// Управляющие сообщения-сигналы для включения и выключения двигателя.
struct turn_engine_on : public so_5::signal_t {};
struct turn_engine_off : public so_5::signal_t {};
// Управляющие сообщения-сигналы для включения и выключения вентилятора.
struct turn_cooler_on : public so_5::signal_t {};
struct turn_cooler_off : public so_5::signal_t {};
// Описание текущего состояния машины.
struct machine_status
{
// Уникальное название-идентификатор для машины.
// Необходимо для того, чтобы отличать машины друг от друга.
const std::string m_id;
// Статус двигателя машины.
const engine_state_t m_engine_status;
// Статус вентилятора машины.
const cooler_state_t m_cooler_status;
// Текущая температура двигателя.
const float m_engine_temperature;
};
```
Соответственно, наш агент a\_machine\_t будет получать управляющие команды в виде сообщений-сигналов turn\_engine\_on/turn\_engine\_off и turn\_cooler\_on/turn\_cooler\_off, а о своем состоянии будет извещать посредством отсылки сообщения machine\_status.
Теперь уже можно перейти к рассмотрению самого агента a\_machine\_t. Начнем с самых потрохов:
```
class a_machine_t : public so_5::agent_t
{
// Этот сигнал будет использоваться для периодического информирования
// о текущем статусе машины.
struct update_status : public so_5::signal_t {};
// Агент-машина может находиться в двух состояниях:
// состояние, когда двигатель включен,
const state_t st_engine_on{ this, "on" };
// состояние, когда двигатель выключен.
const state_t st_engine_off{ this, "off" };
// Уникальный идентификатор-название этой машины.
const std::string m_id;
// В этот почтовый ящик будет отсылаться сообщение machine_status.
const so_5::mbox_t m_status_distrib_mbox;
// Уникальные параметры конкретной машины:
// начальная температура,
const float m_initial_temperature;
// шаг изменения температуры двигателя во время нагревания,
const float m_engine_heating_step;
// шаг изменения температуры двигателя во время охлаждения.
const float m_cooler_impact_step;
// Текущая температура двигателя.
float m_engine_temperature;
// Текущие состояния двигателя и вентилятора.
engine_state_t m_engine_status = engine_state_t::off;
cooler_state_t m_cooler_status = cooler_state_t::off;
// ID таймера для периодического сообщения update_status.
// В SO-5 для периодических сообщений ID таймера нужно сохранять
// в течении всего времени работы, иначе произойдет автоматическая
// отмена периодического сообщения.
so_5::timer_id_t m_update_status_timer;
```
Агент a\_machine\_t представляет из себя очень простой конечный автомат с двумя состояниями: «двигатель включен» и «двигатель выключен». В каждом из них он реагирует на некоторые сообщения по-разному. Для того, чтобы представить агента в виде конечного автомата в SObjectizer нам и потребовались два отдельных атрибута st\_engine\_on и st\_engine\_off.
При своем старте агент инициирует периодическое сообщение update\_status. Каждый раз, когда он получает это сообщение, агент пересчитывает значение m\_engine\_temperature с учетом того, работают ли сейчас двигатель и вентилятор или нет. После чего в почтовый ящик m\_status\_distrib\_mbox отсылается сообщение machine\_status с текущими показаниями.
[Конструктор агента](https://sourceforge.net/p/sobjectizer/repo/HEAD/tree/tags/so_5/5.5.19.2/dev/sample/so_5/machine_control/main.cpp#l56) выглядит объемным из-за обилия начальных параметров, но на самом деле он тривиален, поэтому мы его рассматривать не будем.
А вот дальше уже интереснее. Во-первых, это специальный метод so\_define\_agent(), который используется для того, чтобы агент мог настроить себя для работы внутри SObjectizer. Нашему a\_machine\_t нужно перейти в свое начальное состояние и подписаться на нужные ему сообщения. Вот как это выглядит:
```
virtual void so_define_agent() override
{
this >>= st_engine_off;
st_engine_on
.event< turn_engine_off >( &a_machine_t::evt_turn_engine_off )
.event< turn_cooler_on >( &a_machine_t::evt_turn_cooler_on )
.event< turn_cooler_off >( &a_machine_t::evt_turn_cooler_off )
.event< update_status >( &a_machine_t::evt_update_status_when_engine_on );
st_engine_off
.event< turn_engine_on >( &a_machine_t::evt_turn_engine_on )
.event< turn_cooler_on >( &a_machine_t::evt_turn_cooler_on )
.event< turn_cooler_off >( &a_machine_t::evt_turn_cooler_off )
.event< update_status >( &a_machine_t::evt_update_status_when_engine_off );
}
```
Можно обратить внимание, что на сигнал update\_status агент в разных состояниях реагирует посредством разных обработчиков. Также можно увидеть, что в состоянии st\_engine\_on сигнал turn\_engine\_on игнорируется, поскольку нет смысла включать уже работающий двигатель. Аналогично и с turn\_engine\_off в состоянии st\_engine\_off.
По поводу метода so\_define\_agent() нельзя не сделать маленького лирического отступления: на первый взгляд этот метод выглядит избыточным и кажется, что без него можно было бы обойтись. Ведь можно все настройки агента выполнить прямо в конструкторе.
Действительно, можно. В простейших случаях так и делается. Но вот если используется наследование для агентов, то настройка агента в so\_define\_agent() оказывается более удобной, чем в конструкторе. Классы наследники получают простой и удобный способ вмешательства в настройки базового класса (например, можно просто не вызывать so\_define\_agent() для базового класса, тогда все настройки будут сделаны производным классом).
Кроме того, по нашему опыту, отдельный метод so\_define\_agent() начинает себя оправдывать в больших проектах, написанных разными людьми: открываешь чужой код, сразу же заглядываешь в so\_define\_agent() чужого агента и видишь все в одном месте. Сильно экономит время и силы.
Следующий важный метод — это so\_evt\_start(). SObjectizer автоматически вызывает его у всех агентов, которые начинают работать внутри SObjectizer-а. Наш a\_machine\_t использует so\_evt\_start() для того, чтобы начать отсылку периодического сообщения update\_status:
```
virtual void so_evt_start() override
{
// Запускаем периодическое сообщение типа update_status и сохраняем
// ID таймера, чтобы сообщение продолжало отсылаться до тех пор,
// пока агент существует.
m_update_status_timer = so_5::send_periodic< update_status >(
// Указываем себя в качестве получателя сообщения.
*this,
// Нет задержки перед появлением сообщения в первый раз.
std::chrono::milliseconds(0),
// Далее сообщение будет отсылаться каждые 200ms.
std::chrono::milliseconds(200) );
}
```
Далее идут обработчики событий агента a\_machine\_t. Обработчиком события называется метод, который SObjectizer вызовет когда агент получит соответствующее сообщение-инцидент. Соответствие между сообщением-инцидентом и обработчиком задается при подписке на сообщение. Так, подписка вида:
```
st_engine_on
.event< turn_engine_off >( &a_machine_t::evt_turn_engine_off )
```
указывает SObjectizer-у, что когда агенту приходит сообщение типа turn\_engine\_off, то у агента нужно вызвать метод evt\_turn\_engine\_off().
У агента a\_machine\_t есть четыре простых обработчика, пояснять работу которых нет смысла:
```
void evt_turn_engine_off()
{
// Меняем текущее состояние агента.
this >>= st_engine_off;
// Обновляем соответствующий статус.
m_engine_status = engine_state_t::off;
}
void evt_turn_engine_on()
{
this >>= st_engine_on;
m_engine_status = engine_state_t::on;
}
void evt_turn_cooler_off()
{
// Состояние агента менять не нужно.
// Поэтому просто обновляем соответствующий статус.
m_cooler_status = cooler_state_t::off;
}
void evt_turn_cooler_on()
{
m_cooler_status = cooler_state_t::on;
}
```
А вот по поводу реакций на периодическое сообщение update\_status нужно будет дать несколько пояснений. Сперва посмотрим на реакцию на update\_status когда двигатель работает:
```
void evt_update_status_when_engine_on()
{
m_engine_temperature += m_engine_heating_step;
if( cooler_state_t::on == m_cooler_status )
m_engine_temperature -= m_cooler_impact_step;
distribute_status();
}
```
Поскольку двигатель у нас работает, а значит и нагревается, то мы должны увеличить текущую температуру. Однако, если включен охлаждающий вентилятор, то температуру нужно откорректировать с учетом влияния охлаждения.
Когда сигнал update\_status обрабатывается в состояние st\_engine\_off, т.е. когда двигатель отключен, нам нужно только учесть влияние охлаждение, если оно сейчас включено:
```
void evt_update_status_when_engine_off()
{
if( cooler_state_t::on == m_cooler_status )
{
m_engine_temperature -= m_cooler_impact_step;
// В данной имитации мы не позволяем температуре двигателя
// опуститься слишком низко.
if( m_engine_temperature < m_initial_temperature )
m_engine_temperature = m_initial_temperature;
}
distribute_status();
}
```
Ну а вспомогательный метод distribute\_status() имеет совсем тривиальную реализацию, т.к. его единственная задача — это отсылка сообщения machine\_status в специально предназначенный для этого почтовый ящик:
```
void distribute_status()
{
// Внутри send-а создается экземпляр типа machine_status,
// который инициализируется параметрами из вызова send.
// После чего этот экземпляр будет отослан в почтовый ящик
// m_status_distrib_mbox.
so_5::send< machine_status >(
// Куда направляется сообщение.
m_status_distrib_mbox,
// Все остальные аргументы используются для конструирования
// экземпляра сообщения machine_status.
m_id,
m_engine_status,
m_cooler_status,
m_engine_temperature );
}
```
### Куда же улетают сообщения machine\_status?
Возможно, у кого-то из читателей возник вопрос: а почему же a\_machine\_t сам не принимает решения по поводу включения/выключения вентилятора и двигателя? Почему вместо того, чтобы самостоятельно анализировать происходящее и предпринимать соответствующие действия, a\_machine\_t лишь периодически отсылает куда-то сообщения о своем текущем состоянии?
Это потому, что декомпозиция :)
Когда мы проектируем какую-то систему на основе объектно-ориентированного подхода, то мы стремимся к тому, чтобы каждый объект отвечал за свою задачу и нужный нам эффект достигался бы за счет их комбинирования. Точно так же происходит и при проектировании системы на базе акторов (агентов): пусть каждый актор отвечает за свою задачу, а мы сформируем решение за счет их комбинации.
Поэтому агент a\_machine\_t решает только одну задачу: реализует интерфейс с оборудованием (в нашем примере он имитирует этот интерфейс). В реальной задаче a\_machine\_t бы занимался выставлением/сбросом битиков, чтением-записью байтиков в какой-то коммуникационный порт с проверками успешности операций ввода-вывода, контролем скорости передачи данных, тайм-аутов и пр. низкоуровневыми вещами.
Так что задача a\_machine\_t — это получить от устройства осмысленную информацию, пригодную для дальнейшей обработки, отдать эту информацию кому-то наверх, принять сверху команду для устройства, преобразовать эту команду в последовательность понимаемых устройством воздействий. Что a\_machine\_t в меру ограничений конкретной имитации и делает.
Агент a\_total\_status\_dashboard\_t
------------------------------------
Агент a\_total\_status\_dashboard\_t должен собирать сообщения machine\_status, агрегировать информацию из этих сообщений и периодически отображать агрегированную информацию в стандартный поток вывода.
Для выполнения своей работы a\_total\_status\_dashboard\_t подписывается на два сообщения:
```
virtual void so_define_agent() override
{
so_subscribe( m_status_distrib_mbox )
.event( &a_total_status_dashboard_t::evt_machine_status );
so_subscribe_self().event< show_dashboard >(
&a_total_status_dashboard_t::evt_show_dashboard );
}
```
Первое сообщение, machine\_status, агент ожидает из специального почтового ящика, в который агенты a\_machine\_t отсылают свои machine\_status-сообщения. А второе сообщение, show\_dashboard, агент a\_total\_status\_dashboard\_t отсылает себе сам в виде периодического сообщения:
```
virtual void so_evt_start() override
{
// Запускаем периодический сигнал для отображения
// текущей информации на консоль.
const auto period = std::chrono::milliseconds( 1500 );
m_show_timer = so_5::send_periodic< show_dashboard >( *this,
period, period );
}
```
Здесь a\_total\_status\_dashboard\_t использует тот же самый подход, как и агент a\_machine\_t — инициирует периодическое сообщение в своем методе so\_evt\_start(), который SObjectizer автоматически вызывает в самом начале работы a\_total\_status\_dashboard\_t.
Обработка machine\_status очень простая: нужно всего лишь сохранить очередную порцию информации в ассоциативный контейнер:
```
void evt_machine_status( const machine_status & status )
{
m_machine_statuses[ status.m_id ] = one_machine_status_t{
status.m_engine_status, status.m_cooler_status,
status.m_engine_temperature
};
}
```
Да и обработчик show\_dashboard не содержит ничего сложного: всего лишь итерация по содержимому ассоциативного контейнера с печатью на стандартный поток вывода:
```
void evt_show_dashboard()
{
auto old_precision = std::cout.precision( 5 );
std::cout << "=== The current status ===" << std::endl;
for( const auto & m : m_machine_statuses )
{
show_one_status( m );
}
std::cout << "==========================" << std::endl;
std::cout.precision( old_precision );
}
```
Поскольку агент a\_total\_status\_dashboard\_t не представляет большого интереса и его реализация весьма проста, то углубляться дальше в его реализацию мы не будем. Кому интересно, полный исходный код a\_total\_status\_dashboard\_t можной увидеть [здесь](https://sourceforge.net/p/sobjectizer/repo/HEAD/tree/tags/so_5/5.5.19.2/dev/sample/so_5/machine_control/main.cpp#l171).
Агенты a\_statuses\_analyser\_t и a\_machine\_controller\_t
-----------------------------------------------------------
В данной реализации примера machine\_control анализом информации от агентов a\_machine\_t и выдачей управляющих команд агентам-машинам занимается связка из нескольких агентов.
Во-первых, это агент a\_statuses\_analyser\_t, который получает сообщения machine\_status, анализирует их и определяет, что конкретный a\_machine\_t нуждается в каком-то воздействии.
Во-вторых, есть группа агентов-шаблонов типа a\_machine\_controller\_t, которые реагируют на сигналы от a\_statuses\_analyser\_t и выдают то или иное воздействие на конкретную машину. Так, один агент a\_machine\_controlle\_t реагирует на ситуацию, когда следует включить охлаждающий вентилятор и отсылает сообщение turn\_cooler\_on соответствующему агенту a\_machine\_t. Другой агент a\_machine\_controller\_t реагирует на ситуацию, когда следует отключить двигатель и отсылает сообщение turn\_engine\_off. И т.д.
Вообще говоря, такое деление на a\_statuses\_analyser\_t и a\_machine\_controller\_t — это явное усложнение нашего примера. Можно было бы вполне обойтись всего одним агентом a\_statuses\_analyser\_t, который бы сам мог и информацию анализировать, и управляющие команды отсылать. Хотя, скорее всего, агент a\_statuses\_analyser\_t сильно бы увеличился в объеме при этом.
Изначально в machaine\_control хотелось показать разнообразные фичи SObjectizer-а, в частности, использование агентов-шаблонов и приоритетов агентов, поэтому мы пошли на разделение логики между a\_statuses\_analyser\_t и a\_machine\_controller\_t.
Итак, суть взаимодействия a\_machine\_t, a\_statuses\_analyser\_t и a\_machine\_controller\_t в следующем:
* a\_machine\_t периодически рассылает информацию о себе в виде сообщения machine\_status;
* a\_statuses\_analyser\_t собирает информацию из machine\_status и определяет, нужно ли какое-то воздействие на конкретный a\_machine\_t. Если воздействие нужно, то a\_status\_analyser\_t отсылает сообщение machine\_needs\_attention с информацией о том, какой машине какое воздействие требуется;
* агенты a\_machine\_controller\_t реагируют на сообщения machine\_needs\_attention и генерируют сообщения turn\_engine\_on/turn\_engine\_off и/или turn\_cooler\_on/turn\_cooler\_off для конкретного агента a\_machine\_t.
Сообщение machine\_needs\_attention имеет следующий вид:
```
// Перечисление, которое определяет какую именно ситуацию диагностировали.
enum class attention_t
{
none,
engine_cooling_done,
engine_cooling_needed,
engine_overheat_detected
};
// Сообщение о том, что с конкретной машиной что-то произошло.
struct machine_needs_attention
{
// Уникальный идентификатор-название машины.
const std::string m_id;
// Что именно диагностировали.
const attention_t m_attention;
// Текущий статус двигателя у машины (включен/выключен).
const engine_state_t m_engine_status;
// Текущий статус охлаждающего вентилятора (включен/выключен).
const cooler_state_t m_cooler_status;
};
```
Агент a\_statuses\_analyser\_t хранит прошлую информацию о каждой машине и сравнивает ее с новой информацией, поступающей с сообщением machine\_status. Если обнаруживается, что двигатель требует охлаждения или что двигатель перегрелся, или что двигатель достиг безопасной температуры, то a\_statuses\_analyser\_t генерирует сообщение machine\_needs\_attention. Это сообщение подхватывается соответствующим a\_machine\_controller\_t и нужному агенту a\_machine\_t будет отослана нужная команда.
### Подробнее об агенте a\_statuses\_analyser\_t
[Потроха у агента a\_statuses\_analyser\_t довольно объемные](https://sourceforge.net/p/sobjectizer/repo/HEAD/tree/tags/so_5/5.5.19.2/dev/sample/so_5/machine_control/main.cpp#l287). Но большая их часть относится к тому, чтобы хранить и анализировать текущее состояние агентов-машин. Разбирать эту часть в деталях мы не будем (если возникнут какие-то вопросы, то я на них отвечу в комментариях), просто поясним в двух словах:
* агент a\_statuses\_analyser\_t хранит ассоциативный контейнер с информацией о последнем известном статусе каждого агента-машины. Ключем в этом контейнере является уникальное имя-идентификатор машины;
* при получении очередного сообщения machine\_status агент сверяет свежую информацию с тем, что у него было сохранено ранее. Если обнаруживаются ситуации, когда требуется воздействие на агента-машину, то генерируется сообщение machine\_needs\_attention;
* после чего агент a\_statuses\_analyser\_t обновляет данные в своем ассоциативном контейнере.
В коде все это занимает приличное количество строк, но ничего сложного там нет.
А вот та часть агента a\_statuses\_analyser\_t, которая относится к взаимодействию с SObjectizer-ом, вообще минимальна: всего лишь подписка на одно-единственное сообщение в so\_define\_agent() и одно-единственное событие для этого сообщения:
```
virtual void so_define_agent() override
{
so_subscribe( m_status_distrib_mbox ).event(
&a_statuses_analyzer_t::evt_machine_status );
}
void evt_machine_status( const machine_status & status )
{
auto it = m_last_infos.find( status.m_id );
if( it == m_last_infos.end() )
// Об этой машине мы еще информацию не получали.
// Добавим информацию в наше хранилище.
it = m_last_infos.insert( last_info_map_t::value_type {
status.m_id,
last_machine_info_t {
attention_t::none,
status.m_engine_temperature
} } ).first;
handle_new_status( status, it->second );
}
```
Где метод handle\_new\_status(), который вызывается внутри evt\_machine\_status(), это уже часть той прикладной логики контроля за статусом агента-машины, о которой мы коротко рассказали ранее.
### Подробнее об агентах a\_machine\_controller\_t
#### В чем вообще смысл a\_machine\_controller\_t?
В наличии нескольких экземпляров агентов a\_machine\_controller\_t есть следующий смысл: когда агент a\_statuses\_analyser\_t определяет, например, что двигатель у машины остыл до безопасной температуры, то в нам может потребоваться сделать несколько разных действий. Во-первых, выключить охлаждающий вентилятор. Во-вторых, может оказаться, что двигатель был предварительно отключен и нам нужно включить его вновь.
Если бы мы разместили всю эту логику внутри a\_statuses\_analyser\_t, то его код бы разросся и понимать его было бы труднее. Вместо этого мы просто заставили a\_statuses\_analyser\_t объявлять на что именно следует обратить внимание в работе агента-машины. А уже реагировать на это объявление будут агенты a\_machine\_controller\_t. И каждый a\_machine\_controller\_t сам определяет, нужно ли ему реагировать или нет. Если нужно, то a\_machine\_contoller\_t получает сообщение machine\_needs\_attention и инициирует соответствующую команду агенту-машине. Если не нужно, то a\_machine\_controller\_t сообщение machine\_needs\_attention просто игнорирует.
#### Агент a\_machine\_controller\_t
Код агента-шаблона a\_machine\_controller\_t небольшой, поэтому для простоты работы с ним приведем весь код этого агента полностью:
```
template< class LOGIC >
class a_machine_controller_t : public so_5::agent_t
{
public :
a_machine_controller_t(
context_t ctx,
so_5::priority_t priority,
so_5::mbox_t status_distrib_mbox,
const machine_dictionary_t & machines )
: so_5::agent_t( ctx + priority )
, m_status_distrib_mbox( std::move( status_distrib_mbox ) )
, m_machines( machines )
, m_logic()
{}
virtual void so_define_agent() override
{
so_set_delivery_filter( m_status_distrib_mbox,
[this]( const machine_needs_attention & msg ) {
return m_logic.filter( msg );
} );
so_subscribe( m_status_distrib_mbox )
.event( [this]( const machine_needs_attention & evt ) {
m_logic.action( m_machines, evt );
} );
}
private :
const so_5::mbox_t m_status_distrib_mbox;
const machine_dictionary_t & m_machines;
const LOGIC m_logic;
};
```
Итак, это шаблонный класс, который параметризуется одним параметром: типом прикладной логики, которую должен иметь конкретный a\_machine\_controller\_t. Этот тип LOGIC должен быть типом с двумя методами следующего вида:
```
struct LOGIC
{
bool filter( const machine_needs_attention & msg ) const;
void action(
const machine_dictionary_t & machines,
const machine_needs_attention & evt ) const;
};
```
Если бы в C++11 были концепты, то можно было бы объявить соответствующий концепт для того, чтобы проще было определять, какой тип может быть параметром для шаблона a\_machine\_controller\_t, а какой — нет. Но, т.к. в C++11 концепты не завезли, то приходится полагаться на утиную типизацию.
Агент a\_machine\_controller\_t создает у себя внутри экземпляр типа LOGIC и делегирует все свои действия этому экземпляру. И этот экземпляр есть не что иное, как контроллер, который выдает управляющие воздействия агенту-машине.
Действий же у контроллера всего два:
Во-первых, нужно отфильтровать сообщения, которые конкретному контроллеру не интересны. Для этого a\_machine\_controller\_t назначает фильтр доставки сообщений:
```
so_set_delivery_filter( m_status_distrib_mbox,
[this]( const machine_needs_attention & msg ) {
return m_logic.filter( msg );
} );
```
Фильтр доставки — это специальный механизм SObjectizer-а. Он нужен в ситуациях, когда агент подписывается на некоторое сообщение типа T из почтового ящика M, но хочет получать не все сообщения типа T, а только те, внутри которых содержится интересная агенту информация.
В этих случаях агент посредством своего метода so\_set\_delivery\_filter() задает фильтр, лямбда-функцию, которую почтовый ящик M будет автоматически вызывать каждый раз, когда в него приходит сообщение типа T. Если фильтр возвращает true, значит экземпляр сообщения агенту интересен и доставка сообщения до агента выполняется. Если же фильтр возвращает false, то сообщение этому агенту не доставляется, тем самым агент не отвлекается на то, что ему не интересно.
*Наглядная схема работы фильтра доставки. Агент Subscriber-1 не использует фильтр доставки и поэтому получает все сообщения из mbox-а. Тогда как агент Subscriber-2 установил фильтр доставки и получает только те сообщения, которые проходят через фильтр.*
Вот метод LOGIC::filter() и должен играть роль фильтра доставки, он пропускает только те экземпляры machine\_needs\_attention, которые интересны контроллеру.
Во-вторых, контроллер должен что-то предпринять при получении сообщения machine\_needs\_attention, в котором уже точно лежит информация, интересная для контроллера.
За это отвечает метод LOGIC::action(). Агент a\_machine\_controller\_t вызывает этот метод в своем обработчике machine\_needs\_attention:
```
so_subscribe( m_status_distrib_mbox )
.event( [this]( const machine_needs_attention & evt ) {
m_logic.action( m_machines, evt );
} );
```
#### Примеры нескольких controller-ов
Ну а для того, чтобы было понятнее, как же именно работают a\_machine\_controller\_t, приведем пару примеров контроллеров. Первый очень простой, он отвечает за выдачу команды turn\_engine\_off, если обнаружили перегрев двигателя:
```
struct engine_stopper_t
{
bool filter( const machine_needs_attention & msg ) const
{
return msg.m_attention == attention_t::engine_overheat_detected;
}
void action(
const machine_dictionary_t & machines,
const machine_needs_attention & evt ) const
{
so_5::send< turn_engine_off >( machines.find_mbox( evt.m_id ) );
}
};
```
Т.е. фильтруются только те сообщения machine\_needs\_attention, которые говорят о перегреве двигателя. Когда же такое сообщение поступает, то соответствующему агенту-машине отсылается сигнал turn\_engine\_off.
А вот этот контроллер уже посложнее:
```
struct cooler_starter_t
{
bool filter( const machine_needs_attention & msg ) const
{
return (msg.m_attention == attention_t::engine_overheat_detected ||
msg.m_attention == attention_t::engine_cooling_needed) &&
msg.m_cooler_status == cooler_state_t::off;
}
void action(
const machine_dictionary_t & machines,
const machine_needs_attention & evt ) const
{
so_5::send< turn_cooler_on >( machines.find_mbox( evt.m_id ) );
}
};
```
Он отвечает за включение охлаждающего вентилятора. Этот вентилятор нужно включать только если на данный момент вентилятор отключен, а двигатель либо просто нуждается в охлаждении, либо уже перегрелся.
Всего таких контроллеров в примере четыре:
* engine\_stopper\_t отвечает за останов двигателя;
* engine\_starter\_t отвечает за запуск двигателя;
* cooler\_starter\_t отвечает за запуск вентилятора;
* cooler\_stopper\_t отвечает за останов вентилятора.
Это означает, что и агентов a\_machine\_controller\_t будет четыре — по одному на каждый тип контроллера.
#### Приоритеты для агентов a\_machine\_controller\_t
При работе примера machine\_control может случиться так, что один и тот же экземпляр machine\_needs\_attention будет получен несколькими контроллерами. Например, если в machine\_needs\_attention передается attention\_t::engine\_overheat\_detected и cooler\_status\_t::off, то такое сообщение будет получено двумя контроллерами: и контроллером engine\_stopper\_t, и контроллером cooler\_starter\_t.
И тут нам важно, в каком порядке эти контроллеры обработают сообщение. Логично же, чтобы в ситуации engine\_overheat\_detected сперва была дана команда turn\_engine\_off, а уже затем команда turn\_cooler\_on. Ведь выполнение команды будет занимать какое-то время, скажем несколько секунд. Если сперва потратить эти секунды на включение вентилятора, то двигатель перегреется еще больше. Поэтому лучше сразу выключить двигатель, а потом уже тратить время на все остальное.
Каким же образом в SObjectizer-е можно управлять порядком обработки сообщений?
Вопрос совсем непростой. Есть опасение, что попытка развернуто ответить на него потребует написания еще одной статьи. Если говорить коротко, то гарантии очередности обработки сообщений могут быть только для диспетчеров с одной рабочей нитью. Но и этого еще недостаточно. Нужно, чтобы очередь сообщений на этой рабочей нити упорядочивалась с учетом приоритетов агентов, которым сообщения адресуются.
В SObjectizer есть такой тип диспетчера: он запускает всех привязанных к нему агентов на одной общей рабочей нити, при этом агенты с более высоким приоритетом обрабатывают свои сообщения перед агентами с более низкими приоритетами. Это диспетчер so\_5::disp::prio\_one\_thread::strictly\_ordered. Именно к нему привязываются агенты a\_machine\_controller\_t в данном примере.
При этом приоритеты для агентов-контроллеров распределены следующим образом:
* самый высокий приоритет у агента с контроллером типа engine\_stopper\_t, т.к. команды на выключение двигателя должны выполняться в первую очередь;
* далее следует агент с контроллером типа cooler\_starter\_t, поскольку включение охлаждающего вентилятора — это вторая по значимости команда;
* далее идет агент с контроллером типа engine\_starter\_t;
* ну и самый низкий приоритет у агента с контроллером типа cooler\_stopper\_t.
Следы того, как задаются приоритеты для агентов a\_machine\_controller\_t можно найти в конструкторе:
```
a_machine_controller_t(
...,
so_5::priority_t priority,
... )
: so_5::agent_t( ctx + priority )
, ...
{}
```
И при непосредственном создании таких агентов:
```
coop.make_agent_with_binder< a_machine_controller_t< engine_stopper_t > >(
disp->binder(),
so_5::prio::p4,
status_distrib_mbox,
machines );
coop.make_agent_with_binder< a_machine_controller_t< cooler_starter_t > >(
disp->binder(),
so_5::prio::p3,
status_distrib_mbox,
machines );
```
Здесь значения so\_5::prio::p4 и so\_5::prio::p3 — это и есть приоритеты агентов.
Агент-стартер
-------------
Можно было обратить внимание, что агенты a\_machine\_t начинают свою работу в состоянии st\_engine\_off, т.е. двигатель считается выключенным. Но запустив пример можно увидеть, что у машин двигатель сразу же включается. Как же так происходит, если ни a\_machine\_t, ни a\_machine\_controller\_t изначально никаких команд на включение двигателя не выдают?
Для того, чтобы у агентов-машин заработал двигатель используется отдельный агент-стартер, единственной задачей которого является выдача команды turn\_engine\_on каждому агенту-машине.
Этот агент настолько прост, что для него мы даже не делаем отдельный C++ класс, как это происходило у нас с a\_machine\_t, a\_total\_status\_dashboard\_t, a\_statuses\_analyser\_t и a\_machine\_controller\_t. Вместо этого мы используем такую штуку, как ad-hoc агент. Т.е. агент, который создается из набора заданных пользователем лямбда-функций. В примере machine\_control это делается следующим образом:
```
coop.define_agent().on_start( [&dict] {
dict.for_each(
[]( const std::string &, const so_5::mbox_t & mbox ) {
so_5::send< turn_engine_on >( mbox );
} );
} );
```
Метод define\_agent() создает пустого ad-hoc агента, которого пользователь может наполнить нужной функциональностью. Здесь мы задаем всего лишь реакцию на начало работы ad-hoc агента внутри SObjectizer-а: при старте всем агентам просто отсылается turn\_engine\_on.
Распределение агентов по диспетчерам
------------------------------------
Одной из самых важных возможностей SObjectizer-а, которая постоянно используется на практике, является возможность задать рабочую нить для агента через привязку агента к тому или иному диспетчеру.
Каждому агенту нужно обрабатывать доставленные ему сообщения. Делать это нужно на контексте какой-то рабочей нити. В SObjectizer рабочую нить агентам предоставляют диспетчеры. Поэтому программист при создании своего агента должен привязать агента к тому диспетчеру, который обеспечит агенту нужный режим работы.
В примере machine\_control используются несколько диспетчеров, благодаря чему происходит следующее распределение агентов по рабочим нитям:
* все агенты-машины работают на одной общей рабочей нити, для чего эти агенты привязываются к отдельному диспетчеру типа one\_thread;
* агент a\_total\_status\_dashboard\_t работает на собственной рабочей нити (привязан к отдельному диспетчеру типа one\_thread);
* агент a\_statuses\_analyser\_t работает на собственной рабочей нити (привязан к отдельному диспетчеру типа one\_thread);
* все агенты a\_machine\_controller\_t работают на одной общей рабочей нити отдельного диспетчера prio\_one\_thread::strictly\_ordered, который обслуживает события агентов с учетом приоритетов;
* агент-стартер отрабатывает свое единственное событие на диспетчере по умолчанию.
Что еще осталось «за кадром»?
-----------------------------
В статье мы не стали рассматривать одну важную для реализации вещь, которая, однако, никак не влияет на поведение агентов в примере: это [machine\_dictionary](https://sourceforge.net/p/sobjectizer/repo/HEAD/tree/tags/so_5/5.5.19.2/dev/sample/so_5/machine_control/main.cpp#l256). Специальный ассоциативный словарь, в котором сохранено соответствие между уникальным названием-идентификатором агента-машины и его персональным почтовым ящиком.
Этот словарь используется для того, чтобы по имени агента-машины (которое присутствует в сообщениях machine\_status и machine\_needs\_attention) получить доступ к почтовому ящику соответствующего агента. Ведь сообщения в SObjectizer отсылаются в почтовые ящики, поэтому, для того, чтобы отослать turn\_engine\_on, нужно по имени получить почтовый ящик. Что и делается посредством machine\_dictionary.
Ну а что же самое важное в этом примере?
========================================
Теперь же, как в любом уважающем себя произведении, вслед за долгим прологом должна последовать основная часть, никакого отношения к прологу не имеющая.
Если читатель подумал, что статья была написана для того, чтобы показать, как можно разрабатывать агентов, похожих на a\_machine\_t или a\_machine\_controller\_t, то он оказался не совсем прав.
Демонстрация конкретных фич SObjectizer-а, вроде привязки агентов к разным диспетчерам или использование ad-hoc агентов для простых действий — это лишь одна из задач данной статьи. Мы надеемся, что знакомство с тем, как может выглядеть более-менее объемный код на SObjectizer, поможет читателям лучше понять, нравится ли им то, что они видят или нет, возникнет ли у них желание разрабатывать свои программы в таком стили или же лучше пойти «другим путем». В конце-концов, примеры чуть посложнее, чем ставший классическим и совершенно бесполезным [ping-pong](https://sourceforge.net/p/sobjectizer/repo/HEAD/tree/tags/so_5/5.5.19.2/dev/sample/so_5/ping_pong_minimal/main.cpp), дают намного лучшее представление о том, как будет выглядеть продакшен код. И захочется ли связываться после подобного знакомства с таким фреймворком, как SObjectizer.
Однако, есть у данного примера и другая задача, не менее важная. Эта задача состоит в том, чтобы показать, как посредством Actor Model и Publish/Subscribe организовать взаимодействие между независимыми сущностями в программе.
Сделаем акцент на взаимодействии
--------------------------------
Ключевой момент в рассмотренном примере machine\_control в том, что взаимодействующие сущности (т.е. агенты) не имеют никакого понятия друг о друге и о взаимосвязях между собой.
Действительно, агент a\_machine\_t просто отсылает сообщение machine\_status в некоторый почтовый ящик и понятия не имеет, кто стоит за этим ящиком, куда реально попадает сообщение и что с этим сообщением происходит дальше. Просто агент a\_machine\_t выполняет свою работу (имитирует периодический опрос оборудования) и выдает результат своей работы во внешний мир. Все, больше его ничего не интересует.
Даже когда к агенту a\_machine\_t приходит внешняя команда (вроде turn\_engine\_on), он не представляет, кто именно эту команду ему прислал. От a\_machine\_t требуется лишь выполнить поступившую команду, если в этом есть смысл. А уж из каких соображений эта команда возникла, через что она прошла по дороге — все это для a\_machine\_t не имеет никакого значения.
Кстати говоря, когда кто-то выдает команду вроде turn\_engine\_on конкретному агенту a\_machine\_t, то это классическое взаимодействие в рамках Actor Model, где акторы общаются в режиме 1:1.
Но вот в случае с сообщениями machine\_status и machine\_needs\_attention мы уже оказываемся за рамками Actor Model, т.к. у нас образуется взаимодействие 1:N. И тут мы пользуемся моделью Publish/Subscribe. Специальный почтовый ящик, куда агенты отсылают сообщения machine\_status и machine\_needs\_attention, играет роль брокера. Отсылка сообщения в этот ящик — это просто-напросто операция Publish. А для получения сообщения из ящика необходимо выполнить операцию Subscribe, что, собственно, агенты a\_total\_status\_dashboard\_t, a\_statuses\_analyser\_t и a\_machine\_controller\_t и делают в своих so\_define\_agent().
И тут можно увидеть еще одну важную штуку, которую дает разработчику SObjectizer: возможность использовать один и тот же экземпляр сообщения для совершенно разных целей. Происходит это как раз благодаря тому, что в SObjectizer есть multi-producer/multi-consumer почтовые ящики, через которые и происходит общение агентов в режиме 1:N.
Действительно, сообщение machine\_status, например, получают и обрабатывают два разных агента, решающих совершенно разные задачи и ничего не знающие друг о друге. Агент a\_total\_status\_dashboard\_t использует machine\_status для периодического отображения хода работы примера на консоль. Тогда как a\_statuses\_analyser\_t использует machine\_status для контроля за агентами a\_machine\_t.
В этом заложена большая гибкость. Мы совершенно спокойно можем добавить еще одного агента, который мог бы собирать информацию о температуре двигателей для построения графиков изменения температуры. И наличие этого агента никак не повлияет на работу a\_total\_status\_dashboard\_t и a\_statuses\_analyser\_t. Или же мы можем заменить агента a\_total\_status\_dashboard\_t на какого-нибудь a\_gui\_status\_dashboard\_t, который будет отображать ход работы примера не на std::cout, а в графическое окно. И это, опять же, никак не повлияет на других агентов приложения, которые работают с сообщениями machine\_status.
Так что разработка приложений на SObjectizer — это все про создание агентов, каждый из которых выполняет свою независимую часть работы, и про каналы связи между агентами. А каналы связи в SObjectizer представляют из себя почтовые ящики и сообщения, посредством которых информация распространяется (хотя есть и CSP-шные каналы).
И как раз основная сложность разработки приложений на SObjectizer состоит в том, чтобы выделить в предметной области те сущности, которые в программе могут быть выражены в виде агентов. А также в выделении и формировании каналов связи (т.е. наборов сообщений и почтовых ящиков), посредством которых агенты будут взаимодействовать друг с другом.
Ну а уже внешний вид самих агентов, их привязка к диспетчерам и пр. технические детали — это всего лишь детали. Но детали, которые оказывают важное влияние на привлекательность конкретного фреймворка. Ну вот не понравится кому-то, что для объявления сообщения-сигнала нужно сделать структуру, отнаследованную от типа с именем so\_5::signal\_t, и ничего уже не поделать. Хотя суть вовсе не в том, нужно ли наследоваться от чего-то или что наследоваться нужно от типа, название которого не отвечает чьим-то эстетическим представлениям. А в том, чтобы выделить в предметной области сущности, для какого-то взаимодействия между которыми вот такое сообщение-сигнал будет необходимо.
Вместо заключения
=================
В финале статьи хочется поблагодарить самых настойчивых читателей за терпение, прекрасно понимаем, что дочитать до заключения было непросто.
Заодно хотим похвастаться тем, что для SObjectizer-а появился сопутствующий проект [so\_5\_extra](https://sourceforge.net/p/sobjectizer/wiki/so5extra%20Documentation/), который будет содержать дополнения и расширения для SObjectizer. Смысл в том, чтобы в SObjectizer включать только самую базовую функциональность, без которой ну никак не обойтись, и которая будет нужна большинству пользователей. Тогда как so\_5\_extra может содержать в том числе и экзотические вещи, необходимые лишь узкому кругу пользователей. Так что если вам чего-то не хватает в SObjectizer, то скажите чего именно. Если мы не увидим смысла добавления этого в SObjectizer, то место вполне может найтись в so\_5\_extra. | https://habr.com/ru/post/332166/ | null | ru | null |
# Алиасы в bash для быстрого набора команд Git
Командный интерпретатор bash позволяет задавать произвольные алиасы для разных команд и выражений. Алиасы не являются командами сами по себе, но им, как и командам, можно передавать аргументы. Алиасы позволяют сделать вызов громоздких команд очень простым, с легко запоминающимися названиями.
Использовать Git я привык исключительно из консоли, но на ввод длинных команд с разными аргументами тратится значительное количество времени. Поэтому я ввёл практику использования алиасов. Для безопасных команд я использовал короткие алиасы, которые по сути стали горячими клавишами, а для функциональных — простые короткие слова из состава команд Git. Если команда опасная, то можно сделать её в два слова, написанных через дефис, для исключения случайного ввода. На самом деле, использование алиасов для работы с Git широко практикуется, я решил лишь преподнести отдельный вариант подборки алиасов, которые для меня оказались очень удобными.
Формат задания алиаса имеет следующий вид:
```
alias name="<выполняемый код>"
```
Основной проблемой алиасов является то, что они не подхватываются автоматически механизмом автодополнения кода. Их написание отличается от тех команд, которые зарегистрированы в системе автодополнения, поэтому приходится дополнительно регистрировать алиасы, назначая им соответствующие спецификации автодополнения (compspec) через встроенную в bash команду `complete`. В случае с Git над `complete` существует обёртка `__git_complete`, в которую необходимо передавать предопределённые функции-обёртки, начинающиеся с префикса `_git_` и оканчивающиеся названием подкоманды git. В Ubuntu весь связанный с этим код можно посмотреть в файле `/usr/share/bash-completion/completions/git`.
| | |
| --- | --- |
| **Алиас** | **Действие** |
| `f` | Получить изменения с сервера |
| `s` | Просмотреть текущее состояние локального репозитория |
| `ss` | Просмотреть текущее состояние локального репозитория и количество изменённых строк |
| `d` | Просмотреть изменения, сделанные в файлах и ожидающие подтверждения, в стандартном diff-формате |
| `dd` | Просмотреть изменения, сделанные в файлах и ожидающие подтверждения, с выделением одним только цветом |
| `l` | Список последних коммитов в кратком формате. |
| `ll` | Список последних коммитов с развёрнутой информацией о них. |
| `go` или `gg` | Переход на другую ветку или коммит, создание новой ветки с опцией `-b`. |
| `pull` | Получить изменения с сервера и влить их в текущую ветку. |
| `commit` | Сделать коммит (зафиксировать изменения). |
| `add` | Добавить файлы или изменения в будущий коммит. |
| `reset` | Отменить добавление изменений в будущий коммит. |
| `push` | Отправить новые коммиты на сервер. |
| `push-fix` | Отправить коммиты на сервер с перезаписью их истории, если другие люди не успели отправить туда свои коммиты. |
| `merge` | Влить заданную ветку в текущую. |
| `amend` | Добавить изменения в уже сделанный коммит или изменить его комментарий. |
| `rebase` | Выполнить перезапись истории коммитов, например, переместив коммиты в конец другой ветки. |
| `branch` | Переименовывание или удаление локальной ветки |
| `pick` | Применить в текущей ветке отдельные существующие коммиты. |
| `stash` | Сохранить свои текущие изменения во временное хранилище. |
| `apply` | Применить свои текущие изменения из временного хранилища, но не удалять и оттуда. |
| `pop` | Забрать свои изменения из временного хранилища и применить их. |
Ниже приведено примерное содержимое файла `~/.bash_aliases` с основными алиасами Git и кодом их автоматической регистрации в механизме автодополнения командой строки.
```
#!/bin/bash
alias f="git fetch --tags"
alias s="git status"
alias ss="git status && git diff --shortstat"
alias d="git diff"
alias dd="git diff --word-diff=color"
alias l="git log -n 20 --graph --pretty=format:'%Cred%h%Creset %an: %s / %Cgreen%cr%Creset %Creset %C(yellow)%d%Creset' --abbrev-commit --date=relative"
alias ll="git log"
alias go="git checkout"
#или alias gg="git checkout"
alias pull="git pull"
alias commit="git commit"
alias add="git add"
alias reset="git reset"
alias push="git push"
alias push-fix="git push --force-with-lease"
alias merge="git merge"
alias amend="git commit --amend"
alias rebase="git rebase"
alias branch="git branch"
alias pick="git cherry-pick"
alias stash="git stash"
alias apply="git stash apply"
alias pop="git stash pop"
# Регистрируем алиасы в системе автодополнения
git_completions="/usr/share/bash-completion/completions/git"
if [ -f "${git_completions}" ]; then
source "${git_completions}"
# Получаем массивы алиасов и соответствующих им команд git
cmds=( $(alias | grep -v ss | grep -Po '(?<=git )[\w-]+' | sed -r 's/[ -]+/_/g') )
aliases=( $(alias | grep -v ss | grep git | grep -Po '(?<=alias )\w+') )
# Регистрируем каждый алиас
for (( i = 0; i < ${#aliases[@]}; i++ )); do
a="${aliases[$i]}"
cmd="${cmds[$i]}"
__git_complete "${a}" _git_"${cmd}"
done
fi
```
Для того, чтобы файл с алиасами применялся при входе в систему, необходимо добавить его подключение в файл `~/.bashrc` с помощью команды `source` (или `.`). Файл `~/.bashrc` запускается на исполнение всегда при старте командного интерпретатора bash, поэтому если файл редактировался из консоли, потребуется её заново открыть или запустить вложенный командный интерпретатор bash.
```
if [ -f ~/.bash_aliases ]; then
. ~/.bash_aliases
fi
```
Алиасы `s`, `d` и `l` простые, дают необходимый минимум информации. Задумка двухбуквенных в том, чтобы дать слегка больше информации, если это требуется. С помощью `f` можно получить последние изменения в репозитории и влить их в текущую ветку с помощью `pull` или `pull -r`. Через `l` можно посмотреть, что за новые коммиты прилетели в ветку, или что было последним из изменений, а через `ll` — подробно изучить коммиты. Переключиться на другую ветку можно через `go`, создать новую ветку можно через `go -b`. При создании коммита, в общем случае, сначала вводится `s`, проверяется на какой мы ветке, какие файлы требуется добавить, затем `d`, чтобы проверить свои изменения. Через `add` добавляются файлы (или `add -i` для выбора отдельных изменений в файлах), через `commit -m` создаётся новый коммит. Если вдруг в тексте сообщения коммита оказалась опечатка, можно быстро всё поправить через `amend`. Если в main-ветку успели прилететь новые коммиты, можно сделать `rebase main`. И потом сделать `push`. Если ветка своя собственная, то можно делать `rebase -i` с исправлениям прошлых коммитов и отправить модифицированные коммиты через `push-fix`.
Если шла работа, но срочно понадобилось переключиться на другую ветку, можно временно убрать свои изменения через `stash`, переключиться на другую ветку через `go`. Потом можно вернуть изменения с помощью `apply` или `pop`. Отдельные коммиты из других веток можно применять с помощью `pick`, также это может быть полезным, если случайно сделать изменения в отделённом HEAD (например, в подмодуле).
Алиасы могут совпадать с существующими командами. Если такие команды обычно не используются, то это проблемой не является. Если же команды понадобятся, то в случае исполняемых файлов всегда можно указать полный путь к файлу. Не будет проблем и с командами, которые запускаются от имени суперпользователя, поскольку алиасы прописаны лишь для непривилегированного пользователя. Если используется язык Go, то с использованием алиаса `go` могут возникнуть проблемы. В качестве решения можно изменить алиас на `gg` или `gc`, либо же сделать алиас `golang` для команды `go`. Здесь кому как удобнее.
*В Ubuntu 21.10 при использовании алиаса над* `git checkout` *выводятся сообщения об ошибках. Происходит это из-за того, что одна из переменных в целочисленных сравнениях оказывается пустой. Вариантом подавления вывода ошибок является замена в файле* `/usr/share/bash-completion/completions/git` *сравнения через* квадратные скобки *на арифметическое сравнение через двойные скобки, например,* `(( var1 < var2 ))`*, в которых можно использовать названия переменных без предшествующего знака* `$`*. Такое исправление работает и в zsh, на который автодополнение тоже рассчитано.*
Патч, решающий проблему
```
--- /usr/share/bash-completion/completions/git 2021-08-09 15:29:27.000000000 +0300
+++ ./git 2022-04-08 23:32:38.501198226 +0300
@@ -1011,7 +1011,7 @@
if [ "$cmd" = "remote" ]; then
((c++))
fi
- while [ $c -lt $cword ]; do
+ while (( c < cword )); do
i="${words[c]}"
case "$i" in
--mirror) [ "$cmd" = "push" ] && no_complete_refspec=1 ;;
@@ -1187,7 +1187,7 @@
done
local wordlist="$1"
- while [ $c -lt $cword ]; do
+ while (( c < cword )); do
for word in $wordlist; do
if [ "$word" = "${words[c]}" ]; then
if [ -n "${show_idx-}" ]; then
@@ -1221,7 +1221,7 @@
done
local wordlist="$1"
- while [ $c -gt "$__git_cmd_idx" ]; do
+ while (( c > __git_cmd_idx )); do
((c--))
for word in $wordlist; do
if [ "$word" = "${words[c]}" ]; then
@@ -1283,7 +1283,7 @@
__git_has_doubledash ()
{
local c=1
- while [ $c -lt $cword ]; do
+ while (( c < cword )); do
if [ "--" = "${words[c]}" ]; then
return 0
fi
@@ -1449,7 +1449,7 @@
{
local i c="$__git_cmd_idx" only_local_ref="n" has_r="n"
- while [ $c -lt $cword ]; do
+ while (( c < cword )); do
i="${words[c]}"
case "$i" in
-d|-D|--delete|-m|-M|--move|-c|-C|--copy)
@@ -2479,7 +2479,7 @@
__git_config_get_set_variables ()
{
local prevword word config_file= c=$cword
- while [ $c -gt "$__git_cmd_idx" ]; do
+ while (( c > __git_cmd_idx )); do
word="${words[c]}"
case "$word" in
--system|--global|--local|--file=*)
@@ -3213,7 +3213,7 @@
_git_tag ()
{
local i c="$__git_cmd_idx" f=0
- while [ $c -lt $cword ]; do
+ while (( c < cword )); do
i="${words[c]}"
case "$i" in
-d|--delete|-v|--verify)
@@ -3388,7 +3388,7 @@
local __git_C_args C_args_count=0
local __git_cmd_idx
- while [ $c -lt $cword ]; do
+ while (( c < cword )); do
i="${words[c]}"
case "$i" in
--git-dir=*)
```
На практике я использую несколько меньший набор алиасов, в списке же привёл все, какие могут пригодиться в повседневной работе. Надеюсь, этот список кому-то окажется полезным, удачного использования! | https://habr.com/ru/post/660615/ | null | ru | null |
# Миграция с Gitolite на GitLab с помощью Shell-скрипта
*Процесс миграции нередко представляет собой трудную задачу, особенно, когда объем информации, который необходимо перенести, настолько велик, что выгоднее становится его автоматизировать. Именно необходимость миграции с Gitolite на GitLab и побудила меня написать статью о моем опыте в данном вопросе.*
Для миграции репозиториев я буду использовать компьютер с установленной операционной системой CentOS 7. На ней необходимо установить следующий набор приложений: *git, ssh-agent, curl, jq, xargs*.
Для начала работы нам необходимо получить ключ доступа к API GitLab. В веб-интерфейсе заходим в раздел настройки пользователя. Далее выбираем пункт меню *«Access Tokens»*. В открывшейся форме необходимо указать наименование получаемого ключа, а также можно указать срок, до которого ключ будет активен. Ниже ставим галочку напротив пункта api и нажимаем кнопку *«Create personal access token»*. Этот ключ будет применяться при отправке запросов в API GitLab.
1. #### Подготовка рабочей среды
Для того чтобы мы могли загружать код в репозиторий GitLab по SSH, необходимо сгенерировать пару приватного и публичного ключей, выполнить регистрацию публичного ключа в GitLab. Для регистрации публичного ключа в панели администратора GitLab *«Admin area»* заходим в раздел *«Deploy keys»* и нажимаем кнопку *«New deploy key»*. В открывшейся форме необходимо указать наименование загружаемого ключа, а также сам публичный ключ. После добавления ключа, нам необходимо определить идентификатор данного ключа в системе GitLab. Чтобы определить его мы можем выполнить следующий команду в bash:
```
curl -k -X GET --header "PRIVATE-TOKEN: " /api/v4/deploy\_keys
```
*Примечание: Чтобы не вводить пароль от приватного SSH ключа при выполнении действий git с сервером, необходимо добавить данный ключ в ssh-agent. Для этого выполним следующие команды:*
```
eval `ssh-agent`
```
```
ssh-add ~/.ssh/id_rsa
```
2. #### Создание репозитория в GitLab с использованием API
Чтобы создать репозиторий в GitLab, необходимо отправить POST запрос в API GitLab, передав параметры, согласно документации. Подробнее о [Projects API GitLab](https://docs.gitlab.com/ee/api/projects.html) читайте в документации на сайте GitLab.
```
# $1 - gitlab remote url
# $2 - api access token
# $3 - remote repository name
# $4 - remote repository namespace identifier
initRemoteRepository() {
local response=`curl -s -k -X POST --header "Private-Token: $2" --data "name=$3&namespace_id=$4&visibility=private&description=$3" $1/api/v4/projects`
local id=`echo $response | jq -r ".id"`
echo "$id"
}
```
Функция *initRemoteRepository* возвращает идентификатор созданного репозитория. В дальнейшем идентификатор репозитория будет использоваться для установки прав доступа.
*Примечание: ключ –k необходим, если серверный сертификат GitLab является самозаверенным.*
3. #### Предоставление доступа на запись и чтение репозитория с использованием API
Для того, чтобы выполнить запись в созданный репозиторий, необходимо выдать соответствующее право. Подробнее о [Deploy Keys API GitLab](https://docs.gitlab.com/ee/api/deploy_keys.html) читайте в документации на сайте GitLab.
```
# $1 - remote url
# $2 - api token
# $3 - repository identifier
# $4 - deploy key identifier
enableRepositoryDeployKey() {
local response=`curl -s -k -X POST --header "Private-Token: $2" $1/api/v4/projects/$3/deploy_keys/$4/enable`
echo "$response"
}
```
Функция *enableRepositoryDeployKey* позволяет добавить публичный ключ с соответствующим идентификатором в список ключей соответствующего репозитория.
```
# $1 - remote url
# $2 - api token
# $3 - repository identifier
# $4 - deploy key identifier
setRepositoryWriteAccess() {
local response=`curl -s -k -X PUT --header "PRIVATE-TOKEN: $2" --header "Content-Type: application/json" --data '{"can_push": true}' $1/api/v4/projects/$3/deploy_keys/$4`
echo "$response"
}
```
Функция *setRepositoryWriteAccess* позволяет установить доступ на запись в конкретный репозиторий.
4. #### Миграция репозиториев включая все ветки
Основной скрипт проходит по предварительно составленному списку репозиториев, указанных в заданном файле. Создается соответствующий репозиторий в GitLab, а также выдаются привилегии для чтения и записи. После подготовительных действий выполняется запрос веток данного репозитория. Далее выполняется переключение на очередную ветку репозитория и отправка в GitLab.
```
# $1 - branch
# $2 – separator
getCanonicalBranchName() {
local branch=""
IFS=$2 read -r -a array <<< "$1"
length=${#array[@]}
for index in "${!array[@]}"
do
if [ $index -gt 0 ]; then
if [ $index -eq 1 ]; then
local branch="${array[index]}"
else
local branch="$branch/${array[index]}"
fi
fi
done
echo "$branch"
}
PSWD="$(dirname "$0")"
cd $PSWD
while IFS= read -r REPOSITORY
do
echo "==================== <$REPOSITORY> ===================="
GITOLITE_REPO=$GITOLITE$REPOSITORY
echo "Run cloning remote repository $GITOLITE_REPO"
git clone $GITOLITE_REPO
cd $REPOSITORY
GITLAB_REPO=$GITLAB$REPOSITORY.git
echo "Initialize remote gitgab repository $GITLAB_REPO"
PROJECT=$(initRemoteRepository $GITLAB_URL $API_TOKEN $REPOSITORY)
echo "Remote repository initialized identifier $PROJECT"
echo "Add deploy key and enable write access to remote repository $REPOSITORY ($PROJECT)"
response=$(enableRepositoryDeployKey $GITLAB_URL $API_TOKEN $PROJECT $DEPLOY_KEY_ID)
response =$(setRepositoryWriteAccess $GITLAB_URL $API_TOKEN $PROJECT $DEPLOY_KEY_ID)
echo "Add new remote url for repository $GITLAB_REPO"
git remote add gitlab $GITLAB_REPO
# push all branches
IFS_BACK=$IFS
IFS=$'\n'
branches=$(git branch -r)
for branchName in $branches; do
trimBranchName=`echo $branchName | xargs`
canonicalBranchName=$(getCanonicalBranchName $trimBranchName '/')
echo "$trimBranchName ($canonicalBranchName) init push"
git checkout -b $canonicalBranchName remotes/origin/$canonicalBranchName
git push -f gitlab $canonicalBranchName
done
IFS=$IFS_BACK
cd ..
rm -r -f $REPOSITORY
echo "==================== <$REPOSITORY> ===================="
echo ""
done < "$REPOSITORIES"
```
Сохраняем файл скрипта и запускаем, при необходимости изменив права доступа. Пример вывода работы данного скрипта можно посмотреть ниже.
**Полный текст скрипта**
```
REPOSITORIES=""
GITOLITE=""
GITLAB\_URL=""
GITLAB=""
API\_TOKEN=""
DEPLOY\_KEY\_ID=""
# $1 - gitlab remote url
# $2 - api access token
# $3 - remote repository name
# $4 - remote repository namespace identifier
initRemoteRepository() {
local response=`curl -s -k -X POST --header "Private-Token: $2" --data "name=$3&namespace\_id=$4&visibility=private&description=$3" $1/api/v4/projects`
local id=`echo $response | jq -r ".id"`
echo "$id"
}
# $1 - remote url
# $2 - api token
# $3 - repository identifier
# $4 - deploy key identifier
setRepositoryWriteAccess() {
local response=`curl -s -k -X PUT --header "PRIVATE-TOKEN: $2" --header "Content-Type: application/json" --data '{"can\_push": true}' $1/api/v4/projects/$3/deploy\_keys/$4`
echo "$response"
}
# $1 - remote url
# $2 - api token
# $3 - repository identifier
# $4 - deploy key identifier
enableRepositoryDeployKey() {
local response=`curl -s -k -X POST --header "Private-Token: $2" $1/api/v4/projects/$3/deploy\_keys/$4/enable`
echo "$response"
}
# $1 - branch
# $2 – separator
getCanonicalBranchName() {
local branch=""
IFS=$2 read -r -a array <<< "$1"
length=${#array[@]}
for index in "${!array[@]}"
do
if [ $index -gt 0 ]; then
if [ $index -eq 1 ]; then
local branch="${array[index]}"
else
local branch="$branch/${array[index]}"
fi
fi
done
echo "$branch"
}
PSWD="$(dirname "$0")"
cd $PSWD
while IFS= read -r REPOSITORY
do
echo "==================== <$REPOSITORY> ===================="
GITOLITE\_REPO=$GITOLITE$REPOSITORY
echo "Run cloning remote repository $GITOLITE\_REPO"
git clone $GITOLITE\_REPO
cd $REPOSITORY
GITLAB\_REPO=$GITLAB$REPOSITORY.git
echo "Initialize remote gitgab repository $GITLAB\_REPO"
PROJECT=$(initRemoteRepository $GITLAB\_URL $API\_TOKEN $REPOSITORY)
echo "Remote repository initialized identifier $PROJECT"
echo "Add deploy key and enable write access to remote repository $REPOSITORY ($PROJECT)"
response=$(enableRepositoryDeployKey $GITLAB\_URL $API\_TOKEN $PROJECT $DEPLOY\_KEY\_ID)
response=$(setRepositoryWriteAccess $GITLAB\_URL $API\_TOKEN $PROJECT $DEPLOY\_KEY\_ID)
echo "Add new remote url for repository $GITLAB\_REPO"
git remote add gitlab $GITLAB\_REPO
# push all branches
IFS\_BACK=$IFS
IFS=$'\n'
branches=$(git branch -r)
for branchName in $branches; do
trimBranchName=`echo $branchName | xargs`
canonicalBranchName=$(getCanonicalBranchName $trimBranchName '/')
echo "$trimBranchName ($canonicalBranchName) init push"
git checkout -b $canonicalBranchName remotes/origin/$canonicalBranchName
git push -f gitlab $canonicalBranchName
done
IFS=$IFS\_BACK
cd ..
rm -r -f $REPOSITORY
echo "==================== <$REPOSITORY> ===================="
echo ""
done < "$REPOSITORIES"
```
**Пример вывода в консоль**
```
==================== ====================
Run cloning remote repository git@skynet-uro.bank.srv:project
Cloning into 'project'...
remote: Counting objects: 62, done.
remote: Compressing objects: 100% (61/61), done.
remote: Total 62 (delta 21), reused 0 (delta 0)
Receiving objects: 100% (62/62), 15.57 KiB | 0 bytes/s, done.
Resolving deltas: 100% (21/21), done.
Current folder path: /app/migration/project
Initialize remote gitgab repository git@127.0.0.1:project.git
Remote repository initialized identifier 222
Enable deploy key write access to remote repository project (222)
Set write access to remote repository project (222)
Add new remote url for repository git@127.0.0.1:project.git
Push to new remote gitlab repository git@127.0.0.1:project.git
Counting objects: 55, done.
Delta compression using up to 2 threads.
Compressing objects: 100% (38/38), done.
Writing objects: 100% (55/55), 14.65 KiB | 0 bytes/s, done.
Total 55 (delta 18), reused 50 (delta 16)
To git@127.0.0.1:project.git
\* [new branch] master -> master
<--- gitlab/master (master) init push
fatal: A branch named 'master' already exists.
Everything up-to-date
---> gitlab/master (master) success pushed
<--- origin/v0.0.0 (v0.0.0) init push
Branch v0.0.0 set up to track remote branch v0.0.0 from origin.
Switched to a new branch 'v0.0.0'
Total 0 (delta 0), reused 0 (delta 0)
remote:
remote: To create a merge request for v0.0.0, visit:
remote: https://127.0.0.1:8082/project/merge\_requests/new?merge\_request%5Bsource\_branch%5D=v0.0.0
remote:
To git@127.0.0.1:project.git
\* [new branch] v0.0.0 -> v0.0.0
---> origin/v0.0.0 (v0.0.0) success pushed
<--- origin/v0.0.0-13 (v0.0.0-13) init push
Branch v0.0.0-13 set up to track remote branch v0.0.0-13 from origin.
Switched to a new branch 'v0.0.0-13'
Total 0 (delta 0), reused 0 (delta 0)
remote:
remote: To create a merge request for v0.0.0-13, visit:
remote: https://127.0.0.1:8082/project/merge\_requests/new?merge\_request%5Bsource\_branch%5D=v0.0.0-13
remote:
To git@127.0.0.1:project.git
\* [new branch] v0.0.0-13 -> v0.0.0-13
---> origin/v0.0.0-13 (v0.0.0-13) success pushed
<--- origin/v0.0.0-15 (v0.0.0-15) init push
Branch v0.0.0-15 set up to track remote branch v0.0.0-15 from origin.
Switched to a new branch 'v0.0.0-15'
Total 0 (delta 0), reused 0 (delta 0)
remote:
remote: To create a merge request for v0.0.0-15, visit:
remote: https://127.0.0.1:8082/project/merge\_requests/new?merge\_request%5Bsource\_branch%5D=v0.0.0-15
remote:
To git@127.0.0.1:project.git
\* [new branch] v0.0.0-15 -> v0.0.0-15
---> origin/v0.0.0-15 (v0.0.0-15) success pushed
<--- origin/v0.0.1 (v0.0.1) init push
Branch v0.0.1 set up to track remote branch v0.0.1 from origin.
Switched to a new branch 'v0.0.1'
Total 0 (delta 0), reused 0 (delta 0)
remote:
remote: To create a merge request for v0.0.1, visit:
remote: https://127.0.0.1:8082/project/merge\_requests/new?merge\_request%5Bsource\_branch%5D=v0.0.1
remote:
To git@127.0.0.1:project.git
\* [new branch] v0.0.1 -> v0.0.1
---> origin/v0.0.1 (v0.0.1) success pushed
<--- origin/v0.0.1-11 (v0.0.1-11) init push
Branch v0.0.1-11 set up to track remote branch v0.0.1-11 from origin.
Switched to a new branch 'v0.0.1-11'
Total 0 (delta 0), reused 0 (delta 0)
remote:
remote: To create a merge request for v0.0.1-11, visit:
remote: https://127.0.0.1:8082/project/merge\_requests/new?merge\_request%5Bsource\_branch%5D=v0.0.1-11
remote:
To git@127.0.0.1:project.git
\* [new branch] v0.0.1-11 -> v0.0.1-11
---> origin/v0.0.1-11 (v0.0.1-11) success pushed
<--- origin/v0.0.2 (v0.0.2) init push
Branch v0.0.2 set up to track remote branch v0.0.2 from origin.
Switched to a new branch 'v0.0.2'
Total 0 (delta 0), reused 0 (delta 0)
remote:
remote: To create a merge request for v0.0.2, visit:
remote: https://127.0.0.1:8082/project/merge\_requests/new?merge\_request%5Bsource\_branch%5D=v0.0.2
remote:
To git@127.0.0.1:project.git
\* [new branch] v0.0.2 -> v0.0.2
---> origin/v0.0.2 (v0.0.2) success pushed
<--- origin/v0.0.3 (v0.0.3) init push
Branch v0.0.3 set up to track remote branch v0.0.3 from origin.
Switched to a new branch 'v0.0.3'
Counting objects: 7, done.
Delta compression using up to 2 threads.
Compressing objects: 100% (4/4), done.
Writing objects: 100% (4/4), 592 bytes | 0 bytes/s, done.
Total 4 (delta 3), reused 1 (delta 0)
remote:
remote: To create a merge request for v0.0.3, visit:
remote: https://127.0.0.1:8082/project/merge\_requests/new?merge\_request%5Bsource\_branch%5D=v0.0.3
remote:
To git@127.0.0.1:project.git
\* [new branch] v0.0.3 -> v0.0.3
---> origin/v0.0.3 (v0.0.3) success pushed
==================== ====================
``` | https://habr.com/ru/post/492122/ | null | ru | null |
# Продвинутые принципы безопасности в Kubernetes
Kubernetes используется для автоматизации таких процессов, как развертывание, администрирование и масштабирование контейнерных приложений. Например, в Kubernetes работает Docker, который развертывает микросервисы и управляет ими. В Kubernetes рекомендуется запускать на одном узле по одному контейнеру, потому что так гораздо безопаснее. Или можно интегрировать несколько программ в один процесс, чтобы оптимизировать обработку и управление.
Некорректная конфигурация может затронуть разные уровни Kubernetes, включая облако, кластер, контейнер и код. Например, у нас есть образ, который использует уязвимый программный пакет и находится в контейнере. Через эту уязвимость злоумышленник может получить доступ ко всему кластеру, куда входит много контейнеров.
В Kubernetes мы продумываем защиту с разных сторон. Например, мы должны защищать хост и его компоненты, а также обеспечить безопасность на этапе сборки, развертывания или выполнения. У каждого аспекта безопасности есть свои методы и стандартные рекомендации для Kubernetes. Безопасность должна обеспечиваться на разных уровнях — код, кластер, контейнер, облако. Давайте рассмотрим методы обеспечения безопасности в Kubernetes.
Пространства имен для изоляции ресурсов Kubernetes
--------------------------------------------------
Пространства имен позволяют разделить наборы ресурсов в одном кластере.
В одном пространстве имена должны быть уникальными, но между пространствами имен они могут повторяться. Каждый ресурс Kubernetes находится только в одном пространстве имен, и в пространство имен можно вложить не больше одного пространства имен.
С их помощью мы реализуем логическое разделение кластера и ограничиваем разрешения пользователей.
Задать пространство имен можно следующей командой:
```
kubectl run nginx --image=nginx --namespace=
```
`kubectl` — это утилита командной строки в Kubernetes. В этой команде мы используем образ nginx с флагом `--namespace` для установки пространства имен. Добавив пространство имен, мы обращаемся к pod’ам в нем следующей командой:
```
kubectl get pods --namespace=
```
Если мы хотим указать пространство имен сразу для нескольких последующих команд, мы выполняем следующую команду:
```
kubectl config set-context --current --namespace=
```
Пространство имен обеспечивает логическое разделение и изоляцию ресурсов.
Защита компонентов Kubernetes
-----------------------------
Если кластеры Kubernetes выполняются на стандартных портах, то для поиска открытых портов достаточно будет выполнить простой скан, и если порт не требует аутентификации, к нему будет легко подключиться. Поэтому рекомендуется настраивать на портах кластера и узлов аутентификацию и авторизацию.
Кроме того, мы можем ограничить потребление ресурсов в кластере, установив минимальное и максимальное значение. Если не продумать эти значения, один контейнер может захватить все ресурсы, ничего не оставив другим.
Указывая минимум и максимум для контейнера, мы оставляем запас для дефолтных операций и обеспечиваем нормальное функционирование для всей среды. По умолчанию все объекты в кластере Kubernetes создаются с неограниченными ресурсами ЦП и памяти. После создания пространства имен Kubernetes можно назначить политики с квотами, чтобы ограничить потребление ресурсов.
Ниже мы создаем пространство имен, чтобы ограничить память, ЦП и pod’ы.
```
apiVersion: v1
metadata: compute-resources
spec:
pods: “6”
request.cpu: “1”
request.memory: 1Gi
limits.cpu: “4”
limits.memory: 4Gi
```
Мы назвали этот фрагмент кода `“com-resources.yaml”`. Теперь развернем его в пространстве имен следующей командой:
```
kubectl create -f ./ –
```
**Ограничение доступа к ресурсам Kubernetes**
Чтобы ограничить доступ к ресурсам Kubernetes, организация должна заблокировать SSH и рекомендовать пользователям использовать `kubectl exec`, чтобы получать доступ к контейнеру, не получая доступ к хосту. В Kubernetes есть плагины авторизации, где можно детально настроить правила контроля доступа пользователей к ресурсам.
Мы можем действовать через запросы Kubernetes API, и это будет работать как наша первая линия обороны, но нужно четко понимать, у кого должен быть доступ и какие действия можно выполнять в среде.
Сервисы должны общаться друг с другом через TLS, чтобы весь трафик был зашифрован, и злоумышленник не мог украсть информацию. Это важный шаг, потому что иногда мы считаем, что кластер и так достаточно защищен и можно не тратить ресурсы на шифрование. Шифрование также осуществляется через Kubernetes API.
Мы знаем, какое важное место в Kubernetes занимает Kubernetes API, так что для защиты API можно использовать аутентификацию. В Kubernetes есть несколько встроенных методов аутентификации (статичный файл токена, токен аккаунта сервиса и т. д.), но они не подходят для продакшена. Приходится использовать внешние методы аутентификации, например OpenID Connect (OIDC), поставщики удостоверений, имперсонацию в Kubernetes и т. д.
Кроме того, для API требуется авторизация с использованием управления доступом на основе ролей (RBAC). Как следует из названия, RBAC предоставляет пользователям доступ к ресурсам в зависимости от роли. Когда в Kubernetes поступает запрос, он сопоставляется с пользователем или группой. Если у них достаточно разрешений, запрос будет обработан. Если нет — отклонен. Авторизация RBAC использует группу API rbac.authorization.k8s.io, чтобы динамически настраивать политики через Kubernetes API.
Команда для этой задачи:
```
kube-apiserver --authorization-mode=Example,RBAC --more-options --other-options
```
Нужно перезапустить сервер API с флагом `authorization-mode` и указать список для RBAC через `--more-options`.
Непрерывные обновления для системы безопасности
-----------------------------------------------
Каждый день мы слышим о новых уязвимостях в разных опенсорс-пакетах. Скорее всего, ваша организация тоже использует какие-то пакеты с уязвимостями, поэтому лучше отслеживать их все. Если вы управляете списком всего используемого программного обеспечения, вы будете вовремя замечать проблемы и при необходимости обновляться.
При этом не стоит устанавливать обновление прямо в продакшене, потому что оно может быть несовместимо с уже используемыми пакетами ПО. Сначала нужно все как следует протестировать в стейджинге и только потом выкатывать в продакшен. Для обновления мы используем команду: `apt- update`.
В Kubernetes лучше всегда использовать функцию последовательных апдейтов и заменять экземпляры pod’ов по одному, чтобы обновление прошло без простоев. Новые pod’ы планируются на узлах, где есть достаточно ресурсов для их размещения.
Применение контекста безопасности к разным ресурсам Kubernetes, таким как pod’ы и контейнеры
--------------------------------------------------------------------------------------------
Мы можем определить в файле deployment.yaml контекст безопасности, например разрешения, чтобы запретить несанкционированный доступ к pod’ам, контейнерам и томам.
Например, мы можем указать `SecurityContext->runAsNonRoot`, чтобы контейнер мог выполняться, только если у пользователя нет прав root. Можно настроить и другие параметры безопасности.
Пример кода для pod’а:
```
apiVersion: v1
metadata:
name: test
spec:
securityContext:
runAsNonRoot : True
readOnlyRootFilesystem : True
```
Заключение
----------
Сегодня все больше организаций переносят рабочие нагрузки в контейнеры и стараются обеспечить безопасность в Kubernetes. Kubernetes содержит ресурсы на разных уровнях, и мы должны защищать каждый из них. Если на одном уровне возникнет уязвимость, вся система Kubernetes будет уязвима. Существует много способов защиты Kubernetes, здесь мы перечислили самые основные.
Еще о безопасности в KubernetesВ учебном центре Слёрм открыта запись на курс [**«Безопасность в Kubernetes»**](https://slurm.club/3E5r8Ii) для инженеров безопасности, DevOps’ов, SRE и разработчиков, самостоятельно работающих в Kubernetes.
На [курсе](https://slurm.club/3E5r8Ii) вы познакомитесь с основными моделями угроз, а также узнаете как им противостоять и что делать, чтобы контейнер запустился в срок, а безопасность была на всех этапах — от разработки до отправки на сервер и последующего разворачивания.
Все знания вы можете закрепить на практике на стендах — проработаете теорию и будете уверены в решениях. Приятный бонус – дарим [бесплатный демо-урок](https://slurm.club/3E5r8Ii) об основных принципах безопасности проекта, живущего в K8s, и о моделях угроз.
Если вы уже имеете базовые знания и хотите потрогать внутрянку Kuba, приходите на [**«Kubernetes Мега»**](https://slurm.club/3NOAbAv)**.** Вас ждут 6 часов практики, приправленной щепоткой теории от спикеров.
**Что будет?**
* авторизация в кластере
* настройка autoscaling
* резервное копирование
* Stateful приложения в кластере
* интеграция Kubernets и Vault для хранения секретов
* HorizontalPodAutoscaler
* ротация сертификатов в кластере
* Blue-Green Deploy и Canary Deploy
* настройка Service mesh
[«Мега»](https://slurm.club/3NOAbAv) подойдет всем, кому предстоит запускать Kubernetes в продакшн и отвечать за работу проекта в дальнейшем: специалистам по безопасности, системным инженерам, администраторам, архитекторам, DevOps и др. Пройдите [бесплатный курс](https://slurm.club/3NOAbAv), чтобы научиться устанавливать Kubernetes в ручном режиме.
**Комплектом дешевле:**
Мы предлагаем комплекты видеокурсов (тариф "Стандарт") со скидкой от 20%
«Безопасность» + «Мега» = 90 000 рублей вместо 130 000
Узнать подробности и записаться: [**«Безопасность в Kubernetes»**](https://slurm.club/3E5r8Ii)**,** [**«Kubernetes Мега»**](https://slurm.club/3NOAbAv)**.** | https://habr.com/ru/post/697806/ | null | ru | null |
# Web3.0 на Python, часть 2: advanced
Привет, хабр! В [первой части](https://habr.com/ru/post/674204/) мы рассмотрели базовые операции на web3py, которые закроют большинство ваших потребностей для проектов на ранних этапах. Здесь же речь в основном пойдет про улучшение производительности и различные "фишки", которые, например, помогут вам уменьшить количество запросов и/или время на эти запросы. Скорее всего, они **не будут полезны** тем, кто делает какой-то pet-project или проект на хакатоне. А **полезны они будут** тем, кто делает реальный боевой проект и кому важна производительность.
Содержание:
* [Оцениваем газ для транзакции](https://habr.com/ru/post/699560/#estimate_gas)
* [Ускоряем инициализацию контрактов](https://habr.com/ru/post/699560/#speed_contract)
* [Узнаем баланс для нескольких токенов за ОДИН запрос](https://habr.com/ru/post/699560/#balances_for_one_request) ⚡
* [Знакомимся с multicall](https://habr.com/ru/post/699560/#multicall) ⚡⚡
* [Используем асинхронный web3py](https://habr.com/ru/post/699560/#async_web3)
* [Полезные сервисы](https://habr.com/ru/post/699560/#useful_services)
---
Оценка газа ⛽
-------------
Мы уже делали [транзакцию с нативной валютой](https://habr.com/ru/post/674204/#txns_with_native), ставя при этом "газ побольше", чтоб точно хватило. А что если хочется показать пользователю **заранее**, сколько именно он должен будет потратить газа на транзакцию? В данном случае нам поможет метод `eth.estimate_gas`. Стоит сказать, что это число подвержено флуктуации. И если вдруг предсказанного газа не хватит, то транзакция зафейлится, а пользователь потеряет какое-то количество нативной валюты. Поэтому я бы советовал увеличивать это количество на ~20%, неиспользованный газ просто не будет потрачен.
```
from web3 import Web3
user_address = "0x2A647559a6c5dcB76ce1751101449ebbC039b157"
rpc_url = "https://matic-mumbai.chainstacklabs.com" # testnet Polygon
web3 = Web3(Web3.HTTPProvider(rpc_url))
amount_of_matic_to_send = 1
txn = { # формируем транзакцию
'chainId': web3.eth.chain_id,
'from': user_address,
'to': user_address,
'value': int(Web3.toWei(amount_of_matic_to_send, 'ether')),
'nonce': web3.eth.getTransactionCount(user_address),
'gasPrice': web3.eth.gas_price,
}
web3.eth.estimate_gas(txn)
# предсказанное количество газа 21000 Wei
```
Ускоряем инициализацию контрактов
---------------------------------
Представим, что нам по адресу ERC-20 токена и адресу юзера нужно узнать его (юзера) баланс. Напомню, как мы делали это в [первой части](https://habr.com/ru/post/674204/#contract_read_operations):
```
import json
from web3 import Web3
# одинаковый для всех ERC20 токенов
ERC20_ABI = json.loads('''[{"inputs":[{"internalType":"string","name":"_name","type":"string"},{"internalType":"string","name":"_symbol","type":"string"},{"internalType":"uint256","name":"_initialSupply","type":"uint256"}],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"spender","type":"address"},{"indexed":false,"internalType":"uint256","name":"value","type":"uint256"}],"name":"Approval","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"from","type":"address"},{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":false,"internalType":"uint256","name":"value","type":"uint256"}],"name":"Transfer","type":"event"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"address","name":"spender","type":"address"}],"name":"allowance","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"approve","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"balanceOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"decimals","outputs":[{"internalType":"uint8","name":"","type":"uint8"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"subtractedValue","type":"uint256"}],"name":"decreaseAllowance","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"addedValue","type":"uint256"}],"name":"increaseAllowance","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint8","name":"decimals_","type":"uint8"}],"name":"setupDecimals","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"symbol","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"recipient","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"transfer","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"sender","type":"address"},{"internalType":"address","name":"recipient","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"transferFrom","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"}]''')
# USDT токен
usdt_contract_address = '0xA11c8D9DC9b66E209Ef60F0C8D969D3CD988782c'
def get_balance_old(web3: Web3, token_address: str, user_address: str) -> int:
# инициализация контракта
token_contract = web3.eth.contract(token_address, abi=ERC20_ABI)
# получение данных из ноды
balance = token_contract.functions.balanceOf(user_address).call()
return int(balance)
```
Напрашивается очевидный вопрос: нам нужна всего лишь одна функция `balanceOf`, но почему мы при этом инициализируем контракт со всеми функциями из `ERC20_ABI`? Да, можно просто вручную убрать все остальные функции из ABI, чтобы в итоге остался список из одной нужной функции. А можно сделать и вот так (такой способ пригодится в дальнейшем):
```
import json
from web3.types import ABIFunction
from eth_utils import encode_hex, function_abi_to_4byte_selector, add_0x_prefix
from web3._utils.contracts import encode_abi
from web3._utils.abi import get_abi_output_types
encode_hex_fn_abi = lambda fn_abi: encode_hex(
function_abi_to_4byte_selector(fn_abi)
)
# словарь с функцией balanceOf. Можно посмотреть тут https://bscscan.com/token/0x8ac76a51cc950d9822d68b83fe1ad97b32cd580d#code
BALANCE_OF_ABI: ABIFunction = json.loads('{"constant":true,"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"balanceOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"}'
balance_of_output_types = get_abi_output_types(BALANCE_OF_ABI)
balance_of_selector = encode_hex_fn_abi(BALANCE_OF_ABI)
def get_balance_new(web3: Web3, user_address: str, token_address: str) -> int:
# инициализация контракта
data = add_0x_prefix(
encode_abi(
web3,
abi=BALANCE_OF_ABI,
arguments=(user_address,), # аргументы функции balanceOf
data=balance_of_selector
),
)
tx = {"to": token_address, "data": data}
# получение данных из ноды
res = web3.eth.call(tx)
output_data = web3.codec.decode_abi(balance_of_output_types, res)
balance = output_data[0]
return balance
```
Сравним, что же у нас получается по времени CPU и Wall Time (WT) в ms, усреднённо:
| | | | | |
| --- | --- | --- | --- | --- |
| | old WT | old CPU | new WT | new CPU |
| Инициализация | 16 | 18 | **3** | **3** |
| Вызов ноды | 155 | 19.5 | **145** | **17** |
Разница не велика, скажете вы, порядка 10 ms. А я скажу вам, что тут десяток, там два десятка и вот он, прирост. И вообще, с миру по нитке 🏮
Баланс нескольких токенов за один запрос ⚡
------------------------------------------
Допустим, мы хотим посмотреть баланс USDT, USDC и других токенов у юзера. Для этого придется делать `N` запросов с функцией `balanceOf`, где `N` — количество токенов. К счастью, для некоторых сетей, а именно:
* Ethereum
* Ethereum Rinkeby
* Ethereum Kovan
* Binance Smart Chain
* Polygon
есть так называемые контракты **BalanceScanner**,адреса [можно найти тут](https://github.com/shamaevnn/awesome-contract-addresses#balancescanner), а интерфейс взаимодействия можно [глянуть тут](https://bscscan.com/address/0x83cb147c13cBA4Ba4a5228BfDE42c88c8F6881F6#readContract). В них есть две очень полезные нам функции:
1. tokensBalance — узнать **баланс нескольких токенов** для юзера;
2. tokenBalances — узнать **баланс нескольких юзеров** для токена.
В качестве примера рассмотрим использование первой функции `tokensBalance`.
```
from eth_utils import encode_hex, function_abi_to_4byte_selector, add_0x_prefix
from web3._utils.contracts import encode_abi
from web3._utils.abi import get_abi_output_types
from web3 import Web3
from web3.types import HexBytes
# инициализация всего и вся
web3 = Web3(Web3.HTTPProvider("https://bsc-dataseed1.defibit.io"))
# ABI функции tokensBalance. Взять можно тут https://bscscan.com/address/0x83cb147c13cBA4Ba4a5228BfDE42c88c8F6881F6#code
TOKENS_BALANCE_ABI = {"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"address[]","name":"contracts","type":"address[]"}],"name":"tokensBalance","outputs":[{"components":[{"internalType":"bool","name":"success","type":"bool"},{"internalType":"bytes","name":"data","type":"bytes"}],"internalType":"struct BalanceScanner.Result[]","name":"results","type":"tuple[]"}],"stateMutability":"view","type":"function"}
TOKENS_BALANCE_SELECTOR = encode_hex(function_abi_to_4byte_selector(TOKENS_BALANCE_ABI))
tokens_balance_output_types = get_abi_output_types(TOKENS_BALANCE_ABI)
# баланс каких токенов будем проверять
tokens_to_check = [
'0x55d398326f99059fF775485246999027B3197955', # USDT
'0x8AC76a51cc950d9822D68b83fE1Ad97B32Cd580d', # USDC
'0xe9e7CEA3DedcA5984780Bafc599bD69ADd087D56', # BUSD
]
# адрес пользователя, для которого будем смотреть баланс
user_address = "0x2A647559a6c5dcB76ce1751101449ebbC039b157"
encoded_data = encode_abi(
web3=web3,
abi=TOKENS_BALANCE_ABI,
arguments=(user_address, [t for t in tokens_to_check]), # аргументы функции tokensBalance
data=TOKENS_BALANCE_SELECTOR,
)
tx = {
"to": "0x83cb147c13cBA4Ba4a5228BfDE42c88c8F6881F6", # адрес контракта BalanceScanner
"data": encoded_data
}
# обращаемся к ноде
tx_raw_data = web3.eth.call(tx)
output_data = web3.codec.decode_abi(tokens_balance_output_types, tx_raw_data)[0]
res = {}
for token_address, (_, bytes_balance) in zip(tokens_to_check, output_data):
wei_balance = web3.codec.decode_abi(["uint256"], HexBytes(bytes_balance))[0]
res[token_address] = wei_balance
# в res получаем словарь, где ключ - адрес токена, значение - баланс
#{
# '0x55d398326f99059fF775485246999027B3197955': 19357349465782901200,
# '0x8AC76a51cc950d9822D68b83fE1Ad97B32Cd580d': 38062949201715000000,
# '0xe9e7CEA3DedcA5984780Bafc599bD69ADd087D56': 0
#}
```
Еще раз: баланс сразу нескольких токенов/юзеров мы можем узнать всего лишь за **один запрос к ноде**, круто же? Просмотр баланса определенного токена для нескольких юзеров c помощью функции `tokenBalances` оставим в качестве домашнего задания.
Его величество multicall ⚡⚡
---------------------------
Контракты **BalanceScanner** объединяют в себе несколько вызовов других контрактов, но они заточены только для просмотра баланса. **Multicall** контракты же позволяют объединить вызовы произвольных контрактов. Список **multicall** контрактов для сетей [можно найти тут](https://github.com/shamaevnn/awesome-contract-addresses#multicall-addresses).
В качестве примера: хотим понять, сколько `allowance` дал пользователь различным контрактам на разные токены ([что такое allowance и зачем он нужен](https://habr.com/ru/post/674204/#contract_read_operations)).
```
from dataclasses import dataclass
from typing import Dict, List
from eth_utils import encode_hex, function_abi_to_4byte_selector, add_0x_prefix
from web3._utils.contracts import encode_abi
from web3._utils.abi import get_abi_output_types
from web3 import Web3
@dataclass
class ApproveAddressesInfo:
approval_address: str # контракт, которому дали approve
token_address: str # адрес токена
encode_hex_fn_abi = lambda fn_abi: encode_hex(
function_abi_to_4byte_selector(fn_abi)
)
# можно подсмотреть в ABI ERC-20
ALLOWANCE_ABI = {"constant": True, "inputs": [{"internalType": "address", "name": "owner", "type": "address"}, {"internalType": "address", "name": "spender", "type": "address"}], "name": "allowance", "outputs": [{"internalType": "uint256", "name": "", "type": "uint256"}], "payable": False, "stateMutability": "view", "type": "function"}
allowance_selector = encode_hex_fn_abi(ALLOWANCE_ABI)
# а это в ABI multicall контрактов
TRY_AGGREGATE_ABI = {"inputs":[{"name":"requireSuccess","type":"bool"},{"components":[{"name":"target","type":"address"},{"name":"callData","type":"bytes"}],"name":"calls","type":"tuple[]"}],"name":"tryAggregate","outputs":[{"components":[{"name":"success","type":"bool"},{"name":"returnData","type":"bytes"}],"name":"returnData","type":"tuple[]"}],"stateMutability":"nonpayable","type":"function"}
try_aggregate_selector = encode_hex_fn_abi(TRY_AGGREGATE_ABI)
try_aggregate_output_types = get_abi_output_types(TRY_AGGREGATE_ABI)
def multicall_check_allowance(
web3: Web3,
multicall_address: str,
user_address: str,
approval_token_addresses: List[ApproveAddressesInfo],
) -> Dict[ApproveAddressesInfo, str]:
encoded = (
(
addresses.token_address,
encode_abi(
web3,
ALLOWANCE_ABI,
# адрес пользователя и адрес контракта на approve
arguments=(sender_address, addresses.approval_address),
data=allowance_selector,
),
)
for addresses in approval_token_addresses
)
data = add_0x_prefix(
encode_abi(
web3,
TRY_AGGREGATE_ABI,
(False, [(token_addr, enc) for token_addr, enc in encoded]),
try_aggregate_selector,
)
)
tx_raw_data = web3.eth.call({"to": multicall_address, "data": data})
output_data = web3.codec.decode_abi(try_aggregate_output_types, tx_raw_data)[0]
output_data = (
str(decode_abi(["uint256"], HexBytes(raw_token_address))[0]) for (_, raw_token_address) in output_data
)
return dict(zip(approval_token_addresses, output_data))
```
Пример вызова этой функции:
```
multicall_check_allowance(
...,
user_address='0x...',
# список из адреса токенов и адреса контракта,
# для которого нужно посомтреть allowance
approval_token_addresses=[
ApproveAddressesInfo(
approval_address="0x24ED43C718714eb63d5aA57B78B54704E256024E",
token_address="0x55d398326f99059fF775485246999027B3197955",
),
ApproveAddressesInfo(
approval_address="0x51FC43C718714eb63d5aA57B78B54704E256024E",
token_address="0x8AC76a51cc950d9822D68b83fE1Ad97B32Cd580d",
)
]
)
# На выходе для каждой пары получим число — сколько юзер разрешил контракту снимать токенов
"""
ApproveAddressesInfo(
approval_address="0x24ED43C718714eb63d5aA57B78B54704E256024E",
token_address="0x55d398326f99059fF775485246999027B3197955",
): 131231231231,
ApproveAddressesInfo(
approval_address="0x51FC43C718714eb63d5aA57B78B54704E256024E",
token_address="0x8AC76a51cc950d9822D68b83fE1Ad97B32Cd580d",
): 0
"""
```
И еще раз: за **один** вызов RPC ноды мы получили `allowance` пользователя сразу для нескольких **различных** пар токенов и контрактов. Думаю, что если вы делаете какой-то web3 сервис, то точно найдете применение для **multicall**. А учитывая тот факт, что многие сервисы по предоставлению RPC нод платные, мы сильно экономим $ на запросах.
Асинхронный web3 🧵
------------------
На дворе уже как минимум 2022 год. Это значит, что пора использовать все прелести асинхронного кода и в web3py. Сравним скорость на простом примере: получение `gas_price` для нескольких сетей (в данном случае 6):
```
import time
import asyncio
from web3 import Web3
from web3.eth import AsyncEth
from typing import Dict, List
rpc_url_by_chain_id = {
56: "https://bsc-dataseed3.ninicoin.io", 137: "https://rpc-mainnet.matic.quiknode.pro",
250: "https://rpc.fantom.network", 43114: "https://rpc.ankr.com/avalanche",
42161: "https://rpc.ankr.com/arbitrum", 10: "https://mainnet.optimism.io",
}
# инициализация СИНХРОННОЙ версии web3 для каждой сети
sync_web3_by_chaid_id = {}
for chain_id, rpc_url in rpc_url_by_chain_id.items():
sync_web3_by_chaid_id[chain_id] = Web3(Web3.HTTPProvider(rpc_url))
# инициализация АСИНХРОННОЙ версии web3 для каждой сети
async_web3_by_chaid_id = {}
for chain_id, rpc_url in rpc_url_by_chain_id.items():
async_web3 = Web3(
Web3.AsyncHTTPProvider(rpc_url),
modules={"eth": (AsyncEth,)}, middlewares=[]
)
async_web3_by_chaid_id[chain_id] = async_web3
def get_sync(chain_ids: List[int]) -> Dict[int, int]:
"""
chain_ids = [56,137,250,43114,42161,10] -> {1: 100_000, 56: 200_000, ...}
"""
res, start_time = {}, time.time()
for chain_id in chain_ids:
web3 = sync_web3_by_chaid_id[chain_id]
res[chain_id] = web3.eth.gas_price
print(f'{(time.time()-start_time):.3f} seconds for SYNC version')
return res
async def get_async(chain_ids: List[int]) -> Dict[int, int]:
"""
chain_ids = [56,137,250,43114,42161,10] -> {1: 100_000, 56: 200_000, ...}
"""
tasks, res, start_time = [], {}, time.time()
for chain_id in chain_ids:
async_web3 = async_web3_by_chaid_id[chain_id]
tasks.append(async_web3.eth.gas_price) # добавляем асинхронные задачи
gas_prices = await asyncio.gather(*tasks) # запускаем сразу несколько задач
print(f'{(time.time()-start_time):.3f} seconds for ASYNC version')
return dict(zip(chain_ids, gas_prices))
if __name__ == "__main__":
get_sync([56,137,250,43114,42161,10])
asyncio.run(get_async([56,137,250,43114,42161,10]))
# (в среднем на 5 запусках)
# 2.391 seconds for SYNC version
# 0.493 seconds for ASYNC version
```
Разница почти в **5 раз**, неплохо, да? В целом, если вы начинаете проект в 2022+ году с web3py, я бы посоветовал вам использовать именно асинхронную версию. Но у этого есть и **подводные камни**. Например, если мы хотим узнать баланс нативной валюты для `N` пользователей, можно написать что-то в духе:
```
tasks = []
for user_address in user_addresses:
tasks.append(web3.eth.get_balance(user_address))
res = asyncio.gather(*tasks)
```
Конечно, в этом случае это также будет намного быстрее синхронного варианта. Но! В этом случае мы почти одновременно делаем `N` запросов к ноде. *Во-первых*, наши запросы = деньги, поэтому стоит их экономить, т.е. делать меньше запросов. *Во-вторых*, не удивляйтесь, что из-за такого "дудоса" нода будет отвечать дольше или не отвечать вовсе. Нужно быть внимательным в этом плане. Например, использовать **BalanceScanner** или **Multicall**, чтобы забирать все одним запросом.
Полезные сервисы 🔮
------------------
Очевидно, что, делая web3-продукт, невозможно обойтись использованием только web3py. На помощь приходят и другие сервисы.
1. [**Провайдеры блокчейн нод.**](https://github.com/shamaevnn/awesome-web3-developer#node-providers-) Конечно, на самых-самых ранних этапах проекта можно обойтись и бесплатными RPC, например, с [chainlist.org](https://chainlist.org/). Но в какой-то момент вы заметите, что этого будет не хватать: ответ будет идти дольше чем нужно или вообще не будет приходить. Есть вариант поднимать свою ноду для каждого блокчейна, но, почти наверное, вы потратите намного больше человеко-часов на ее поднятие и поддержку. Поэтому рекомендуется использовать платные сервисы, которые все делают за вас.
2. [**Цены токенов.**](https://github.com/shamaevnn/awesome-web3-developer#token-prices-) У юзера есть портфель из токенов, хочется посчитать общую сумму. Вам нужен сервис, позволяющий узнать цену каждого токена. По факту, многие используют [CoinGecko](https://www.coingecko.com/en/api/documentation). Также, из этого списка можно выделить [chain.link](https://data.chain.link/categories/crypto-usd?), т.к. этот сервис позволяет узнавать цену напрямую с помощью вызова функций контракта.
3. [**Блокчейн-эксплореры (сканнеры)**](https://github.com/shamaevnn/awesome-web3-developer#evm-explorers-). Позволяют узнать информацию о сущностях блокчейна: детали транзакции, текущий газ, все транзакции юзера и т.д.
4. [Баланс-эксплореры.](https://github.com/shamaevnn/awesome-web3-developer#balance-explorers-) У юзера N токенов, хочется понять его баланс в $. Конечно, можно сделать N запросов по цене этих токенов к сервисам из пункта 3., перемножить, сложить и получить желаемое, а можно воспользоваться сервисами из данного пункта.
5. [Токен листы.](https://github.com/shamaevnn/awesome-web3-developer#token-lists-) Бывает так, что у юзера много скам-токенов, с которыми практически ничего нигде нельзя сделать. Но как такие токены отфильтровать? Для этого нам и нужны токен листы от проверенных провайдеров. К счастью, есть уже единый агрегированный список от множества провайдеров.
Вот и всё!
----------
Надеюсь, вы узнали что-то новое для себя, а эти примеры будут полезны для ваших проектов: уменьшат количество запросов, сэкономят секунды и $.
![]()##### Никита Шамаев
Залетайте в [телеграм-канал](https://t.me/shamaevnn). Там больше постов про разработку/технологии/датасеты, и там вы не пропустите анонс следующей статьи 😉 | https://habr.com/ru/post/699560/ | null | ru | null |
# Работа отдела техподдержки системы локального позиционирования
Проработав в разных компаниях инженером службы технической поддержки, впоследствии замечаешь абсолютно разный подход к решению задач/проблем клиента. У интернет-провайдеров все проблемы привязываются к конкретному потребителю. Осуществляется не столько поддержка услуг компании (IPTV, интернет), сколько решение задач, которые пользователь создает себе сам (вырванные провода, неработающий скайп, почему-то быстро закончившиеся деньги и т.д.). Исключение составляют лишь проблемы, вызванные неполадкой коммутирующего оборудования, линий связи и прочего.
В данный момент я работаю в службе технической поддержки компании «RTL-Service», которая занимается разработкой систем локального позиционирования с обеспечением голосовой связи. Подход нашей компании заметно отличается от прочих мест, где мне приходилось работать – поскольку клиентов меньше, чем у провайдера, вся поддержка строится для конкретной версии продукта, к которой изначально привязываются клиенты.
Мы используем автоматизированную систему обработки заявок на базе Redmine. А, вернее, некоторые плагины:
Redmine helpdesk plugin — [www.redmine.org/plugins/redmine\_helpdesk](http://www.redmine.org/plugins/redmine_helpdesk)
Document Management System Features — [www.redmine.org/plugins/dmsf](http://www.redmine.org/plugins/dmsf) (Необходим для хранения и сортировки логов, версий софта и прочих вложений.)
Любое обращение по e-mail моментально создает trouble ticket в этой системе, а дальше направляется в соответствующий отдел для решения. Статус тикета обновляется и может просматриваться всеми сотрудниками отдела поддержки. Руководители могут контролировать все действия, которые производятся/производились в режиме реального времени.
Со всех обращений от клиентов только 10% уходит в другие отделы компании, основная же масса – вопросы инфраструктуры клиента (настройка сервера, сетевые параметры, виртуализация)
**Пример**– Здравствуйте! Не запускается виртуальная машина на железе клиента.
– Добрый вечер! Опишите Вашу конфигурацию оборудования.
– «Описание конфигурации железа»
– Вам необходимо в BIOS проставить опцию поддержки виртуализации. Могу ли я Вам еще чем-либо помочь?
– Спасибо, все завелось. Если будут вопросы, я обращусь.
– Всего доброго, рад был помочь.
Но есть и запросы, связанные с работой системы локального позиционирования. И некоторые из них также решаются на уровне отдела технической поддержки.
**Для примера**
– Добрый день!
Не работает связь с диспетчером после переноса АРМ в другой город. В чем может быть дело?
C Уважением, mr. Black, компания N.
— Mr. Black, с большой долей вероятности можно говорить о том, что проблема состоит в том, что шлюзовая точка доступа (ШТД) «не знает» адрес сервера.
В случае, если пул адресов 10.73.50.0/24 обслуживает dhcp-сервер на Catalyst 3650 на новом объекте, то необходимо в его настройку добавить дополнительную опцию 48 (X Window System Font Server Option), которая используется по умолчанию для передачи IP-адреса сервера ШТД.
Примерный конфиг Catalyst 3650 должен выглядеть так:
`ip dhcp pool main
network 10.73.50.0 255.255.255.0
default-router
dns-server
domain-name rtlservice.com
option 48 ip 10.101.32.21`
Для применения настроек dhcp требуется сбросить ШТД по питанию.
Если на Check-Point все открыто — должно заработать.
Yours sincerely, компания RTL Service
Если вопрос касается нарушения функционала самой системы позиционирования, практически всегда необходимо запрашивать у клиента данные с сервера, логи, скриншоты ошибок. Вся информация передается в отдел тестирования.
**Пример обращения, которое передается в службу тестирования**
Добрый день!
При редактировании (добавление карты, новой точки) и нажатии кнопки «сохранить» в клиенте возникает ошибка «RTLSCP server is unavailable». Перезагрузка страницы не помогает. Клиент оживает после реконфигурации сервера приложений и обновления страницы.
В консоли браузера сообщение:
*«2015/1/21 15:7:6.411 [error: js/rtls.web.ext/api/Rtls.API.RtlsCP.js:979:36] RTLSCP: ERROR: server localhost:9003/rtlscp/ is unavailable logs2indexeddb.js:221
GET localhost:9003/rtlscp/version/get/ Rtls.API.RtlsCP.js:1013»*
Версия ПО:
*ii rtls-appserver-demo-2.15 2.15.8587 all RTLS application server
ii rtls-incputils-2.15 2.15.8499 all Collection of INCP command line utilities
ii rtls-server-2.15 2.15.8587 all RTLS services for DEMO installation*
Время 15:04 -15:05.
Логи в LOG.zip.
Видео в файле «видео.mp4»
Это произошло в режиме DEBUG.
видео.mp4 (1,772 МБ)
LOG.zip (4,243 МБ)
Отдел тестирования воспроизводит на нужной версии программного обеспечения ошибку, передает разработчикам на доработку/исправление. Отдел Software присылает уже исправленную версию ПО в отдел тестирования. Его сотрудники воспроизводят ошибку, подтверждают, что она не возникает и передают в саппорт. Мы же, в свою очередь, отправляем исправленную версию уже клиенту. И ждем от него обратной связи.
Все обращения и решения по ним необходимо сохранять для увеличения скорости поддержки клиента. Также, необходима база знаний для существующих сотрудников и быстрого обучения новых. Для всего этого мы используем KnowledgeBase – систему, построенную на движке Wiki.
Обобщая все вышесказанное, отмечу, что можно построить неплохую систему для отдела технической поддержки на базе Redmine, т.к. все плагины бесплатны и их функционала более чем достаточно. И, вообще, саппорт всегда крайне важен для любой компании, поскольку это не только «лицо» организации, но и первая линия фронта в обслуживании и взаимодействии с клиентом. Берегите службу технической поддержки, обучайте и подготавливайте сотрудников.
Автор: Илья Кузнецов | https://habr.com/ru/post/305568/ | null | ru | null |
# WPF: использование Attached Property и Behavior
Пожалуй, любой разработчик WPF знает о механизме Attached Property, но многие даже не слышали о Behavior. Хотя эти механизмы и имеют схожие функциональные возможности, они, все же, имеют совершенно разную смысловую нагрузку, и очень важно правильно различать их и использовать.
Давайте вспомним, что из себя представляют эти механизмы:
**Attached Property**. Это Dependency Property, которое объявлено не в классе объекта, для которого оно будет использоваться, но ведет себя, как будто является его частью.
Объявляется в отдельном классе, имеет getter и setter в виде статических методов. Можно добавить обработчик на PropertyChanged событие.
```
public static class UiConfigurator
{
public static readonly DependencyProperty CustomValueProperty = DependencyProperty.RegisterAttached(
"CustomValue", typeof(bool), typeof(UiConfigurator), new PropertyMetadata(false));
public static void SetCustomValue(DependencyObject element, bool value)
{
element.SetValue(CustomValueProperty, value);
}
public static bool GetCustomValue(DependencyObject element)
{
return (bool)element.GetValue(CustomValueProperty);
}
}
```
Используется так же как и обычное Dependency Property, только необходимо указать класс, в котором оно определено.
```
```
Благодаря обработчику PropertyChanged очень часто с помощью этого механизма пытаются добавлять к UI элементу некоторую функциональность. Например, мы хотим запоминать расположение и размер окна между запусками приложения. Делаем Attached Property SaveBounds и добавляем обработчик PropertyChanged. Если установленно в true, то выполняем код по восстановлению/сохранению позиции окна. Правильно ли это? Нет. Давайте посмотрим как Microsoft использует этот механизм у себя. Отличными примерами являются Grid.Column и DockPanel.Dock. Все эти свойства никак не влияют на функциональность объекта, а просто добавляют некоторую информацию, чтобы другие участники дерева отображения смогли более корректно с ним взаимодействовать. Сам же объект об этом ничего не знает и знать не должен. Отсюда следует, что само по себе использование события PropertyChanged для Attached Property уже повод задуматься: а все ли я правильно делаю? Он необходим только в очень редких случаях. Например, так мы может запоминать историю изменения этого свойства, чтобы при необходимости провести более глубокий анализ и взаимодействовать более интеллектуально. Но это из разряда задач “делал один раз в жизни”.
Так как Attached Property не влияет на состояние объекта, то и несколько таких свойств конфликтовать не должны, а значит мы можем навешивать их на него сколько угодно. Например, те же Grid.Column и DockPanel.Dock (хоть это и несколько нелогично) можно легко сочетать. Вот вам и вторая подсказка правильно ли вы используете этот механизм: если вы можете представить код, который может быть написан в целевом объекте или где-либо еще и который будет конфликтовать с вашим свойством – вы что-то сделали не так.
**Behavior**. В WPF есть абстрактный шаблонный класс Behavior. Сделав наследника, мы можем присоединить его к объекту в дереве отображения. В этом классе есть методы OnAttached и OnDetaching, которые вызовутся в соответствующих случаях.
Ниже пример CloseBehavior, который можно присоединить любой кнопке и сделать ее таким образом кнопкой закрытия приложения.
```
public class CloseBehavior : Behavior
{
protected override void OnAttached()
{
AssociatedObject.Click += OnClick;
}
protected override void OnDetaching()
{
AssociatedObject.Click -= OnClick;
}
private void OnClick(object sender, RoutedEventArgs e)
{
Application.Current.Shutdown();
}
}
```
Добавляется следующим кодом:
```
```
Вот Behavior уже в отличии от Attached Property служит для добавления функциональных возможностей UI элементам. В него можно добавлять любые Dependency Property, и, так как он является частью дерева отображения, Binding тут отлично работает. Так как для WPF принято использовать MVVM, а он, в свою очередь, предполагает минимум кода в теле View, то Behavior тут как нельзя кстати. Эти немногочисленные функциональные блоки, которые нельзя выполнить при помощи стандартного Binding, можно выносить и использовать повсеместно комбинирую друг с другом.
Не все объекты Behavior должны быть совместимы друг с другом. Например, мы не сможем совместить CloseButtonBehavior и HelpButtonBehavior. И это, разумеется, нормально. | https://habr.com/ru/post/254887/ | null | ru | null |
# Приемы использования масочных регистров в AVX512 коде
В процессорах компании Intel на смену AVX2 приходит новый набор инструкций [AVX512](https://software.intel.com/en-us/isa-extensions/intel-avx), в котором появилась концепция масочных регистров. Автор этой статьи уже несколько лет занимается разработкой версии библиотеки [Intel Integrated Performance Primitives](https://software.intel.com/en-us/intel-ipp), оптимизированной для AVX512, и накопил довольно большой опыт использования AVX512 инструкций с масками, который было решено объединить в одну отдельную статью, поскольку само использование таких инструкций с масками позволяет упростить и ускорить код в дополнение к ускорению от двукратного увеличения ширины регистров.
Пример 1. Применяем инструкции с масками «до и после» основного цикла
=====================================================================
Рассмотрим функцию сложения двух изображений.
**Лист 1.1**
```
void add_ref( const float* pSrc1, int src1Step, const float* pSrc2, int src2Step,
float* pDst, int dstStep, int width, int height)
{
int h, i;
for( h = 0; h < height; h++ ) {
for( i = 0; i < width; i++ ) {
pDst[i] = pSrc1[i] + pSrc2[i];
}
pSrc1 = pSrc1 + src1Step;
pSrc2 = pSrc2 + src2Step;
pDst = pDst + dstStep;
}
}
```
Код функции очень прост и в принципе компилятор icl вполне способен векторизовать данный код. Однако наша цель – продемонстрировать использование масочных avx512 регистров, поэтому напишем первую и очевидную версию avx512 кода.
**Лист 1.2**
```
void add_avx512( const float* pSrc1, int src1Step, const float* pSrc2, int src2Step,
float* pDst, int dstStep, int width, int height)
{
int h, i;
for( h = 0; h
```
В данном коде добавлен цикл, складывающий сразу по 16 элементов за итерацию. Поскольку ширина изображения может быть произвольной и не кратной 16, то в следующем цикле складываются элементы, оставшиеся до конца строки. Число таких элементов может достигать 15-ти, и влияние этого цикла на общую производительность может быть достаточно велико. Использование же масочных регистров позволяет существенно ускорить обработку «хвоста».
**Лист 1.3**
```
__mmask16 len2mask[] = { 0x0000, 0x0001, 0x0003, 0x0007,
0x000F, 0x001F, 0x003F, 0x007F,
0x00FF, 0x01FF, 0x03FF, 0x07FF,
0x0FFF, 0x1FFF, 0x3FFF, 0x7FFF,
0xFFFF };
void add_avx512_2( float* pSrc1, int src1Step, const float* pSrc2, int src2Step,
float* pDst, int dstStep, int width, int height)
{
int h, i;
for( h = 0; h < height; h++ ) {
i = 0;
__m512 zmm0, zmm1;
__mmask16 msk;
for(i=i; i < (width&(~15)); i+=16 ) {
zmm0 = _mm512_loadu_ps(pSrc1+i );
zmm1 = _mm512_loadu_ps(pSrc2+i );
zmm0 = _mm512_add_ps (zmm0, zmm1);
_mm512_storeu_ps (pDst+i, zmm0 );
}
msk = len2mask[width - i];
if(msk){
zmm0 = _mm512_mask_loadu_ps(_mm512_setzero_ps(),msk,pSrc1+i );
zmm1 = _mm512_mask_loadu_ps(_mm512_setzero_ps(),msk,pSrc2+i );
zmm0 = _mm512_add_ps (zmm0, zmm1);
_mm512_mask_storeu_ps (pDst+i, msk, zmm0 );
}
pSrc1 = pSrc1 + src1Step;
pSrc2 = pSrc2 + src2Step;
pDst = pDst + dstStep;
}
}
```
Массив len2mask используется для преобразования числа в соответствующее число битов подряд. И вместо скалярного цикла, мы получаем всего один if, который в-принципе тоже не обязателен, поскольку в случае маски состоящей из одних нулей, чтение и запись не будут осуществляться.
Для достижения максимальной производительности рекомендуется выравнивать данные на ширину кэш линии, а загрузки осуществлять по выровненному на ширину регистра адресу. В Skylake ширина кэш линии по прежнему 64 байта, поэтому, в нашем коде мы можем добавить такое выравнивание по pDst опять же с помощью масочных операций, но только до основного цикла.
**Лист 1.4**
```
void add_avx512_3(float* pSrc1, int src1Step, const float* pSrc2, int src2Step,
float* pDst, int dstStep, int width, int height)
{
int h, i, t;
for( h = 0; h < height; h++ ) {
i = 0;
__m512 zmm0, zmm1;
__mmask16 msk;
t = ((((int)pDst) & (63)) >> 2);
msk = len2mask[t];
if(msk){
zmm0 = _mm512_mask_loadu_ps(_mm512_setzero_ps(),msk,pSrc1+i );
zmm1 = _mm512_mask_loadu_ps(_mm512_setzero_ps(),msk,pSrc2+i );
zmm0 = _mm512_add_ps (zmm0, zmm1);
_mm512_mask_storeu_ps (pDst+i, msk, zmm0 );
}
i += t;
for(i=i; i < (width&(~15)); i+=16 ) {
zmm0 = _mm512_loadu_ps(pSrc1+i );
zmm1 = _mm512_loadu_ps(pSrc2+i );
zmm0 = _mm512_add_ps (zmm0, zmm1);
_mm512_storeu_ps (pDst+i, zmm0 );
}
msk = len2mask[width - i];
if(msk){
zmm0 = _mm512_mask_loadu_ps(_mm512_setzero_ps(),msk,pSrc1+i );
zmm1 = _mm512_mask_loadu_ps(_mm512_setzero_ps(),msk,pSrc2+i );
zmm0 = _mm512_add_ps (zmm0, zmm1);
_mm512_mask_storeu_ps (pDst+i, msk, zmm0 );
}
pSrc1 = pSrc1 + src1Step;
pSrc2 = pSrc2 + src2Step;
pDst = pDst + dstStep;
}
}
Рассмотренная функция add довольно простая и тут вполне допустимо сделать загрузки по маске до и после основного цикла. Но в более сложных, к примеру целочисленных с округлением к ближайшему четному, алгоритмах количество таких операций может достигать десятков и такая методика маски для выравнивания и обработки хвоста может привести к существенному увеличению размера кода. А править ошибки придется в трех разных местах этого довольно длинного кода. Использование же масочных регистров позволяет и снизить размер кода и упростить его дальнейшую поддержку. Лист. 1.5 демонстрирует эту идею
#define min(a,b) ((a)<(b)?(a):(b))
void add\_avx512\_4( const float\* pSrc1, int src1Step, const float\* pSrc2, int src2Step,
float\* pDst, int dstStep,
int width, int height)
{
int h, i;
for( h = 0; h < height; h++ ) {
i = 0;
\_\_m512 zmm0, zmm1;
\_\_mmask16 msk;
for(i=i; i < width; i+=16 ) {
msk = len2mask[min(16, width - i)];
zmm0 = \_mm512\_mask\_loadu\_ps(\_mm512\_setzero\_ps(),msk,pSrc1+i );
zmm1 = \_mm512\_mask\_loadu\_ps(\_mm512\_setzero\_ps(),msk,pSrc2+i );
zmm0 = \_mm512\_add\_ps (zmm0, zmm1);
/\*THE LONG PIPELINE HERE\*/
\_mm512\_mask\_storeu\_ps (pDst+i, msk, zmm0 );
}
pSrc1 = pSrc1 + src1Step;
pSrc2 = pSrc2 + src2Step;
pDst = pDst + dstStep;
}
}
```
Код стал выглядеть короче, и при достаточно длинной последовательности вычислений, затраты на вычисление маски в каждой итерации на таком фоне могут оказаться незначительными.
Пример 2. Маска как непосредственная часть реализуемого алгоритма.
==================================================================
В различных алгоритмах обработки изображений одним из входных параметров может быть бинарная маска. К примеру, такая маска используется в операциях морфологии изображений.
**Лист 2.1**
```
void morph_3x3_ref( const float* pSrc1, int src1Step, char* pMask,
float* pDst, int dstStep, int width, int height)
{
int h, i;
for( h = 0; h < height; h++ ) {
for(i=0; i < width; i++ ) {
int x, y;
char* pm = pMask;
/*we assume that pMask is not zero total*/
float m = 3.402823466e+38f;
float val = 0.0;
for (y = 0; y < 3;y++){
for (x = 0; x < 3; x++){
if (*pm){
val = pSrc1[i + src1Step*y + x];
if (val < m) {
m = val;
}
}
pm++;
}
}
pDst[i] = m;
}
pSrc1 = pSrc1 + src1Step;
pDst = pDst + dstStep;
}
}
```
Функция ищет минимальный по величине пиксель внутри квадрата 3x3. Входная маска pMask представляет собой массив из 3x3=9 байтов. Если значение байта не равно нулю, то входной пиксель из квадрата 3x3 участвует в поиске, если равно, то не участвует.
Пишем avx512 код.
**Лист 2.2**
```
void morph_3x3_avx512( const float* pSrc1, int src1Step, char* pMask, float* pDst, int dstStep, int width, int height)
{
int h, i;
__mmask msk[9], tail_msk;
for ( i = 0; i < 9; i++){
msk[i] = (!pMask[i]) ? 0 : 0xFFFF;//create load mask
}
tail_msk = len2mask[width & 15]; //tail mask
for( h = 0; h < height; h++ ) {
__m512 zmm0, zmmM;
int x, y;
i = 0;
for(i=i; i < (width&(~15)); i+=16 ) {
zmmM = _mm512_set1_ps(3.402823466e+38f);
for (y = 0; y < 3;y++){
for (x = 0; x < 3; x++){
zmm0 = _mm512_mask_loadu_ps(zmmM, msk[3*y+x], &pSrc1[i + src1Step*y + x]);
zmmM = _mm512_min_ps(zmm0, zmmM);
}
}
_mm512_storeu_ps (pDst+i, zmmM );
}
if(tail_msk) {
zmmM = _mm512_set1_ps(3.402823466e+38f);
for (y = 0; y < 3;y++){
for (x = 0; x < 3; x++){
zmm0=_mm512_mask_loadu_ps(zmmM,msk[3*y+x]&tail_msk,&pSrc1[i+src1Step*y+x]);
zmmM=_mm512_min_ps(zmm0, zmmM);
}
}
_mm512_mask_storeu_ps (pDst+i, tail_msk, zmmM );
}
pSrc1 = pSrc1 + src1Step;
pDst = pDst + dstStep;
}
}
```
Вначале формируется массив масок \_\_mmask msk[9]. Каждая маска получается заменой байта из pMask на бит (0 на 0, все другие значения на 1) и этот бит размножается на 16 элементов. Основной цикл загружает по этой маске 16 элементов. Причем, если элемент не участвует в поиске, то он и не будет загружен. В данном коде также с помощью масок обрабатывается и хвост, мы просто выполняем операцию & над маской операции морфологии и маской хвоста.
Конечно, продемонстрированый код не совсем оптимален, однако он демонструет саму идею, а усложнение кода привело бы к потере наглядности.
Пример 3. Инструкции семейства expand/compress
==============================================
Еще в первом 256 битном наборе инструкций AVX регистры были разделены барьером на 2 части, называемые lane. Большинство векторных инструкции независимо обрабатывают эти части. Выглядит это как 2 параллельные SSE инструкции. В avx512 регистр разделяется уже на четыре 128-битные части по четыре float/int элемента. А во многих алгоритмах обработки изображений используются три канала и объединение их по 4 довольно проблематично. В этом случае можно рассмотреть возможность использования инструкций вида expand/compress
\_\_m512 \_mm512\_mask\_expandloadu\_ps (\_\_m512 src, \_\_mmask16 k, void const\* mem\_addr)
void \_mm512\_mask\_compressstoreu\_ps (void\* base\_addr, \_\_mmask16 k, \_\_m512 a)
Инструкция \_mm512\_mask\_expandloadu\_ps загружает из памяти непрерывный блок float данных длиной равной количеству единичных бит в маске. Таким образом может быть загружен блок длиной от 0 до 16 элементов. В регистр-приемник данные помещаются следующим образом. Начиная с самого младшего бита маски проверяется, если бит равен 1, то элемент из памяти записывается в регистр, если 0, то переходим к рассмотрению следующего бита и того же самого элемента, рис. 3.1
Рис. 3.1 Демонстрация работы \_mm512\_mask\_expandloadu\_ps
Видно, что область памяти как бы “растягивается” (expand) по всему 512 битному регистру. Инструкция \_mm512\_mask\_compressstoreu\_ps работает в противоположную сторону — “сжимает”(compress) регистр по маске и записывает в непрерывную область памяти.
Итак, допустим нам необходимо перейти из цветового пространства RGB в XYZ.
**Лист 3.1**
```
void rgb_ref( const float* pSrc1, int src1Step,
float* pDst, int dstStep, int width, int height)
{
int h, i;
for( h = 0; h < height; h++ ) {
for(i=0; i < width; i++ ) {
pDst[3*i+0]=(0.412f*pSrc1[3*i]+0.357f*pSrc1[3*i+1]+0.180f*pSrc1[3*i+2]);
pDst[3*i+1]=(0.212f*pSrc1[3*i]+0.715f*pSrc1[3*i+1]+0.072f*pSrc1[3*i+2]);
pDst[3*i+2]=(0.019f*pSrc1[3*i]+0.119f*pSrc1[3*i+1]+0.950f*pSrc1[3*i+2]);
if (pDst[3 * i + 2] < 0.0){
pDst[3 * i + 2] = 0.0;
}
if (pDst[3 * i + 2] > 1.0){
pDst[3 * i + 2] = 1.0;
}
}
pSrc1 = pSrc1 + src1Step;
pDst = pDst + dstStep;
}
}
```
Используя expand/compress avx512 код может выглядеть следующим образом.
**Лист 3.2**
```
void rgb_avx512( const float* pSrc1, int src1Step, float* pDst, int dstStep, int width, int height)
{
int h, i;
for( h = 0; h < height; h++ ) {
__m512 zmm0, zmm1, zmm2, zmm3;
i = 0;
for(i=i; i < (width&(~3)); i+=4 ) {
zmm0 = _mm512_mask_expandloadu_ps(_mm512_setzero_ps(), 0x7777, &pSrc1[3*i ]);
zmm1 = _mm512_mul_ps(_mm512_set4_ps(0.0f, 0.019f, 0.212f, 0.412f), _mm512_shuffle_ps(zmm0, zmm0, 0x00));
zmm2 = _mm512_mul_ps(_mm512_set4_ps(0.0f, 0.119f, 0.715f, 0.357f), _mm512_shuffle_ps(zmm0, zmm0, 0x55));
zmm3 = _mm512_mul_ps(_mm512_set4_ps(0.0f, 0.950f, 0.072f, 0.180f), _mm512_shuffle_ps(zmm0, zmm0, 0xAA));
zmm0 = _mm512_add_ps(zmm1, zmm2);
zmm0 = _mm512_add_ps(zmm0, zmm3);
zmm0 = _mm512_mask_max_ps(zmm0, 0x4444,_mm512_set1_ps(0.0f), zmm0);
zmm0 = _mm512_mask_min_ps(zmm0, 0x4444,_mm512_set1_ps(1.0f), zmm0);
_mm512_mask_compressstoreu_ps (pDst+3*i, 0x7777, zmm0 );
}
pSrc1 = pSrc1 + src1Step;
pDst = pDst + dstStep;
}
}
```
С помощью \_mm512\_mask\_expandloadu\_ps мы помещаем 4 пикселя в разные lane, после чего последовательно формируем r3r3r3r3 … r0r0r0, …g0g0g0, b0b0b0 и умножаем на коэффициенты преобразования. Для проверки переполнения также используются операции с масками \_mm512\_mask\_max/min\_ps. Запись преобразованных данных обратно в память выполняется командой \_mm512\_mask\_compressstoreu\_ps. В этой функции для обработки хвоста также можно использовать маски, в зависимости от длины хвоста.
Пример 4. Векторизация ветвления
================================
Если Вы дочитали до этого места, то уже подготовлены к самой, на мой взгляд, интересной области применения масочных регистров. Это векторизация циклов с условиями. Речь идет о некоем подобии предикатных регистров, имеющихся в процессорах семейства Itanium. Рассмотрим простую функцию, у которой есть if внутри цикла for.
**Лист 4.1**
```
#define ABS(A) (A)>=0.0f?(A):(-(A))
void avg_ref( float* pSrc1, int src1Step,
float* pDst, int dstStep, int width, int height)
{
int h, i;
for( h = 0; h < height; h++ ) {
for(i=0; i < width; i++ ) {
float dv, dh;
float valU = pSrc1[src1Step*(h - 1) + i ];
float valD = pSrc1[src1Step*(h + 1) + i ];
float valL = pSrc1[src1Step*( h ) + (i-1)];
float valR = pSrc1[src1Step*( h ) + (i+1)];
dv = ABS(valU - valD);
dh = ABS(valL - valR);
if(dv<=dh){
pDst[i] = (valU + valD) * 0.5f; //A branch
} else {
pDst[i] = (valL + valR) * 0.5f; //B branch
}
}
pDst = pDst + dstStep;
}
}
```
Функция осуществляет интерполяцию по соседним горизонтальным или вертикальнам элементам, между которыми разность минимальна. Главное здесь то, что внутри цикла идет разделения на две ветки, когда if-условие истенно, и когда нет. Но, мы можем вычислить на avx512 регистрах значения в том и другом случае, а потом их объединить по маске.
**Лист 4.2**
```
void avg_avx512( const float* pSrc1, int src1Step,
float* pDst, int dstStep, int width, int height)
{
int h, i;
for( h = 0; h < height; h++ ) {
i = 0;
for(i=i; i < (width&(~15)); i+=16 ) {
__m512 zvU, zvD, zvL, zvR;
__m512 zdV, zdH;
__m512 zavgV, zavgH, zavg;
__mmask16 mskV;
zvU = _mm512_loadu_ps(pSrc1+src1Step*(h - 1) + i );
zvD = _mm512_loadu_ps(pSrc1+src1Step*(h + 1) + i );
zvL = _mm512_loadu_ps(pSrc1+src1Step*( h ) + (i-1));
zvR = _mm512_loadu_ps(pSrc1+src1Step*( h ) + (i+1));
zdV = _mm512_sub_ps(zvU, zvD);
zdH = _mm512_sub_ps(zvL, zvR);
zdV = _mm512_abs_ps(zdV);
zdH = _mm512_abs_ps(zdH);
mskV = _mm512_cmp_ps_mask(zdV, zdH, _CMP_LE_OS);
zavgV = _mm512_mul_ps(_mm512_set1_ps(0.5f), _mm512_add_ps(zvU, zvD));
zavgH = _mm512_mul_ps(_mm512_set1_ps(0.5f), _mm512_add_ps(zvL, zvR));
zavg = _mm512_mask_or_ps(zavgH, mskV, zavgV, zavgV);
_mm512_storeu_ps(pDst + i, zavg);
}
//remainder skipped
pDst = pDst + dstStep;
}
}
```
Таких if в реализуемом алгоритме может быть несколько, для них можно завести новые маски до тех пор пока код будет быстрее скалярного.
В действительности, компилятор icc вполне способен векторизовать код 4.1 Для этого достаточно всего лишь добавить ключевое слово restrict к указателям pSrc1 и pDst и ключ –Qrestrict.
```
void avg_ref( float* restrict pSrc1, int src1Step, float* restrict pDst, int dstStep, int width, int height)
```
Напомню, что модификатор restrict указывает компилятору, что доступ к объекту осуществляется только через этот указатель и таким образом вектора pSrc1 и pDst не пересекаются, что и делает возможной векторизацию.
Измерения на внутреннем симуляторе CPU с поддержкоий avx512 показывают, что производительность практически равна производительности нашего avx512 кода. Т.е компилятор тоже умеет эффективно использовать маски
Казалось бы на этом все. Но посмотрим, что будет если мы слегка модицифируем нашу функцию и внесем в нее зависимость между итерациями.
**Лист 4.3**
```
void avg_ref( float* restrict pSrc1, int src1Step,
float* restrict pDst, int dstStep, int width, int height)
{
int h, i;
for( h = 0; h < height; h++ ) {
int t = 1;
for(i=0; i < width; i++ ) {
float dv, dh;
float valU = pSrc1[src1Step*(h - 1) + i ];
float valD = pSrc1[src1Step*(h + 1) + i ];
float valL = pSrc1[src1Step*( h ) + (i-1)];
float valR = pSrc1[src1Step*( h ) + (i+1)];
dv = ABS(valU - valD);
dh = ABS(valL - valR);
if(dvdh){
pDst[i] = (valL + valR) \* 0.5f;
t = 0;
} else if (t == 1) {
pDst[i] = (valU + valD) \* 0.5f;
} else {
pDst[i] = (valL + valR) \* 0.5f;
}
}
pDst = pDst + dstStep;
}
}
```
Функция также осуществляет интерполяцию по соседним пикселям, и если разница по вертикали и горизонтали одинакова, то используется то направление интерполяции, которое было в предыдущей итерации. На алгоритмах такого рода снижается эффект от механизма out of order, реализованных в современных cpu из-за того, что образуется длинная последовательность зависимых операций. Компилятор также теперь не может векторизовать цикл и производительность стала в 17 раз медленее. Т.е. как раз примерно на ширину в 16 float элементов в AVX512 регистре. Теперь попробуем как-то модифицировать и наш avx512 код, чтобы получить хоть какое то ускорение.
Введем в рассмотрение следующие бинарные маски-переменные
mskV(n) – для n-го элемента V разница минимальна
mskE(n) – для n-го элемента V и H разницы одинаковы
mskD(n) – для n-го элемента использована V интерполяция.
Теперь построим таблицу истинности, как формируется mskD(n) в зависимости от mskV(n),mskE(n) и предыдущей использованой маски – mskD(n-1)
Из таблицы следует, что
mskD(n) = mskV(n) | (mskE(n)&mskD(n-1)),
что в общем-то и так было очевидно. Итак наш avx512 код будет выглядеть следующим образом.
**Лист 4.4**
```
void avg_avx512( const float* pSrc1, int src1Step,
float* pDst, int dstStep, int width, int height)
{
int h, i;
for( h = 0; h < height; h++ ) {
__mmask16 mskD = 0xFFFF;
i = 0;
for(i=i; i < (width&(~15)); i+=16 ) {
__m512 zvU, zvD, zvL, zvR;
__m512 zdV, zdH;
__m512 zavgV, zavgH, zavg;
__mmask16 mskV, mskE;
zvU = _mm512_loadu_ps(pSrc1+src1Step*(h - 1) + i );
zvD = _mm512_loadu_ps(pSrc1+src1Step*(h + 1) + i );
zvL = _mm512_loadu_ps(pSrc1+src1Step*( h ) + (i-1));
zvR = _mm512_loadu_ps(pSrc1+src1Step*( h ) + (i+1));
zdV = _mm512_sub_ps(zvU, zvD);
zdH = _mm512_sub_ps(zvL, zvR);
zdV = _mm512_abs_ps(zdV);
zdH = _mm512_abs_ps(zdH);
mskV = _mm512_cmp_ps_mask(zdV, zdH, _CMP_LT_OS);
mskE = _mm512_cmp_ps_mask(zdV, zdH, _CMP_EQ_OS);
mskD = mskV | (mskE & (mskD >>15) & (1<<0)); // 0 bit
mskD = mskD | (mskE & (mskD << 1) & (1<<1)); // 1 bit
mskD = mskD | (mskE & (mskD << 1) & (1<<2)); // 2 bit
mskD = mskD | (mskE & (mskD << 1) & (1<<3)); // 3 bit
mskD = mskD | (mskE & (mskD << 1) & (1<<4)); // 4 bit
mskD = mskD | (mskE & (mskD << 1) & (1<<5)); // 5 bit
mskD = mskD | (mskE & (mskD << 1) & (1<<6)); // 6 bit
mskD = mskD | (mskE & (mskD << 1) & (1<<7)); // 7 bit
mskD = mskD | (mskE & (mskD << 1) & (1<<8)); // 8 bit
mskD = mskD | (mskE & (mskD << 1) & (1<<9)); // 9 bit
mskD = mskD | (mskE & (mskD << 1) & (1<<10)); // 10 bit
mskD = mskD | (mskE & (mskD << 1) & (1<<11)); // 11 bit
mskD = mskD | (mskE & (mskD << 1) & (1<<12)); // 12 bit
mskD = mskD | (mskE & (mskD << 1) & (1<<13)); // 13 bit
mskD = mskD | (mskE & (mskD << 1) & (1<<14)); // 14 bit
mskD = mskD | (mskE & (mskD << 1) & (1 << 15)); // 15 bit
zavgV = _mm512_mul_ps(_mm512_set1_ps(0.5f), _mm512_add_ps(zvU, zvD));
zavgH = _mm512_mul_ps(_mm512_set1_ps(0.5f), _mm512_add_ps(zvL, zvR));
zavg = _mm512_mask_or_ps(zavgH, mskD, zavgV, zavgV);
_mm512_storeu_ps(pDst + i, zavg);
}
pDst = pDst + dstStep;
}
}
```
В нем последовательно перебираются все 16 бит маски. На размере 64x64 он работает в **~1.7X** раз быстрее чем С-шный. Ну хотя бы что-то удалось получить. Следующая возможная оптимизация заключается в том, что можно предварительно просчитать все комбинации масок. На каждой итерации по 16 элементов у нас есть 16 бит mskV, 16 бит mskE, и 1 бит от предыдущей итерации. Итого 2^33 степени вариантов для mskD. Это много. А что если обрабатывать не по 16, а по 8 элементов за итерацию? Получаем 2^(8+8+1)=128кбайт таблицу. А это вполне вменяемый размер. Создаем функцию инициализации.
**Лист 4.5**
```
unsigned char table[2*256 * 256];
extern init_table_mask()
{
int mskV, mskE, mskD=0;
for (mskD = 0; mskD < 2; mskD++){
for (mskV = 0; mskV < 256; mskV++){
for (mskE = 0; mskE < 256; mskE++){
int msk;
msk = mskV | (mskE & (mskD ) & (1 << 0)); // 0 bit
msk = msk | (mskE & (msk << 1) & (1 << 1)); // 1 bit
msk = msk | (mskE & (msk << 1) & (1 << 2)); // 2 bit
msk = msk | (mskE & (msk << 1) & (1 << 3)); // 3 bit
msk = msk | (mskE & (msk << 1) & (1 << 4)); // 4 bit
msk = msk | (mskE & (msk << 1) & (1 << 5)); // 5 bit
msk = msk | (mskE & (msk << 1) & (1 << 6)); // 6 bit
msk = msk | (mskE & (msk << 1) & (1 << 7)); // 7 bit
table[256*256*mskD+256 * mskE + mskV] = (unsigned char)msk;
}
}
}
}
```
Переписываем код.
**Лист 4.6**
```
void avg_avx512( const float* pSrc1, int src1Step,
float* pDst, int dstStep, int width, int height)
{
int h, i;
for( h = 0; h < height; h++ ) {
__mmask16 mskD = 0xFFFF;
i = 0;
mskD = 0x00FF;
for(i=i; i < (width&(~7)); i+=8 ) {
__m512 Z = _mm512_setzero_ps();
__m512 zvU, zvD, zvL, zvR;
__m512 zdV, zdH;
__m512 zavgV, zavgH, zavg;
__mmask16 mskV, mskE;
zvU = _mm512_mask_loadu_ps(Z,0xFF, pSrc1+src1Step*(h - 1) + i );
zvD = _mm512_mask_loadu_ps(Z,0xFF, pSrc1+src1Step*(h + 1) + i );
zvL = _mm512_mask_loadu_ps(Z,0xFF, pSrc1+src1Step*( h ) + (i-1));
zvR = _mm512_mask_loadu_ps(Z,0xFF, pSrc1+src1Step*( h ) + (i+1));
zdV = _mm512_sub_ps(zvU, zvD);
zdH = _mm512_sub_ps(zvL, zvR);
zdV = _mm512_abs_ps(zdV);
zdH = _mm512_abs_ps(zdH);
mskV = _mm512_cmp_ps_mask(zdV, zdH, _CMP_LT_OS)&0xFF;
mskE = _mm512_cmp_ps_mask(zdV, zdH, _CMP_EQ_OS)&0xFF;
mskD = table[256 * 256 * (mskD >> 7) + 256 * mskE + mskV];
zavgV = _mm512_mul_ps(_mm512_set1_ps(0.5f), _mm512_add_ps(zvU, zvD));
zavgH = _mm512_mul_ps(_mm512_set1_ps(0.5f), _mm512_add_ps(zvL, zvR));
zavg = _mm512_mask_or_ps(zavgH, mskD, zavgV, zavgV);
_mm512_mask_storeu_ps(pDst + i, 0xFF, zavg);
}
pDst = pDst + dstStep;
}
}
```
Код стал работать в **~4.1X** раз быстрее. Можно добававить обработку по 16 элементов, но к таблице придется обратиться дважды за итерацию.
**Лист 4.7**
```
void avg_avx512( const float* pSrc1, int src1Step,
float* pDst, int dstStep, int width, int height)
{
int h, i;
for( h = 0; h < height; h++ ) {
__mmask16 mskD = 0xFFFF;
i = 0;
for(i=i; i < (width&(~15)); i+=16 ) {
__m512 zvU, zvD, zvL, zvR;
__m512 zdV, zdH;
__m512 zavgV, zavgH, zavg;
__mmask16 mskV, mskE;
ushort mskD_0_7=0, mskD_8_15=0;
zvU = _mm512_loadu_ps(pSrc1+src1Step*(h - 1) + i );
zvD = _mm512_loadu_ps(pSrc1+src1Step*(h + 1) + i );
zvL = _mm512_loadu_ps(pSrc1+src1Step*( h ) + (i-1));
zvR = _mm512_loadu_ps(pSrc1+src1Step*( h ) + (i+1));
zdV = _mm512_sub_ps(zvU, zvD);
zdH = _mm512_sub_ps(zvL, zvR);
zdV = _mm512_abs_ps(zdV);
zdH = _mm512_abs_ps(zdH);
mskV = _mm512_cmp_ps_mask(zdV, zdH, _CMP_LT_OS);
mskE = _mm512_cmp_ps_mask(zdV, zdH, _CMP_EQ_OS);
mskD_0_7 = table[256 * 256 * (((ushort)mskD) >> 15) +
256 * (((ushort)mskE) & 0xFF) + (((ushort)mskV) & 0xFF)];
mskD_8_15 = table[256 * 256 * (((ushort)mskD_0_7) >> 7) +
256 * (((ushort)mskE)>> 8 ) + (((ushort)mskV) >>8 )];
mskD = (mskD_8_15 << 8) | mskD_0_7;
zavgV = _mm512_mul_ps(_mm512_set1_ps(0.5f), _mm512_add_ps(zvU, zvD));
zavgH = _mm512_mul_ps(_mm512_set1_ps(0.5f), _mm512_add_ps(zvL, zvR));
zavg = _mm512_mask_or_ps(zavgH, mskD, zavgV, zavgV);
_mm512_storeu_ps(pDst + i, zavg);
}
pDst = pDst + dstStep;
}
}
```
Теперь ускорение составляет **~5.6X** по сравнению с изначальным С кодом, что очень даже неплохо для алгоритма с обратной связью. Таким образом комбинация масочного регистра и предварительно вычисленной таблицы позволяет получить существенный прирост производительности. Код такого рода вовсе не является специально подобранным для статьи и встречается к примеру в алгоритмах обработки фотографий, при конвертации изображения из RAW формата. Правда там используются целочисленные значения, но такой табличный метод вполне можно применить и для них.
Итог
====
В этой статье показаны лишь некоторые способы применения масочных инструкций AVX 512. Вы можете применять их в своих приложениях или придумывать свои приемы. А можете воспользоваться библиотекой [IPP](https://software.intel.com/en-us/intel-ipp), в которой уже присутствует код, оптимизированный специально для процессоров Intel с поддержкой avx512, важной частью которого являются инструкции с масочными регистрами. | https://habr.com/ru/post/266055/ | null | ru | null |
# Скачивание любого сайта с помощью Python себе на компьютер
Здравствуйте!
Сегодня я Вам расскажу про интересную библиотеку для Python под названием [Pywebcopy](https://github.com/rajatomar788/pywebcopy/).
PyWebCopy – бесплатный инструмент для копирования отдельных веб-страниц или же полного копирования сайта на жесткий диск.
Модуль обладает такими полезными методами как:
* save\_webpage() - для сохранения одной страницы;
* save\_website() - позволяет копировать сайт целиком.
Как предупреждают разработчики используйте save\_website() аккуратно, т.к метод отправляет множество запросов, что может повлечь за собой значительную нагрузку на сервер.
Итак, не будем тянуть и приступим к коду. Сначала скачаем необходимые библиотеки:
```
pip install pywebcopy
```
```
pip install validators
```
Теперь приступаем к написанию скрипта. Для начала импортируем заранее установленные библиотеки:
```
from pywebcopy import save_webpage, save_website
import validators
```
Теперь напишем блоки, которые будут скачивать весь веб-сайт или его отдельную страницу:
```
def webpage(url, folder, name):
save_webpage(
url=url,
project_folder=folder,
project_name=name,
bypass_robots=True,
debug=True,
open_in_browser=True,
delay=None,
threaded=False,
)
def website(url, folder, name):
save_website(
url=url,
project_folder=folder,
project_name=name,
bypass_robots=True,
debug=True,
open_in_browser=True,
delay=None,
threaded=False,
)
```
Блок webpage скачивает отдельную страницу сайта по ссылке **url** в папку **folder** и называет папку с сайтом **name.** Блок website скачивает весь сайт, а не его отдельную страницу.
Теперь напишем блок, который будет выводить текст красного цвета в терминал, для вывода ошибок.
```
def warning(text):
print("\033[1m\033[31m{}\033[0m".format(text))
```
Теперь соединяем всё это вместе:
```
print("""Выберите цифру:
1 - Сохранить страницу
2 - Сохранить сайт""")
b=False
while b==False:
try:
a = int(input())
if a==1 or a==2:
b=True
else:
warning("Выберите корректный номер!")
except:
warning("Только цифры!")
c=False
while c==False:
url = input("Введите ссылку: ")
if validators.url(url):
c=True
else:
warning("Некорректная ссылка!")
folder=input("Куда сохранять: ")
name=input("Название проекта: ")
if a==1:
webpage(url, folder, name)
else:
website(url, folder, name)
```
В этом куске кода мы просим пользователя выбрать один из вариантов, или скачать весь сайт или только одну его страницу. Потом делаем проверку того, что пользователь ввел цифру, и что это число равно 1 либо 2. Потом с помощью библиотеки validators проверяем корректность введённой пользователем ссылки, если такая ссылка существует, то просим пользователя ввести путь к папке в которую будет сохранен сайт. А потом просим ввести название проекта. После чего, если все данные введены верно, то начинается закачка сайта на Ваш компьютер.
Ну вроде бы всё. Теперь Вы можете скачивать любой сайт к себе на компьютер. Но будьте окуратны с этим скриптом, так как если попытаться скачать весь сайт YouTube, то комп просто ляжет от огромного размера данных. Удачи!
Вот весь исходный код данного скрипта:
```
from pywebcopy import save_webpage, save_website
import validators
def warning(text):
print("\033[1m\033[31m{}\033[0m".format(text))
def webpage(url, folder, name):
save_webpage(
url=url,
project_folder=folder,
project_name=name,
bypass_robots=True,
debug=True,
open_in_browser=True,
delay=None,
threaded=False,
)
def website(url, folder, name):
save_website(
url=url,
project_folder=folder,
project_name=name,
bypass_robots=True,
debug=True,
open_in_browser=True,
delay=None,
threaded=False,
)
print("""Выберите цифру:
1 - Сохранить страницу
2 - Сохранить сайт""")
b=False
while b==False:
try:
a = int(input())
if a==1 or a==2:
b=True
else:
warning("Выберите корректный номер!")
except:
warning("Только цифры!")
c=False
while c==False:
url = input("Введите ссылку: ")
if validators.url(url):
c=True
else:
warning("Некорректная ссылка!")
folder=input("Куда сохранять: ")
name=input("Название проекта: ")
if a==1:
webpage(url, folder, name)
else:
website(url, folder, name)
``` | https://habr.com/ru/post/669766/ | null | ru | null |
# Руководство разработчика Prism — часть 3, управление зависимостями между компонентами
> **Оглавление**
>
> 1. [Введение](http://habrahabr.ru/post/176851/)
> 2. [Инициализация приложений Prism](http://habrahabr.ru/post/176853/)
> 3. [Управление зависимостями между компонентами](http://habrahabr.ru/post/176861/)
> 4. [Разработка модульных приложений](http://habrahabr.ru/post/176863/)
> 5. [Реализация паттерна MVVM](http://habrahabr.ru/post/176867/)
> 6. [Продвинутые сценарии MVVM](http://habrahabr.ru/post/176869/)
> 7. [Создание пользовательского интерфейса](http://habrahabr.ru/post/176895/)
>
> 1. [Рекомендации по разработке пользовательского интерфейса](http://habrahabr.ru/post/177925/)
> 8. [Навигация](http://habrahabr.ru/post/178009/)
> 1. [Навигация на основе представлений (View-Based Navigation)](http://habrahabr.ru/post/182052/)
> 9. [Взаимодействие между слабо связанными компонентами](http://habrahabr.ru/post/182580/)
>
Приложения, созданные с помощью библиотеки Prism, обычно являются составными приложениями, потенциально состоящими из слабо связанных служб и компонентов. Они должны взаимодействовать друг с другом так, чтобы предоставлять содержание пользовательскому интерфейсу и получать уведомления о действиях пользователя. Поскольку они слабо связаны, им необходим способ взаимодействия, без которого необходимая функциональность не сможет быть получена.
Для связи всех частей воедино, Prism приложения полагаются на DI контейнер. DI контейнеры уменьшают зависимости между объектами, предоставляя способ создания экземпляров классов и управления их временем жизни в зависимости от конфигурации контейнера. При создании объектов с помощью контейнера, он инжектирует в них необходимые зависимости. Если зависимости ещё не были созданы, то контейнер в начале создаёт их и разрешает их собственные зависимости. В некоторых случаях, сам контейнер внедряется как зависимость. Например, при использовании Unity, в модули внедряется контейнер для того, чтобы они могли зарегистрировать в нём свои представления и службы.
Есть несколько преимуществ использования контейнера:
* Контейнер устраняет потребность компонента определять местоположение его зависимостей или управлять временем их жизни.
* Контейнер позволяет заменять реализации, не влияя на компоненты.
* Контейнер облегчает тестируемость, позволяя внедрять в объекты фальшивые зависимости.
* Контейнер упрощает обслуживание, позволяя легко добавлять к системе новые компоненты.
В контексте приложения, основанного на библиотеке Prism, есть определённые преимущества использования контейнера:
* Контейнер разрешает зависимости модуля при его загрузке.
* Контейнер используется для регистрации и создания моделей представления и представлений.
* Контейнер может создавать модели представления и внедрять представления.
* Контейнер внедряет службы составного приложения, такие как менеджер регионов, или агрегатор событий.
* Контейнер используется для регистрации специфичных для модуля служб со специфичной для модуля функциональностью.
> **Заметка**
>
> Некоторые примеры в руководстве Prism используют контейнер Unity Application Block (Unity). Другие, например *Modularity QuickStarts*, используют Managed Extensibility Framework (MEF). Библиотека самого Prism не зависима от применяемого контейнера, и вы можете использовать её службы и паттерны с другими контейнерами, такими как CastleWindsor, Autofac, Structuremap, Spring.NET, или с любым другим.
### Ключевое решение: выбор контейнера внедрения зависимостей
Библиотека Prism предоставляет два DI контейнера по умолчанию: Unity и MEF. Prism расширяема, таким образом вы можете использовать другие контейнеры, написав небольшое количество кода для их адаптации. И Unity, и MEF обеспечивают одинаковую основную функциональность, необходимую для внедрения зависимостей, даже учитывая то, что они работают сильно по-разному. Некоторые из возможностей, предоставляемые обоими контейнерами:
* Оба позволяют регистрировать типы в контейнере.
* Оба позволяют регистрировать экземпляры в контейнере.
* Оба позволяют принудительно создавать экземпляры зарегистрированных типов.
* Оба внедряют экземпляры зарегистрированных типов в конструкторы.
* Оба внедряют экземпляры зарегистрированных типов в свойства.
* У них обоих есть декларативные атрибуты для управления типами и зависимостями.
* Они оба разрешают зависимости в графе объектов.
Unity предоставляет несколько возможностей, которых нет в MEF:
* Разрешает конкретные типы без регистрации.
* Разрешает открытые обобщения (*Generics*).
* Может использовать перехват вызова методов для добавления дополнительной функциональности к целевому объекту (*Interception*).
MEF предоставляет несколько возможностей, которых нет в Unity:
* Самостоятельно обнаруживает сборки в каталоге файловой системы.
* Загружает XAP файлы и ищет в них сборки.
* Проводит рекомпозицию свойств и коллекций при обнаружении новых типов.
* Автоматически экспортирует производные типы.
* Поставляется вместе с .NET Framework, начиная с четвёртой версии.
Контейнеры различаются по возможностям и работают по-разному, но библиотека Prism может работать с любым контейнером, обеспечивая одинаковую функциональность. Рассматривая, какой контейнер использовать, имейте в виду свой предыдущий опыт и определите, какой контейнер лучше подходит для сценариев вашего приложения.
### Соображения по использованию контейнера
Что следует рассмотреть перед использованием контейнеров:
* Рассмотрите, уместно ли регистрировать и разрешать компоненты, используя контейнер:
+ Рассмотрите, является ли воздействие на производительность при регистрации в контейнере и разрешении экземпляров, приемлемым для вашего случая. Например, если вы должны создать 10000 многоугольников, чтобы нарисовать что-то внутри метода отрисовки, то создание всех многоугольников через контейнер может привести к существенной потере производительности.
> **Заметка.**
>
> Некоторые контейнеры способны разрешать экземпляры объектов почти так же быстро, как и их создание через ключевое слово new. Но, в любом случае, разрешение через контейнер большого количества объектов в цикле, должно быть серьёзно обосновано.
>
>
+ Если присутствует множество глубоких зависимостей, то затраты по времени на их разрешение могут существенно возрасти.
+ Если компонент не имеет зависимостей или сам не является зависимостью для других типов, возможно, не имеет смысла пользоваться контейнером при его создании, или помещать его в контейнер, соответственно.
+ Если у компонента есть единственный набор зависимостей, которые являются неотъемлемой его частью и никогда не будут изменяться, возможно, не имеет смысла пользоваться контейнером при его создании. Хотя, в этом случае, его тестирование может усложниться.
* Рассмотрите, должен ли компонент быть зарегистрирован как синглтон, или как экземпляр:
+ Если компонент является глобальной службой, которая действует как менеджер единственного ресурса, например служба протоколирования, то можно зарегистрировать его как синглтон.
+ Если компонент даёт доступ к общему состоянию многочисленным потребителям, то его можно зарегистрировать как синглтон.
+ Если объект нуждается в создании нового экземпляра каждый раз при внедрении, то его нельзя регистрировать как синглтон. Например, каждое представление, вероятно, нуждается в новом экземпляре модели представления.
* Рассмотрите, хотите ли вы конфигурировать контейнер в коде или через файл конфигурации:
+ Если вы хотите централизованно управлять всеми службами, используйте файл конфигурации.
+ Если вы хотите регистрировать различные службы в зависимости от каких-либо обстоятельств, конфигурируйте контейнер в коде.
+ Если у вас есть службы уровня модуля, конфигурируйте контейнер через код так, чтобы они были зарегистрированы только при загрузке модуля.
> **Заметка**
>
> Некоторые контейнеры, такие как MEF, не могут быть сконфигурированы через конфигурационный файл и должны быть сконфигурированы в коде.
### Базовые сценарии
Контейнеры используются для двух основных целей, а именно: регистрация и разрешение.
#### Регистрация
Прежде, чем можно будет внедрить зависимости в объект, типы зависимостей должны быть зарегистрированы в контейнере. Регистрация типа обычно включает передачу контейнеру интерфейса и конкретного типа, который реализует этот интерфейс. Есть, прежде всего, два способа регистрации типов и объектов: в коде, или через файл конфигурации. Детали реализации могут изменяться в зависимости от контейнера.
Как правило, есть два способа зарегистрировать типы и объекты в контейнере в коде:
* Можно зарегистрировать тип, или отображение одного типа в другой. В подходящее время контейнер создаст экземпляр типа, который вы задали.
* Можно зарегистрировать существующий экземпляр объекта, как синглтон. Контейнер возвратит ссылку на существующий объект.
##### Регистрация типов в *UnityContainer*
Во время инициализации, тип может зарегистрировать другие типы, такие как представления и службы. Регистрация позволяет разрешать их зависимости контейнером и стать доступными другим типам. Чтобы сделать это, необходимо внедрить контейнер в конструктор модуля. Следующий код показывает, как `OrderModule` из *Commanding QuickStart* регистрирует тип репозитория при инициализации, как синглтон.
```
public class OrderModule : IModule {
public void Initialize() {
this.container.RegisterType(new ContainerControlledLifetimeManager());
...
}
...
}
```
В зависимости от того, какой контейнер вы используете, регистрация может также быть выполнена вне кода через файл конфигурации. Для примера смотрите, «Registering Modules using a Configuration File» в Главе 4, "[Modular Application Development](http://msdn.microsoft.com/en-us/library/gg405479(v=PandP.40).aspx)."
##### Регистрация типов с контейнером MEF
Для регистрации типов в контейнере, MEF использует систему, основанную на атрибутах. В результате довольно легко добавить регистрацию типа к контейнеру: для этого требуется добавить атрибут `[Export]` к типу, который вы хотите зарегистрировать в контейнере, как показано в следующем примере.
```
[Export(typeof(ILoggerFacade))]
public class CallbackLogger: ILoggerFacade {
...
}
```
Другим вариантом использования MEF, может быть создание экземпляра класса и регистрация именно этого экземпляра в контейнере. `QuickStartBootstrapper` в *Modularity for Silverlight with MEF QuickStart* показывает пример этого в методе `ConfigureContainer`.
```
protected override void ConfigureContainer() {
base.ConfigureContainer();
// Поскольку мы создали CallbackLogger, и он должен использоваться сразу,
// мы проводим его композицию, чтобы удовлетворить любой импорт (зависимость), который он имеет.
this.Container.ComposeExportedValue(this.callbackLogger);
}
```
> **Заметка**
>
> При использовании MEF как контейнера рекомендуется использование именно атрибутов для регистрации типов.
#### Разрешение
После того, как тип зарегистрирован, он может быть разрешён или внедрён как зависимость. Когда тип разрешается, и контейнер должен создать новый экземпляр этого типа, то он внедряет зависимости в этот экземпляр.
Вообще, когда тип разрешается, происходит одна из трёх вещей:
* Если тип не был зарегистрирован, контейнер выдаёт исключение.
> **Заметка**
>
> Некоторые контейнеры, включая Unity, позволяют разрешать конкретный тип, который не был зарегистрирован.
* Если тип был зарегистрирован как синглтон, контейнер возвращает экземпляр синглтона. Если это первый вызов, контейнер может создать экземпляр и сохранить его для будущих вызовов.
* Если тип не был зарегистрирован как синглтон, контейнер возвращает новый экземпляр.
> **Заметка**
>
> По умолчанию, типы, зарегистрированные в MEF, являются синглтонами, и контейнер хранит ссылки на объекты. В Unity, по умолчанию, возвращаются новые экземпляры объектов, и контейнер не сохраняет на них ссылок.
##### Разрешение экземпляров в Unity
Следующий пример кода из *Commanding QuickStart* показывает, как представления `OrdersEditorView` и `OrdersToolBar` разрешаются из контейнера для привязки их к соответствующим регионам.
```
public class OrderModule : IModule {
public void Initialize() {
this.container.RegisterType(new ContainerControlledLifetimeManager());
// Показываем представление Orders Editor в главном регионе оболочки.
this.regionManager.RegisterViewWithRegion("MainRegion",
() =>; this.container.Resolve());
// Показываем представление Orders Toolbar в регионе панели инструментов.
this.regionManager.RegisterViewWithRegion("GlobalCommandsRegion",
() => this.container.Resolve());
}
...
}
```
Конструктор `OrdersEditorPresentationModel` содержит следующие зависимости (репозиторий заказов и прокси команды заказов), которые вводятся при его разрешении.
```
public OrdersEditorPresentationModel(IOrdersRepository ordersRepository, OrdersCommandProxy commandProxy) {
this.ordersRepository = ordersRepository;
this.commandProxy = commandProxy;
// Создание фиктивных данных о заказе.
this.PopulateOrders();
// Инициализация CollectionView для основной коллекции заказов.
#if SILVERLIGHT
this.Orders = new PagedCollectionView( _orders );
#else
this.Orders = new ListCollectionView( _orders );
#endif
// Отслеживание текущего выбора.
this.Orders.CurrentChanged += SelectedOrderChanged;
this.Orders.MoveCurrentTo(null);
}
```
В дополнение к внедрению в конструктор, как показано в предыдущем примере, Unity также может внедрять зависимости в свойства. Любые свойства, к которым применён атрибут `[Dependency]`, автоматически разрешаются и внедряются, при разрешении объекта. Если свойство помечено атрибутом `OptionalDependency`, то при невозможности разрешить зависимость, свойству присваивается `null` и исключение не генерируется.
##### Разрешение экземпляров в MEF
Следующий пример кода показывает, как `Bootstrapper` в *Modularity for Silverlight with MEF QuickStart* получает экземпляр оболочки. Вместо того чтобы запросить конкретный тип, код мог бы запросить экземпляр интерфейса.
```
protected override DependencyObject CreateShell() {
return this.Container.GetExportedValue();
}
```
В любом классе, который разрешается MEF, можно также использовать инжекцию в конструктор, как показано в следующем примере кода из `ModuleA` в *Modularity for Silverlight with MEF QuickStart*, у которого внедряются `ILoggerFacade` и `IModuleTracker`.
```
[ImportingConstructor]
public ModuleA(ILoggerFacade logger, IModuleTracker moduleTracker) {
if (logger == null) {
throw new ArgumentNullException("logger");
}
if (moduleTracker == null) {
throw new ArgumentNullException("moduleTracker");
}
this.logger = logger;
this.moduleTracker = moduleTracker;
this.moduleTracker.RecordModuleConstructed(WellKnownModuleNames.ModuleA);
}
```
С другой стороны, можно использовать инжекцию свойства, как показано в классе `ModuleTracker` из *Modularity for Silverlight with MEF QuickStart*, у которого есть экземпляр внедряемого `ILoggerFacade`.
```
[Export(typeof(IModuleTracker))]
public class ModuleTracker : IModuleTracker {
// Из-за ограничений Silverlight/MEF, поле должно быть общедоступно.
[Import] public ILoggerFacade Logger;
}
```
> **Заметка**
>
> В Silverlight импортируемые свойства и поля должны быть общедоступными.
### Использование контейнеров внедрения зависимостей и служб в Prism
Контейнеры внедрения зависимости, используются, чтобы удовлетворить зависимости между компонентами. Удовлетворение этих зависимостей обычно включает регистрацию и разрешение. Библиотека Prism предоставляет поддержку для контейнеров Unity и MEF, но не зависит от них. Поскольку библиотека имеет доступ к контейнеру через интерфейс `IServiceLocator`, контейнер может быть легко заменён. Чтобы сделать это, вы должны реализовать интерфейс `IServiceLocator`. Обычно, если вы замените контейнер, то вы должны будете также написать свой собственный контейнерно-специфичный загрузчик. Интерфейс `IServiceLocator` определяется в *Common Service Locator Library*. Это open source проект по обеспечению абстракции контейнеров IoC (Inversion of Control), таких как контейнеры внедрения зависимостей, и локаторы службы. Цель использования этой библиотеки состоит в том, чтобы использовать IoC и Service Location, без предоставления определённой реализации контейнера.
Библиотека Prism предоставляет `UnityServiceLocatorAdapter` и `MefServiceLocatorAdapter`. Оба адаптера реализуют интерфейс `ISeviceLocator`, расширяя тип `ServiceLocatorImplBase`. Следующая иллюстрация показывает иерархию классов.
Хотя библиотека Prism не ссылается и не полагается на определённый контейнер, для приложения характерно использовать вполне конкретный DI контейнер. Это означает, что для приложения разумно ссылаться на определённый контейнер, но библиотека Prism не ссылается на контейнер непосредственно. Например, приложение *Stock Trader RI* и несколько из QuickStarts, используют Unity в качестве контейнера. Другие примеры и QuickStarts используют MEF.
### IServiceLocator
Следующий код показывает интерфейс `IServiceLocator` и его методы.
```
public interface IServiceLocator : IServiceProvider {
object GetInstance(Type serviceType);
object GetInstance(Type serviceType, string key);
IEnumerable GetAllInstances(Type serviceType);
TService GetInstance();
TService GetInstance(string key);
IEnumerable GetAllInstances();
}
```
Service Locator дополняет библиотеку Prism методами расширения, показанными в следующем коде. Можно увидеть, что `IServiceLocator` используется только для разрешения, а не для регистрации.
```
public static class ServiceLocatorExtensions {
public static object TryResolve(this IServiceLocator locator, Type type) {
try {
return locator.GetInstance(type);
}
catch (ActivationException) {
return null;
}
}
public static T TryResolve(this IServiceLocator locator) where T: class {
return locator.TryResolve(typeof(T)) as T;
}
}
```
Метод расширения `TryResolve`, который контейнер Unity не поддерживает, возвращает экземпляр типа, который должен быть разрешён, если он было зарегистрирован, иначе он возвращает `null`.
`ModuleInitializer` использует `IServiceLocator` для того, чтобы разрешить зависимости модуля во время его загрузки, как показано в следующих примерах кода.
```
IModule moduleInstance = null;
try {
moduleInstance = this.CreateModule(moduleInfo);
moduleInstance.Initialize();
}
...
```
```
protected virtual IModule CreateModule(string typeName) {
Type moduleType = Type.GetType(typeName);
if (moduleType == null) {
throw new ModuleInitializeException(string.Format(CultureInfo.CurrentCulture, Properties.Resources.FailedToGetType, typeName));
}
return (IModule)this.serviceLocator.GetInstance(moduleType);
}
```
### Соображения по использованию *IServiceLocator*
`IServiceLocator` не предназначается для использования в качестве контейнера общего назначения. У контейнеров может быть различная семантика использования, которая часто влияет на выбор контейнера. Принимая это во внимание, *Stock Trader RI* использует контейнер внедрения зависимости непосредственно вместо того, чтобы использовать `IServiceLocator`. Это является рекомендованным подходом при разработке приложений.
В следующих ситуациях использование `IServiceLocator` является уместным:
* Вы — независимый поставщик программного обеспечения (ISV), разрабатывающий стороннюю службу, которая должна поддерживать различные контейнеры.
* Вы разрабатываете службу, которая будет использоваться в организации, где используются различные контейнеры.
### Дополнительная информация
Для получения информации, связанной с DI контейнерами, смотрите:
* «Unity Application Block» on MSDN:<http://www.msdn.com/unity>
* Unity community site on CodePlex:<http://www.codeplex.com/unity>
* «Managed Extensibility Framework Overview» on MSDN:<http://msdn.microsoft.com/en-us/library/dd460648.aspx>
* MEF community site on CodePlex:<http://mef.codeplex.com/>
* «Inversion of Control containers and the Dependency Injection pattern» on Martin Fowler's website:<http://www.martinfowler.com/articles/injection.html>
* «Design Patterns: Dependency Injection» in *MSDN Magazine*:<http://msdn.microsoft.com/en-us/magazine/cc163739.aspx>
* «Loosen Up: Tame Your Software Dependencies for More Flexible Apps» in *MSDN Magazine*:<http://msdn.microsoft.com/en-us/magazine/cc337885.aspx>
* Castle Project:<http://www.castleproject.org/container/index.html>
* StructureMap:<http://structurcodeap.sourceforge.net/Default.htm>
* Spring.NET:<http://www.springframework.net/> | https://habr.com/ru/post/176861/ | null | ru | null |
# C++. Убираем приватные поля из описания класса или немного дурачества
Всем привет! Решил на выходных продолжить писать свой домашний проект и наступила пора реализовать платформозависимый код. Самым простым вариантом было бы описать классы в \*.h файле, а в зависимости от платформы, закрытые поля засунуть под #define. При этом, саму реализацию по конкретным платформам разнести по \*.cpp файлам и включать их в компиляцию в зависимости от текущей платформы. Но... мне не нравится как выглядит описание класса с #define, поэтому я решил убрать препроцессор и оставить в описании класса только интерфейс. И да, я не пользовался абстрактными классами и pimpl, всё еще хуже :-)
ДисклеймерОсновной язык автора С.
Данный материал не несет в себе цель оскорбить или еще как-то нанести вред приверженцам чистого кода. Также автор не претендует на новизну, поскольку идея, по сути, тривиальна. Информация предоставлена исключительно потому как автор посчитал ее забавной.
Продолжим. Какие варианты здесь приходят сразу на ум. У меня два:
1. Использовать абстрактный класс с виртуальными методами, затем наследовать его и реализовать эти методы. Добавить статичный метод для создания конкретного экземпляра.
2. Воспользоваться техникой pimpl (**P**ointer to **Impl**ementation), когда в исходном классе только указатель на другой класс/структуру, который(ая) реализует требуемый функционал или содержит поля с данными.
Первый вариант мне не нравится поскольку на ровном месте создается ненужная дополнительная нагрузка (тот самый overhead) в виде таблицы виртуальный методов. По сути это указатели на функции. Возможно при некой оптимизации какой-нибудь компилятор додумается оптимизировать вызовы, возможно.
Второй вариант тоже не нравится, ибо для доступа к полям скрытого класса нужно каждый раз считать еще одно смещение. К тому же здесь есть дополнительная нагрузка в виде вызова new/malloc для скрытого класса/структуры.
Как бы было проще если можно было бы так
```
// A.h
class A
{
private:
static const size_t _sizeofdata;
unsigned char _data[_sizeofdata];
};
// A.cpp
struct LinuxSpecifiecData
{
int a, b, c;
};
const size_t A::_sizeofdata = sizeof(LinuxSpecifiecData);
```
Но ясен пень так нельзя
И тут я подумал, а можно ли реализовать класс, который будет без этих дополнительных нагрузок и при этом не надо будет в описании класса декларировать закрытые поля. Тут я задумался как бы я сделал это на чистом С и у меня возникла идея. Экстремально простая. Естественно, не без минусов, но об этом позже.
***Необходимо при вызове new для класса выделять память для другого (скрытого) класса, ну или структуры*.** К примеру имеется у нас описание класса со следующими методами (файл Render.h):
```
class Render
{
public:
void clear();
void present();
void clipRegion(int x, int y, int width, int height);
void drawLine(int x1, int y1, int x2, int y2, unsigned int color);
void drawRectangle(
int x, int y, int width, int height,
unsigned int cornerRadius,
unsigned int solidColor, unsigned int borderColor);
void drawPicture(int x, int y, int width, int height, int pictureIndex);
void drawText(
int x, int y, int width, int height,
int fontIndex,
const char *text, unsigned int textLength,
unsigned int foregroundColor, unsigned int backgroundColor);
};
```
У каждой платформы своя реализация и свои закрытые поля у этого класса, но объявлять мы их здесь не будем. Лучше объявим их в новой структуре в исходном файле, к примеру LinuxRender.cpp:
```
...
struct LinuxRenderData
{
int a, b, c;
};
...
```
Теперь переопределим для класса Render операторы new и delete.
```
// Render.h
class Render
{
public:
...
void *operator new(std::size_t size);
void operator delete(void *ptr);
...
};
// LinuxRender.cpp
...
void *Render::operator new(std::size_t size) {
return malloc(sizeof(LinuxRenderData));
}
void Render::operator delete(void *ptr) {
free(ptr);
}
...
```
Теперь у нас при создании экземпляра объекта выделяется память для скрытой структуры. И мы можем использовать данные этой структуры в методах класса Render. К примеру добавим метод initialize.
```
// Render.h
class Render
{
public:
...
int initialize();
...
};
// LinuxRender.cpp
...
int Render::initialize() {
LinuxRenderData *pdata = (LinuxRenderData *)this;
pdata->a = pdata->b = pdata->c = 0;
return 0;
}
...
```
Вот собственно и вся идея. Но, воскликнет читатель, что будет если класс Render будет создан не через new, а, к примеру, в стеке или глобально. И тут начинаются минусы. Тут я скажу что всё сломается) Ибо sizeof(Render) будет 1, поскольку полей класс Render не имеет. Лепим костыли. Поэтому надо запретить создавать класс не через new. Для этого делаем конструкторы закрытыми. А также создадим статичный метод create для создания экземпляров класса.
```
// Render.h
class Render
{
public:
static Render *create();
...
private:
Render();
Render(const Render &);
...
};
// LinuxRender.cpp
...
Render *Render::create() {
return new Render();
}
...
```
Здесь можно добавить ещё один костыль в виде статичного метода sizeOf, ибо sizeof не будет выдавать правильное значение.
```
// Render.h
class Render
{
public:
static size_t sizeOf();
...
};
// LinuxRender.cpp
...
size_t Render::sizeOf() {
return sizeof(LinuxRenderData);
}
...
```
Итоги
-----
Я, конечно, получил что хотел. Но здесь есть минусы:
1. Автоматически вычисленные фишки компилятора, такие как sizeof или еще какие-либо операции над типом работать не будут. И тут надо четко понимать что вы делаете, ибо можно выстрелить себе во все места на ровном месте.
2. Необходимость переопределять для каждого класса оператор new
3. Нельзя выделять память под экземпляр объекта без new (по умолчанию, стек, глобальная память работать не будут)
4. Необходимость создания метода для каждого подобного класса, который будет создавать экземпляр этого класса
5. Еще не очень удобно в каждом методе класса приводить тип к скрытому классу/структуре (LinuxRenderData \*pdata = (LinuxRenderData \*)this)
Поэтому не рекомендую пользоваться никому. Рассматривайте статью как запоздалый пятничный юмор :-) | https://habr.com/ru/post/676058/ | null | ru | null |
# Chosen: сделай выпадающие списки более дружественными
Плагин Chosen создан для оформления красивых и удобных выпадающих списков с помощью jQuery и Prototype. Для установки плагина достаточно просто скачать [файлы](https://github.com/harvesthq/chosen) и прописать одну строчку:
```
$(".chzn-select").chosen()
```
(версия для jQuery)
По умолчанию в Chosen вместо длинного текстового списка предлагается поле, по нажатию на которое появляется список. Поддерживается автодополнение ввода, выбор нескольких пунктов меню, элемент *optgroup* и др. Выглядит вполне нативно. В общем, [лучше один раз увидеть](http://harvesthq.github.com/chosen/).
Поскольку Chosen заменяет стандартный элемент HTML, то не нужно беспокоиться, как он работает с браузерами без поддержки JavaScript. Также не нужно ничего менять в бэкенде: формы сабмиттятся как обычно, изменения только в пользовательском интерфейсе.
**Некоторые форки:**
[Chosen для MooTools](https://github.com/julesjanssen/chosen)
[Модуль Chosen для Drupal 7](https://github.com/Polzme/chosen) | https://habr.com/ru/post/124899/ | null | ru | null |
# Выгружаем данные в Excel. Цивилизованно
Есть в IT-отрасли задачи, которые на фоне успехов в *big data*, *machine learning*, *blockchain* и прочих модных течений выглядят совершенно непривлекательно, но на протяжении десятков лет не перестают быть актуальными для целой армии разработчиков. Речь пойдёт о старой как мир задаче формирования и выгрузки Excel-документов, с которой сталкивался каждый, кто когда-либо писал приложения для бизнеса.
Какие возможности построения файлов Excel существуют в принципе?
1. VBA-макросы. В наше время по соображениям безопасности идея использовать макросы чаще всего не подходит.
2. Автоматизация Excel внешней программой через API. Требует наличия Excel на одной машине с программой, генерирующей Excel-отчёты. Во времена, когда клиенты были толстыми и писались в виде десктопных приложений Windows, такой способ годился (хотя не отличался скоростью и надёжностью), в нынешних реалиях это с трудом достижимый случай.
3. Генерация XML-Excel-файла напрямую. Как известно, Excel поддерживает XML-формат сохранения документа, который потенциально можно сгенерировать/модифицировать с помощью любого средства работы с XML. Этот файл можно сохранить с расширением .xls, и хотя он, строго говоря, при этом не является xls-файлом, Excel его хорошо открывает. Такой подход довольно популярен, но к недостаткам следует отнести то, что всякое решение, основанное на прямом редактировании XML-Excel-формата, является одноразовым «хаком», лишенным общности.
4. Наконец, возможна генерация Excel-файлов с использованием open source библиотек, из которых особо известна [Apache POI](https://poi.apache.org/). Разработчики Apache POI проделали титанический труд по reverse engineering бинарных форматов документов MS Office, и продолжают на протяжении многих лет поддерживать и развивать эту библиотеку. Результат этого reverse engineering-а, например, [используется](https://poi.apache.org/#Mission+Statement) в Open Office для реализации сохранения документов в форматах, совместимых с MS Office.
На мой взгляд, именно последний из способов является сейчас предпочтительным для генерации MS Office-совместимых документов. С одной стороны, он не требует установки никакого проприетарного ПО на сервер, а с другой стороны, предоставляет богатый API, позволяющий использовать все функциональные возможности MS Office.
Но у прямого использования Apache POI есть и недостатки. Во-первых, это Java-библиотека, и если ваше приложение написано не на одном из JVM-языков, вы ей вряд ли сможете воспользоваться. Во-вторых, это низкоуровневая библиотека, работающая с такими понятиями, как «ячейка», «колонка», «шрифт». Поэтому «в лоб» написанная процедура генерации документа быстро превращается в обильную «лапшу» трудночитаемого кода, где отсутствует разделение на модель данных и представление, трудно вносить изменения и вообще — боль и стыд. И прекрасный повод делегировать задачу самому неопытному программисту – пусть ковыряется.
Но всё может быть совершенно иначе. Проект [Xylophone](https://github.com/CourseOrchestra/xylophone) под лицензией LGPL, построенный на базе Apache POI, основан на идее, которая имеет примерно 15-летнюю историю. В проектах, где я участвовал, он использовался в комбинации с самыми разными платформами и языками – а счёт разновидностей форм, сделанных с его помощью в самых разнообразных проектах, идёт, наверное, уже на тысячи. Это Java-проект, который может работать как в качестве утилиты командной строки, так и в качестве библиотеки (если у вас код на JVM-языке — вы можете [подключить](https://search.maven.org/search?q=g:ru.curs%20AND%20a:xylophone&core=gav) её как Maven-зависимость).
Xylophone реализует принцип отделения модели данных от их представления. В процедуре выгрузки необходимо сформировать данные в формате XML (не беспокоясь о ячейках, шрифтах и разделительных линиях), а Xylophone, при помощи Excel-шаблона и дескриптора, описывающего порядок обхода вашего XML-файла с данными, сформирует результат, как показано на диаграмме:
Шаблон документа (xls/xlsx template) выглядит примерно следующим образом:
Как правило, заготовку такого шаблона предоставляет сам заказчик. Вовлечённый заказчик с удовольствием принимает участие в создании шаблона: начиная с выбора нужной формы из «Консультанта» или придумывания собственной с нуля, и заканчивая размерами шрифтов и ширинами разделительных линий. Преимущество шаблона в том, что мелкие правки в него легко вносить уже тогда, когда отчёт полностью разработан.
Когда «оформительская» работа выполнена, разработчику остаётся
1. Создать процедуру выгрузки необходимых данных в формате XML.
2. Создать дескриптор, описывающий порядок обхода элементов XML-файла и копирования фрагментов шаблона в результирующий отчёт
3. Обеспечить привязку ячеек шаблона к элементам XML-файла с помощью [XPath](https://www.w3schools.com/xml/xpath_intro.asp)-выражений.
С выгрузкой в XML всё более-менее понятно: достаточно выбрать адекватное XML-представление данных, необходимых для заполнения формы. Что такое дескриптор?
Если бы в форме, которую мы создаём, не было повторяющихся элементов с разным количеством (таких, как строки накладной, которых разное количество у разных накладных), то дескриптор выглядел бы следующим образом:
```
```
Здесь root – название корневого элемента нашего XML-файла с данными, а диапазон A1:Z100 – это прямоугольный диапазон ячеек из шаблона, который будет скопирован в результат. При этом, как можно видеть из предыдущей иллюстрации, подстановочные поля, значения которых заменяются на данные из XML-файла, имеют формат `~{XPath-выражение}` (тильда, фигурная скобка, XPath-выражение относительно текущего элемента XML, закрывающая фигурная скобка).
Что делать, если в отчёте нам нужны повторяющиеся элементы? Естественным образом их можно представить в виде элементов XML-файла с данными, а помочь проитерировать по ним нужным образом помогает дескриптор. Повторение элементов в отчёте может иметь как вертикальное направление (когда мы вставляем строки накладной, например), так и горизонтальное (когда мы вставляем столбцы аналитического отчёта). При этом мы можем пользоваться вложенностью элементов XML, чтобы отразить сколь угодно глубокую вложенность повторяющихся элементов отчёта, как показано на диаграмме:
Красными квадратиками отмечены ячейки, которые будут являться левым верхним углом очередного прямоугольного фрагмента, который пристыковывает генератор отчёта.
Есть и ещё один возможный вариант повторяющихся элементов: листы в книге Excel. Возможность организовать такую итерацию тоже имеется.
Рассмотрим чуть более сложный пример. Допустим, нам надо получить сводный отчёт наподобие следующего:
Пусть диапазон лет для выгрузки выбирает пользователь, поэтому в этом отчёте динамически создаваемыми являются как строки, так и столбцы. XML-представление данных для такого отчёта может выглядеть следующим образом:
**testdata.xml**
```
xml version="1.0" encoding="UTF-8"?
```
Мы вольны выбирать названия тэгов по своему вкусу, структура также может быть произвольной, но с оглядкой на простоту конвертации в отчёт. Например, выводимые на лист значения я обычно записываю в атрибуты, потому что это упрощает XPath-выражения (удобно, когда они имеют вид `@имяатрибута`).
Шаблон такого отчёта будет выглядеть так (сравните XPath-выражения с именами атрибутов соответствующих тэгов):
Теперь наступает самая интересная часть: создание дескриптора. Т. к. это практически полностью динамически собираемый отчёт, дескриптор довольно сложен, на практике (когда у нас есть только «шапка» документа, его строки и «подвал») всё обычно гораздо проще. Вот какой в данном случае необходим дескриптор:
**descriptor.xml**
```
xml version="1.0" encoding="UTF-8"?
```
Полностью элементы дескриптора описаны в [документации](https://corchestra.ru/wiki/index.php?title=Xylophone). Вкратце, основные элементы дескриптора означают следующее:
* **element** — переход в режим чтения элемента XML-файла. Может или являться корневым элементом дескриптора, или находиться внутри `iteration`. С помощью атрибута `name` могут быть заданы разнообразные фильтры для элементов, например
+ `name="foo"` — элементы с именем тэга foo
+ `name="*"` — все элементы
+ `name="tagname[@attribute='value']"` — элементы с определённым именем и значением атрибута
+ `name="(before)"`, `name="(after)"` — «виртуальные» элементы, предшествующие итерации и закрывающие итерацию.
* **iteration** — переход в режим итерации. Может находиться только внутри `element`. Могут быть выставлены различные параметры, например
+ `mode="horizontal"` — режим вывода по горизонтали (по умолчанию — vertical)
+ `index=0` — ограничить итерацию только самым первым встреченным элементом
* **output** — переход в режим вывода. Основные атрибуты следующие:
+ `sourcesheet` —лист книги шаблона, с которого берётся диапазон вывода. Если не указывать, то применяется текущий (последний использованный) лист.
+ `range` – диапазон шаблона, копируемый в результирующий документ, например “A1:M10”, или “5:6”, или “C:C”. (Применение диапазонов строк типа “5:6” в режиме вывода horizontal и диапазонов столбцов типа “C:C” в режиме вывода vertical приведёт к ошибке).
+ `worksheet` – если определён, то в файле вывода создаётся новый лист и позиция вывода смещается в ячейку A1 этого листа. Значение этого атрибута, равное константе или XPath-выражению, подставляется в имя нового листа.
В действительности всевозможных опций в дескрипторе гораздо больше, смотрите документацию.
Ну что же, настало время скачать Xylophone и запустить формирование отчёта.
Возьмите архив с [bintray](https://bintray.com/courseorchestra/libs-release-local/download_file?file_path=ru%2Fcurs%2Fxylophone%2F6.1.3%2Fxylophone-6.1.3-bin.zip) или [Maven Central](https://repo1.maven.org/maven2/ru/curs/xylophone/6.1.3/xylophone-6.1.3-bin.zip) (NB: на момент прочтения этой статьи возможно наличие более свежих версий). В папке /bin находится shell-скрипт, при запуске которого без параметров вы увидите подсказку о параметрах командной строки. Для получения результата нам надо «скормить» ксилофону все приготовленные ранее ингредиенты:
```
xylophone -data testdata.xml -template template.xlsx -descr descriptor.xml -out report.xlsx
```
Открываем файл report.xlsx и убеждаемся, что получилось именно то, что нам нужно:
Так как библиотека ru.curs:xylophone [доступна](https://search.maven.org/search?q=g:ru.curs%20AND%20a:xylophone&core=gav) на Maven Central под лицензией LGPL, её можно без проблем использовать в программах на любом JVM-языке. Пожалуй, самый компактный полностью рабочий пример получается на языке Groovy, код в комментариях не нуждается:
```
@Grab('ru.curs:xylophone:6.1.3')
import ru.curs.xylophone.XML2Spreadsheet
baseDir = '.'
new File(baseDir, 'testdata.xml').withInputStream {
input ->
new File(baseDir, 'report.xlsx').withOutputStream {
output ->
XML2Spreadsheet.process(input,
new File(baseDir, 'descriptor.xml'),
new File(baseDir, 'template.xlsx'),
false, output)
}
}
println 'Done.'
```
У класса `XML2Spreadsheet` есть несколько перегруженных вариантов статического метода `process`, но все они сводятся к передаче всё тех же «ингредиентов», необходимых для подготовки отчёта.
Важная опция, о которой я до сих пор не упомянул — это возможность выбора между DOM и SAX парсерами на этапе разбора файла с XML-данными. Как известно, DOM-парсер загружает весь файл в память целиком, строит его объектное представление и даёт возможность обходить его содержимое произвольным образом (в том числе повторно возвращаясь в один и тот же элемент). SAX-парсер никогда не помещает файл с данными целиком в память, вместо этого обрабатывает его как «поток» элементов, не давая возможности вернуться к элементу повторно.
Использование SAX-режима в Xylophone (через параметр командной строки `-sax` или установкой в `true` параметра `useSax` метода `XML2Spreadsheet.process`) бывает критически полезно в случаях, когда необходимо генерировать очень большие файлы. За счёт скорости и экономичности к ресурсам SAX-парсера скорость генерации файлов возрастает многократно. Это даётся ценой некоторых небольших ограничений на дескриптор (описано в документации), но в большинстве случаев отчёты удовлетворяют этим ограничениям, поэтому я бы рекомендовал использование SAX-режима везде, где это возможно.
Надеюсь, что способ выгрузки в Excel через Xylophone вам понравился и сэкономит много времени и нервов — как сэкономил нам.
И напоследок ещё раз ссылки:
* исходники — здесь: [github.com/CourseOrchestra/xylophone](https://github.com/CourseOrchestra/xylophone)
* документация — здесь: [courseorchestra.github.io/xylophone](https://courseorchestra.github.io/xylophone/)
* все примеры кода из этой статьи — здесь: [github.com/inponomarev/xylophone-example](https://github.com/inponomarev/xylophone-example). | https://habr.com/ru/post/422059/ | null | ru | null |
# Dropbox — прекращение отображения в браузере HTML-контента
Сегодня утром (01.09.2016) на мой имейл пришло письмо со следующим содержанием:
```
Приветствуем, username!
Сообщаем вам, что мы отменим функцию передачи контента HTML в браузере по ссылке на доступ или общую папку.
Если вы используете ссылки на общий доступ в Dropbox для размещения файлов HTML для веб-сайта, содержание
больше не будет отображаться в браузере.
```
```
Обратите внимание на то, что это изменение вступит в силу для вашего аккаунта с 3 октября 2016.
Оно повлияет только на отображение общих файлов в Интернете. Ваши файлы будут оставаться в безопасности в Dropbox.
Спасибо за лояльность к Dropbox.
команда Dropbox
```
Это мой перевод с украинского языка. Возможно русский текст чуть-чуть отличается, но не суть.
Странное, на первый взгляд, решение. Но, возможно, оно как-то связано с [недавней утечкой данных](http://thehackernews.com/2016/08/dropbox-data-breach.html).
Лично я, как и сотни других юзеров, давно полюбил простой и удобный дропбоксовский HTML-шаринг как лучший инструмент для показа интерактивных 2Д/3Д демо (для Unity Assetstore, посредством Unity Web Player) или даже полноценных 2Д игр — на WebGL, HTML5.
**Пример**3Д демо — [dl.dropboxusercontent.com/u/96409476/antique%20walk/antique%20bild.html](https://dl.dropboxusercontent.com/u/96409476/antique%20walk/antique%20bild.html)
Интересно, что в блогах Dropbox я эту печальную новость не нашёл. Ну что ж, придётся искать альтернативу.
**UPD**
По совету [goooseman](https://habrahabr.ru/users/goooseman/):
```
Если git не пугает, то GitHub Pages просто отличная альтернатива.
Плюс, учитывая популярность, вероятность того, что ее вдруг прикроют не велика.
```
Я сделал то же самое, но на Битбакет.
Конечно, это чуточку сложнее, чем просто закинуть контент в публичную папку, но работает отлично.
~~А ещё адрес короче и красивее.~~
**Пример**[acorngame.bitbucket.org/wooden\_house](http://acorngame.bitbucket.org/wooden_house/) | https://habr.com/ru/post/308998/ | null | ru | null |
# Библиотеки для глубокого обучения: Keras
Привет, Хабр! Мы уже говорили про [Theano](https://habrahabr.ru/company/ods/blog/323272/) и [Tensorflow](https://habrahabr.ru/company/ods/blog/324898/) (а также много про что еще), а сегодня сегодня пришло время поговорить про Keras.
Изначально Keras вырос как удобная надстройка над Theano. Отсюда и его греческое имя — κέρας, что значит "рог" по-гречески, что, в свою очередь, является отсылкой к Одиссее Гомера. Хотя, с тех пор утекло много воды, и Keras стал сначала поддерживать Tensorflow, а потом и вовсе стал его частью. Впрочем, наш рассказ будет посвящен не сложной судьбе этого фреймворка, а его возможностям. Если вам интересно, добро пожаловать под кат.
Начать стоит от печки, то есть с оглавления.
* [Установка]
* [Бэкенды]
* [Практический пример]
+ [Данные]
+ [Модель]
- [Sequential API]
- [Functional API]
+ [Подготовка модели к работе]
+ [Custom loss]
+ [Обучение и тестирование]
+ [Callbacks]
- [Tensorboard]
* [Продвинутые графы]
* [Заключение]
Установка
---------
Установка Keras чрезвычайно проста, т.к. он является обычным питоновским пакетом:
```
pip install keras
```
Теперь мы можем приступить к его разбору, но сначала поговорим про бэкенды.
**ВНИМАНИЕ:** Чтобы работать с Keras, у вас уже должен быть установлен хотя бы один из фреймворков — Theano или Tensorflow.
Бэкенды
-------
Бэкенды — это то, из-за чего Keras стал известен и популярен (помимо прочих достоинств, которые мы разберем ниже). Keras позволяет использовать в качестве бэкенда разные другие фреймворки. При этом написанный вами код будет исполняться независимо от используемого бэкенда. Начиналась разработка, как мы уже говорили, с Theano, но со временем добавился Tensorflow. Сейчас Keras по умолчанию работает именно с ним, но если вы хотите использовать Theano, то есть два варианта, как это сделать:
1. Отредактировать файл конфигурации keras.json, который лежит по пути `$HOME/.keras/keras.json` (или `%USERPROFILE%\.keras\keras.json` в случае операционных систем семейства Windows). Нам нужно поле `backend`:
```
{
"image_data_format": "channels_last",
"epsilon": 1e-07,
"floatx": "float32",
"backend": "theano"
}
```
2. Второй путь — это задать переменную окружения `KERAS_BACKEND`, например, так:
```
KERAS_BACKEND=theano python -c "from keras import backend"
Using Theano backend.
```
Стоит отметить, что сейчас ведется работа по написанию биндингов для CNTK от Microsoft, так что через некоторое время появится еще один доступный бэкенд. Следить за этим можно [здесь](https://github.com/Microsoft/CNTK/issues/797).
Также существует [MXNet Keras backend](https://github.com/dmlc/mxnet/issues/4173), который пока не обладает всей функциональностью, но если вы используете MXNet, вы можете обратить внимание на такую возможность.
Еще существует интересный проект [Keras.js](https://github.com/transcranial/keras-js), дающий возможность запускать натренированные модели Keras из браузера на машинах, где есть GPU.
Так что бэкенды Keras ширятся и со временем захватят мир! (Но это неточно.)
Практический пример
-------------------
В прошлых статьях много внимания было уделено описанию работы классических моделей машинного обучения на описываемых фреймворках. Кажется, теперь мы можем взять в качестве примера [не очень] глубокую нейронную сеть.
### Данные
Обучение любой модели в машинном обучении начинается с данных. Keras содержит внутри несколько обучающих датасетов, но они уже приведены в удобную для работы форму и не позволяют показать всю мощь Keras. Поэтому мы возьмем более сырой датасет. Это будет датасет 20 newsgroups — 20 тысяч новостных сообщений из групп Usenet (это такая система обмена почтой родом из 1990-х, родственная FIDO, который, может быть, чуть лучше знаком читателю) примерно поровну распределенных по 20 категориям. Мы будем учить нашу сеть правильно распределять сообщения по этим новостным группам.
```
from sklearn.datasets import fetch_20newsgroups
newsgroups_train = fetch_20newsgroups(subset='train')
newsgroups_test = fetch_20newsgroups(subset='test')
```
Вот пример содержания документа из обучающей выборки:
**newsgroups\_train['data'][0]**From: lerxst@wam.umd.edu (where's my thing)
Subject: WHAT car is this!?
Nntp-Posting-Host: rac3.wam.umd.edu
Organization: University of Maryland, College Park
Lines: 15
I was wondering if anyone out there could enlighten me on this car I saw
the other day. It was a 2-door sports car, looked to be from the late 60s/
early 70s. It was called a Bricklin. The doors were really small. In addition,
the front bumper was separate from the rest of the body. This is
all I know. If anyone can tellme a model name, engine specs, years
of production, where this car is made, history, or whatever info you
have on this funky looking car, please e-mail.
Thanks,
* IL
— brought to you by your neighborhood Lerxst ----
### Препроцессинг
Keras содержит в себе инструменты для удобного препроцессинга текстов, картинок и временных рядов, иными словами, самых распространенных типов данных. Сегодня мы работаем с текстами, поэтому нам нужно разбить их на токены и привести в матричную форму.
```
tokenizer = Tokenizer(num_words=max_words)
tokenizer.fit_on_texts(newsgroups_train["data"]) # теперь токенизатор знает словарь для этого корпуса текстов
x_train = tokenizer.texts_to_matrix(newsgroups_train["data"], mode='binary')
x_test = tokenizer.texts_to_matrix(newsgroups_test["data"], mode='binary')
```
На выходе у нас получились бинарные матрицы вот таких размеров:
```
x_train shape: (11314, 1000)
x_test shape: (7532, 1000)
```
Первое число — количество документов в выборке, а второе — размер нашего словаря (одна тысяча в этом примере).
Еще нам понадобится преобразовать метки классов к матричному виду для обучения с помощью кросс-энтропии. Для этого мы переведем номер класса в так называемый one-hot вектор, т.е. вектор, состоящий из нулей и одной единицы:
```
y_train = keras.utils.to_categorical(newsgroups_train["target"], num_classes)
y_test = keras.utils.to_categorical(newsgroups_test["target"], num_classes)
```
На выходе получим также бинарные матрицы вот таких размеров:
```
y_train shape: (11314, 20)
y_test shape: (7532, 20)
```
Как мы видим, размеры этих матриц частично совпадают с матрицами данных (по первой координате — числу документов в обучающей и тестовой выборках), а частично — нет. По второй координате у нас стоит число классов (20, как следует из названия датасета).
Все, теперь мы готовы учить нашу сеть классифицировать новости!
### Модель
Модель в Keras можно описать двумя основными способами:
#### Sequential API
Первый — последовательное описание модели, например, вот так:
```
model = Sequential()
model.add(Dense(512, input_shape=(max_words,)))
model.add(Activation('relu'))
model.add(Dropout(0.5))
model.add(Dense(num_classes))
model.add(Activation('softmax'))
```
или вот так:
```
model = Sequential([
Dense(512, input_shape=(max_words,)),
Activation('relu'),
Dropout(0.5),
Dense(num_classes),
Activation('softmax')
])
```
#### Functional API
Некоторое время назад появилась возможность использовать функциональное API для создания модели — второй способ:
```
a = Input(shape=(max_words,))
b = Dense(512)(a)
b = Activation('relu')(b)
b = Dropout(0.5)(b)
b = Dense(num_classes)(b)
b = Activation('softmax')(b)
model = Model(inputs=a, outputs=b)
```
Принципиального отличия между способами нет, выбирайте, какой вам больше по душе.
Класс `Model` (и унаследованный от него `Sequential`) имеет удобный интерфейс, позволяющий посмотреть, какие слои входят в модель — `model.layers`, входы — `model.inputs`, и выходы — `model.outputs`.
Также очень удобный метод отображения и сохранения модели — `model.to_yaml`.
**Под спойлером его вывод для нашей модели.**
```
backend: tensorflow
class_name: Model
config:
input_layers:
- [input_4, 0, 0]
layers:
- class_name: InputLayer
config:
batch_input_shape: !!python/tuple [null, 1000]
dtype: float32
name: input_4
sparse: false
inbound_nodes: []
name: input_4
- class_name: Dense
config:
activation: linear
activity_regularizer: null
bias_constraint: null
bias_initializer:
class_name: Zeros
config: {}
bias_regularizer: null
kernel_constraint: null
kernel_initializer:
class_name: VarianceScaling
config: {distribution: uniform, mode: fan_avg, scale: 1.0, seed: null}
kernel_regularizer: null
name: dense_10
trainable: true
units: 512
use_bias: true
inbound_nodes:
- - - input_4
- 0
- 0
- {}
name: dense_10
- class_name: Activation
config: {activation: relu, name: activation_9, trainable: true}
inbound_nodes:
- - - dense_10
- 0
- 0
- {}
name: activation_9
- class_name: Dropout
config: {name: dropout_5, rate: 0.5, trainable: true}
inbound_nodes:
- - - activation_9
- 0
- 0
- {}
name: dropout_5
- class_name: Dense
config:
activation: linear
activity_regularizer: null
bias_constraint: null
bias_initializer:
class_name: Zeros
config: {}
bias_regularizer: null
kernel_constraint: null
kernel_initializer:
class_name: VarianceScaling
config: {distribution: uniform, mode: fan_avg, scale: 1.0, seed: null}
kernel_regularizer: null
name: dense_11
trainable: true
units: !!python/object/apply:numpy.core.multiarray.scalar
- !!python/object/apply:numpy.dtype
args: [i8, 0, 1]
state: !!python/tuple [3, <, null, null, null, -1, -1, 0]
- !!binary |
FAAAAAAAAAA=
use_bias: true
inbound_nodes:
- - - dropout_5
- 0
- 0
- {}
name: dense_11
- class_name: Activation
config: {activation: softmax, name: activation_10, trainable: true}
inbound_nodes:
- - - dense_11
- 0
- 0
- {}
name: activation_10
name: model_1
output_layers:
- [activation_10, 0, 0]
keras_version: 2.0.2
```
Это позволяет сохранять модели в человеко-читаемом виде, а также инстанциировать модели из такого описания:
```
from keras.models import model_from_yaml
yaml_string = model.to_yaml()
model = model_from_yaml(yaml_string)
```
Важно отметить, что модель, сохраненная в текстовом виде (кстати, возможно сохранение также и в JSON) не содержит весов. Для сохранения и загрузки весов используйте функции `save_weights` и `load_weights` соответственно.
### Визуализация модели
Нельзя обойти стороной визуализацию. Keras имеет встроенную визуализацию для моделей:
```
from keras.utils import plot_model
plot_model(model, to_file='model.png', show_shapes=True)
```
Этот код сохранит под именем `model.png` вот такую картинку:
Здесь мы дополнительно отобразили размеры входов и выходов для слоев. `None`, идущий первым в кортеже размеров — это размерность батча. Т.к. стоит `None`, то батч может быть произвольным.
Если вы захотите отобразить ее в `jupyter`-ноутбуке, вам нужен немного другой код:
```
from IPython.display import SVG
from keras.utils.vis_utils import model_to_dot
SVG(model_to_dot(model, show_shapes=True).create(prog='dot', format='svg'))
```
Важно отметить, что для визуализации нужен пакет [graphviz](http://www.graphviz.org/), а также питоновский пакет `pydot`. Есть тонкий момент, что для корректной работы визуализации пакет `pydot` из репозитория не пойдет, нужно взять его обновленную версию `pydot-ng`.
```
pip install pydot-ng
```
Пакет `graphviz` в Ubuntu ставится так (в других дистрибутивах Linux аналогично):
```
apt install graphviz
```
На MacOS (используя систему пакетов HomeBrew):
```
brew install graphviz
```
Инструкцию установки на Windows можно посмотреть [здесь](http://www.graphviz.org/Download_windows.php).
### Подготовка модели к работе
Итак, мы сформировали нашу модель. Теперь нужно подготовить ее к работе:
```
model.compile(loss='categorical_crossentropy',
optimizer='adam',
metrics=['accuracy'])
```
Что означают параметры функции `compile`? `loss` — это функция ошибки, в нашем случае — это перекрестная энтропия, именно для нее мы подготавливали наши метки в виде матриц; `optimizer` — используемый оптимизатор, здесь мог бы быть обычный стохастический градиентный спуск, но Adam показывает лучшую сходимость на этой задаче; `metrics` — метрики, по которым считается качество модели, в нашем случае — это точность (accuracy), то есть доля верно угаданных ответов.
### Custom loss
Несмотря на то, что Keras содержит большинство популярных функций ошибки, для вашей задачи может потребоваться что-то уникальное. Чтобы сделать свой собственный `loss`, нужно немного: просто определить функцию, принимающую векторы правильных и предсказанных ответов и выдающую одно число на выход. Для тренировки сделаем свою функцию расчета перекрестной энтропии. Чтобы она чем-то отличалась, введем так называемый clipping — обрезание значений вектора сверху и снизу. Да, еще важное замечание: нестандартный `loss` может быть необходимо описывать в терминах нижележащего фреймворка, но мы можем обойтись средствами Keras.
```
from keras import backend as K
epsilon = 1.0e-9
def custom_objective(y_true, y_pred):
'''Yet another cross-entropy'''
y_pred = K.clip(y_pred, epsilon, 1.0 - epsilon)
y_pred /= K.sum(y_pred, axis=-1, keepdims=True)
cce = categorical_crossentropy(y_pred, y_true)
return cce
```
Здесь `y_true` и `y_pred` — тензоры из Tensorflow, поэтому для их обработки используются функции Tensorflow.
Для использования другой функции потерь достаточно изменить значения параметра `loss` функции `compile`, передав туда объект нашей функции потерь (в питоне функции — тоже объекты, хотя это уже совсем другая история):
```
model.compile(loss=custom_objective,
optimizer='adam',
metrics=['accuracy'])
```
### Обучение и тестирование
Наконец, пришло время для обучения модели:
```
history = model.fit(x_train, y_train,
batch_size=batch_size,
epochs=epochs,
verbose=1,
validation_split=0.1)
```
Метод `fit` делает именно это. Он принимает на вход обучающую выборку вместе с метками — `x_train` и `y_train`, размером батча `batch_size`, который ограничивает количество примеров, подаваемых за раз, количеством эпох для обучения `epochs` (одна эпоха — это один раз полностью пройденная моделью обучающая выборка), а также тем, какую долю обучающей выборки отдать под валидацию — `validation_split`.
Возвращает этот метод `history` — это история ошибок на каждом шаге обучения.
И наконец, тестирование. Метод `evaluate` получает на вход тестовую выборку вместе с метками для нее. Метрика была задана еще при подготовке к работе, так что больше ничего не нужно. (Но мы укажем еще размер батча).
```
score = model.evaluate(x_test, y_test, batch_size=batch_size)
```
### Callbacks
Нужно также сказать несколько слов о такой важной особенности Keras, как колбеки. Через них реализовано много полезной функциональности. Например, если вы тренируете сеть в течение очень долгого времени, вам нужно понять, когда пора остановиться, если ошибка на вашем датасете перестала уменьшаться. По-английски описываемая функциональность называется "early stopping" ("ранняя остановка"). Посмотрим, как мы можем применить его при обучении нашей сети:
```
from keras.callbacks import EarlyStopping
early_stopping=EarlyStopping(monitor='value_loss')
history = model.fit(x_train, y_train,
batch_size=batch_size,
epochs=epochs,
verbose=1,
validation_split=0.1,
callbacks=[early_stopping])
```
Проведите эксперимент и проверьте, как быстро сработает early stopping в нашем примере?
#### Tensorboard
Еще в качестве колбека можно использовать сохранение логов в формате, удобном для Tensorboard (о нем разговор был в статье про Tensorflow, вкратце — это специальная утилита для обработки и визуализации информации из логов Tensorflow).
```
from keras.callbacks import TensorBoard
tensorboard=TensorBoard(log_dir='./logs', write_graph=True)
history = model.fit(x_train, y_train,
batch_size=batch_size,
epochs=epochs,
verbose=1,
validation_split=0.1,
callbacks=[tensorboard])
```
После того, как обучение закончится (или даже в процессе!), вы можете запустить `Tensorboard`, указав абсолютный путь к директории с логами:
```
tensorboard --logdir=/path/to/logs
```
Там можно посмотреть, например, как менялась целевая метрика на валидационной выборке:
(Кстати, тут можно заметить, что наша сеть переобучается.)
Продвинутые графы
-----------------
Теперь рассмотрим построение чуть более сложного графа вычислений. У нейросети может быть множество входов и выходов, входные данные могут преобразовываться разнообразными отображениями. Для переиспользования частей сложных графов (в частности, для `transfer learning`) имеет смысл описывать модель в модульном стиле, позволяющем удобным образом извлекать, сохранять и применять к новым входным данным куски модели.
Наиболее удобно описывать модель, смешивая оба способа — `Functional API` и `Sequential API`, описанные ранее.
Рассмотрим этот подход на примере модели Siamese Network. Схожие модели активно используются на практике для получения векторных представлений, обладающих полезными свойствами. Например, подобная модель может быть использована для того, чтобы выучить такое отображение фотографий лиц в вектор, что вектора для похожих лиц будут близко друг к другу. В частности, этим пользуются приложения поиска по изображениям, такие как FindFace.
Иллюстрацию модели можно видеть на диаграмме:
Здесь функция `G` превращает входную картинку в вектор, после чего вычисляется расстояние между векторами для пары картинок. Если картинки из одного класса, расстояние нужно минимизировать, если из разных — максимизировать.
После того, как такая нейросеть будет обучена, мы сможем представить произвольную картинку в виде вектора `G(x)` и использовать это представление либо для поиска ближайших изображений, либо как вектор признаков для других алгоритмов машинного обучения.
Будем описывать модель в коде соответствующим образом, максимально упростив извлечение и переиспользование частей нейросети.
Сначала определим на Keras функцию, отображающую входной вектор.
```
def create_base_network(input_dim):
seq = Sequential()
seq.add(Dense(128, input_shape=(input_dim,), activation='relu'))
seq.add(Dropout(0.1))
seq.add(Dense(128, activation='relu'))
seq.add(Dropout(0.1))
seq.add(Dense(128, activation='relu'))
return seq
```
Обратите внимание: мы описали модель с помощью `Sequential API`, однако обернули ее создание в функцию. Теперь мы можем создать такую модель, вызвав эту функцию, и применить ее с помощью `Functional API` ко входным данным:
```
base_network = create_base_network(input_dim)
input_a = Input(shape=(input_dim,))
input_b = Input(shape=(input_dim,))
processed_a = base_network(input_a)
processed_b = base_network(input_b)
```
Теперь в переменных `processed_a` и `processed_b` лежат векторные представления, полученные путем применения сети, определенной ранее, к входным данным.
Нужно посчитать между ними расстояния. Для этого в Keras предусмотрена функция-обертка `Lambda`, представляющая любое выражение как слой (`Layer`). Не забудьте, что мы обрабатываем данные в батчах, так что у всех тензоров всегда есть дополнительная размерность, отвечающая за размер батча.
```
from keras import backend as K
def euclidean_distance(vects):
x, y = vects
return K.sqrt(K.sum(K.square(x - y), axis=1, keepdims=True))
distance = Lambda(euclidean_distance)([processed_a, processed_b])
```
Отлично, мы получили расстояние между внутренними представлениями, теперь осталось собрать входы и расстояние в одну модель.
```
model = Model([input_a, input_b], distance)
```
Благодаря модульной структуре мы можем использовать `base_network` отдельно, что особенно полезно после обучения модели. Как это можно сделать? Посмотрим на слои нашей модели:
```
>>> model.layers
[, , , ]
```
Видим третий объект в списке типа `models.Sequential`. Это и есть модель, отображающая входную картинку в вектор. Чтобы ее извлечь и использовать как полноценную модель (можно дообучать, валидировать, встраивать в другой граф) достаточно всего лишь вытащить ее из списка слоев:
```
>>> embedding_model = model.layers[2]
>>> embedding_model.layers
[, , , , ]
```
Например для уже обученной на данных MNIST сиамской сети с размерностью на выходе `base_model`, равной двум, можно визуализировать векторные представления следующим образом:
Загрузим данные и приведем картинки размера `28x28` к плоским векторам.
```
(x_train, y_train), (x_test, y_test) = mnist.load_data()
x_test = x_test.reshape(10000, 784)
```
Отобразим картинки с помощью извлеченной ранее модели:
```
embeddings = embedding_model.predict(x_test)
```
Теперь в `embeddings` лежат двумерные вектора, их можно изобразить на плоскости:
Полноценный пример сиамской сети можно увидеть [здесь](https://github.com/fchollet/keras/blob/master/examples/mnist_siamese_graph.py).
Заключение
----------
Вот и все, мы сделали первые модели на Keras! Надеемся, что предоставляемые им возможности заинтересовали вас, так что вы будете его использовать в своей работе.
Пришло время обсудить плюсы и минусы Keras. К очевидным плюсам можно отнести простоту создания моделей, которая выливается в высокую скорость прототипирования. Например, авторы недавней статьи [про спутники](https://habrahabr.ru/company/ods/blog/325096/) использовали именно Keras. В целом этот фреймворк становится все более и более популярным:
Keras за год догнал Torch, который разрабатывается уже 5 лет, судя по упоминаниям в научных статьях. Кажется, своей цели — простоты использования — Франсуа Шолле (François Chollet, автор Keras) добился. Более того, его инициатива не осталась незамеченной: буквально через несколько месяцев разработки компания Google пригласила его заниматься этим в команде, разрабатывающей Tensorflow. А также с версии Tensorflow 1.2 Keras будет включен в состав TF (tf.keras).
Также надо сказать пару слов о недостатках. К сожалению, идея Keras о универсальности кода выполняется не всегда: Keras 2.0 поломал совместимость с первой версией, некоторые функции стали называться по-другому, некоторые переехали, в общем, история похожа на второй и третий python. Отличием является то, что в случае Keras была выбрана только вторая версия для развития. Также код Keras работает на Tensorflow пока медленнее, чем на Theano (хотя для нативного кода фреймворки, как минимум, [сравнимы](https://arxiv.org/abs/1511.06435)).
В целом, можно порекомендовать Keras к использованию, когда вам нужно быстро составить и протестировать сеть для решения конкретной задачи. Но если вам нужны какие-то сложные вещи, вроде нестандартного слоя или распараллеливания кода на несколько GPU, то лучше (а подчас просто неизбежно) использовать нижележащий фреймворк.
Практически весь код из статьи есть в виде одного ноутбука [здесь](https://gist.github.com/madrugado/63c068b52a135c6fdbbb6fe17acbc0c8). Также очень рекомендуем вам документацию по Keras: [keras.io](http://keras.io), а так же [официальные примеры](https://github.com/fchollet/keras/tree/master/examples), на которых эта статья во многом основана.
Пост написан в сотрудничестве с [Wordbearer](https://habrahabr.ru/users/wordbearer/). | https://habr.com/ru/post/325432/ | null | ru | null |
# Кривые и что это такое ч.2
Всем привет!
Итак, это продолжение предыдущей статьи с той же темой - кривые, их разбор.
---
Основная часть
--------------
Как вы помните, в прошлой части я предложил два примера кривой. Одна интерполирует на отрезке между двумя точками, но учитывает еще и соседние точки. Другая интерполирует на всем отрезке и в каждой точке интерполяции учитывает все данные точки. Говорить мы будет о последней.
Для начала представим эту кривую целым семейством кривых. Их можно выразить в виде формулы
для которой нужно определить коэффициенты. Но раз это семейство, то они одного вида. Каждый параметр можно представить в виде
где функция принимает значение от  до  и преобразует его. Причем важно, что она должна возвращать значения от  до (противоположные функции найдут применение в следующей статье). Примерами таких функций могут быть     и множество других функций и полиномов.
Для коэффициента  тоже есть различные варианты. Для выбора одного из них нужно выбирать между производительностью и областью значений функции. Сделаем замену  на  чтобы нам не мешалась эта дробь в дальнейшем. Тогда может быть определен как
что лучше для производительности, но при этом в узлах не будут определены значения, или как
тогда область значений не ограничена. Чтобы прийти к таким формулам, достаточно просто подумать, в каком случае коэффициент будет меньше при меньшем . Первое - простое деление, которое тем больше, чем меньше знаменатель. Второе - перемножение значений  всех других точек, так как при минимальном  остальные будут больше.
В обоих вариантах есть две версии интерполяции. Одна – интерполирует более-менее в пределах точек, то есть похожа на линейную интерполяцию. Другая – сильно выходит за значения точек, но выглядит, по моему субъективному мнение, лучше.
Первая версия - модуль  он одинаковый для обоих вариантов. Вторая версия -
для варианта без узлов и с узлами, соответственно. Стоит помнить, что для второй версии функция должна быть нечетной, принимающей значения от  до  либо нужно будет выносить знак за функцию и передавать в нее модуль.
---
Квадрат
-------
первая версия, квадратВ данном случае можно немного сократить параметр  до вида  поскольку знаменатель у каждого параметра одинаковый и сокращается у числителя и знаменателя дроби функции. Так как расстояние до  очень сильно влияет, то не имеет смысла использовать вторую версию. При второй версии значение функции около точек будет незначительно отличаться от значения  точки.
Очевидно, что вместо  в показателе степени может быть любое число, но если это число нецелое, то нужно брать модуль. Также я не рекомендую использовать степень выше  ведь даже тогда видно, что функция прижата к значениям точек около них.
```
public static float power(Vector2[] points, float x, float n)
{
float b = 0;
float y = 0;
for (int i = 0; i < points.Length; i++)
{
if (points[i].x == x)
return points[i].y;
float k = 1 / Mathf.Pow(Mathf.Abs(points[i].x - x), n);
y += points[i].y * k;
b += k;
}
return y / b;
}
```
---
Синус/Косинус
-------------
вторая версия, косинус, a=0.7, b=0.9Перейдем к тригонометрии. Рассмотрим функции синуса и косинуса. Они сдвинуты на полупериод, поэтому рассматривать их обе не имеет смысла. Итак, функция должна возвращать значения от  до . Для синуса и косинуса это, соответственно
Поскольку функция косинуса короче, но при этом идентична синусу, я буду пользоваться ею. Сейчас у нас есть формула для косинуса, но она всегда одинаковая, поэтому нужно добавить параметры. Меняться может только сдвиг и растяжение по оси абсцисс. При этом нужно еще чтобы при  возвращаемое значение было тоже равно  Тогда функция с параметрами  и для растяжения и сдвига соответственно выглядит так
Мы вычитаем косинус сдвига, чтобы при  значение функции тоже было равно  Значения параметров тоже ограничены – ![a\in\left(0;1\right], b\in\left[a;1\right].](https://habrastorage.org/getpro/habr/upload_files/5c3/373/8c5/5c33738c5bdc72a4532fa91053f923fa.svg) Это вызвано тем, что растяжение не может быть больше  иначе период будет меньше .
Получается, для получения формулы функции  нужно  заменить на 
```
public static float cosine(Vector2[] points, float x, float k1, float k2)
{
float b = 0;
float y = 0;
for (int i = 0; i < points.Length; i++)
{
if (points[i].x == x)
return points[i].y;
float k = 1 / (Mathf.Cos((points[i].x - x) / (points[points.Length-1].x - points[0].x) * k1 * Mathf.PI - k2 * Mathf.PI) - Mathf.Cos(k2 * Mathf.PI));
y += points[i].y * k;
b += k;
}
return y / b;
}
```
---
Экспонента
----------
вторая версия, экспонентаФункция экспоненты - лишь частный случай  но поскольку именно от  происходит название для подобных функций, их назвают экспоненциальными, то и примером будет экспонента. При поэтому функцию можно перезаписать в виде  что верно для любого основания.
вторая версия, параболическая экспонента, a=1, b=10, c=1Еще один случай, который я хочу рассмотреть - это объединение параболы и экспоненты. Функция будет вида и в степени"улучшает" функцию, ведь до этого только от зависело, насколько сильная разница между и При  разница наибольшая, а  в показателе степени сдвигает этот максимум вправо, то есть для нас к наибольшему расстоянию. Таким образом, можно добавить параметры в формулу
где параметр  увеличивает влияние расстояния, но не сильно. Параметр тоже увеличивает влияние расстояния, причем достаточно сильно и гладко. Параметр уменьшает влияние расстояния, причем при  расстояние начинает влиять не совсем корректно.
```
public static float exponent(Vector2[] points, float x, float n)
{
float b = 0;
float y = 0;
for (int i = 0; i < points.Length; i++)
{
if (points[i].x == x)
return points[i].y;
float k = 1 / Mathf.Pow(n, Mathf.Abs(x - points[i].x) / (points[points.Length-1].x - points[0].x));
y += points[i].y * k;
b += k;
}
return y / b;
}
```
---
Тангенс
-------
вторая версия, тангенс, a=1, b=0.7Тангенс - следующая тригонометрическая функция. Рассматривать котангенс отдельно не имеет смысла, поскольку . Минус будет сокращаться, а сдвиг будет задаваться параметром. Итак, нам нужны параметры для сдвига и растяжения, как и у косинуса. Получается вид формулы будет такой:
где  – параметр растяжения, а – сдвига. Параметр  параметр  Это обусловлено тем, что при  не будет учитываться  Если  то период функции будет меньше или равен  При  знаки будут сокращаться, поэтому не имеет смысла. Если  то будет сокращаться с периодом функции, минимальный -  Если  то опять же сокращается с периодом. Граничные условия обусловлены ограничениями области определения функции.
```
public static float tangent(Vector2[] points, float x, float k1, float k2)
{
float b = 0;
float y = 0;
for (int i = 0; i < points.Length; i++)
{
if (points[i].x == x)
return points[i].y;
float k = 1 / (Mathf.Tan((points[i].x - x) / (points[points.Length-1].x - points[0].x) * k1 * Mathf.PI + k2 * Mathf.PI) - Mathf.Tan(k2 * Mathf.PI));
y += points[i].y * k;
b += k;
}
return y / b;
}
```
---
Итоги
-----
Возможность оптимизировать вычисления и огромный выбор различных функций интерполяции – все это говорит в пользу моих кривых. Для любой задачи можно выбрать нужную функцию и параметры, что расширяет область применения.
Остается добавить выбор версии интерполяции и совместить экспоненту и степень. Еще я добавил кривую с кастомной функцией, поэтому конечный код выглядит так:
```
public struct Interpolation
{
public static float simple(Vector2[] points, float x, bool v2 = true)
{
float b = 0;
float y = 0;
for (int i = 0; i < points.Length; i++)
{
float k = 0;
if (points[i].x == x)
return points[i].y;
if (v2)
k = 1 / ((points[i].x - x) * (i % 2 == 0 ? 1 : -1));
else
k = 1 / Mathf.Abs(points[i].x - x);
y += points[i].y * k;
b += k;
}
return y / b;
}
public static float power(Vector2[] points, float x, float k1,
float k2, float k3, float k4, bool v2 = false)
{
float b = 0;
float y = 0;
for (int i = 0; i < points.Length; i++)
{
float k = 0;
if (points[i].x == x)
return points[i].y;
float f = Mathf.Pow(k1 * Mathf.Abs(x - points[i].x) /
(points[points.Length-1].x - points[0].x) + k2, k3 * Mathf.Abs(x - points[i].x) /
(points[points.Length-1].x - points[0].x) + k4);
if (v2)
k = 1 / (Mathf.Sign(x - points[i].x) * (i % 2 == 0 ? 1 : -1) * f);
else
k = 1 / f;
y += points[i].y * k;
b += k;
}
return y / b;
}
public static float cosine(Vector2[] points, float x, float k1,
float k2, bool v2 = false)
{
float b = 0;
float y = 0;
for (int i = 0; i < points.Length; i++)
{
float k = 0;
if (points[i].x == x)
return points[i].y;
float f = (Mathf.Cos((points[i].x - x) /
(points[points.Length-1].x - points[0].x) *
k1 * Mathf.PI - k2 * Mathf.PI) - Mathf.Cos(k2 * Mathf.PI));
if (v2)
k = 1 / (Mathf.Sign(x - points[i].x) * (i % 2 == 0 ? 1 : -1) * f);
else
k = 1 / f;
y += points[i].y * k;
b += k;
}
return y / b;
}
public static float tangent(Vector2[] points, float x, float k1,
float k2, bool v2 = false)
{
float b = 0;
float y = 0;
for (int i = 0; i < points.Length; i++)
{
float k = 0;
if (points[i].x == x)
return points[i].y;
float f = (Mathf.Tan((points[i].x - x) /
(points[points.Length-1].x - points[0].x) *
k1 * Mathf.PI + k2 * Mathf.PI) - Mathf.Tan(k2 * Mathf.PI));
if (v2)
k = 1 / (Mathf.Sign(x - points[i].x) * (i % 2 == 0 ? 1 : -1) * f);
else
k = 1 / f;
y += points[i].y * k;
b += k;
}
return y / b;
}
public delegate float function(float f);
public static float delegat(Vector2[] points, float x, function func, bool v2 = true)
{
float b = 0;
float y = 0;
for (int i = 0; i < points.Length; i++)
{
float k = 0;
if (points[i].x == x)
return points[i].y;
float f = func((points[i].x - x) / (points[points.Length-1].x - points[0].x));
if (v2)
k = 1 / (Mathf.Sign(x - points[i].x) * (i % 2 == 0 ? 1 : -1) * f);
else
k = 1 / f;
y += points[i].y * k;
b += k;
}
return y / b;
}
}
```
Надеюсь, я вам чем-то помог, и вы найдете применение данному материалу)
Весь приведенный выше код разработан для использования в Unity, для чистого c# нужно определить классы Vector3 и Vector2, также можно заменить float на double для большей точности. | https://habr.com/ru/post/671078/ | null | ru | null |
# Международный конкурс по обфускации кода на C
[IOCCC](http://www.ioccc.org/) возвращается! Знаменитый конкурс на самый запутанный код призван «проверять компиляторы на стресс, демонстрировать тонкости языка программирования Си и важность соблюдения стиля программирования (делая обратное)».
По условиям, участвовать в конкурсе могут готовые программы размером меньше 4096 байт, при этом количество значимых символов (без учёта пробелов, знаков табуляции) и знаков ; ( ), не должно превышать 2048. Первого декабря форма заявки на участие в конкурсе будет размещена [здесь](http://www.ioccc.org/2011/submit).
Международный конкурс на самый запутанный код проходил ежегодно с 1984 года, но с 2006-го мероприятие удалось организовать впервые.
В 2004 году победителем конкурса стала графическая многозадачная ОС размером около [3,5 КБ](http://www0.us.ioccc.org/2004/gavin.c), с поддержкой клавиатуры, мыши, примитивной оконной подсистемой, поддержкой файловой системы и возможностью запускать ELF-программы.
Любителям необычного кода будет на что посмотреть: например, вот [код авиасимулятора](http://www.ioccc.org/1998/banks.c), который в редакторе похож на самолёт (победитель конкурса 1988 года).
```
#include
#include
#include
#include
double L ,o ,P
,\_=dt,T,Z,D=1,d,
s[999],E,h= 8,I,
J,K,w[999],M,m,O
,n[999],j=33e-3,i=
1E3,r,t, u,v ,W,S=
74.5,l=221,X=7.26,
a,B,A=32.2,c, F,H;
int N,q, C, y,p,U;
Window z; char f[52]
; GC k; main(){ Display\*e=
XOpenDisplay( 0); z=RootWindow(e,0); for (XSetForeground(e,k=XCreateGC (e,z,0,0),BlackPixel(e,0))
; scanf("%lf%lf%lf",y +n,w+y, y+s)+1; y ++); XSelectInput(e,z= XCreateSimpleWindow(e,z,0,0,400,400,
0,0,WhitePixel(e,0) ),KeyPressMask); for(XMapWindow(e,z); ; T=sin(O)){ struct timeval G={ 0,dt\*1e6}
; K= cos(j); N=1e4; M+= H\*\_; Z=D\*K; F+=\_\*P; r=E\*K; W=cos( O); m=K\*W; H=K\*T; O+=D\*\_\*F/ K+d/K\*E\*\_; B=
sin(j); a=B\*T\*D-E\*W; XClearWindow(e,z); t=T\*E+ D\*B\*W; j+=d\*\_\*D-\_\*F\*E; P=W\*E\*B-T\*D; for (o+=(I=D\*W+E
\*T\*B,E\*d/K \*B+v+B/K\*F\*D)\*\_; p K)N=1e4; else{ q=W/K \*4E2+2e2; C= 2E2+4e2/ K
\*D; N-1E4&& XDrawLine(e ,z,k,N ,U,q,C); N=q; U=C; } ++p; } L+=\_\* (X\*t +P\*M+m\*l); T=X\*X+ l\*l+M \*M;
XDrawString(e,z,k ,20,380,f,17); D=v/l\*15; i+=(B \*l-M\*r -X\*Z)\*\_; for(; XPending(e); u \*=CS!=N){
XEvent z; XNextEvent(e ,&z);
++\*((N=XLookupKeysym
(&z.xkey,0))-IT?
N-LT? UP-N?& E:&
J:& u: &h); --\*(
DN -N? N-DT ?N==
RT?&u: & W:&h:&J
); } m=15\*F/l;
c+=(I=M/ l,l\*H
+I\*M+a\*X)\*\_; H
=A\*r+v\*X-F\*l+(
E=.1+X\*4.9/l,t
=T\*m/32-I\*T/24
)/S; K=F\*M+(
h\* 1e4/l-(T+
E\*5\*T\*E)/3e2
)/S-X\*d-B\*A;
a=2.63 /l\*d;
X+=( d\*l-T/S
\*(.19\*E +a
\*.64+J/1e3
)-M\* v +A\*
Z)\*\_; l +=
K \*\_; W=d;
sprintf(f,
"%5d %3d"
"%7d",p =l
/1.7,(C=9E3+
O\*57.3)%0550,(int)i); d+=T\*(.45-14/l\*
X-a\*130-J\* .14)\*\_/125e2+F\*\_\*v; P=(T\*(47
\*I-m\* 52+E\*94 \*D-t\*.38+u\*.21\*E) /1e2+W\*
179\*v)/2312; select(p=0,0,0,0,&G); v-=(
W\*F-T\*(.63\*m-I\*.086+m\*E\*19-D\*25-.11\*u
)/107e2)\*\_; D=cos(o); E=sin(o); } }
```
Вот ещё пример.
Программа вычисления числа Пи путём анализа собственной площади ([1988 г.](http://www0.us.ioccc.org/1988/westley.c))
```
#define _ -F<00||--F-OO--;
int F=00,OO=00;main(){F_OO();printf("%1.3f\n",4.*-F/OO/OO);}F_OO()
{
_-_-_-_
_-_-_-_-_-_-_-_-_
_-_-_-_-_-_-_-_-_-_-_-_
_-_-_-_-_-_-_-_-_-_-_-_-_-_
_-_-_-_-_-_-_-_-_-_-_-_-_-_-_
_-_-_-_-_-_-_-_-_-_-_-_-_-_-_
_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_
_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_
_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_
_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_
_-_-_-_-_-_-_-_-_-_-_-_-_-_-_
_-_-_-_-_-_-_-_-_-_-_-_-_-_-_
_-_-_-_-_-_-_-_-_-_-_-_-_-_
_-_-_-_-_-_-_-_-_-_-_-_
_-_-_-_-_-_-_-_
_-_-_-_
}
``` | https://habr.com/ru/post/132665/ | null | ru | null |
# Новости из мира OpenStreetMap № 488 (19.11.2019-25.11.2019)
Каждый год – Карта сезона [1](#wn488_21388) | OpenStreetBrowser – Map data OpenStreetMap contributors
Картографирование
-----------------
* Пользователь kreuzschnabel [предполагает](https://forum.openstreetmap.org/viewtopic.php?id=68063), что рекомендация, содержащаяся в WikiOSM, относительно использования тега `bridge=yes/no` — это картографирование под рендер, поскольку предлагается добавить имя моста через тег `name=`, а не присвоить название дороги мосту. Однако, скорее всего, это было добавлено в статью [в 2012](https://wiki.openstreetmap.org/w/index.php?title=Key:bridge&diff=prev&oldid=719898) году. Тег `man_made=bridge`, к которому принадлежит тег `name=`, похоже, добавили [в 2013 году](https://wiki.openstreetmap.org/w/index.php?title=Tag:man_made%3Dbridge&action=history).
Сообщество
----------
* 26 ноября проект «GeoChicas» [отметил](https://twitter.com/GeochicasOSM/status/1199455810440572928) свой третий день рождения. На [карте](http://umap.openstreetmap.fr/es/map/geochicas-osm_161167#3/13.75/-64.51) можно увидеть страны, в которых есть участницы этого проекта. «GeoChicas» ставит своей целью повышение осведомленности о гендерных пробелах, которые существуют в OpenStreetMap.
* Сообщество OSM в Латинской Америке [опубликовало](https://www.youtube.com/channel/UCzYgQtCudy1ihZYAlpC3EXQ/videos) видео с конференции SotM Latam, которая не так давно прошла в городе Энкарнасьоне (Парагвай).
* В связи с [закрытием](https://www.openstreetmap.org/user/Zverik/diary/391311) рейд-шеринговой компании Juno, которая базировалась в Белоруссии, Илья Зверев и ряд других разработчиков были переведены в компанию [Lyft](https://wiki.openstreetmap.org/wiki/Lyft), входящую в состав Фонда OSM. Однако в свою очередь это привело к тому, что Илью попросили [удалить](http://shtosm.ru/all/buduschee-raydsheringa-eto-avtobus/) одну из его публикации в личном блоге SHTOSM. Как пояснил Илья, трудовой договор Lyft ограничивает ведение личных блогов без разрешения компании. Надеемся, что это временная трудность.
Фонд OpenStreetMap
------------------
* Хизер Лесон в своем личном блоге [подвела](https://www.openstreetmap.org/user/Heather%20Leson/diary/391284) итоги своей двухлетней работы в Совете Фонда OSM. Из ее поста вы сможете узнать об управлении, стратегическом планировании в экосистеме OSM или его отсутствии, а также здоровью общества и токсичности мужского начала.
* Пользователь Imagico, как и в прошлом году, решил [проанализировать](https://www.openstreetmap.org/user/imagico/diary/391322) членов Фонда OSM по странам, используя соотношения числа членов Фонда к числу ежедневных активных редакторов. Результаты исследования мало чем отличаются от 2018 года. Причем самые высокие показатели отмечены в англоязычных странах и иных странах Западной Европы. Но в целом наблюдаются некоторые тенденции к появлению разнообразия. Imagico надеется, что обсуждаемая сейчас программа «Fee waiver» ускорит этот процесс. Исследование сделано на основе данных Рабочей группы по членству Фонда OSM и статистики сервисов Паскаля Нейса.
События
-------
* Организаторы конференции State of the Map Africa 2019 опубликовали в [Твиттере](https://twitter.com/sotmafrica/status/1197811209858375681) [видео](https://www.youtube.com/watch?v=328t90vkots&feature=youtu.be) с открытия.
* Пользователь Kleper [опубликовал](https://www.openstreetmap.org/user/Kleper/diary/391303) в своем блоге краткий обзор конференции State of the Map Latam 2019, которая проходила с 14 по 16 ноября в городе Энкарнасьон (Парагвай).
* 9 декабря в Гейдельберге (Германия) [состоится](https://www.openstreetmap.at/2019/11/vienna-geo-meetup-6/) 6-ой венский Geo Meetup, на котором ожидается доклад об использовании векторных данных на сайте basemap.at и выступления о прошедшей конфереции State of the Map 2019 в Гейдельберге. Помимо этого планируется проведение картатона, организованного некоммерческой организацией «Врачи без границ».
* Geonews [сообщает](https://geo-news.jp/archives/928) о второй встрече между картографами OSM и mapbox.jp. Встреча состоялась 4 декабря.
Гуманитарный OSM
----------------
* Под лозунгом #MaptheDifference некоммерческая организация HOT [начала](https://www.hotosm.org/updates/help-local-communities-to-number-mapthedifference/) сбор средств на программу микрогрантов 2020 года, а именно на 6 конкретных проектов и в общий фонд.
Карты
-----
* Теренс Иден [опубликовал](https://shkspr.mobi/blog/2019/11/creating-an-organization-of-cartographers-for-social-equality-map-with-openstreetmap/) в своем блоге руководство по созданию карты с помощью сервиса OpenLayers, которая повернута на юг и выполнена в [проекции Питерса](https://en.wikipedia.org/wiki/Gall%E2%80%93Peters_projection).
Переходим на OSM
----------------
* Как и многие другие спортивные приложения или порталы, Polar Flow теперь тоже [использует](https://support.polar.com/en/updates/polar-flow-update-new-maps) OpenStreetMap. В качестве причин выбора, среди прочего, отмечается «более подробные данные» и «лучшие тропинки».
Лицензии
--------
* Гийом Ришар предупреждает, что 308 спутниковых снимков или картографических источников для редакторов OSM, таких как iD и JOSM, — [не имеют](https://github.com/osmlab/editor-layer-index/issues/439) известных лицензий. Можете ли вы помочь найти некоторые из них?
Программное обеспечение
-----------------------
* Java WebStart, который использовался для запуска редактора JOSM без установки, [теперь](https://twitter.com/josmeditor/status/1196884836234989569) может быть заменен [OpenWebStart](https://github.com/karakun/OpenWebStart/releases/tag/v1.0.0).
Релизы
------
* На днях должны были быть обновлены серверы [MapOSMatic](https://maposmatic.osm-baustelle.de/). Основная [причина](https://blog.osm-baustelle.de/index.php/2019/11/23/maintenance-notice-nov-30-dec-1/) — обновление Mapnik'a до версии 3.0.22, что в свою очередь означает, что наконец-то векторные шаблоны SVG будут включены в визуализируемые PDF карты в качестве по-настоящему векторных данных, а не преобразованных сначала из растровых изображений достаточно низкого разрешения.
* 17 ноября вышла новая версия [Leaflet 1.6.0.](https://leafletjs.com/2019/11/17/leaflet-1.6.0.html). Исправлены ошибки и незначительные улучшения.
Знаете ли вы …
--------------
* … что на карте [OpenStreetBrowser](https://www.openstreetbrowser.org/#map=13/50.9390/6.9622&categories=xmas) вы можете найти [данные](https://wiki.openstreetmap.org/wiki/Key:xmas:feature), связаные с Рождеством, например, новогодие елки или рождественские рынки?
* … что на карте [Soup Map](https://www.tasteatlas.com/europe/soups) можно посмотреть, кто ест какие супы в разных частях Европы?
* … что не так давно в WikiOSM был [обновлен](https://wiki.openstreetmap.org/wiki/List_of_OSM-based_services) список сервисов, которые используют данные OSM? Обращаем ваше внимание на интересный ресурс [Historic Place](https://wiki.openstreetmap.org/wiki/List_of_OSM-based_services).
* … о сервисе [OpenRailwayMap](https://openrailwaymap.org/)? Этот на сайт, в основе которого OSM, активно обсуждается в списке рассылки [rails\_dev](https://lists.openstreetmap.org/pipermail/rails-dev/2019-November/017276.html).
* … о редакторе [OsmInEdit](https://wiki.openstreetmap.org/wiki/OsmInEdit), с помощью которого можно картографировать помещения? На прошедшей конференции SotM в Гейдельберге данному [редактору](https://osminedit.pavie.info/#18/48.13678/-1.69533/0) на JavaScript был посвящен [доклад](https://media.ccc.de/v/sotm2019-1181-osminedit-a-simple-indoor-editor#t=2).
OSM в СМИ
---------
* «Такие проекты, как Википедия, OpenStreetMap и мир программного обеспечения с открытым исходным кодом — это те конструктивные инструменты, которые я надеялся получить из интернета”, — [пишет](https://www.nytimes.com/2019/11/24/opinion/world-wide-web.html) Тим Бернерс-Ли, изобретатель Всемирной паутины.
Другие „гео“ события
--------------------
* Джефф Боинг из Университета Южной Калифорнии в Лос-Анджелесе [разработал](https://arxiv.org/abs/1910.00118) пакет программного обеспечения с открытым исходным кодом OSMnx. Он помогает градостроителям [создавать](https://www.heise.de/tr/artikel/Geographie-2-0-4587077.html) карты. Инструмент использует OpenstreetMap в качестве картоосновы.
* [Minecraft Earth](https://t3n.de/news/minecraft-earth-da-fuss-1225687/) — игра дополненной реальности на основе OSM теперь доступна и в Западной Европе в качестве версии раннего доступа.
* Согласно одному [исследованию](https://www.sciencedaily.com/releases/2019/11/191122112807.htm), аварийно-спасательные службы могут сократить расходы и сэкономить время, если будут использовать данные со спутниковых снимков почти в реальном времени совместно с рядом других инструментов для принятия решений в случае наводнения.
---
Общение российских участников OpenStreetMap идёт в [чатике](https://t.me/ruosm) Telegram и на [форуме](http://forum.openstreetmap.org/viewforum.php?id=21). Также есть группы в социальных сетях [ВКонтакте](https://vk.com/openstreetmap), [Facebook](https://www.facebook.com/openstreetmap.ru), но в них в основном публикуются новости.
[Присоединяйтесь к OSM!](https://www.openstreetmap.org/user/new)
---
Предыдущие выпуски: [487](https://habr.com/ru/post/478196/), [486](https://habr.com/ru/post/477166/), [485](https://habr.com/ru/post/476060/), [484](https://habr.com/ru/post/475200/), [483](https://habr.com/ru/post/473888/), | https://habr.com/ru/post/479234/ | null | ru | null |
# Можно всё: решение NLP задач при помощи spacy
Обработка естественного языка сейчас используется повсеместно: стремительно развиваются голосовые интерфейсы и чат-боты, разрабатываются модели для обработки больших текстовых данных, продолжает развиваться машинный перевод.
В этой статье мы рассмотрим относительно новую библиотеку SpaCy, которая на данный момент является одним из самых популярных и удобных решений при обработке текста в Python. Её функционал позволяет решать очень широкий спектр задач: от определения частей речи и выделения именованных сущностей до создания собственных моделей для анализа.
Для начала давайте наглядно рассмотрим, как происходит обработка данных в SpaCy. Загруженный для обработки текст последовательно проходит через различные компоненты обработки и сохраняется как экземпляр объекта Doc:
Doc является центральной структурой данных в SpaCy, именно в нём хранятся последовательности слов или, как их ещё называют, токенов. Внутри объекта Doc можно выделить два других типа объекта: Token и Span. Token представляет собой ссылку на отдельные слова документа, а Span – ссылку на последовательность из нескольких слов (их можно создавать самостоятельно):
Ещё одной важной структурой данных является объект Vocab, который хранит набор справочных таблиц, общий для всех документов. Это позволяет экономить память и обеспечивать единый источник информации для всех обрабатываемых документов.
Токены документов связаны с объектом Vocab через хеш, используя который можно получить начальные формы слов или другие лексические атрибуты токенов:
Теперь мы знаем, как устроено хранение и обработка данных в библиотеке SpaCy. А как воспользоваться возможностями, которые она предоставляет? Давайте последовательно рассмотрим операции, с помощью которых можно обработать текст.
### 1. Базовые операции
Прежде чем начинать работу с текстом, следует импортировать языковую модель. Для русского языка существует официальная модель от SpaCy, поддерживающая токенизацию (разбиение текста на отдельные токены) и ряд других базовых операций:
```
from spacy.lang.ru import Russian
```
После импорта и создания экземпляра языковой модели можно начинать обработку текста. Для этого нужно всего лишь передать текст созданному экземпляру:
```
nlp = Russian()
doc = nlp("Съешь ещё этих мягких французских булок, да выпей чаю.")
```
Работа с получившимся объектом Doc очень схожа с работой со списками: можно обращаться к нужному токену по индексу или делать срезы из нескольких токенов. А чтобы получить текст токена или среза, можно использовать атрибут text:
```
token = doc[0]
print(token.text)
span = doc[3:6]
print(span.text)
Съешь
мягких французских булок
```
Для получения дополнительной информации о том, какой тип информации содержится в токене, можно использовать следующие атрибуты:
1. is\_alpha – проверка на то, содержит ли токен только буквенные символы
2. is\_punct – проверка на то, является ли токен знаком пунктуации
3. like\_num – проверка на то, является ли токен числом
```
print("is_alpha: ", [token.is_alpha for token in doc])
print("is_punct: ", [token.is_punct for token in doc])
print("like_num: ", [token.like_num for token in doc])
```
Рассмотрим ещё пример, где на экран выводятся все токены, предшествующие точке. Чтобы получить такой результат, при переборе токенов следует делать проверку следующего токена, используя атрибут token.i:
```
for token in doc:
if token.i+1 < len(doc):
next_token = doc[token.i+1]
if next_token.text == ".":
print(token.text)
чаю
```
### 2. Операции с синтаксисом
Для более сложных операций по обработке текста используются другие модели. Они специально натренированы для задач, связанных с синтаксисом, выделением именованных сущностей и работы со значениями слов. Например, для английского языка существует 3 официальных модели, различающихся размером. Для русского языка на настоящий момент официальная модель ещё не обучена, однако уже есть модель ru2 из сторонних источников, которая умеет работать с синтаксисом.
В конце этой статьи мы разберём, как создавать свои собственные модели или дополнительно обучать существующие, чтобы они лучше работали для конкретных задач.
Чтобы полностью проиллюстрировать возможности SpaCy, в этой статье мы будем использовать модели для английского языка. Давайте установим маленькую модель en\_core\_web\_sm, которая отлично подойдёт для демонстрации возможностей. Для её установки в командной строке необходимо набрать:
```
python -m spacy download en_core_web_sm
```
С использованием этой модели мы можем для каждого из токенов получить часть речи, роль в предложении и токен, от которого он зависит:
```
import spacy
nlp = spacy.load("en_core_web_sm")
doc = nlp("New Apple MacBook set launch tomorrow")
for token in doc:
token_text = token.text
token_pos = token.pos_
token_dep = token.dep_
token_head = token.head.text
print(f"{token_text:<12}{token_pos:<10}" \
f"{token_dep:<10}{token_head:<12}")
```
```
New PROPN compound MacBook
Apple PROPN compound MacBook
MacBook PROPN nsubj set
set VERB ROOT set
to PART aux launch
launch VERB xcomp set
tomorrow NOUN npadvmod launch
```
Несомненно, лучший способ увидеть зависимости – не вчитываться в текстовые данные, а построить синтаксическое дерево. В этом может помочь функция displacy, которой нужно просто передать документ:
```
from spacy import displacy
displacy.render(doc, style='dep', jupyter=True)
```
В результате выполнения кода мы получаем дерево, на котором расположена вся синтаксическая информация о предложении:
Для расшифровки названий тегов можно воспользоваться функций explain:
```
print(spacy.explain("aux"))
print(spacy.explain("PROPN"))
auxiliary
proper noun
```
Здесь на экран выводятся расшифровки аббревиатур, из которых мы можем узнать, что aux обозначает вспомогательную частицу (auxiliary), а PROPN – имя собственное (proper noun).
В SpaCy также реализована возможность узнать начальную форму слова для любого из токенов (для местоимений используется -PRON-):
```
import spacy
nlp = spacy.load("en_core_web_sm")
doc = nlp("I saw a movie yesterday")
print(' '.join([token.lemma_ for token in doc]))
'-PRON- see a movie yesterday'
```
### 3. Выделение именованных сущностей
Часто для работы с текстом требуется выделить сущности, упомянутые в тексте. Чтобы получить список именованных сущностей в документе, используется атрибут doc.ents, а для получения метки для этой сущности – атрибут ent.label\_:
```
import spacy
nlp = spacy.load("en_core_web_sm")
doc = nlp("Apple is looking at buying U.K. startup for 1$ billion")
for ent in doc.ents:
print(ent.text, ent.label_)
Apple ORG
U.K. GPE
1$ billion MONEY
```
Здесь также можно использовать атрибут explain, чтобы узнать расшифровки меток именованных сущностей:
```
print(spacy.explain("GPE"))
```
Countries, cities, states
А функция displacy поможет наглядно обозначить списки сущностей прямо в тексте:
from spacy import displacy
displacy.render(doc, style='ent', jupyter=True)
### 4. Создание собственных шаблонов для поиска текста
Модуль spaCy содержит очень полезный инструмент, который позволяет строить свои собственные шаблоны для поиска текста. В частности, можно искать слова определённой части речи, все формы слова по его начальной форме, делать проверку на тип содержимого в токене. Вот список основных параметров:
Давайте попробуем создать собственный шаблон для распознавания последовательности токенов. Допустим, мы хотим извлечь из текста строки про кубки мира FIFA или ICC Cricket с упоминанием года:
```
import spacy
from spacy.matcher import Matcher
nlp = spacy.load("en_core_web_sm")
matcher = Matcher(nlp.vocab)
pattern = [
{"IS_DIGIT": True},
{"LOWER": {"REGEX": "(fifa|icc)"}},
{"LOWER": "cricket", "OP": "?"},
{"LOWER": "world"},
{"LOWER": "cup"}
]
matcher.add("fifa_pattern", None, pattern)
doc = nlp("2018 ICC Cricket World Cup: Afghanistan won!")
matches = matcher(doc)
for match_id, start, end in matches:
matched_span = doc[start:end]
print(matched_span)
```
```
2018 ICC Cricket World Cup
```
Итак, в этом блоке кода мы импортировали специальный объект Matcher, позволяющий хранить набор пользовательских шаблонов. После его инициализации мы создали шаблон, где указали последовательность токенов. Обратите внимание, что для выбора между ICC и FIFA мы использовали регулярные выражения, а для токена Cricket – ключ, указывающий на необязательность наличия этого токена.
После создания шаблона требуется добавить его к набору с помощью функции add, указав в параметрах уникальный ID шаблона. Результаты поиска представлены в форме списка кортежей. Каждый из кортежей состоит из ID совпадения, а также начального и конечного индексов найденного в документе среза.
### 5. Определение семантической близости
Два слова могут быть очень схожи по смыслу, но как измерить их близость? В подобных задачах на помощь могут прийти семантические вектора. Если два слова или многословных выражения похожи, то их вектора будут лежать близко друг к другу.
Посчитать семантическую близость векторов в SpaCy несложно, если языковая модель была обучена для решения таких задач. Результат сильно зависит от размера модели, поэтому для этой задачи возьмём модель побольше:
```
import spacy
```
```
nlp = spacy.load("en_core_web_md")
doc1 = nlp("I like burgers")
doc2 = nlp("I like pizza")
print(doc1.similarity(doc2))
```
```
0.9244169833828932
```
Значение может колебаться от нуля до единицы: чем ближе к единице, тем больше схожесть. В примере выше мы сравнивали два документа, однако точно так же можно сравнивать отдельные токены и срезы.
Оценка семантической близости может быть полезна при решении множества задач. Например, с её помощью можно настроить рекомендательную систему, чтобы она предлагала пользователю похожие тексты на основе уже прочитанных.
Важно помнить, что семантическая близость очень субъективна и всегда зависит от контекста задачи. Например, фразы «я люблю собак» и «я ненавижу собак» похожи, поскольку обе выражают мнение о собаках, но в то же время сильно различаются по настроению. В некоторых случаях придётся дополнительное обучить языковые модели, чтобы результаты коррелировали с контекстом вашей задачи.
### 6. Создание своих собственных компонентов обработки
Модуль SpaCy поддерживает ряд встроенных компонентов (токенизатор, выделение именованных сущностей), но также позволяет определять свои собственные компоненты. По сути, компоненты – это последовательно вызывающиеся функции, которые принимают на вход документ, изменяют его и отдают обратно. Новые компоненты можно добавлять с помощью атрибута add\_pipe:
```
import spacy
def length_component(doc):
doc_length = len(doc)
print(f"This document is {doc_length} tokens long.")
return doc
nlp = spacy.load("en_core_web_sm")
nlp.add_pipe(length_component, first=True)
print(nlp.pipe_names)
doc = nlp("This is a sentence.")
```
```
['length_component', 'tagger', 'parser', 'ner']
This document is 5 tokens long.
```
В примере выше мы создали и добавили собственную функцию, которая выводит на экран количество токенов в обрабатываемом документе. С помощью атрибута nlp.pipe\_names мы получили порядок выполнения компонентов: как мы видим, созданный компонент первый в списке. Чтобы указать, куда добавить новый компонент, можно использовать следующие параметры:
Возможность добавления пользовательских компонентов – очень мощный инструмент, позволяющий оптимизировать обработку под свои задачи.
### 7. Обучение и обновление моделей
Статистические модели делают прогнозы на основе тех примеров, на которых они обучались. Как правило, точность таких моделей можно улучшить, дополнительно обучив их на примерах, характерных для вашей задачи. Дополнительное обучение существующих моделей может быть очень полезно (например, для распознавания именованных сущностей или синтаксического анализа).
Дополнительные примеры для обучения можно добавлять прямо в интерфейсе SpaCy. Сами примеры должны состоять из текстовых данных и списка меток для этого примера, на которых модель будет обучаться.
В качестве иллюстрации рассмотрим обновление модели для извлечения именованных сущностей. Чтобы обновить такую модель, нужно передать ей множество примеров, которые содержат текст, указание на сущности и их класс. В примерах необходимо использовать целые предложения, поскольку при извлечении сущностей модель во многом ориентируется на контекст предложения. Очень важно всесторонне обучить модель, чтобы она умела распознавать токены, не являющиеся сущностями.
Например:
```
("What to expect at Apple's 10 November event", {"entities": [(18,23,"COMPANY")]})
("Is that apple pie I smell?", {"entities": []})
```
В первом примере упоминается компания: для обучения мы выделяем позиции, где начинается и заканчивается её наименование, а затем проставляем нашу метку о том, что эта сущность является компанией. Во втором примере речь идёт о фрукте, поэтому сущности отсутствуют.
Данные для обучения модели обычно размечаются людьми, однако эту работу можно немного автоматизировать, используя собственные поисковые шаблоны в SpaCy или специализированные программы для разметки (например, [Prodigy](https://prodi.gy/)).
После того, как примеры будут подготовлены, можно приступать непосредственно к обучению модели. Чтобы модель эффективно обучилась, нужно провести серию из нескольких обучений. С каждым обучением модель будет оптимизировать веса тех или иных параметров. Модели в SpaCy используют методику стохастического градиентного спуска, поэтому неплохим решением будет перемешивать примеры при каждом обучении, а также передавать их небольшими порциями (пакетами). Это увеличит надежность оценок градиента.
```
import spacy
import random
from spacy.lang.en import English
TRAINING_DATA = [
("What to expect at Apple's 10 November event",
{"entities": [(18,23,"COMPANY")]})
# Другие примеры...
]
nlp = English()
for i in range(10):
random.shuffle(TRAINING_DATA)
for batch in spacy.util.minibatch(TRAINING_DATA):
texts = [text for text, annotation in batch]
annotations = [annotation for text, annotation in batch]
nlp.update(texts, annotations)
nlp.to_disk("model")
```
В примере выше цикл состоял из 10 обучений. После завершения обучения модель была сохранена на диск, в папку model.
Для случаев, когда нужно не просто обновить, а создать новую модель, перед началом обучения требуется совершить ряд операций.
Рассмотрим процесс создания новой модели для выделения именованных сущностей:
```
nlp = spacy.blank("en")
ner = nlp.create_pipe("ner")
nlp.add_pipe(ner)
ner.add_label("COMPANY")
nlp.begin_training()
```
Сначала мы создаём пустую модель при помощи функции spacy.blank(«en»). Модель содержит только языковые данные и правила токенизации. Затем добавляем компонент ner, отвечающий за выделение именованных сущностей, и с помощью атрибута add\_label добавляем метки для сущностей. После чего применяем функцию nlp.begin\_training(), чтобы инициализировать модель для обучения со случайным распределением весов. Ну а дальше достаточно будет обучить модель, как было показано в предыдущем примере. | https://habr.com/ru/post/531940/ | null | ru | null |
# Mysql performance
Написание этой статьи навеяно вот этой трилогией: [один](http://habrahabr.ru/blogs/mysql/38907/), [два](http://habrahabr.ru/blogs/mysql/39260/), [три](http://habrahabr.ru/blogs/mysql/39818/). Захотелось добавить свои 0.02$, по использованию трюков и особенностей.
Чтоб мне не запутаться в мыслях, в первом своём посте, возмём примеры запросов из одного open-source продукта. Используемые «хитрости» работают также на PostgreSQL, Oracle, SQLite, DB2 и не являются MySQL направленными, хотя оптимизация в первую очередь нацелена на MySQL InnoDB:
> `SELECT h.hostid,hg.groupid,h.name
>
> FROM hosts h,hosts\_groups hg
>
> WHERE (hg.groupid IN ('4'))
>
> AND hg.hostid=h.hostid
>
> AND hg.groupid BETWEEN 000000000000000 AND 099999999999999
>
> AND h.status IN (0,1)
>
> AND EXISTS (
>
> SELECT hh.hostid
>
> FROM hosts hh, hosts\_groups hgg, rights r, users\_groups ug
>
> WHERE hh.hostid=h.hostid
>
> AND hh.hostid=hgg.hostid
>
> AND r.id=hgg.groupid
>
> AND r.groupid=ug.usrgrpid
>
> AND ug.userid=3
>
> AND r.permission>=3
>
> AND NOT EXISTS(
>
> SELECT hggg.groupid
>
> FROM hosts\_groups hggg, rights rr, users\_groups gg
>
> WHERE hggg.hostid=hgg.hostid
>
> AND rr.id=hggg.groupid
>
> AND rr.groupid=gg.usrgrpid
>
> AND gg.userid=3
>
> AND rr.permission<3
>
> ))
>
> ORDER BY h.name ASC
>
> LIMIT 1001
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Ситуация: есть авторизированный пользователь, пользователь принадлежит к группе пользователей. Есть хосты принадлежащие группе хостов.
Суть: вытащить хосты к которым пользователь имеет доступ. Доступ даётся группам пользователей на группы хостов.
Первое на что хочу обратить внимание это на условие [EXISTS](http://dev.mysql.com/doc/refman/5.0/en/exists-and-not-exists-subqueries.html). Очень редко вижу использование этой структуры. EXISTS — это подзапрос, который проверят наличие строк в подзапросе. Такая конструкция запроса позволяет манипулировать используемыми в запросе индексами (как в основном запросе, так и в подзапросе) вне зависимости от общего запроса, к тому же, в случае успеха, подзапрос останавливается на первой найденной строке, удовлетворяющей запросу. Манипулировать ключами часто приходится когда в запросе используется сортировка. Поскольку MySQL не может использовать разные ключи для поиска и сортировки.
Если запрос происходит по одной таблице, то иногда можно использовать такие хитрости:
> `CREATE TABLE events (
>
> eventid bigint unsigned NOT NULL,
>
> source integer DEFAULT '0' NOT NULL,
>
> object integer DEFAULT '0' NOT NULL,
>
> objectid bigint unsigned DEFAULT '0' NOT NULL,
>
> clock integer DEFAULT '0' NOT NULL,
>
> value integer DEFAULT '0' NOT NULL,
>
> acknowledged integer DEFAULT '0' NOT NULL,
>
> ns integer DEFAULT '0' NOT NULL,
>
> value\_changed integer DEFAULT '0' NOT NULL,
>
> PRIMARY KEY (eventid)
>
> ) ENGINE=InnoDB;
>
> CREATE INDEX events\_1 ON events (object,objectid,eventid);
>
> CREATE INDEX events\_2 ON events (clock,eventid);
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
> `EXPLAIN
>
> SELECT eventid,clock,value
>
> FROM events
>
> WHERE objectid=17131
>
> AND object=0
>
> AND clock>=1325635327
>
> ORDER BY clock DESC, eventid DESC;
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
`+----+-------------+--------+------+-------------------+----------+---------+-------------+------+-----------------------------+
| id | select_type | table | type | possible_keys | key | key_len | ref | rows | Extra |
+----+-------------+--------+------+-------------------+----------+---------+-------------+------+-----------------------------+
| 1 | SIMPLE | events | ref | events_1,events_2 | events_1 | 12 | const,const | 113056 | Using where; Using filesort |
+----+-------------+--------+------+-------------------+----------+---------+-------------+------+-----------------------------+`
Например MySQL посчитал, что использовать в WHERE выгоднее индекс «events\_1», это и понятно, ведь в WHERE задействованы два поля ключа, но он не учёл, что результат содержит 100к строк и их надо сортировать.
В данном случае, изменив в запросе критерий первого поля выбранного MySQL индекса:
> `EXPLAIN
>
> SELECT eventid,clock,value
>
> FROM events
>
> WHERE objectid=17131
>
> AND object+0=0
>
> AND clock>=1325635327
>
> ORDER BY clock DESC, eventid DESC;
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
`+----+-------------+--------+-------+---------------+----------+---------+------+------+-------------+
| id | select_type | table | type | possible_keys | key | key_len | ref | rows | Extra |
+----+-------------+--------+-------+---------------+----------+---------+------+------+-------------+
| 1 | SIMPLE | events | range | events_2 | events_2 | 4 | NULL | 113056 | Using where |
+----+-------------+--------+-------+---------------+----------+---------+------+------+-------------+`
MySQL не может использовать индексы на модифицированных значениях полей, в данном случае применив арифметическое присваивание мы заставляем использовать индекс events\_2, который подходит как для выборки данных так и для сортировки, что видно из EXPLAIN.
Обращаю внимание, что MySQL не умеет сортировать по индексу, если используемые поля сортируются в разном порядке:
> `EXPLAIN
>
> SELECT eventid,clock,value
>
> FROM events
>
> WHERE objectid=17131
>
> AND object+0=0
>
> AND clock>=1325635327
>
> ORDER BY clock ASC, eventid DESC;
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
`+----+-------------+--------+-------+---------------+----------+---------+------+------+-----------------------------+
| id | select_type | table | type | possible_keys | key | key_len | ref | rows | Extra |
+----+-------------+--------+-------+---------------+----------+---------+------+------+-----------------------------+
| 1 | SIMPLE | events | range | events_2 | events_2 | 4 | NULL | 113056 | Using where; Using filesort |
+----+-------------+--------+-------+---------------+----------+---------+------+------+-----------------------------+`
Так же, индекс не используется, если сортировка происходит по полям стоящим в другом порядке нежели в индексе. Вообще, MySQL хранит индексы как [B-дерево](http://en.wikipedia.org/wiki/B-tree), по-этому использовать поля стоящие в середине или конце индекса не получится.
Если невозможно использовать один индекс для выборки и сортировки, то случалось так, что MySQL не правильно делал оценку и выбирал индексы для сортировки. Это случается при прохождении некого количества записей в таблице, когда становится выгодней, чтоб MySQL использовать индекс для выборки, а не для сортировки или на оборот. Такие моменты предусмотреть сложно, и выявляются проверяя одни и те же запросы на разном количестве записей.
Вернёмся к первому запросу. На мой взгляд лучше сортировать уже средствами исполняемого скрипта, разумеется если выборка в пределах тысяч строк.
Во-первых, в этом случае MySQL не приходится делать полную выборку из таблицы, а останавливается по достижению LIMIT;
Во-вторых, редко когда действительно нужно одновременно выводить больше информации, если это только не отчёты;
В-третьих, страницы с большим количеством информации будут медленными, даже если это просто выпадающий список с 1000+ вариантами, это уже не юзабельно;
В-четвёртых, в MySQL нет натуральной сортировки;
Но в реальных примерах это редко возможно, т.к. приходится давать пользователям возможность сортировки, да и без указания сортировки MySQL не гарантирует одинаковую выборку. Как вариант можно в индекс ставить первым полем, то по которому чаще происходит сортировка, тем самым MySQL будет использовать один индекс и для поиска и для сортировки.
COUNT, многие делают второй запрос для постраничного вывода, но тот же гугле, хоть и говорит, что найдено миллионы+ совпадений, реально вам выдаст, примерно, первую тысячу и всё. Причём на последней странице сообщит, что на самом деле найдено меньше. Так вот, выбрав 1001 строку мы просто говорим пользователю, что найдено 1000+ совпадений и нет нужды выбирать на данном этапе больше. Кода пользователь запросит больше, тогда и будем выбирать шаг за шагом по 1ой страничке. Проверяя на 1 строку больше чем надо.
Индексы. По мере запросов к таблицам, индексы этих таблиц кешируются в памяти и там остаются пока не закончится память и тогда их «просят» выйти. Так вот, если у вас гигабайты информации, то индексы будут занимать ± 40% процентов места, зависит от количества тех самых индексов. К примеру у Вас скромный сервер с 16гб оперативки выделенными под MySQL. При запросе в таблицу с индексом весом в 10гб+, вся память выделенная под MySQL будет высвобождена и заполнена этим индексом и все предыдущие закешированные индексы скинутся в небытие. Таким образом, делая один тяжёлый запрос вы можете убить весь перформанс сервера. Что делать? Вариантов много, но не сказал бы, что они просты и сходятся к хранению больших >10 миллионов+ таблиц на отдельных хранителях, например [BigTable](http://en.wikipedia.org/wiki/BigTable), [NoSQL](http://en.wikipedia.org/wiki/NoSQL) или даже [NoSQL для MySQL](http://yoshinorimatsunobu.blogspot.com/2010/10/using-mysql-as-nosql-story-for.html) и т.д.
На этом, пока всё. Буду рад выслушать ваше решения и советы по выше сказанному. | https://habr.com/ru/post/135775/ | null | ru | null |
# Введение в юнит-тестирование в Unity
Вам любопытно, как работает юнит-тестирование в Unity? Не знаете, что такое юнит-тестирование в целом? Если вы ответили положительно на эти вопросы, то данный туториал будет вам полезен. Из него вы узнаете о юнит-тестировании следующее:
* Что это такое
* Его польза
* Достоинства и недостатки
* Как оно работает в Unity при использовании Test Runner
* Как писать и выполнять юнит-тесты, которые будут проходить проверку
> *Примечание*: в этом туториале предполагается, что вы знакомы с языком C# и основами разработки в Unity. Если вы новичок в Unity, то [изучите сначала другие туториалы по этому движку](https://www.raywenderlich.com/unity).
Что такое юнит-тест (Unit Test)?
--------------------------------
Прежде чем углубляться в код, важно получить чёткое понимание того, что такое юнит-тестирование. Если говорить просто, то юнит-тестирование — это тестирование… юнитов.
*Юнит-тест* (в идеале) предназначен для тестирования отдельного «юнита» кода. Состав «юнита» может варьироваться, но важно помнить, что юнит-тестирование должно тестировать ровно один «элемент» за раз.
Юнит-тесты необходимо создавать для проверки того, что небольшой логический фрагмент кода в конкретном сценарии выполняется именно так, как вы ожидаете. Это может быть сложно понять, прежде чем вы начнёте писать собственные юнит-тесты, поэтому давайте рассмотрим пример:
Вы написали метод, позволяющий пользователю вводить имя. Метод написан так, что в имени не допускаются цифры, а само имя может состоять только из десяти или менее символов. Ваш метод перехватывает нажатие каждой клавиши и добавляет соответствующий символ в поле `name`:
```
public string name = ""
public void UpdateNameWithCharacter(char: character)
{
// 1
if (!Char.IsLetter(char))
{
return;
}
// 2
if (name.Length >= 10)
{
return;
}
// 3
name += character;
}
```
Что здесь происходит:
1. Если символ не является буквой, то код выполняет предварительный выход из функции и не добавляет символ в строку.
2. Если длина имени составляет десять или более символов, то код не позволяет пользователю добавить ещё один символ.
3. Если эти две проверки пройдены, то код добавляет в конец имени символ.
Этот юнит можно протестировать, потому что он представляет собой «модуль» выполняемой работы. Юнит-тесты *принудительно выполняют* логику метода.
Пример юнит-тестов
------------------
Как нам написать юнит-тесты для метода `UpdateNameWithCharacter`?
Прежде чем мы начнём реализовывать эти юнит-тесты, нужно тщательно продумать, что делают эти тесты, и придумать для них названия.
Посмотрите на показанные ниже примеры названий юнит-тестов. Из названий должно быть понятно, что они проверяют:
`UpdateNameDoesntAllowCharacterAddingToNameIfNameIsTenOrMoreCharactersInLength`
`UpdateNameAllowsLettersToBeAddedToName`
`UpdateNameDoesntAllowNonLettersToBeAddedToName`
Из этих названий тестовых методов видно, что мы действительно проверяем, выполняется ли «юнит» работы методом `UpdateNameWithCharacter`. Эти названия тестов могут показаться слишком длинными и подробными, но это нам на пользу.
Каждый написанный вами юнит-тест является частью комплекса тестов. *Комплекс тестов* содержит все юнит-тесты, относящиеся к логической группе функционала (например, «юнит-тесты боя»). Если любой тест из комплекта не проходит проверку, то её не проходит весь комплект тестов.
Запуск игры
-----------
Откройте *Crashteroids Starter project* (скачать его можно [отсюда](https://koenig-media.raywenderlich.com/uploads/2019/01/Crashteroids-project-files.zip)), а затем откройте сцену *Game* из папки *Assets / RW / Scenes*.
Нажмите на *Play*, чтобы запустить Crashteroids, а затем нажмите на кнопку *Start Game*. Перемещайте космический корабль стрелками *влево* и *вправо* на клавиатуре.
Для выстрела лазерным лучом нажимайте *пробел*. Если луч попадёт в астероид, то счёт увеличится на единицу. Если астероид сталкивается с кораблём, то корабль взрывается и игра завершается (с возможностью начать заново).
Попробуйте немного поиграть и убедиться, что после столкновения астероида с кораблём появляется надпись Game Over.
Начинаем работу с Unity Test Runner
-----------------------------------
Теперь, когда мы знаем, как выполняется игра, настало время писать юнит-тесты, чтобы проверить, что всё работает как надо. Таким образом, если вы (или кто-то ещё) решите обновить игру, то будете уверены, что обновление не сломает ничего из работавшего раньше.
Чтобы писать тесты, сначала нужно узнать о Unity Test Runner. *Test Runner* позволяет выполнять тесты и проверять, проходятся ли они успешно. Чтобы открыть Unity Test Runner, выберите *Window ▸ General ▸ Test Runner*.
После того, как в новом окне откроется Test Runner, можно будет упростить себе жизнь, нажав на окно Test Runner и *перетащив* его на место рядом с окном Scene.
Подготовка NUnit и папок тестов
-------------------------------
Test Runner — это предоставляемая Unity функция юнит-тестирования, но она использует фреймворк *NUnit*. Когда вы начнёте работать с юнит-тестами серьёзнее, то рекомендую изучить [wiki по NUnit](https://github.com/nunit/docs/wiki), чтобы узнать больше. Про всё необходимое на первое время будет рассказано в этой статье.
Для запуска тестов нам сначала нужно создать папку тестов, в которой будут храниться классы тестов.
В окне *Project* выберите папку *RW*. Посмотрите на окно *Test Runner* и убедитесь, что выбран *PlayMode*.
Нажмите кнопку с названием *Create PlayMode Test Assembly Folder*. Вы увидите, что в папке RW появится новая папка. Нас устроит стандартное название *Tests*, поэтому можно просто нажать *Enter*.
Возможно, вам интересно, что это за две разные вкладки внутри Test Runner.
Вкладка *PlayMode* используется для тестов, выполняемых в режиме Play (когда игра выполняется в реальном времени). Тесты вкладки *EditMode* выполняются вне режима Play, что удобно для тестирования таких вещей, как пользовательские behaviors в Inspector.
В этом туториале мы будем рассматривать тесты PlayMode. Но когда освоитесь, можете попробовать поэкспериментировать и с тестированием в EditMode. *При работе с Test Runner в этом туториале всегда проверяйте, что выбрана вкладка PlayMode*.
Что находится в комплекте тестов?
---------------------------------
Как мы узнали выше, юнит-тест — это функция, тестирующая поведение небольшого конкретного фрагмента кода. Поскольку юнит-тест является методом, для его запуска он должен находиться в файле класса.
Test Runner обходит все файлы классов тестов и выполняет юнит-тесты из них. Файл класса, содержащий юнит-тесты, называется комплектом тестов (test suite).
В комплекте тестов мы логически подразделяем наши тесты. Мы должны разделять код тестов на отдельные логичные комплекты (например, комплект тестов для физики и отдельный комплект для боя). В этом туториале нам понадобится только один комплект тестов, и настало время его создать.
Подготовка тестовой сборки и комплекта тестов
---------------------------------------------
Выберите папку *Tests* и в окне *Test Runner* нажмите на кнопку *Create Test Script in current folder*. Назовите новый файл *TestSuite*.
Кроме нового файла C# движок Unity также создаёт ещё один файл под названием *Tests.asmdef*. Это *файл определения сборки (assembly definition file)*, который используется для того, чтобы показать Unity, где находятся зависимости файла теста. Это нужно, потому что код готового приложения содержится отдельно от тестового кода.
Если у вас возникла ситуация, когда Unity не может найти файлы тестов или тесты, то убедитесь, что существует файл определения сборки, в который включён ваш комплект тестов. Следующим шагом будет его настройка.
Чтобы код тестов имел доступ к классам игры, мы создадим сборку кода классов и зададим ссылку в сборке Tests. Нажмите на папку *Scripts*, чтобы выбрать её. Нажмите правой клавишей на эту папку и выберите *Create ▸ Assembly Definition*.
Назовите файл *GameAssembly*.
Нажмите на папку *Tests*, а затем на файл определения сборки *Tests*. В *Inspector* нажмите на кнопку *плюс* под заголовком *Assembly Definition References*.
Вы увидите поле *Missing Reference*. Нажмите на *точку* рядом с этим полем, чтобы открыть окно выбора. Выберите файл *GameAssembly*.
Вы должны увидеть файл сборки GameAssembly в разделе ссылок. Нажмите на кнопку *Apply*, чтобы сохранить эти изменения.
Если вы не выполните эти действия, то не сможете ссылаться на файлы классов игры внутри файлов юнит-тестов. Разобравшись с этим, можно приступать к коду.
Пишем первый юнит-тест
----------------------
Дважды нажмите на скрипт *TestSuite*, чтобы открыть его в редакторе кода. Замените весь код на такой:
```
using UnityEngine;
using UnityEngine.TestTools;
using NUnit.Framework;
using System.Collections;
public class TestSuite
{
}
```
Какие тесты нам нужно написать? Честно говоря, даже в такой крошечной игре, как Crashteroids, можно написать довольно много тестов для проверки того, что всё работает как надо. В этом туториале мы ограничимся только ключевыми областями: распознаванием коллизий и базовой игровой механикой.
> *Примечание*: когда дело доходит до написания юнит-тестов продукта уровня продакшена, стоит уделить достаточно времени, чтобы учесть все граничные случаи, которые нужно протестировать во всех областях кода.
В качестве первого теста неплохо будет проверить, действительно ли астероиды движутся вниз. Им будет сложно столкнуться с кораблём, если они будут от него отдаляться! Добавим в скрипт *TestSuite* следующий метод и частную переменную:
```
private Game game;
// 1
[UnityTest]
public IEnumerator AsteroidsMoveDown()
{
// 2
GameObject gameGameObject =
MonoBehaviour.Instantiate(Resources.Load("Prefabs/Game"));
game = gameGameObject.GetComponent();
// 3
GameObject asteroid = game.GetSpawner().SpawnAsteroid();
// 4
float initialYPos = asteroid.transform.position.y;
// 5
yield return new WaitForSeconds(0.1f);
// 6
Assert.Less(asteroid.transform.position.y, initialYPos);
// 7
Object.Destroy(game.gameObject);
}
```
Здесь всего несколько строк кода, но они выполняют множество действий. Так что давайте остановимся и разберёмся с каждой частью:
1. Это *атрибут*. Атрибуты определяют особые поведения компилятора. Данный атрибут сообщает компилятору Unity, что код является юнит-тестом. Благодаря этому он отобразится в Test Runner при запуске тестов.
2. Создаём экземпляр Game. Всё остальное вложено в game, поэтому когда мы создадим его, в нём будет находиться всё, что нужно тестировать. В среде продакшена скорее всего все элементы не будут находиться внутри одного префаба. Поэтому вам потребуется воссоздать все объекты, необходимые в сцене.
3. Здесь мы создаём астероид, чтобы можно было следить за тем, двигается ли он. Метод `SpawnAsteroid` возвращает экземпляр созданного астероида. Компонент Asteroid имеет метод `Move` (если вам любопытно, как работает движение, то можете взглянуть на скрипт *Asteroid* внутри *RW / Scripts*).
4. Отслеживание исходной позиции необходимо для того, чтобы убедиться, что астероид сместился вниз.
5. Все юнит-тесты Unity являются корутинами, поэтому нужно добавить мягкий возврат. Также мы добавляем шаг времени в 0,1 секунды, чтобы симулировать течение времени, за которое астероид должен был двигаться вниз. Если вам не нужно симулировать шаг времени, то можно вернуть null.
6. Это этап *утверждения (assertion)*, на котором мы утверждаем, что позиция астероида меньше исходной позиции (то есть он сдвинулся вниз). Понимание утверждений — важная часть юнит-тестирования, и NUnit предоставляет различные методы утверждений. Прохождение или непрохождение теста определяется этой строкой.
7. Разумеется, никто не наругает вас за оставленный после завершения тестов беспорядок, но другие тесты могут из-за него закончиться неудачно. Всегда важно подчищать (удалять или сбрасывать) код после юнит-теста, чтобы при запуске следующего юнит-теста не оставалось артефактов, которые могли бы повлиять на этот тест. Нам достаточно просто удалить игровой объект, потому что для каждого теста мы создаём полностью новый экземпляр game.
Прохождение тестов
------------------
Отлично, вы написали свой первый юнит-тест, но как узнать, что он работает? Разумеется, с помощью Test Runner! В окне Test Runner раскройте все строки со стрелками. Вы должны увидеть тест `AsteroidsMoveDown` в списке с серыми кружками:
Серый кружок означает, что тест пока не выполнялся. Если тест был запущен и пройден, то рядом показывается зелёная стрелка. Если тест завершился с ошибкой, то рядом с ним будет отображён красный X. Запустим тест, нажав на кнопку *RunAll*.
При этом создастся временная сцена и будет запущен тест. После завершения вы должны увидеть, что тест пройден.
Вы успешно написали первый юнит-тест, утверждающий, что создаваемые астероиды движутся вниз.
> *Примечание*: прежде чем начать писать собственные юнит-тесты, вам нужно понять реализацию, которую вы тестируете. Если вам любопытно, как работает тестируемая вами логика, то изучите код в папке *RW / Scripts*.
Использование интеграционных тестов
-----------------------------------
Прежде чем двигаться глубже в кроличью нору юнит-тестов, самое время рассказать, что такое интеграционные тесты, и чем они отличаются от юнит-тестирования.
*Интеграционные тесты* — это тесты, проверяющие как работают «модули» кода совместно. «Модуль» — это ещё один нечёткий термин. Важное отличие заключается в том, что интеграционные тесты должны тестировать работу ПО в настоящем продакшене (т.е. когда игрок по-настоящему играет в игру).
Допустим, вы сделали игру с боями, где игрок убивает монстров. Можно создать интеграционный тест, чтобы убедиться, что когда игрок убивает 100 врагов, открывается достижение («ачивка»).
Этот тест затронет несколько модулей кода. Скорее всего, он будет касаться физического движка (распознавание коллизий), диспетчеров врагов (отслеживающих здоровье врага и обрабатывающих урон, а также переходящих к другим связанным событиям) и трекера событий, отслеживающего все сработавшие события (например «монстр убит»). Затем, когда настанет время разблокировки достижения, он может вызвать диспетчер достижений.
Интеграционный тест будет симулировать игрока, убивающего 100 монстров, и проверять, разблокируется ли достижение. Он очень отличается от юнит-теста, потому что тестирует крупные компоненты кода, работающие совместно.
В этом туториале мы не будем изучать интеграционные тесты, но это должно показать разницу между «юнитом» работы (и то, зачем её юнит-тестируют) и «модулем» кода (и то, зачем его тестируют интеграционно).
Добавление теста в комплект тестов
----------------------------------
Следующий тест будет тестировать конец игры, когда корабль сталкивается с астероидом. Открыв в редакторе кода *TestSuite*, добавьте под первым юнит-тестом показанный ниже тест и сохраните файл:
```
[UnityTest]
public IEnumerator GameOverOccursOnAsteroidCollision()
{
GameObject gameGameObject =
MonoBehaviour.Instantiate(Resources.Load("Prefabs/Game"));
Game game = gameGameObject.GetComponent();
GameObject asteroid = game.GetSpawner().SpawnAsteroid();
//1
asteroid.transform.position = game.GetShip().transform.position;
//2
yield return new WaitForSeconds(0.1f);
//3
Assert.True(game.isGameOver);
Object.Destroy(game.gameObject);
}
```
Мы уже видели бОльшую часть этого кода в предыдущем тесте, но здесь есть некоторые отличия:
1. Мы вынуждаем астероид и корабль столкнуться, явно задавая астероиду ту же позицию, что и кораблю. Это создаст коллизию их хитбоксов и приведёт к концу игры. Если вам любопытно, как работает этот код, то взгляните на файлы *Ship*, *Game*, и *Asteroid* в папке Scripts.
2. Шаг времени необходим, чтобы сработало событие Collision физического движка, поэтому возвращается задержка в 0,1 секунды.
3. Это утверждение истины, и оно проверяет, что флаг `gameOver` в скрипте Game принимает значение true. Флаг принимает значение true во время работы игры, когда уничтожается корабль, то есть мы тестируем, чтобы убедиться, что ему присваивается значение true после уничтожения корабля.
Вернитесь в окно Test Runner и вы увидите, что там появился новый юнит-тест.
На этот раз мы запустим вместо всего комплекта тестов только этот. Нажмите на *GameOverOccursOnAsteroidCollision*, а затем на кнопку *Run Selected*.
И вуаля, мы прошли ещё один тест.
Этапы настройки и разрушения
----------------------------
Вы могли заметить, что в двух наших тестах есть повторяющийся код: там, где создаётся игровой объект Game и где задаётся ссылка на скрипт Game:
```
GameObject gameGameObject = MonoBehaviour.Instantiate(Resources.Load("Prefabs/Game"));
game = gameGameObject.GetComponent();
```
Также вы заметите, что повтор есть в уничтожении игрового объекта Game:
```
Object.Destroy(game.gameObject);
```
При тестировании такое случается очень часто. Когда дело доходит до запуска юнит-тестов, то на самом деле существует два этапа: этап *«настройки» (Setup)* и этап *«разрушения» (Tear Down)*.
Весь код внутри метода Setup будет выполняться до юнит-теста (в этом комплекте), а весь код внутри метода Tear Down будет выполняться после юнит-теста (в этом комплекте).
Настало время упростить нашу жизнь, переместив код setup и tear down в специальные методы. Откройте редактор кода и добавьте следующий код в начало файла *TestSuite*, прямо перед первым атрибутом [UnityTest]:
```
[SetUp]
public void Setup()
{
GameObject gameGameObject =
MonoBehaviour.Instantiate(Resources.Load("Prefabs/Game"));
game = gameGameObject.GetComponent();
}
```
Атрибут `SetUp` указывает, что этот метод вызывается до выполнения каждого теста.
Затем добавим следующий метод и сохраним файл:
```
[TearDown]
public void Teardown()
{
Object.Destroy(game.gameObject);
}
```
Атрибут `TearDown` указывает, что этот метод вызывается после выполнения каждого теста.
Подготовив код настройки и разрушения, удалим строки кода, присутствующие в этих методах, и заменим их вызовами соответствующих методов. После этого код будет выглядеть так:
```
public class TestSuite
{
private Game game;
[SetUp]
public void Setup()
{
GameObject gameGameObject =
MonoBehaviour.Instantiate(Resources.Load("Prefabs/Game"));
game = gameGameObject.GetComponent();
}
[TearDown]
public void Teardown()
{
Object.Destroy(game.gameObject);
}
[UnityTest]
public IEnumerator AsteroidsMoveDown()
{
GameObject asteroid = game.GetSpawner().SpawnAsteroid();
float initialYPos = asteroid.transform.position.y;
yield return new WaitForSeconds(0.1f);
Assert.Less(asteroid.transform.position.y, initialYPos);
}
[UnityTest]
public IEnumerator GameOverOccursOnAsteroidCollision()
{
GameObject asteroid = game.GetSpawner().SpawnAsteroid();
asteroid.transform.position = game.GetShip().transform.position;
yield return new WaitForSeconds(0.1f);
Assert.True(game.isGameOver);
}
}
```
Тестируем Game Over и стрельбу лазером
--------------------------------------
Подготовив упрощающие нашу жизнь методы настройки и разрушения, можно приступить к добавлению новых тестов, в которых они используются. Следующий тест должен проверять, что когда игрок нажимает *New Game*, значение *gameOver bool* не равно true. Добавьте такой тест в конец файла и сохраните его:
```
[UnityTest]
public IEnumerator NewGameRestartsGame()
{
//1
game.isGameOver = true;
game.NewGame();
//2
Assert.False(game.isGameOver);
yield return null;
}
```
Это уже должно казаться вам привычным, но стоит упомянуть следующее:
1. Эта часть кода подготавливает этот тест к тому, что булев флаг `gameOver` должен иметь значение true. При вызове метода `NewGame` он должен снова присваивать флагу значение `false`.
2. Здесь мы утверждаем, что bool `isGameOver` равен `false`, что должно быть справедливо при вызове новой игры.
Вернитесь в Test Runner и вы должны увидеть что там появился новый тест *NewGameRestartsGame*. Запустите этот тест, как мы делали это ранее, и вы увидите, что он успешно выполняется:
Утверждение о движении лазерного луча
-------------------------------------
Следующим тестом нужно добавить тест того, что выстреливаемый кораблём лазерный луч летит вверх (аналогично первому написанному нами юнит-тесту). Откройте в редакторе файл *TestSuite*. Добавьте следующий метод и сохраните файл:
```
[UnityTest]
public IEnumerator LaserMovesUp()
{
// 1
GameObject laser = game.GetShip().SpawnLaser();
// 2
float initialYPos = laser.transform.position.y;
yield return new WaitForSeconds(0.1f);
// 3
Assert.Greater(laser.transform.position.y, initialYPos);
}
```
Вот что делает этот код:
1. Получает ссылку на созданный лазерный луч, испущенный из корабля.
2. Исходная позиция записывается, чтобы мы могли проверить, что он движется вверх.
3. Это утверждение соответствует утверждению из юнит-теста `AsteroidsMoveDown`, только теперь мы утверждаем, что значение больше (то есть лазер движется вверх).
Сохраните файл и вернитесь в Test Runner. Запустите тест *LaserMovesUp* и понаблюдайте за его прохождением:
Теперь вы уже должны начать разбираться, как всё устроено, поэтому настало время добавить последние два теста и завершить туториал.
Проверка того, что лазер уничтожает астероиды
---------------------------------------------
Далее мы убедимся, что при попадании лазер уничтожает астероид. Откройте редактор и добавьте в конец *TestSuite* следующий тест, а потом сохраните файл:
```
[UnityTest]
public IEnumerator LaserDestroysAsteroid()
{
// 1
GameObject asteroid = game.GetSpawner().SpawnAsteroid();
asteroid.transform.position = Vector3.zero;
GameObject laser = game.GetShip().SpawnLaser();
laser.transform.position = Vector3.zero;
yield return new WaitForSeconds(0.1f);
// 2
UnityEngine.Assertions.Assert.IsNull(asteroid);
}
```
Вот как это работает:
1. Мы создаём астероид и лазерный луч, и присваиваем им одинаковую позицию для срабатывания коллизии.
2. Это особая проверка с важным отличием. Видите, что мы явным образом используем для этого теста *UnityEngine.Assertions*? Так происходит потому, что в Unity есть особый класс *Null*, отличающийся от «обычного» класса Null. Утверждение фреймворка NUnit `Assert.IsNull()` *не будет работать* в проверках Unity на null. При проверках на null в Unity, нужно явным образом использовать UnityEngine.Assertions.Assert, а не Assert из NUnit.
Вернитесь в Test Runner и запустите новый тест. Вы увидите радующий нас зелёный значок.
Тестировать или не тестировать — вот в чём вопрос
-------------------------------------------------
Решение придерживаться юнит-тестов — непростое решение, и к нему не стоит относиться легкомысленно. Однако преимущества тестов стоят вложенных усилий. Существует даже методология разработки, называющаяся *разработкой через тестирование* (Test Driven Development, TDD).
Работая в рамках TDD, вы пишете тесты до написания самой логики приложения. Сначала вы создаёте тесты, убеждаетесь, что программа их не проходит, а затем пишете только код, предназначенный для прохождения тестов. Пусть это очень отличающийся подход к кодингу, но он гарантирует, что вы пишете код пригодным для тестирования образом.
Помните об этом, когда приступите к работе над следующим проектом. Но пока время писать собственные юнит-тесты, для которых нужна игра, которую мы вам и предоставили.
> *Примечание*: нужно принять решение — тестировать только общие методы, или ещё и частные. Некоторые люди считают, что частные методы должны тестироваться только через использующие их общие методы. Это может сделать «юнит» кода, который нужно протестировать, довольно большим и может оказаться нежелательным. С другой стороны, тестирование частных методов может быть проблематичным и требовать особых фреймворков или инструментов рефлексии. Каждый из вариантов имеет свою плюсы и минусы, рассмотрение которых не входит в рамки данного туториала. В этом туториале все методы сделаны общими, чтобы их проще было отслеживать, поэтому не берите его в качестве примера при написании кода для продакшена.
Тестирование может быть большим вложением усилий, поэтому стоит рассмотреть достоинства и недостатки добавления юнит-тестирования в ваш проект:
Достоинства юнит-тестирования
-----------------------------
У юнит-тестирования есть множество важных плюсов, в том числе и такие:
* Оно даёт уверенность, что метод ведёт себя так, как ожидалось.
* Служит документацией для новых людей, изучающих кодовую базу (юнит-тесты отлично подходят для преподавания).
* Заставляет вас писать код тестируемым образом.
* Позволяет изолировать и устранять ошибки быстрее.
* Не позволяет будущим обновлениям добавлять новые баги в старый работающий код (они называются регрессионными ошибками).
Недостатки юнит-тестирования
----------------------------
Однако у вас может и не быть времени или бюджета на юнит-тестирование. Вот его недостатки которые нужно учесть:
* Написание тестов может занять больше времени, чем сам код.
* Плохие или неточные тесты создают ложную уверенность.
* Для правильной реализации нужно больше знаний.
* Возможно, важные части кодовой базы нельзя будет покрыть тестами.
* Некоторые фреймворки не позволяют с лёгкостью тестировать частные методы, что может усложнить юнит-тестирование.
* Если тесты слишком хрупки (их слишком легко не пройти по ошибочным причинам), то на обслуживание может уйти много времени.
* Юнит-тесты не отлавливают интеграционные ошибки.
* UI тестировать сложно.
* Неопытные разработчики могут тратить зря время на тестирование не тех аспектов.
* Иногда тестирование элементов с внешними зависимостями или зависимостями времени выполнения может быть очень сложным.
Тестирование того, что при уничтожении астероидов увеличивается счёт
--------------------------------------------------------------------
Настало время писать последний тест. Откройте редактор кода, добавьте показанный ниже код в конец файла *TestSuite* и сохраните его:
```
[UnityTest]
public IEnumerator DestroyedAsteroidRaisesScore()
{
// 1
GameObject asteroid = game.GetSpawner().SpawnAsteroid();
asteroid.transform.position = Vector3.zero;
GameObject laser = game.GetShip().SpawnLaser();
laser.transform.position = Vector3.zero;
yield return new WaitForSeconds(0.1f);
// 2
Assert.AreEqual(game.score, 1);
}
```
Это важный тест, проверяющий, что когда игрок уничтожает астероид, счёт увеличивается. Вот из чего он состоит:
1. Мы создаём астероид и лазерный луч, и помещаем их в одну позицию. Благодаря этому возникает коллизия, которая запускает увеличение счёта.
2. Утверждение, что game.score теперь равно 1 (а не 0, как было в начале).
Сохраните код и вернитесь в Test Runner, чтобы запустить этот последний тест и проверить, проходит ли его игра:
Потрясающе! Все тесты пройдены.
Куда двигаться дальше?
----------------------
В статье мы рассмотрели большой объём информации. Если вы хотите сравнить свою работу с финальным проектом, то посмотрите его в [архиве](https://koenig-media.raywenderlich.com/uploads/2019/01/Crashteroids-project-files.zip), ссылка на который также указана в начале статьи.
Из этого туториала вы узнали, что такое юнит-тесты и как писать их в Unity. Кроме того, вы написали шесть юнит-тестов, которые успешно прошёл код, и познакомились с некоторыми из плюсов и минусов юнит-тестирования.
Чувствуете себя уверенно? Тогда можно написать ещё множество тестов. Изучите файлы классов игры и попробуйте написать юнит-тесты для других частей кода. Подумайте над добавлением тестов для следующих сценариев:
* Каждый тип астероида при касании корабля приводит к концу игры.
* Запуск новой игры обнуляет счёт.
* Движение влево и вправо для корабля действует правильно.
Если вы хотите повысить уровень своих знаний о юнит-тестировании, то стоит изучить [внедрение зависимостей](https://en.wikipedia.org/wiki/Dependency_injection) и [фреймворки для работы с mock-объектами](https://en.wikipedia.org/wiki/Mock_object). Это может сильно упростить настройку тестов.
Также прочитайте [документацию NUnit](https://github.com/nunit/docs/wiki/NUnit-Documentation), чтобы узнать больше о фреймворке NUnit.
И не стесняйтесь делиться своими мыслями и вопросами на форумах.
Успешного тестирования! | https://habr.com/ru/post/456090/ | null | ru | null |
# Как я воровал данные с пользовательских аккаунтов в Google
Вы со мной не знакомы, но существует известная вероятность, что я знаком с вами. Причина в том, что у меня есть полный, неограниченный доступ к приватной информации миллионов людей, размещённой на аккаунтах Google. Отправленные по почте выписки по банковским счетам, медицинские документы, хранящиеся на Google Drive, сохранённые и пересланные чаты из Facebook, голосовые сообщения на Google Voice, личные фотографии на Google Photos. Список можно продолжать. Никто из них не знает об этом сейчас и никогда не узнает в будущем. Возможно, в их число входите и вы.
И как же я такое провернул? Всё началось с разработанного мной приложения. По очевидным причинам, обнародовать название я не стану. Приложение довольно нехитрое, оно рассчитано на людей, увлекающихся фитнесом, и предлагает возможности типа внесения данных о скорости во время пробежки или готовых комплексов силовых упражнений. Как и многие другие продукты, оно требует, чтобы пользователь первым делом создал аккаунт. По данным аналитики, примерно 60% людей вместо того, чтобы полностью проходить процедуру регистрации, соблазняются заманчивой кнопкой «Войти с Google».
Вы, наверное, в общих чертах знаете, что происходит в таких случаях: когда пользователь нажимает на кнопку, внутри приложения открывается браузерное окошко входа в аккаунт Google.
У данного пользователя подключена двухфакторная идентификация, поэтому после того, как он ввёл почту и пароль, выскакивает диалоговое окошко, уточняющее, точно ли это он. Местоположение и тип устройства совпадают, поэтому он кликает на «Да».
Вот, собственно, и всё. Теперь человек может спокойно пользоваться приложением, а я, между тем, получаю полный, неограниченный доступ к его аккаунту с удалённого сервера. Ему никогда не придёт никаких сообщений по этому поводу. А если он окажется из дотошных и начнёт изучать сетевой трафик, то увидит, что устройство направляло сетевые запросы только и исключительно на различные поддомены google.com.
Но как такое вообще возможно? Давайте вернёмся к нашей кнопке «Войти с Google». Сразу проясним одну вещь: для тех, кто не в курсе, после нажатия этой кнопки приложение может сделать всё что угодно. Запустить процесс авторизации в Google, издать трубный глас, показать гифку с котиком. Не все варианты из этого списка равно вероятны, но помечтать-то можно.
В моём случае, по клику на кнопку приложение при помощи WebView открывает диалоговое окно и задаёт веб-адрес: [accounts.google.com/EmbeddedSetup](https://accounts.google.com/EmbeddedSetup). Он действительно соответствует странице входа в аккаунт Google, только особой, рассчитанной на новые устройства Android. Это обстоятельство сыграет свою роль позже, когда нам любезно предоставят всю необходимую информацию в виде cookie.
К сожалению, эта страница и выглядит, и действует иначе, чем стандартная страница авторизации (по крайней мере, такая, какой она должна быть по умолчанию):
*Обратите внимание на странную синюю полоску, слова Learn more и примерно всё на правой картинке*
И вот теперь-то начинается веселье. Я использую стандартные API, встроенные как в iOS, так и в Android, чтобы внедрить тщательно прописанный фрагмент [кода на Javascript](https://gist.github.com/ethanblake4/7083605857355e0369aa10f4859c245b), который произведёт необходимые модификации, чтобы страница не отличалась от стандартной ни своим видом, ни поведением.
Догадливые сейчас подумают: «Стоп, так раз можно внедрить код на JavaScript, что мешает просто похитить логин и пароль прямо из текстовых полей?». Абсолютно ничего – вообще говоря, для этой цели уже и [готовый код](https://gist.github.com/ethanblake4/2a426d52f3e83a98cc080ac9b016ba72) существует. Но в наше время доступа к логину и паролю уже недостаточно. Разве что очень повезёт и сервер окажется в радиусе нескольких сотен миль от местоположения пользователя. В противном случае пользователь получит письмо и оповещение с сообщением о «подозрительной активности» и попытка взлома будет пресечена. А двухфакторная авторизация усложняет нам жизнь ещё сильнее.
Так что давайте поговорим о чём-нибудь другом, например, о мастер-токене. На первый взгляд, выглядит как-то недобро, а на второй – оказывается ещё хуже, чем казалось.
Когда на устройстве Android впервые проводится процедура авторизации, он отсылает токен, полученный от вышеупомянутой встроенной страницы входа в аккаунт, на особый endpoint. Вот пример типичного запроса:
```
POST /auth HTTP/1.1
Content-Type: application/x-www-form-urlencoded
Content-Length: 349
Host: android.clients.google.com
Connection: Keep-Alive
User-Agent: GoogleLoginService/1.3 (a10 JZO54K);gzip
app: com.google.android.gmsapp=com.google.android.gms&client_sig=38918a453d07199354f8b19af05ec6562ced5788&callerPkg=com.google.android.gms&callerSig=38918a453d07199354f8b19af05ec6562ced5788&service=ac2dm&Token=oauth2_4%2F4AY0e-l5vPImYAf8XsnlrdshQQeNir3rSBx5uJ2oO9Tfl17LpsaBpGf1E2euc18UyOc8MnM&ACCESS_TOKEN=1&add_account=1&get_accountid=1&google_play_services_version=204713000
```
Токен в этом запросе берётся из cookies страницы входа в аккаунт, а всё остальное – информация, которая находится в открытом доступе (спасибо, [microG](https://github.com/microg/GmsCore)!). Та же страница входа в аккаунт улаживает дела с двухфакторной авторизацией – нам вообще не приходится ничего предпринимать.
После этого вышеупомянутый endpoint отсылает тот самый мастер-токен. Но как бы мне получить к нему доступ без подозрительных сетевых запросов? Очень просто: через лог в Google Firebase.
А мастер-токен – это мощная штука. У него неограниченный срок действия при условии, что пользователь не меняет пароль или настройки двухфакторной идентификации. Насколько мне известно, он не подвергается никаким проверкам безопасности, невзирая на местоположение, IP и производимые действия. Он никогда не провоцирует систему на отправление пользователю уведомления или письма.
И главное: он открывает мне путь ко всем без исключения сервисам, которые когда-либо были доступны с мобильного устройства, от лица владельца соответствующего аккаунта. Достаточно одного запроса POST, чтобы я мог прикинуться официальным аккаунтом Google и обзавестись OAuth-токеном для доступа к чему угодно, включая частные (и, скорее всего, нигде не опубликованные) API. Я могу читать письма, бродить по Google Drive, просматривать бэкапы с телефона и фотографии на Google Photos, а заодно ознакомиться с веб-историей пользователя и поболтать с его друзьями по Google Messenger. Я даже создал модифицированную версию microG, с которой могу управлять всеми этими пользовательскими аккаунтами непосредственно из обычных приложений Google.
И напоминаю, весь процесс выглядит [вот так](https://www.youtube.com/watch?v=PSwMZIHTmF4). Предлагаю всем задаться вопросом: а вы бы попались?
#### Разоблачение
Как многие из вас уже догадались, не всё в этой статье правда. Я не публиковал никаких фитнес-приложений на Play Store и не собирал миллионы мастер-токенов. Спасибо [этому материалу](https://hackernoon.com/im-harvesting-credit-card-numbers-and-passwords-from-your-site-here-s-how-9a8cb347c5b5) за вдохновение. Но сам метод работает. Я, да и любой другой разработчик, определённо мог бы сделать приложение с таким сюрпризом (возможно, кто-то уже и сделал).
#### FAQ
*Но ведь страница отличается от нормального входа в аккаунт. Я бы заметил!*
Отличия не так уже бросаются в глаза, так что, скорее всего, не заметили бы. Страница входа в аккаунт Google на Android, как правило, имеет интерфейс типа «выберите аккаунт», но бывают и исключения – например, многие веб-приложения, вроде тех, которые делают на Ionic и Cordova. Большинство iOS-приложений тоже часто отдают предпочтение веб-версии, очень напоминающей приведённый вариант. Кроме того, даже если вам кажется, что отсутствие экрана с «такое-то приложение просит доступ…», вас точно насторожит, то его вполне можно внедрить ценой нескольких лишних часов работы.
*Это и на iOS работает?*
Я не пробовал, но нет оснований считать, что не сработает.
*И что с этим делать?*
Вообще, вопрос сложный. Ни одно из моих действий, строго говоря, не подпадает под определение эксплойта, но результат, тем не менее, несёт большую опасность. Для начала Google неплохо бы разобраться со своими уведомлениями насчёт «входа с нового устройства», чтобы они нормально работали. Лично я их получаю, когда пытаюсь зайти в аккаунт с компьютера, но, пока тестировал это приложение, система не сработала ни разу. Другая хорошая идея – обновить [гайдлайны](https://developers.google.com/identity/branding-guidelines), в том, что касается кнопок «Войти с Google»; сейчас там вообще ничего не говорится о требованиях к реализации. Возможно, им стоило бы углубиться в дебри безопасности через неясность – этот принцип, несмотря на все свои недостатки, пока что отлично служит Apple для обеспечения безопасности в iMessage.
Вынужден признать: у меня нет уверенности, что тут можно найти техническое решение, которое полностью устранило бы проблему. Если у официального приложения Google есть возможность выполнить какое-то действие, значит, и сторонние программы при должном старании смогут его повторить. Впрочем, в компании работают неглупые люди, так что поживём – увидим.
*Эта проблема актуальна для всех систем авторизации в сторонних приложениях?*
Вполне вероятно. Я не разбирался досконально, в каких случаях рассылаются оповещения, а в каких – нет, но даже когда оповещения приходят, из них не всегда понятно, что происходит. Функция «Войти с Apple», как бы там ни было, снабжена очень жёстким гайдлайном, причём администрация App Store (где функция, полагаю, в основном и используется) строго отслеживает выполнение требований. С другой стороны, у них [свои проблемы](https://bhavukjain.com/blog/2020/05/30/zeroday-signin-with-apple/) с авторизацией, на фоне которых эта меркнет.
#### Реальная история
Пусть это были не миллионы, но небольшое количество мастер-токенов у ничего не подозревающих пользователей я как-то раз действительно собрал, причём совершенно непреднамеренно.
Реальная история моего прозрения началась с того, что я разработал приложение-проигрыватель Carbon Player; сейчас оно уже кануло в лету, так и не получив широкого распространения. Приложение замышлялось как замена Google Play Music (помните времена, когда такое существовало?), только с дизайном в разы круче. Чтобы получить доступ к пользовательской папке с музыкой, я перевёл [gmusicapi](https://github.com/simon-weber/gmusicapi) Саймона Вебера на Java, но, переписывая код, поначалу особо не вникал, как там устроен процесс авторизации. Понял только, что нужны логин и пароль пользователя, которые я запрашивал через незамысловатое диалоговое окошко, а потом идут какие-то запросы и вываливаются какие-то токены, которые мне подходят для извлечения музыки.
Перед тем как передать первую версию приложения небольшой группе тестировщиков, я прочесал код, везде добавил логирование и ещё внедрил интерцептор, который должен был автоматически загружать все логи на Firebase. Конечно, не логать пароли мне ума хватило, но три токена, полученные моей имплементацией gmusicapi, я по ошибке залогал. Два из них были довольно безобидными – давали доступ только к разным хранилищам музыки. А вот третий оказался мастер-токеном.
В общем, приложение за всё время своего существования собрало от силы двадцать пять скачиваний, и я быстро махнул на него рукой, чтобы не отвлекаться от учёбы. Но перед этим успел выпустить пару обновлений, в одном из которых появился редизайн новой отпадной (ну, по тем временам) домашней страницы Google Play Music – одного из немногих элементов исходного продукта, которые неплохо смотрелись.
Процесс оказался намного заморочнее, чем я думал, и пришлось неожиданно много заниматься обратной разработкой Protocol Buffers. Что важнее, по какой-то причине теперь там требовался совершенно иной токен, который в gmusicapi реализован уже не был. В итоге, чтобы его внедрить, я на несколько часов зарылся в систему авторизации, пытаясь разобраться, как она устроена. Это привело к ужасному моменту прозрения, когда я осознал, что логировал самую секретную информацию, какую только можно. Скажу одно: логирование прекратилось. Двадцать пять человек, которые скачали приложение, простите меня, пожалуйста (ваши токены я с Firebase удалил!).
Был ещё один, не связанный с первым случай, когда я работал в стартапе, создававшем менеджер паролей. Одним из ключевых преимуществ приложения было то, что оно хранило пароли строго на телефоне, но при этом позволяло авторизоваться с компьютера благодаря букмарклету на JavaScript, который «соединял девайсы» через QR-код. Чтобы всё проходило гладко, когда пользователь открывал сайт на компьютере, приложение обращалось к тому же сайту с телефона и внедряло тщательно прописанный фрагмент кода на JavaScript, который фиксировал логины, пароли и всё прочее. Знакомо звучит?
В конце концов, эти две идеи срослись у меня в голове. У меня был создан прототип Carbon Player, но не хватало времени взять его в работу. Спустя несколько лет я наконец начал создавать на его базе что-то вроде демо-версии. В процессе пришлось многое изменить – метод, описанный в этой статье, значительно отличается от того, что было реализовано в прототипе, поскольку Google внёс изменения в систему авторизации. Но конечный итог остаётся прежним и пугает не меньше, чем тогда.
Если хотите, можете [скачать демо-версию](https://drive.google.com/file/d/1NvS-uRpJ09wap8qdkiBsu_mNJGpHSLq7/view?usp=sharing) и посмотреть на систему в действии; даю слово, что на облако ничего не логируется. Имейте в виду, что приложение очень простое и практически не тестировалось, так что есть немалая вероятность, что метод не сработает, если у вашего аккаунта иная конфигурация. Спасибо, что прочитали статью, надеюсь, вы получили удовольствие от небольшого напоминания о том, насколько важно ставить всё под сомнение. Даже самые безобидные вещи иногда таят внутри что-то не слишком приятное (хотя в случае с тортом-мороженым бывает и наоборот). | https://habr.com/ru/post/539890/ | null | ru | null |
# Примеры работы с разными map API
Есть много статей на тему знакомства с Google Map Api и Yandex Map Api, но про остальные картографические сервисы не так много практического материала. В недавнем времени работал с Api:
1. Google map
2. Yandex map
3. Yahoo map
4. Bing map
5. OpenStreet map
И хотел обобщить работу с вышеупомянутыми сервисами, а именно инициализация карты и установление маркеров по клику мышки. Материалы в статье представлены в виде Html кода, javascript и результата — скриншота, а так же исходники на vs 2010 MVC3.
С Google map ситуация проще всего: практического материала много, мой пример выглядит следующим образом:
Html page:
```
GoogleMap
---------
```
Script:
```
$(document).ready(function () {
initialize();
});
//инициализация карты в div "map"
function initialize() {
var haightAshbury = new google.maps.LatLng(51.0532, 31.83);//(долгота, широта)
var mapOptions = {
zoom: 12,//масштаб
center: haightAshbury,//позиционируем карту на заданые координаты
mapTypeId: google.maps.MapTypeId.TERRAIN//задаем тип карты
};
map = new google.maps.Map(document.getElementById("map"), mapOptions);//инициализация карты
google.maps.event.addListener(map, 'click', function (event) {
addMarker(event.latLng);
});//добавляем событие нажание мышки
}
//функция добавления маркера
function addMarker(location) {
var shadow = new google.maps.MarkerImage('/Images/roles.png',
new google.maps.Size(37, 32),
new google.maps.Point(0, 0),
new google.maps.Point(0, 32)); // Теневое изображение
var image = new google.maps.MarkerImage('/Images/smilies.png',
new google.maps.Size(20, 32),
new google.maps.Point(0, 0),
new google.maps.Point(0, 32)); //изображение маркера
marker = new google.maps.Marker({
position: location,
map: map,
shadow: shadow,
icon: image,
title: "My title!)",
zIndex: 999
});//добавление маркера
```
В результате получим карту Google c возможностью добавлять маркеры:
Для инициализации Yandex map вам понадобится ключ доступа к сервису и следующий пример:
Html page:
```
YandexMap
---------
```
Script:
```
$(document).ready(function () {
initialize();
});
function initialize() {
map = new YMaps.Map(document.getElementById("YMapsID"));//инициализация карты
map.setCenter(new YMaps.GeoPoint(31.87, 51.0532)//(широта, долгота)
, 12 //Масштаб
, YMaps.MapType.MAP);//тип карты
map.addControl(new YMaps.TypeControl());//смена типа карты
map.addControl(new YMaps.ToolBar());//инструменты
map.addControl(new YMaps.Zoom());//смена масштаба
map.addControl(new YMaps.MiniMap());//Небольшая отображающая местоположение
map.addControl(new YMaps.ScaleLine());//Отображение масштаба
YMaps.Events.observe(map, map.Events.Click, function (map, mEvent) {
addMarker(mEvent.getGeoPoint());
});// событие щелчка мыши на карте
}
//функция добавления маркера
function addMarker(location) {
var geoPlacemark = new YMaps.Placemark(new YMaps.GeoPoint(location.__lng, location.__lat), { draggable: 1 });
//координаты добавления метки
geoPlacemark.name = "Название чего то";
geoPlacemark.description = "описание чего то";
map.addOverlay(geoPlacemark);//добавление метки
}
```
В результате получим карту Yandex c возможностью добавлять маркеры:
Обратите внимание на координаты, в Google идет сначала долгота, потом широта, а в Yandex наоборот!
Пример работы с Yahoo map api:
Html page:
```
YahooMap
--------
```
Script:
```
function initialize_ymap() {
var yPoint = new YGeoPoint(51.0532, 31.83);//(долгота, широта)
var map = new YMap(document.getElementById('ymap'));//инициализация карты
map.setMapType(YAHOO_MAP_SAT);//тип карты
map.drawZoomAndCenter(yPoint, 6);//масштаб
map.addTypeControl();//добавление контроля типа
YEvent.Capture(map, EventsList.MouseClick, reportPosition); //событие нажатия на карте
//функция добавления маркера
function reportPosition(_e, _c){
var mapmapCoordCenter = map.convertLatLonXY(map.getCenterLatLon()); //переобразование координат
var currentGeoPoint = new YGeoPoint( _c.Lat, _c.Lon ); //Точка куда нужно поставить маркер
map.addMarker(currentGeoPoint); //Добавление маркера
}
}
```
В результате получим карту Yahoo c возможностью добавлять маркеры:
Для работы с Bing map api нужно взять ключ:
[www.microsoft.com/maps/developers/web.aspx](http://www.microsoft.com/maps/developers/web.aspx)
Пример работы с Bing map api:
Html page:
```
BingMap
-------
```
Script:
```
function GetMap() {
var map = new Microsoft.Maps.Map(document.getElementById("mapDiv"), { credentials: "ххххххххxxxxxxxxxxxxxxxxx",//ключ
center: new Microsoft.Maps.Location(51.0532, 31.83),//(долгота,широта)
mapTypeId: Microsoft.Maps.MapTypeId.road,//(тип карты)
zoom: 8//масштаб
});
//Событие на кликание мышки на карте
Microsoft.Maps.Events.addHandler(map, 'click', displayLatLong);
function displayLatLong(e) {
if (e.targetType == "map") {
var point = new Microsoft.Maps.Point(e.getX(), e.getY());//координаты вставки маркера
var loc = e.target.tryPixelToLocation(point);//позиция маркера
var pin = new Microsoft.Maps.Pushpin(loc);//маркер
map.entities.push(pin);//вставляем маркер
}
}
}
```
В результате получим карту Bing c возможностью добавлять маркеры:
Пример работы с OpenStreet map api:
Html page:
```
OpenStreetMap
-------------
```
Script:
```
function GetMap() {
map = new OpenLayers.Map("OSMap");//инициализация карты
var mapnik = new OpenLayers.Layer.OSM();//создание слоя карты
map.addLayer(mapnik);//добавление слоя
map.setCenter(new OpenLayers.LonLat(31.83, 51.0532) //(широта, долгота)
.transform(
new OpenLayers.Projection("EPSG:4326"), // переобразование в WGS 1984
new OpenLayers.Projection("EPSG:900913") // переобразование проекции
), 10 // масштаб
);
var layerMarkers = new OpenLayers.Layer.Markers("Markers");//создаем новый слой маркеров
map.addLayer(layerMarkers);//добавляем этот слой к карте
map.events.register('click', map, function (e) {
var size = new OpenLayers.Size(21, 25);//размер картинки для маркера
var offset = new OpenLayers.Pixel(-(size.w / 2), -size.h); //смещение картинки для маркера
var icon = new OpenLayers.Icon('/Images/smilies.png', size, offset);//картинка для маркера
layerMarkers.addMarker(//добавляем маркер к слою маркеров
new OpenLayers.Marker(map.getLonLatFromViewPortPx(e.xy), //координаты вставки маркера
icon));//иконка маркера
}); //добавление событие клика по карте
}
```
В результате получим карту OpenStreet c возможностью добавлять маркеры:
Вот такие интересные примеры работы с картами, думаю кому то будут полезны.
[Исходники на VS2010 MVC3](http://webfile.ru/5617716). | https://habr.com/ru/post/131249/ | null | ru | null |
# Модификация Android приложения от новичка и для новичков
Добрый день!
Хочу поделиться с вами историей как я модифицировал одно из системных приложений Adroid'а, точнее его модификации [LeWa OS](http://lewa.org.ua/). С Андроидом я познакомился недавно, всего месяц назад, и постараюсь тут описать весь ход своих мыслей, что несомненно будет полезно всем тем кто хочет улучшить Андроид, но не знает с чего начать. Пост постараюсь сделать подробным, а потому длинным.
#### Для начало немного истории.
Как только я получил свой первый китайфон, решил попробовать разные прошивки и в результате остановился на Lewa. Но глаза постоянно мозолил один ее недочет — список контактов, а точнее быстрая навигация на английском.
[](http://fastpic.ru/view/54/2013/0217/e6addb98039616abb5915a3c61c11c20.png.html)
Информации о данной проблеме немного, поэтому начал копать сам.
#### Набор инструментов
Первое что нам надо — научиться распаковывать программы. Для этого нам понадобится:
* [установить Java](http://www.java.com/ru/download/)
* [APKTOOLS](http://yadi.sk/d/lMWF3cD22fMOm) для распаковки \*.apk
* Прочитать данный [пост](http://forum.china-iphone.ru/viewtopic.php?p=514322#p514322)
* Получить объект исследования. Если вы пользуетесь Lewa то надо из архива с прошивкой или прямо с телефона нужно вытянуть /system/app/PIM.apk и все apk из папки /system/framework/ обычно это framework-res.apk, lewa-res.apk и
mediatek-res.apk. Если вы хотите просто потренироваться то могу дать [свои](http://yadi.sk/d/z52sTGEo2fOhp)
#### Приступим
Итак, первое что нам надо это разобрать наше приложение, для этого все apk надо скопировать в папку с apktools. Все apk которые лежали в /system/framework/ надо выделить, подцепить мышью и перенести на apktool-if.cmd тем самым открыв их с помощью этого bat'ника. PIM.apk таким же образом надо открыть с помощью apktool-d.cmd. В результате получаем папку с распакованным приложением.
#### Изучаем код
Первое что нам необходимо понять — что и где править. Так как мой список контактов изобилует русскими именами, а в быстротой навигации одни английские буквы резонно предположить, что буквы просто жестко забиты где то в коде, а не генерируются динамически исходя из того какие имена у вас в контактах. Обычно такие данные хранятся в папке res, а точнее в *res\values\arrays.xml* но в нашем случае там ничего похожего нет.
Думаем дальше — раз нет там, значит есть где то в коде. Весь код находится в папе smali, по сути там не исходный код а так называемый [Байт-код](http://ru.wikipedia.org/wiki/%D0%91%D0%B0%D0%B9%D1%82-%D0%BA%D0%BE%D0%B4), и его там много. Так где же искать? Я поступил так, в папке *res\layout\* хранятся все «окошки» нашего приложения, то что нам надо находится где-то в списке контактов, поэтому я наобум открыл *contact\_list\_content.xml* и начал изучать.
**contact\_list\_content.xml**
```
xml version="1.0" encoding="utf-8"?
```
Там меня заинтересовала строчка
```
```
. Что это за индексер такой?? Смотрим
**alphabet\_fast\_indexer.xml**
```
xml version="1.0" encoding="utf-8"?
```
Тут ключевые стороки
Что это за элемент который прижимается к правой части экрана *(android:layout\_gravity=«right»)*, не то ли что мы ищем?
*com.lewa.PIM.widget.AlphabetFastIndexer* это ссылка на код *PIM\smali\com\lewa\PIM\widget\AlphabetFastIndexer.smali*, но изучать его неудобно, и тут на сцену выходит связка dex2jar-0.0.9.7 jd-gui-0.3.3.windows которые мы скачали из поста на форуме и так же научились ими пользоваться. Превращаем classes.dex в classes\_dex2jar.jar и открываем через jd-gui.exe
[](http://fastpic.ru/view/53/2013/0217/2580ede5e451b46016e78bef0574fdf3.png.html)
**AlphabetFastIndexer.smali Декомпилированный**
```
package com.lewa.PIM.widget;
import android.content.Context;
import android.content.res.Resources;
import android.graphics.Canvas;
import android.graphics.Color;
import android.graphics.Paint;
import android.graphics.Typeface;
import android.util.AttributeSet;
import android.view.MotionEvent;
import android.view.View;
import java.util.ArrayList;
public class AlphabetFastIndexer extends View
{
public static String[] b = { "★", "#", "A", "B", "C", "D", "E", "F", "G", "H", "I", "J", "K", "L", "M", "N", "O", "P", "Q", "R", "S", "T", "U", "V", "W", "X", "Y", "Z" };
private int choose = 0;
private int mChooseColor;
private boolean mHasFav = true;
private ArrayList mLetters = new ArrayList();
private int mPaddingBottom;
private int mTextsize;
OnTouchingLetterChangedListener onTouchingLetterChangedListener;
private Paint paint = new Paint();
private boolean showBkg = false;
public AlphabetFastIndexer(Context paramContext)
{
super(paramContext);
init(paramContext);
setHasFavorite(false);
}
public AlphabetFastIndexer(Context paramContext, AttributeSet paramAttributeSet)
{
super(paramContext, paramAttributeSet);
init(paramContext);
setHasFavorite(false);
}
public AlphabetFastIndexer(Context paramContext, AttributeSet paramAttributeSet, int paramInt)
{
super(paramContext, paramAttributeSet, paramInt);
init(paramContext);
setHasFavorite(false);
}
private void init(Context paramContext)
{
this.mChooseColor = paramContext.getResources().getColor(17170450);
this.mTextsize = paramContext.getResources().getDimensionPixelSize(2131361937);
this.mPaddingBottom = paramContext.getResources().getDimensionPixelSize(2131361938);
}
public boolean dispatchTouchEvent(MotionEvent paramMotionEvent)
{
int i = paramMotionEvent.getAction();
int j = (int)(paramMotionEvent.getY() / getHeight() \* this.mLetters.size());
switch (i)
{
default:
return true;
case 0:
this.showBkg = true;
case 2:
drawThumb(j);
return true;
case 1:
}
this.showBkg = false;
invalidate();
return true;
}
public void drawThumb(int paramInt)
{
OnTouchingLetterChangedListener localOnTouchingLetterChangedListener = this.onTouchingLetterChangedListener;
if ((this.choose != paramInt) && (localOnTouchingLetterChangedListener != null) && (paramInt >= 0) && (paramInt < this.mLetters.size()))
{
if (localOnTouchingLetterChangedListener != null)
localOnTouchingLetterChangedListener.onTouchingLetterChanged((String)this.mLetters.get(paramInt));
this.choose = paramInt;
invalidate();
}
}
public void drawThumb(String paramString)
{
if ((paramString != null) && (!paramString.equals(this.mLetters.get(this.choose))))
{
int i = this.mLetters.indexOf(paramString);
if (i == -1)
i = 0;
if (this.choose != i)
{
this.choose = i;
invalidate();
}
}
}
protected void onDraw(Canvas paramCanvas)
{
super.onDraw(paramCanvas);
if (this.showBkg)
paramCanvas.drawColor(Color.parseColor("#4C000000"));
while (true)
{
int i = getHeight();
int j = getWidth();
int k = this.mLetters.size();
int m = i / k;
for (int n = 0; n < k; n++)
{
this.paint.setColor(-1);
this.paint.setTypeface(Typeface.DEFAULT\_BOLD);
this.paint.setAntiAlias(true);
this.paint.setTextSize(this.mTextsize);
if (n == this.choose)
{
this.paint.setColor(this.mChooseColor);
this.paint.setFakeBoldText(true);
}
String str = (String)this.mLetters.get(n);
paramCanvas.drawText(str, j / 2 - this.paint.measureText(str) / 2.0F, m + m \* n, this.paint);
this.paint.reset();
}
paramCanvas.drawColor(Color.parseColor("#26000000"));
}
}
protected void onMeasure(int paramInt1, int paramInt2)
{
if (this.mHasFav)
paramInt2 -= this.mPaddingBottom;
setMeasuredDimension(paramInt1, paramInt2);
}
public boolean onTouchEvent(MotionEvent paramMotionEvent)
{
return super.onTouchEvent(paramMotionEvent);
}
public void setHasFavorite(boolean paramBoolean)
{
int k;
if (this.mHasFav != paramBoolean)
{
this.mHasFav = paramBoolean;
this.mLetters.clear();
String[] arrayOfString = b;
int i = arrayOfString.length;
int j = 0;
if (j < i)
{
String str = arrayOfString[j];
if ((!paramBoolean) && (str.equals("★")));
while (true)
{
j++;
break;
this.mLetters.add(str);
}
}
if (this.choose != 0)
{
if (!paramBoolean)
break label117;
k = 1 + this.choose;
this.choose = k;
}
if (this.choose >= 0)
break label128;
this.choose = 0;
}
while (true)
{
requestLayout();
return;
label117: k = -1 + this.choose;
break;
label128: if (this.choose >= this.mLetters.size())
this.choose = (-1 + this.mLetters.size());
}
}
public void setOnTouchingLetterChangedListener(OnTouchingLetterChangedListener paramOnTouchingLetterChangedListener)
{
this.onTouchingLetterChangedListener = paramOnTouchingLetterChangedListener;
}
public static abstract interface OnTouchingLetterChangedListener
{
public abstract void onTouchingLetterChanged(String paramString);
}
}
```
Вот же оно- *public static String[] b = { "★", "#", «A», «B», «C», «D», «E», «F», «G», «H», «I», «J», «K», «L», «M», «N», «O», «P», «Q», «R», «S», «T», «U», «V», «W», «X», «Y», «Z» };*!!! Но править прямо тут нельзя, декомпилированный код примерный, и врядли соберется обратно без ошибок, тем более у нас нет остальных частей программы. Так что правим байт код в *PIM\smali\com\lewa\PIM\widget\AlphabetFastIndexer.smali*
**AlphabetFastIndexer.smali**
```
.class public Lcom/lewa/PIM/widget/AlphabetFastIndexer;
.super Landroid/view/View;
.source "AlphabetFastIndexer.java"
# annotations
.annotation system Ldalvik/annotation/MemberClasses;
value = {
Lcom/lewa/PIM/widget/AlphabetFastIndexer$OnTouchingLetterChangedListener;
}
.end annotation
# static fields
.field public static b:[Ljava/lang/String;
# instance fields
.field private choose:I
.field private mChooseColor:I
.field private mHasFav:Z
.field private mLetters:Ljava/util/ArrayList;
.annotation system Ldalvik/annotation/Signature;
value = {
"Ljava/util/ArrayList",
"<",
"Ljava/lang/String;",
">;"
}
.end annotation
.end field
.field private mPaddingBottom:I
.field private mTextsize:I
.field onTouchingLetterChangedListener:Lcom/lewa/PIM/widget/AlphabetFastIndexer$OnTouchingLetterChangedListener;
.field private paint:Landroid/graphics/Paint;
.field private showBkg:Z
# direct methods
.method static constructor ()V
.locals 3
.prologue
.line 19
const/16 v0, 0x1c
new-array v0, v0, [Ljava/lang/String;
const/4 v1, 0x0
const-string v2, "\u2605"
aput-object v2, v0, v1
const/4 v1, 0x1
const-string v2, "#"
aput-object v2, v0, v1
const/4 v1, 0x2
const-string v2, "A"
aput-object v2, v0, v1
const/4 v1, 0x3
const-string v2, "B"
aput-object v2, v0, v1
const/4 v1, 0x4
const-string v2, "C"
aput-object v2, v0, v1
const/4 v1, 0x5
const-string v2, "D"
aput-object v2, v0, v1
const/4 v1, 0x6
const-string v2, "E"
aput-object v2, v0, v1
const/4 v1, 0x7
const-string v2, "F"
aput-object v2, v0, v1
const/16 v1, 0x8
const-string v2, "G"
aput-object v2, v0, v1
const/16 v1, 0x9
const-string v2, "H"
aput-object v2, v0, v1
const/16 v1, 0xa
const-string v2, "I"
aput-object v2, v0, v1
const/16 v1, 0xb
const-string v2, "J"
aput-object v2, v0, v1
const/16 v1, 0xc
const-string v2, "K"
aput-object v2, v0, v1
const/16 v1, 0xd
const-string v2, "L"
aput-object v2, v0, v1
const/16 v1, 0xe
const-string v2, "M"
aput-object v2, v0, v1
const/16 v1, 0xf
const-string v2, "N"
aput-object v2, v0, v1
const/16 v1, 0x10
const-string v2, "O"
aput-object v2, v0, v1
const/16 v1, 0x11
const-string v2, "P"
aput-object v2, v0, v1
const/16 v1, 0x12
const-string v2, "Q"
aput-object v2, v0, v1
const/16 v1, 0x13
const-string v2, "R"
aput-object v2, v0, v1
const/16 v1, 0x14
const-string v2, "S"
aput-object v2, v0, v1
const/16 v1, 0x15
const-string v2, "T"
aput-object v2, v0, v1
const/16 v1, 0x16
const-string v2, "U"
aput-object v2, v0, v1
const/16 v1, 0x17
const-string v2, "V"
aput-object v2, v0, v1
const/16 v1, 0x18
const-string v2, "W"
aput-object v2, v0, v1
const/16 v1, 0x19
const-string v2, "X"
aput-object v2, v0, v1
const/16 v1, 0x1a
const-string v2, "Y"
aput-object v2, v0, v1
const/16 v1, 0x1b
const-string v2, "Z"
aput-object v2, v0, v1
sput-object v0, Lcom/lewa/PIM/widget/AlphabetFastIndexer;->b:[Ljava/lang/String;
return-void
.end method
.method public constructor (Landroid/content/Context;)V
.locals 2
.parameter "context"
.prologue
const/4 v1, 0x0
.line 44
invoke-direct {p0, p1}, Landroid/view/View;->(Landroid/content/Context;)V
.line 22
iput v1, p0, Lcom/lewa/PIM/widget/AlphabetFastIndexer;->choose:I
.line 23
new-instance v0, Landroid/graphics/Paint;
invoke-direct {v0}, Landroid/graphics/Paint;->()V
iput-object v0, p0, Lcom/lewa/PIM/widget/AlphabetFastIndexer;->paint:Landroid/graphics/Paint;
.line 27
const/4 v0, 0x1
iput-boolean v0, p0, Lcom/lewa/PIM/widget/AlphabetFastIndexer;->mHasFav:Z
.line 29
new-instance v0, Ljava/util/ArrayList;
invoke-direct {v0}, Ljava/util/ArrayList;->()V
iput-object v0, p0, Lcom/lewa/PIM/widget/AlphabetFastIndexer;->mLetters:Ljava/util/ArrayList;
.line 112
iput-boolean v1, p0, Lcom/lewa/PIM/widget/AlphabetFastIndexer;->showBkg:Z
.line 45
invoke-direct {p0, p1}, Lcom/lewa/PIM/widget/AlphabetFastIndexer;->init(Landroid/content/Context;)V
.line 46
invoke-virtual {p0, v1}, Lcom/lewa/PIM/widget/AlphabetFastIndexer;->setHasFavorite(Z)V
.line 47
return-void
.end method
.method public constructor (Landroid/content/Context;Landroid/util/AttributeSet;)V
.locals 2
.parameter "context"
.parameter "attrs"
.prologue
const/4 v1, 0x0
.line 38
invoke-direct {p0, p1, p2}, Landroid/view/View;->(Landroid/content/Context;Landroid/util/AttributeSet;)V
.line 22
iput v1, p0, Lcom/lewa/PIM/widget/AlphabetFastIndexer;->choose:I
.line 23
new-instance v0, Landroid/graphics/Paint;
invoke-direct {v0}, Landroid/graphics/Paint;->()V
iput-object v0, p0, Lcom/lewa/PIM/widget/AlphabetFastIndexer;->paint:Landroid/graphics/Paint;
.line 27
const/4 v0, 0x1
iput-boolean v0, p0, Lcom/lewa/PIM/widget/AlphabetFastIndexer;->mHasFav:Z
.line 29
new-instance v0, Ljava/util/ArrayList;
invoke-direct {v0}, Ljava/util/ArrayList;->()V
iput-object v0, p0, Lcom/lewa/PIM/widget/AlphabetFastIndexer;->mLetters:Ljava/util/ArrayList;
.line 112
iput-boolean v1, p0, Lcom/lewa/PIM/widget/AlphabetFastIndexer;->showBkg:Z
.line 39
invoke-direct {p0, p1}, Lcom/lewa/PIM/widget/AlphabetFastIndexer;->init(Landroid/content/Context;)V
.line 40
invoke-virtual {p0, v1}, Lcom/lewa/PIM/widget/AlphabetFastIndexer;->setHasFavorite(Z)V
.line 41
return-void
.end method
.method public constructor (Landroid/content/Context;Landroid/util/AttributeSet;I)V
.locals 2
.parameter "context"
.parameter "attrs"
.parameter "defStyle"
.prologue
const/4 v1, 0x0
.line 32
invoke-direct {p0, p1, p2, p3}, Landroid/view/View;->(Landroid/content/Context;Landroid/util/AttributeSet;I)V
.line 22
iput v1, p0, Lcom/lewa/PIM/widget/AlphabetFastIndexer;->choose:I
.line 23
new-instance v0, Landroid/graphics/Paint;
invoke-direct {v0}, Landroid/graphics/Paint;->()V
iput-object v0, p0, Lcom/lewa/PIM/widget/AlphabetFastIndexer;->paint:Landroid/graphics/Paint;
.line 27
const/4 v0, 0x1
iput-boolean v0, p0, Lcom/lewa/PIM/widget/AlphabetFastIndexer;->mHasFav:Z
.line 29
new-instance v0, Ljava/util/ArrayList;
invoke-direct {v0}, Ljava/util/ArrayList;->()V
iput-object v0, p0, Lcom/lewa/PIM/widget/AlphabetFastIndexer;->mLetters:Ljava/util/ArrayList;
.line 112
iput-boolean v1, p0, Lcom/lewa/PIM/widget/AlphabetFastIndexer;->showBkg:Z
.line 33
invoke-direct {p0, p1}, Lcom/lewa/PIM/widget/AlphabetFastIndexer;->init(Landroid/content/Context;)V
.line 34
invoke-virtual {p0, v1}, Lcom/lewa/PIM/widget/AlphabetFastIndexer;->setHasFavorite(Z)V
.line 35
return-void
.end method
.method private init(Landroid/content/Context;)V
.locals 2
.parameter "context"
.prologue
.line 50
invoke-virtual {p1}, Landroid/content/Context;->getResources()Landroid/content/res/Resources;
move-result-object v0
const v1, 0x1060012
invoke-virtual {v0, v1}, Landroid/content/res/Resources;->getColor(I)I
move-result v0
iput v0, p0, Lcom/lewa/PIM/widget/AlphabetFastIndexer;->mChooseColor:I
.line 51
invoke-virtual {p1}, Landroid/content/Context;->getResources()Landroid/content/res/Resources;
move-result-object v0
const v1, 0x7f0a0091
invoke-virtual {v0, v1}, Landroid/content/res/Resources;->getDimensionPixelSize(I)I
move-result v0
iput v0, p0, Lcom/lewa/PIM/widget/AlphabetFastIndexer;->mTextsize:I
.line 52
invoke-virtual {p1}, Landroid/content/Context;->getResources()Landroid/content/res/Resources;
move-result-object v0
const v1, 0x7f0a0092
invoke-virtual {v0, v1}, Landroid/content/res/Resources;->getDimensionPixelSize(I)I
move-result v0
iput v0, p0, Lcom/lewa/PIM/widget/AlphabetFastIndexer;->mPaddingBottom:I
.line 53
return-void
.end method
# virtual methods
.method public dispatchTouchEvent(Landroid/view/MotionEvent;)Z
.locals 6
.parameter "event"
.prologue
const/4 v5, 0x1
.line 116
invoke-virtual {p1}, Landroid/view/MotionEvent;->getAction()I
move-result v0
.line 117
.local v0, action:I
invoke-virtual {p1}, Landroid/view/MotionEvent;->getY()F
move-result v2
.line 118
.local v2, y:F
invoke-virtual {p0}, Lcom/lewa/PIM/widget/AlphabetFastIndexer;->getHeight()I
move-result v3
int-to-float v3, v3
div-float v3, v2, v3
iget-object v4, p0, Lcom/lewa/PIM/widget/AlphabetFastIndexer;->mLetters:Ljava/util/ArrayList;
invoke-virtual {v4}, Ljava/util/ArrayList;->size()I
move-result v4
int-to-float v4, v4
mul-float/2addr v3, v4
float-to-int v1, v3
.line 120
.local v1, c:I
packed-switch v0, :pswitch\_data\_0
.line 143
:goto\_0
return v5
.line 122
:pswitch\_0
iput-boolean v5, p0, Lcom/lewa/PIM/widget/AlphabetFastIndexer;->showBkg:Z
.line 135
:pswitch\_1
invoke-virtual {p0, v1}, Lcom/lewa/PIM/widget/AlphabetFastIndexer;->drawThumb(I)V
goto :goto\_0
.line 138
:pswitch\_2
const/4 v3, 0x0
iput-boolean v3, p0, Lcom/lewa/PIM/widget/AlphabetFastIndexer;->showBkg:Z
.line 140
invoke-virtual {p0}, Lcom/lewa/PIM/widget/AlphabetFastIndexer;->invalidate()V
goto :goto\_0
.line 120
:pswitch\_data\_0
.packed-switch 0x0
:pswitch\_0
:pswitch\_2
:pswitch\_1
.end packed-switch
.end method
.method public drawThumb(I)V
.locals 2
.parameter "position"
.prologue
.line 152
iget-object v0, p0, Lcom/lewa/PIM/widget/AlphabetFastIndexer;->onTouchingLetterChangedListener:Lcom/lewa/PIM/widget/AlphabetFastIndexer$OnTouchingLetterChangedListener;
.line 153
.local v0, listener:Lcom/lewa/PIM/widget/AlphabetFastIndexer$OnTouchingLetterChangedListener;
iget v1, p0, Lcom/lewa/PIM/widget/AlphabetFastIndexer;->choose:I
if-eq v1, p1, :cond\_1
if-eqz v0, :cond\_1
.line 154
if-ltz p1, :cond\_1
iget-object v1, p0, Lcom/lewa/PIM/widget/AlphabetFastIndexer;->mLetters:Ljava/util/ArrayList;
invoke-virtual {v1}, Ljava/util/ArrayList;->size()I
move-result v1
if-ge p1, v1, :cond\_1
.line 155
if-eqz v0, :cond\_0
.line 156
iget-object v1, p0, Lcom/lewa/PIM/widget/AlphabetFastIndexer;->mLetters:Ljava/util/ArrayList;
invoke-virtual {v1, p1}, Ljava/util/ArrayList;->get(I)Ljava/lang/Object;
move-result-object v1
check-cast v1, Ljava/lang/String;
invoke-interface {v0, v1}, Lcom/lewa/PIM/widget/AlphabetFastIndexer$OnTouchingLetterChangedListener;->onTouchingLetterChanged(Ljava/lang/String;)V
.line 158
:cond\_0
iput p1, p0, Lcom/lewa/PIM/widget/AlphabetFastIndexer;->choose:I
.line 159
invoke-virtual {p0}, Lcom/lewa/PIM/widget/AlphabetFastIndexer;->invalidate()V
.line 162
:cond\_1
return-void
.end method
.method public drawThumb(Ljava/lang/String;)V
.locals 3
.parameter "letter"
.prologue
.line 165
if-eqz p1, :cond\_1
iget-object v1, p0, Lcom/lewa/PIM/widget/AlphabetFastIndexer;->mLetters:Ljava/util/ArrayList;
iget v2, p0, Lcom/lewa/PIM/widget/AlphabetFastIndexer;->choose:I
invoke-virtual {v1, v2}, Ljava/util/ArrayList;->get(I)Ljava/lang/Object;
move-result-object v1
invoke-virtual {p1, v1}, Ljava/lang/String;->equals(Ljava/lang/Object;)Z
move-result v1
if-nez v1, :cond\_1
.line 166
iget-object v1, p0, Lcom/lewa/PIM/widget/AlphabetFastIndexer;->mLetters:Ljava/util/ArrayList;
invoke-virtual {v1, p1}, Ljava/util/ArrayList;->indexOf(Ljava/lang/Object;)I
move-result v0
.line 167
.local v0, i:I
const/4 v1, -0x1
if-ne v0, v1, :cond\_0
const/4 v0, 0x0
.line 168
:cond\_0
iget v1, p0, Lcom/lewa/PIM/widget/AlphabetFastIndexer;->choose:I
if-eq v1, v0, :cond\_1
.line 169
iput v0, p0, Lcom/lewa/PIM/widget/AlphabetFastIndexer;->choose:I
.line 170
invoke-virtual {p0}, Lcom/lewa/PIM/widget/AlphabetFastIndexer;->invalidate()V
.line 173
.end local v0 #i:I
:cond\_1
return-void
.end method
.method protected onDraw(Landroid/graphics/Canvas;)V
.locals 12
.parameter "canvas"
.prologue
const/4 v11, 0x1
.line 83
invoke-super {p0, p1}, Landroid/view/View;->onDraw(Landroid/graphics/Canvas;)V
.line 84
iget-boolean v8, p0, Lcom/lewa/PIM/widget/AlphabetFastIndexer;->showBkg:Z
if-eqz v8, :cond\_1
.line 85
const-string v8, "#4C000000"
invoke-static {v8}, Landroid/graphics/Color;->parseColor(Ljava/lang/String;)I
move-result v8
invoke-virtual {p1, v8}, Landroid/graphics/Canvas;->drawColor(I)V
.line 90
:goto\_0
invoke-virtual {p0}, Lcom/lewa/PIM/widget/AlphabetFastIndexer;->getHeight()I
move-result v0
.line 91
.local v0, height:I
invoke-virtual {p0}, Lcom/lewa/PIM/widget/AlphabetFastIndexer;->getWidth()I
move-result v5
.line 92
.local v5, width:I
iget-object v8, p0, Lcom/lewa/PIM/widget/AlphabetFastIndexer;->mLetters:Ljava/util/ArrayList;
invoke-virtual {v8}, Ljava/util/ArrayList;->size()I
move-result v4
.line 93
.local v4, size:I
div-int v3, v0, v4
.line 94
.local v3, singleHeight:I
const/4 v1, 0x0
.local v1, i:I
:goto\_1
if-ge v1, v4, :cond\_2
.line 95
iget-object v8, p0, Lcom/lewa/PIM/widget/AlphabetFastIndexer;->paint:Landroid/graphics/Paint;
const/4 v9, -0x1
invoke-virtual {v8, v9}, Landroid/graphics/Paint;->setColor(I)V
.line 96
iget-object v8, p0, Lcom/lewa/PIM/widget/AlphabetFastIndexer;->paint:Landroid/graphics/Paint;
sget-object v9, Landroid/graphics/Typeface;->DEFAULT\_BOLD:Landroid/graphics/Typeface;
invoke-virtual {v8, v9}, Landroid/graphics/Paint;->setTypeface(Landroid/graphics/Typeface;)Landroid/graphics/Typeface;
.line 97
iget-object v8, p0, Lcom/lewa/PIM/widget/AlphabetFastIndexer;->paint:Landroid/graphics/Paint;
invoke-virtual {v8, v11}, Landroid/graphics/Paint;->setAntiAlias(Z)V
.line 98
iget-object v8, p0, Lcom/lewa/PIM/widget/AlphabetFastIndexer;->paint:Landroid/graphics/Paint;
iget v9, p0, Lcom/lewa/PIM/widget/AlphabetFastIndexer;->mTextsize:I
int-to-float v9, v9
invoke-virtual {v8, v9}, Landroid/graphics/Paint;->setTextSize(F)V
.line 99
iget v8, p0, Lcom/lewa/PIM/widget/AlphabetFastIndexer;->choose:I
if-ne v1, v8, :cond\_0
.line 100
iget-object v8, p0, Lcom/lewa/PIM/widget/AlphabetFastIndexer;->paint:Landroid/graphics/Paint;
iget v9, p0, Lcom/lewa/PIM/widget/AlphabetFastIndexer;->mChooseColor:I
invoke-virtual {v8, v9}, Landroid/graphics/Paint;->setColor(I)V
.line 101
iget-object v8, p0, Lcom/lewa/PIM/widget/AlphabetFastIndexer;->paint:Landroid/graphics/Paint;
invoke-virtual {v8, v11}, Landroid/graphics/Paint;->setFakeBoldText(Z)V
.line 103
:cond\_0
iget-object v8, p0, Lcom/lewa/PIM/widget/AlphabetFastIndexer;->mLetters:Ljava/util/ArrayList;
invoke-virtual {v8, v1}, Ljava/util/ArrayList;->get(I)Ljava/lang/Object;
move-result-object v2
check-cast v2, Ljava/lang/String;
.line 104
.local v2, letterStr:Ljava/lang/String;
div-int/lit8 v8, v5, 0x2
int-to-float v8, v8
iget-object v9, p0, Lcom/lewa/PIM/widget/AlphabetFastIndexer;->paint:Landroid/graphics/Paint;
invoke-virtual {v9, v2}, Landroid/graphics/Paint;->measureText(Ljava/lang/String;)F
move-result v9
const/high16 v10, 0x4000
div-float/2addr v9, v10
sub-float v6, v8, v9
.line 105
.local v6, xPos:F
mul-int v8, v3, v1
add-int/2addr v8, v3
int-to-float v7, v8
.line 106
.local v7, yPos:F
iget-object v8, p0, Lcom/lewa/PIM/widget/AlphabetFastIndexer;->paint:Landroid/graphics/Paint;
invoke-virtual {p1, v2, v6, v7, v8}, Landroid/graphics/Canvas;->drawText(Ljava/lang/String;FFLandroid/graphics/Paint;)V
.line 107
iget-object v8, p0, Lcom/lewa/PIM/widget/AlphabetFastIndexer;->paint:Landroid/graphics/Paint;
invoke-virtual {v8}, Landroid/graphics/Paint;->reset()V
.line 94
add-int/lit8 v1, v1, 0x1
goto :goto\_1
.line 87
.end local v0 #height:I
.end local v1 #i:I
.end local v2 #letterStr:Ljava/lang/String;
.end local v3 #singleHeight:I
.end local v4 #size:I
.end local v5 #width:I
.end local v6 #xPos:F
.end local v7 #yPos:F
:cond\_1
const-string v8, "#26000000"
invoke-static {v8}, Landroid/graphics/Color;->parseColor(Ljava/lang/String;)I
move-result v8
invoke-virtual {p1, v8}, Landroid/graphics/Canvas;->drawColor(I)V
goto :goto\_0
.line 110
.restart local v0 #height:I
.restart local v1 #i:I
.restart local v3 #singleHeight:I
.restart local v4 #size:I
.restart local v5 #width:I
:cond\_2
return-void
.end method
.method protected onMeasure(II)V
.locals 1
.parameter "widthMeasureSpec"
.parameter "heightMeasureSpec"
.prologue
.line 77
iget-boolean v0, p0, Lcom/lewa/PIM/widget/AlphabetFastIndexer;->mHasFav:Z
if-eqz v0, :cond\_0
iget v0, p0, Lcom/lewa/PIM/widget/AlphabetFastIndexer;->mPaddingBottom:I
sub-int/2addr p2, v0
.end local p2
:cond\_0
invoke-virtual {p0, p1, p2}, Lcom/lewa/PIM/widget/AlphabetFastIndexer;->setMeasuredDimension(II)V
.line 78
return-void
.end method
.method public onTouchEvent(Landroid/view/MotionEvent;)Z
.locals 1
.parameter "event"
.prologue
.line 148
invoke-super {p0, p1}, Landroid/view/View;->onTouchEvent(Landroid/view/MotionEvent;)Z
move-result v0
return v0
.end method
.method public setHasFavorite(Z)V
.locals 6
.parameter "hasFav"
.prologue
.line 56
iget-boolean v4, p0, Lcom/lewa/PIM/widget/AlphabetFastIndexer;->mHasFav:Z
if-eq v4, p1, :cond\_4
.line 57
iput-boolean p1, p0, Lcom/lewa/PIM/widget/AlphabetFastIndexer;->mHasFav:Z
.line 58
iget-object v4, p0, Lcom/lewa/PIM/widget/AlphabetFastIndexer;->mLetters:Ljava/util/ArrayList;
invoke-virtual {v4}, Ljava/util/ArrayList;->clear()V
.line 59
sget-object v0, Lcom/lewa/PIM/widget/AlphabetFastIndexer;->b:[Ljava/lang/String;
.local v0, arr$:[Ljava/lang/String;
array-length v2, v0
.local v2, len$:I
const/4 v1, 0x0
.local v1, i$:I
:goto\_0
if-ge v1, v2, :cond\_1
aget-object v3, v0, v1
.line 60
.local v3, letter:Ljava/lang/String;
if-nez p1, :cond\_0
const-string v4, "\u2605"
invoke-virtual {v3, v4}, Ljava/lang/String;->equals(Ljava/lang/Object;)Z
move-result v4
if-eqz v4, :cond\_0
.line 59
:goto\_1
add-int/lit8 v1, v1, 0x1
goto :goto\_0
.line 62
:cond\_0
iget-object v4, p0, Lcom/lewa/PIM/widget/AlphabetFastIndexer;->mLetters:Ljava/util/ArrayList;
invoke-virtual {v4, v3}, Ljava/util/ArrayList;->add(Ljava/lang/Object;)Z
goto :goto\_1
.line 64
.end local v3 #letter:Ljava/lang/String;
:cond\_1
iget v4, p0, Lcom/lewa/PIM/widget/AlphabetFastIndexer;->choose:I
if-eqz v4, :cond\_2
if-eqz p1, :cond\_5
iget v4, p0, Lcom/lewa/PIM/widget/AlphabetFastIndexer;->choose:I
add-int/lit8 v4, v4, 0x1
:goto\_2
iput v4, p0, Lcom/lewa/PIM/widget/AlphabetFastIndexer;->choose:I
.line 65
:cond\_2
iget v4, p0, Lcom/lewa/PIM/widget/AlphabetFastIndexer;->choose:I
if-gez v4, :cond\_6
const/4 v4, 0x0
iput v4, p0, Lcom/lewa/PIM/widget/AlphabetFastIndexer;->choose:I
.line 68
:cond\_3
:goto\_3
invoke-virtual {p0}, Lcom/lewa/PIM/widget/AlphabetFastIndexer;->requestLayout()V
.line 70
.end local v0 #arr$:[Ljava/lang/String;
.end local v1 #i$:I
.end local v2 #len$:I
:cond\_4
return-void
.line 64
.restart local v0 #arr$:[Ljava/lang/String;
.restart local v1 #i$:I
.restart local v2 #len$:I
:cond\_5
iget v4, p0, Lcom/lewa/PIM/widget/AlphabetFastIndexer;->choose:I
add-int/lit8 v4, v4, -0x1
goto :goto\_2
.line 66
:cond\_6
iget v4, p0, Lcom/lewa/PIM/widget/AlphabetFastIndexer;->choose:I
iget-object v5, p0, Lcom/lewa/PIM/widget/AlphabetFastIndexer;->mLetters:Ljava/util/ArrayList;
invoke-virtual {v5}, Ljava/util/ArrayList;->size()I
move-result v5
if-lt v4, v5, :cond\_3
iget-object v4, p0, Lcom/lewa/PIM/widget/AlphabetFastIndexer;->mLetters:Ljava/util/ArrayList;
invoke-virtual {v4}, Ljava/util/ArrayList;->size()I
move-result v4
add-int/lit8 v4, v4, -0x1
iput v4, p0, Lcom/lewa/PIM/widget/AlphabetFastIndexer;->choose:I
goto :goto\_3
.end method
.method public setOnTouchingLetterChangedListener(Lcom/lewa/PIM/widget/AlphabetFastIndexer$OnTouchingLetterChangedListener;)V
.locals 0
.parameter "onTouchingLetterChangedListener"
.prologue
.line 181
iput-object p1, p0, Lcom/lewa/PIM/widget/AlphabetFastIndexer;->onTouchingLetterChangedListener:Lcom/lewa/PIM/widget/AlphabetFastIndexer$OnTouchingLetterChangedListener;
.line 182
return-void
.end method
```
Тут нас интересует следующий участок
**AlphabetFastIndexer.smali**
```
const/16 v0, 0x1c
new-array v0, v0, [Ljava/lang/String;
const/4 v1, 0x0
const-string v2, "\u2605"
aput-object v2, v0, v1
const/4 v1, 0x1
const-string v2, "#"
aput-object v2, v0, v1
const/4 v1, 0x2
const-string v2, "A"
aput-object v2, v0, v1
const/4 v1, 0x3
const-string v2, "B"
aput-object v2, v0, v1
const/4 v1, 0x4
const-string v2, "C"
aput-object v2, v0, v1
const/4 v1, 0x5
const-string v2, "D"
aput-object v2, v0, v1
const/4 v1, 0x6
const-string v2, "E"
aput-object v2, v0, v1
const/4 v1, 0x7
const-string v2, "F"
aput-object v2, v0, v1
const/16 v1, 0x8
const-string v2, "G"
aput-object v2, v0, v1
const/16 v1, 0x9
const-string v2, "H"
aput-object v2, v0, v1
const/16 v1, 0xa
const-string v2, "I"
aput-object v2, v0, v1
const/16 v1, 0xb
const-string v2, "J"
aput-object v2, v0, v1
const/16 v1, 0xc
const-string v2, "K"
aput-object v2, v0, v1
const/16 v1, 0xd
const-string v2, "L"
aput-object v2, v0, v1
const/16 v1, 0xe
const-string v2, "M"
aput-object v2, v0, v1
const/16 v1, 0xf
const-string v2, "N"
aput-object v2, v0, v1
const/16 v1, 0x10
const-string v2, "O"
aput-object v2, v0, v1
const/16 v1, 0x11
const-string v2, "P"
aput-object v2, v0, v1
const/16 v1, 0x12
const-string v2, "Q"
aput-object v2, v0, v1
const/16 v1, 0x13
const-string v2, "R"
aput-object v2, v0, v1
const/16 v1, 0x14
const-string v2, "S"
aput-object v2, v0, v1
const/16 v1, 0x15
const-string v2, "T"
aput-object v2, v0, v1
const/16 v1, 0x16
const-string v2, "U"
aput-object v2, v0, v1
const/16 v1, 0x17
const-string v2, "V"
aput-object v2, v0, v1
const/16 v1, 0x18
const-string v2, "W"
aput-object v2, v0, v1
const/16 v1, 0x19
const-string v2, "X"
aput-object v2, v0, v1
const/16 v1, 0x1a
const-string v2, "Y"
aput-object v2, v0, v1
const/16 v1, 0x1b
const-string v2, "Z"
aput-object v2, v0, v1
```
Тут и так все понятно, меняем буквы на русские, и так как русских букв больше придется добавить несколько строк типа
```
const/16 v1, 0x1b
const-string v2, ""
aput-object v2, v0, v1
```
*const/16 v1, 0x1b* это порядковый номер буквы он тоже будет с каждой новой буквой расти. Так же в начале вы могли заметить стоку
```
const/16 v0, 0x1c
```
Это размер всего массива, так как мы добавили несколько букв ее нам тоже надо поменять. Я добавил 3 буквы по этому в моем случае ее надо поменять на
```
const/16 v0, 0x1f
```
В итоге у меня получился следующий код:
**AlphabetFastIndexer.smali Исправленный**
```
const/16 v0, 0x1f
new-array v0, v0, [Ljava/lang/String;
const/4 v1, 0x0
const-string v2, "\u2605"
aput-object v2, v0, v1
const/4 v1, 0x1
const-string v2, "#"
aput-object v2, v0, v1
const/4 v1, 0x2
const-string v2, "\u0410"
aput-object v2, v0, v1
const/4 v1, 0x3
const-string v2, "\u0411"
aput-object v2, v0, v1
const/4 v1, 0x4
const-string v2, "\u0412"
aput-object v2, v0, v1
const/4 v1, 0x5
const-string v2, "\u0413"
aput-object v2, v0, v1
const/4 v1, 0x6
const-string v2, "\u0414"
aput-object v2, v0, v1
const/4 v1, 0x7
const-string v2, "\u0415"
aput-object v2, v0, v1
const/16 v1, 0x8
const-string v2, "\u0416"
aput-object v2, v0, v1
const/16 v1, 0x9
const-string v2, "\u0417"
aput-object v2, v0, v1
const/16 v1, 0xa
const-string v2, "\u0418"
aput-object v2, v0, v1
const/16 v1, 0xb
const-string v2, "\u041a"
aput-object v2, v0, v1
const/16 v1, 0xc
const-string v2, "\u041b"
aput-object v2, v0, v1
const/16 v1, 0xd
const-string v2, "\u041c"
aput-object v2, v0, v1
const/16 v1, 0xe
const-string v2, "\u041d"
aput-object v2, v0, v1
const/16 v1, 0xf
const-string v2, "\u041e"
aput-object v2, v0, v1
const/16 v1, 0x10
const-string v2, "\u041f"
aput-object v2, v0, v1
const/16 v1, 0x11
const-string v2, "\u0420"
aput-object v2, v0, v1
const/16 v1, 0x12
const-string v2, "\u0421"
aput-object v2, v0, v1
const/16 v1, 0x13
const-string v2, "\u0422"
aput-object v2, v0, v1
const/16 v1, 0x14
const-string v2, "\u0423"
aput-object v2, v0, v1
const/16 v1, 0x15
const-string v2, "\u0424"
aput-object v2, v0, v1
const/16 v1, 0x16
const-string v2, "\u0425"
aput-object v2, v0, v1
const/16 v1, 0x17
const-string v2, "\u0426"
aput-object v2, v0, v1
const/16 v1, 0x18
const-string v2, "\u0427"
aput-object v2, v0, v1
const/16 v1, 0x19
const-string v2, "\u0428"
aput-object v2, v0, v1
const/16 v1, 0x1a
const-string v2, "\u0429"
aput-object v2, v0, v1
const/16 v1, 0x1b
const-string v2, "\u042b"
aput-object v2, v0, v1
const/16 v1, 0x1c
const-string v2, "\u042d"
aput-object v2, v0, v1
const/16 v1, 0x1d
const-string v2, "\u042e"
aput-object v2, v0, v1
const/16 v1, 0x1e
const-string v2, "\u042f"
aput-object v2, v0, v1
```
"\u042f" — это «юникоды» наших букв, так надежней)
После этого можно попробовать собрать риложение перетянув папку PIM на apktool-b.cmd, через некоторое время появится *PIM\dist\PIM.apk*
Теперь можно заменить им PIM.apk своего телефона, как это сделать выходит за рамки данной статьи. Могу лишь скзать что можно прошится [моим патчем](http://yadi.sk/d/NNp0xR_k2fZIQ), предварительно заменив в нем PIM.apk на свой.
#### PROFIT?
Не совсем… Да, буквы русские но поиск то не работает!
Изучаем дальше декомпилированный AlphabetFastIndexer.smali
тут больше ничего интересного кроме
```
public static abstract interface OnTouchingLetterChangedListener
{
public abstract void onTouchingLetterChanged(String paramString);
}
```
Хотя по идее он к нашей проблеме не относится я все же решил посмотреть что это такое. public static abstract говорит о том, что этот интерфейс реализован где то в другом файле. Ищем поиском и находим пару файлов где встречается *OnTouchingLetterChangedListener*:
*PIM\smali\com\lewa\PIM\contacts\list\ContactEntryListFragment.smali
PIM\smali\com\lewa\PIM\mms\choiceContacts\MmsChoicePhoneNumbersContacts.smali*
Они достаточно длинные поэтому приведу только то что нас интересует
**ContactEntryListFragment.smali**
```
Runnable FirstLettersRunnable = new Runnable()
{
public void run()
{
ContactEntryListFragment.this.marrFirstCharacters.clear();
ContactEntryListFragment.this.marrFirstLetters.clear();
Cursor localCursor = ContactEntryListFragment.this.mAdapter.getCursor(0);
CharArrayBuffer localCharArrayBuffer1;
CharArrayBuffer localCharArrayBuffer2;
if ((localCursor != null) && (!localCursor.isClosed()) && (localCursor.getCount() > 0))
{
localCursor.moveToFirst();
boolean bool = ContactEntryListFragment.this.mAdapter instanceof ContactEntryListAdapter;
int i = 0;
int j = 0;
if (bool)
j = ContactEntryListFragment.this.mAdapter.getStarredCount();
do
{
localCharArrayBuffer1 = new CharArrayBuffer(128);
localCharArrayBuffer2 = new CharArrayBuffer(128);
if ((i >= j) || (localCursor.getInt(12) != 1))
break;
localCharArrayBuffer1.data[0] = '★';
int k = 9733;
i++;
ContactEntryListFragment.this.marrFirstLetters.add(String.valueOf(k));
ContactEntryListFragment.this.marrFirstCharacters.add(String.copyValueOf(localCharArrayBuffer1.data, 0, 1));
}
while (localCursor.moveToNext());
if (ContactEntryListFragment.this.mAdapter != null)
ContactEntryListFragment.this.mAdapter.notifyDataSetChanged();
}
ContactEntryListFragment.access$302(ContactEntryListFragment.this, true);
return;
localCursor.copyStringToBuffer(1, localCharArrayBuffer1);
if ((localCharArrayBuffer1.data[0] >= 'a') && (localCharArrayBuffer1.data[0] <= 'z'))
{
char[] arrayOfChar = localCharArrayBuffer1.data;
arrayOfChar[0] = ((char)('￠' + arrayOfChar[0]));
}
while (true)
{
localCursor.copyStringToBuffer(10, localCharArrayBuffer2);
int m = Character.toUpperCase(localCharArrayBuffer2.data[0]);
if ((m >= 65) && (m <= 90))
break;
m = 35;
break;
if ((localCharArrayBuffer1.data[0] < '') && ((localCharArrayBuffer1.data[0] < 'A') || (localCharArrayBuffer1.data[0] > 'Z')))
localCharArrayBuffer1.data[0] = '#';
}
}
};
```
Как и откуда вызывается это функция я не понял но факт — она собирает первые буквы контактов и все что не относится к английским буквам приравневает к # И поэтому у нас ничего не работает… конкретно эта функция находится в «подфайле» *PIM\smali\com\lewa\PIM\contacts\list\ContactEntryListFragment$3.smali*
Там нужно найти участок
```
.method public run()V
.locals 13
.prologue
.local p0, this:Lcom/lewa/PIM/contacts/list/ContactEntryListFragment$3;,"Lcom/lewa/PIM/contacts/list/ContactEntryListFragment.3;"
const/16 v12, 0x5a
const/16 v11, 0x41
```
0x41 и 0x5a это буквы 'A' и 'Z' их надо поменять на русские:
```
.method public run()V
.locals 13
.prologue
.local p0, this:Lcom/lewa/PIM/contacts/list/ContactEntryListFragment$3;,"Lcom/lewa/PIM/contacts/list/ContactEntryListFragment.3;"
const/16 v12, 0x42f
const/16 v11, 0x410
```
После чего найти
```
aget-char v6, v6, v8
const/16 v7, 0x61
if-lt v6, v7, :cond_6
iget-object v6, v3, Landroid/database/CharArrayBuffer;->data:[C
aget-char v6, v6, v8
const/16 v7, 0x7a
if-gt v6, v7, :cond_6
```
0x61 — 'a'
0x7a — 'z'
Меняем
```
aget-char v6, v6, v8
const/16 v7, 0x430
if-lt v6, v7, :cond_6
iget-object v6, v3, Landroid/database/CharArrayBuffer;->data:[C
aget-char v6, v6, v8
const/16 v7, 0x44f
if-gt v6, v7, :cond_6
```
В файле MmsChoicePhoneNumbersContacts.smali примерно такая же история
**ContactEntryListFragment.smali**
```
protected void onQueryComplete(int paramInt, Object paramObject, Cursor paramCursor)
{
switch (paramInt)
{
default:
return;
case 0:
}
MmsChoicePhoneNumbersContacts.this.mAdapter.changeCursor(paramCursor);
if (paramCursor.getCount() > 0)
{
MmsChoicePhoneNumbersContacts.this.marrFirstCharacters.clear();
MmsChoicePhoneNumbersContacts.this.marrFirstLetters.clear();
paramCursor.moveToPosition(-1);
if (paramCursor.moveToNext())
{
CharArrayBuffer localCharArrayBuffer1 = new CharArrayBuffer(128);
paramCursor.copyStringToBuffer(4, localCharArrayBuffer1);
if ((localCharArrayBuffer1.data[0] >= 'a') && (localCharArrayBuffer1.data[0] <= 'z'))
{
char[] arrayOfChar = localCharArrayBuffer1.data;
arrayOfChar[0] = ((char)('￠' + arrayOfChar[0]));
}
while (true)
{
CharArrayBuffer localCharArrayBuffer2 = new CharArrayBuffer(128);
paramCursor.copyStringToBuffer(11, localCharArrayBuffer2);
char c = Character.toUpperCase(localCharArrayBuffer2.data[0]);
if ((c < 'A') || (c > 'Z'))
c = '#';
MmsChoicePhoneNumbersContacts.this.marrFirstLetters.add(String.valueOf(c));
MmsChoicePhoneNumbersContacts.this.marrFirstCharacters.add(String.copyValueOf(localCharArrayBuffer1.data, 0, 1));
break;
if ((localCharArrayBuffer1.data[0] < '') && ((localCharArrayBuffer1.data[0] < 'A') || (localCharArrayBuffer1.data[0] > 'Z')))
localCharArrayBuffer1.data[0] = '#';
}
}
MmsChoicePhoneNumbersContacts.access$502(MmsChoicePhoneNumbersContacts.this, true);
paramCursor.moveToFirst();
MmsChoicePhoneNumbersContacts.this.mEmptyTextView.setVisibility(8);
return;
}
MmsChoicePhoneNumbersContacts.this.mEmptyTextView.setVisibility(0);
}
```
```
# virtual methods
.method protected onQueryComplete(ILjava/lang/Object;Landroid/database/Cursor;)V
.locals 10
.parameter "token"
.parameter "cookie"
.parameter "cursor"
.prologue
const/16 v9, 0x5a
const/16 v8, 0x41
```
Меняем на
```
# virtual methods
.method protected onQueryComplete(ILjava/lang/Object;Landroid/database/Cursor;)V
.locals 10
.parameter "token"
.parameter "cookie"
.parameter "cursor"
.prologue
const/16 v9, 0x42f
const/16 v8, 0x410
```
и соответсвенно
```
aget-char v3, v3, v5
const/16 v4, 0x61
if-lt v3, v4, :cond_3
iget-object v3, v1, Landroid/database/CharArrayBuffer;->data:[C
aget-char v3, v3, v5
const/16 v4, 0x7a
if-gt v3, v4, :cond_3
```
на
```
aget-char v3, v3, v5
const/16 v4, 0x430
if-lt v3, v4, :cond_3
iget-object v3, v1, Landroid/database/CharArrayBuffer;->data:[C
aget-char v3, v3, v5
const/16 v4, 0x44f
if-gt v3, v4, :cond_3
```
Собираем это дело обратно и запихиваем а телефон. Вот теперь работает!
[](http://fastpic.ru/view/53/2013/0217/3ee814af680470c961a1f00b3be7e05f.png.html)
Спасибо всем за внимание!
P.S. Надеюсь мой ход мыслей кому то поможет. В идеале бы найти как строятся группы в списке контактов и привинтить это дело сюда. Тогда бы в этом списке были толко те буквы, которые дейсвительно присутствуют в контактах, при том что на нескольких языках одновременно, но это мне пока не по зубам. | https://habr.com/ru/post/169767/ | null | ru | null |
# Сeph — от «на коленке» до «production»
Выбор CEPH. Часть 1
===================
*У нас было пять стоек, десять оптических свичей, настроенный BGP, пару десятков SSD и куча SAS дисков всех цветов и размеров, а ещё proxmox и желание засунуть всю статику в собственное S3 хранилище. Не то чтобы это всё было нужно для виртуализации, но раз начал использовать opensource — то иди в своём увлечении до конца. Единственное, что меня беспокоило — это BGP. В мире нет никого более беспомощного, безответственного и безнравственного, чем внутренняя маршртутизация по BGP. И я знал, что довольно скоро мы в это окунёмся.*
Задача стояла банальная — имелся CEPH, работал не очень хорошо. Надо было сделать "хорошо".
Доставшийся мне кластер был разнородным, настроенным на скорую руку и практически не тюнингованным. Он состоял из двух групп разных нод, с одной общей сеткой выполняющей роль как cluster так и public network. Ноды были набиты четырьмя типами дисков — два типа SSD, собранными в два отдельных placement rule и два типа HDD разного размера, собранными в третью группу. Проблема с разными размерами была решена разными весами OSD.
Саму настройку разделили на две части — **тюнинг операционной системы** и **тюнинг самого CEPH** и его настроек.
Прокачка OS
-----------
### Network
Высокое latency сказывалось как при записи, так и при балансировке. При записи — потому, что клиент не получит ответ об успешной записи, пока реплики данных в других плейсмент группах не подтвердят успех. Поскольку правила распределения реплик в CRUSH map у нас были по одной реплике на хост, то сеть использовалась всегда.
Потому первым делом решил слегка настроить текущую сеть, параллельно пытаясь убедить переехать на раздельные сети.
Для начала покрутил настройки сетевых карт. Начал с настройки очередей:
что было:
**ethtool -l ens1f1**
```
root@ceph01:~# ethtool -l ens1f1
Channel parameters for ens1f1:
Pre-set maximums:
RX: 0
TX: 0
Other: 1
Combined: 63
Current hardware settings:
RX: 0
TX: 0
Other: 1
Combined: 1
root@ceph01:~# ethtool -g ens1f1
Ring parameters for ens1f1:
Pre-set maximums:
RX: 4096
RX Mini: 0
RX Jumbo: 0
TX: 4096
Current hardware settings:
RX: 256
RX Mini: 0
RX Jumbo: 0
TX: 256
root@ceph01:~# ethtool -l ens1f1
Channel parameters for ens1f1:
Pre-set maximums:
RX: 0
TX: 0
Other: 1
Combined: 63
Current hardware settings:
RX: 0
TX: 0
Other: 1
Combined: 1
```
Видно, что current параметры далеки от maximums. Увеличил:
```
root@ceph01:~#ethtool -G ens1f0 rx 4096
root@ceph01:~#ethtool -G ens1f0 tx 4096
root@ceph01:~#ethtool -L ens1f0 combined 63
```
Руководствуясь отличной статьей
<https://blog.packagecloud.io/eng/2017/02/06/monitoring-tuning-linux-networking-stack-sending-data/>
увеличил длинну очереди отправки **txqueuelen** с 1000 до 10 000
```
root@ceph01:~#ip link set ens1f0 txqueuelen 10000
```
Ну и следуя документации самого ceph
<https://ceph.com/geen-categorie/ceph-loves-jumbo-frames/>
увеличил **MTU** до 9000.
```
root@ceph01:~#ip link set dev ens1f0 mtu 9000
```
Добавил в /etc/network/interfaces, чтоб все вышеперечисленное грузилось при старте
**cat /etc/network/interfaces**
```
root@ceph01:~# cat /etc/network/interfaces
auto lo
iface lo inet loopback
auto ens1f0
iface ens1f0 inet manual
post-up /sbin/ethtool -G ens1f0 rx 4096
post-up /sbin/ethtool -G ens1f0 tx 4096
post-up /sbin/ethtool -L ens1f0 combined 63
post-up /sbin/ip link set ens1f0 txqueuelen 10000
mtu 9000
auto ens1f1
iface ens1f1 inet manual
post-up /sbin/ethtool -G ens1f1 rx 4096
post-up /sbin/ethtool -G ens1f1 tx 4096
post-up /sbin/ethtool -L ens1f1 combined 63
post-up /sbin/ip link set ens1f1 txqueuelen 10000
mtu 9000
```
После чего, следуя этой же статье, начал вдумчиво накручивать ручки ядра 4.15. Учитывая, что на нодах 128G RAM, получился некий файл конфигурации для **sysctl**
**cat /etc/sysctl.d/50-ceph.conf**
```
net.core.rmem_max = 56623104
#Максимальный размер буфера приема данных для всех соединений 54M
net.core.wmem_max = 56623104
#Максимальный размер буфера передачи данных для всех соединений 54M
net.core.rmem_default = 56623104
#Размер буфера приема данных по умолчанию для всех соединений. 54M
net.core.wmem_default = 56623104
#Размер буфера передачи данных по умолчанию для всех соединений 54M
# на каждый сокет
net.ipv4.tcp_rmem = 4096 87380 56623104
#Векторная (минимум, по умолчанию, максимум) переменная в файле tcp_rmem
# содержит 3 целых числа, определяющих размер приемного буфера сокетов TCP.
# Минимум: каждый сокет TCP имеет право использовать эту память по
# факту своего создания. Возможность использования такого буфера
# гарантируется даже при достижении порога ограничения (moderate memory pressure).
# Размер минимального буфера по умолчанию составляет 8 Кбайт (8192).
#Значение по умолчанию: количество памяти, допустимое для буфера
# передачи сокета TCP по умолчанию. Это значение применяется взамен
# параметра /proc/sys/net/core/rmem_default, используемого другими протоколами.
# Значение используемого по умолчанию буфера обычно (по умолчанию)
# составляет 87830 байт. Это определяет размер окна 65535 с
# заданным по умолчанию значением tcp_adv_win_scale и tcp_app_win = 0,
# несколько меньший, нежели определяет принятое по умолчанию значение tcp_app_win.
# Максимум: максимальный размер буфера, который может быть автоматически
# выделен для приема сокету TCP. Это значение не отменяет максимума,
# заданного в файле /proc/sys/net/core/rmem_max. При «статическом»
# выделении памяти с помощью SO_RCVBUF этот параметр не имеет значения.
net.ipv4.tcp_wmem = 4096 65536 56623104
net.core.somaxconn = 5000
# Максимальное число открытых сокетов, ждущих соединения.
net.ipv4.tcp_timestamps=1
# Разрешает использование временных меток (timestamps), в соответствии с RFC 1323.
net.ipv4.tcp_sack=1
# Разрешить выборочные подтверждения протокола TCP
net.core.netdev_max_backlog=5000 (дефолт 1000)
# максимальное количество пакетов в очереди на обработку, если
# интерфейс получает пакеты быстрее, чем ядро может их обработать.
net.ipv4.tcp_max_tw_buckets=262144
# Максимальное число сокетов, находящихся в состоянии TIME-WAIT одновременно.
# При превышении этого порога – «лишний» сокет разрушается и пишется
# сообщение в системный журнал.
net.ipv4.tcp_tw_reuse=1
#Разрешаем повторное использование TIME-WAIT сокетов в случаях,
# если протокол считает это безопасным.
net.core.optmem_max=4194304
#Увеличить максимальный общий буфер-космической ALLOCATABLE
#измеряется в единицах страниц (4096 байт)
net.ipv4.tcp_low_latency=1
#Разрешает стеку TCP/IP отдавать предпочтение низкому времени ожидания
# перед более высокой пропускной способностью.
net.ipv4.tcp_adv_win_scale=1
# Эта переменная влияет на вычисление объема памяти в буфере сокета,
# выделяемой под размер TCP-окна и под буфер приложения.
# Если величина tcp_adv_win_scale отрицательная, то для вычисления размера
# используется следующее выражение:
# Bytes- bytes\2в степени -tcp_adv_win_scale
# Где bytes – это размер окна в байтах. Если величина tcp_adv_win_scale
# положительная, то для определения размера используется следующее выражение:
# Bytes- bytes\2в степени tcp_adv_win_scale
# Переменная принимает целое значение. Значение по-умолчанию – 2,
# т.е. под буфер приложения отводится ¼ часть объема, определяемого переменной
# tcp_rmem.
net.ipv4.tcp_slow_start_after_idle=0
# механизм перезапуска медленного старта, который сбрасывает значение окна
# перегрузки, если соединение не использовалось заданный период времени.
# Лучше отключить SSR на сервере, чтобы улучшить производительность
# долгоживущих соединений.
net.ipv4.tcp_no_metrics_save=1
#Не сохранять результаты измерений TCP соединения в кеше при его закрытии.
net.ipv4.tcp_syncookies=0
#Отключить механизм отправки syncookie
net.ipv4.tcp_ecn=0
#Explicit Congestion Notification (Явное Уведомление о Перегруженности) в
# TCP-соединениях. Используется для уведомления о возникновении «затора»
# на маршруте к заданному хосту или сети. Может использоваться для извещения
# хоста-отправителя о необходимости снизить скорость передачи пакетов через
# конкретный маршрутизатор или брандмауэр.
net.ipv4.conf.all.send_redirects=0
# выключает выдачу ICMP Redirect … другим хостам. Эта опция обязательно
# должна быть включена, если хост выступает в роли маршрутизатора любого рода.
# У нас нет маршрутизации.
net.ipv4.ip_forward=0
#Сопсно отключение форвардинга. Мы не шлюз, докер на машинах не поднят,
# нам это не нужно.
net.ipv4.icmp_echo_ignore_broadcasts=1
#Не отвечаем на ICMP ECHO запросы, переданные широковещательными пакетами
net.ipv4.tcp_fin_timeout=10
#определяет время сохранения сокета в состоянии FIN-WAIT-2 после его
# закрытия локальной стороной. Дефолт 60
net.core.netdev_budget=600 # (дефолт 300)
# Если выполнение программных прерываний не выполняются достаточно долго,
# то темп роста входящих данных может превысить возможность ядра
# опустошить буфер. В результате буферы NIC переполнятся, и трафик будет потерян.
# Иногда, необходимо увеличить длительность работы SoftIRQs
# (программных прерываний) с CPU. За это отвечает netdev_budget.
# Значение по умолчанию 300. Параметр заставит процесс SoftIRQ обработать
# 300 пакетов от NIC перед тем как отпустить CPU
net.ipv4.tcp_fastopen=3
# TFO TCP Fast Open
# если и клиент и сервер имеют поддержку TFO, о которой сообщают за счет
# специального флага в TCP пакете. В нашем случае является плацебо, просто
# выглядит красиво)
```
С**luster network** была выделена на отдельных 10Gbps сетевых интерфейсах в отдельную плоскую сеть. На каждой машине были поставлены сетевые двухпортовые карты **mellanox** 10/25 Gbps, воткнутые в два отдельных 10Gbps свича. Агрегация осуществлялась с помощью OSPF, поскольку бондинг с lacp почему-то показал суммарную пропускную способность максимум в 16 Gbps, в то время как ospf успешно утилизировал полностью обе десятки на каждой машине. В дальнейших планах было воспользоваться ROCE на этих меланоксах, для уменьшения лэтэнси. Как настраивали эту часть сети:
1. Поскольку сами машины имеют внешние айпишники на BGP, то необходимы нам софт — *( а точнее на момент написания статьи это был [frr=6.0-1](https://frrouting.org/) )* уже стоял.
2. Всего на машинах было две сетевых по два интерфейса — в сумме 4 порта. Одна сетевая карта двумя портами смотрела на фабрику и на ней был настроен BGP, вторая — двумя портами смотрела в два разных свитча и на неё был натравлен OSPF
Подробнее по настройке OSPF: Основная задача — агрегировать два линка и иметь fault tolerance.
два сетевых интерфейса настроены в две простых плоских сети — 10.10.10.0/24 и 10.10.20.0/24
```
1: ens1f0: mtu 9000 qdisc mq state UP group default qlen 1000
inet 10.10.10.2/24 brd 10.10.10.255 scope global ens1f0
2: ens1f1: mtu 9000 qdisc mq state UP group default qlen 1000
inet 10.10.20.2/24 brd 10.10.20.255 scope global ens1f1
```
по которым машины друг друга видят.
### DISK
Следующим шагом решил оптимизировать работу дисков. Для SSD поменял планировщик на **noop**, для HDD — **deadline**. Если грубо — то NOOP работает по принципу "кто первый встал — того и тапки", что по английский звучит как "FIFO (First In, First Out)". Запросы встают в очередь по мере их поступления. DEADLINE более заточен на чтение, плюс процесс из очереди получает практически монопольный доступ к диску на момент операции. Для нашей системы это отлично подходит — ведь с каждым диском работает только один процесс — OSD daemon.
(Желающие погрузится в планировщик ввода-вывода могут почитать о нем тут:
<http://www.admin-magazine.com/HPC/Articles/Linux-I-O-Schedulers>
Предпочитающие читать на русском: <https://www.opennet.ru/base/sys/linux_shedulers.txt.html>)
В рекомендациях по тюнингу линукса советуют так-же увеличить nr\_request
> *nr\_requests
>
> The value of nr\_requests determines the amount of I/O requests that get buffered before the I/O scheduler sends / receives data to the block device, if you are using a RAID card / Block Device that can handle a larger queue than what the I/O scheduler is set to, raising the value of nr\_requests may help to improve throughout and reduce server load when large amounts of I/O occur on the server. If you are using Deadline or CFQ as the scheduler, it is suggested that you should set the nr\_request value to 2 times the value of queue depth.*
НО! Сами граждане разработчики CEPH убеждают нас, что их система приоритетов работает лучше
**WBThrottle и/или nr\_requests**
> WBThrottle и/или nr\_requests
>
> Файловое хранилище использует для записи буферизованные операции ввода/ вывода; это привносит целый ряд преимуществ если журнал файлового хранения находится на более быстром носителе. Запросы клиентов получают уведомления как только данные записаны в журнал, а затем сбрасываются на сам диск данных в более позднее время пользуясь стандартной функциональностью Linux. Это делает возможным для OSD шпиндельных дисков предоставлять латентность записи аналогичную SSD при записях малыми пакетами. Такая задержанная отложенная запись также позволяет самому ядру перестраивать запросы операций ввода/ вывода к диску с надеждой либо слить их воедино, либо позволить имеющимся головкам диска выбрать некий более оптимальный путь поверх своих пластин. Конечный эффект состоит в том, что вы можете выжать слегка больше операций ввода/ вывода из каждого диска чем это было бы возможно при прямых или синхронных операциях ввода/ вывода.
Однако, возникает определённая проблема если объём приходящих записей в данный кластер Ceph будут опережать все возможности лежащих в основе дисков. При таком сценарии общее число находящихся в рассмотрении операций ввода/ вывода в ожидании записи на диск могут неконтролируемо расти и иметь результатом очереди операций ввода/ вывода, заполняющую весь диск и очереди Ceph. Запросы на чтение воздействуют в особенности плохо, так как они застревают между запросами записи, которые могут требовать нескольких секунд для сброса на основной диск.
Для победы над этой проблемой Ceph имеет встроенный в файловое хранение механизм дросселирования отложенной записи (writeback) с названием WBThrottle. Он разработан для ограничения общего объёма операций ввода/ вывода отложенной записи, которые могут выстраиваться в очередь и начинать свой процесс сброса раньше чем чем это произошло бы естественным образом за счёт включения самим ядром. К сожалению, тестирование демонстрирует, что установленные по умолчанию значения всё ещё могут не урезать имеющееся поведение до уровня, который может уменьшать такое воздействие на латентность операций чтения. Регулировка может изменить это поведение и уменьшить общие длины очередей записи и сделать возможным не сильным такое воздействие. Однако имеется некий компромисс: уменьшая общее максимальное число разрешённых к постановке в очередь записей, вы можете снизить возможность самого ядра максимизировать свою эффективность упорядочения поступающих запросов. Стоит немного задуматься что вам более необходимо для вашего конкретного случая применения, рабочих нагрузок и регулировать под соответствие им.
Чтобы управлять глубиной такой очереди отложенной записи, вы можете либо уменьшать общее максимальное количество невыполненных операций ввода/ вывода, применяя установки WBThrottle, либо уменьшая максимальное значение для невыполненных операций на самом блочном уровне своего ядра. И то, и другое могут эффективно управлять одним и тем же поведением и именно ваши предпочтения будут в основе реализации данной настройки.
Также следует отметить, что имеющаяся в Ceph система приоритетов операций является более эффективной для более коротких запросов на дисковом уровне. При сокращении общей очереди к данному диску основное местоположение нахождения в очереди перемещается в Ceph, где он имеет большее управление над тем какой приоритет имеет операция ввода/ вывода. Рассмотрим следующий пример:
```
echo 8 > /sys/block/sda/queue/nr_requests
```
<http://onreader.mdl.ru/MasteringCeph/content/Ch09.html#030202>
### COMMON
И еще несколько настроек ядра, позволяющие сделать ~~вашу тачку мягкой и шелковистой~~ выжать еще немного производительности из железа
**cat /etc/sysctl.d/60-ceph2.conf**
```
kernel.pid_max = 4194303
#Дисков в каждой машине по 25, потому рассчитывали что процессов будет много
kernel.threads-max=2097152
# Тредов, естессно, тоже.
vm.max_map_count=524288
# Увеличили количество областей карты памяти процесса.
# Как следует из документации по ядерным переменным
# Области карты памяти используется как побочный эффект вызова
# malloc, напрямую с помощью mmap, mprotect и madvise, а также при загрузке
# общих библиотек.
fs.aio-max-nr=50000000
# Подтюним параметры input-output
# Ядро Linux предоставляет функцию асинхронного неблокирующего ввода-вывода (AIO),
# которая позволяет процессу инициировать несколько операций ввода-вывода
# одновременно, не дожидаясь завершения какой-либо из них.
# Это помогает повысить производительность приложений,
# которые могут перекрывать обработку и ввод-вывод.
# Параметр aio-max-nr определяет максимальное количество допустимых
# одновременных запросов.
vm.min_free_kbytes=1048576
# минимальный размер свободной памяти который необходимо поддерживать.
# Выставлен 1Gb, чего вполне достаточно для работы операционной системы,
# и позволяет избегать OOM Killer для процессов OSD. Хотя памяти и так
# как у дурака фантиков, но запас карман не тянет
vm.swappiness=10
# Говорим использовать своп если осталось свободным 10% памяти.
# На машинах 128G оперативы, и 10% это 12 Гигов. Более чем достаточно для работы.
# Штатный параметр в 60% заставлял тормозить систему, залезая в своп,
# когда есть еще куча свободной памяти
vm.vfs_cache_pressure=1000
# Увеличиваем со штатных 100. Заставляем ядро активнее выгружать
# неиспользуемые страницы памяти из кеша.
vm.zone_reclaim_mode=0
# Позволяет устанавливать более или менее агрессивные подходы к
# восстановлению памяти, когда в зоне заканчивается память.
# Если он установлен на ноль, то не происходит восстановление зоны.
# Для файловых серверов или рабочих нагрузок
# выгодно, если их данные кэшированы, zone_reclaim_mode
# оставить отключенным, поскольку эффект кэширования,
# вероятно, будет более важным, чем местонахождение данных.
vm.dirty_ratio=20
# Процент оперативной памяти, который можно выделить под "грязные" страницы
# Вычисляли из примерного расчета:
# В система 128 гигов памяти.
# Примерно по 20 дисков SSD, у которых в настройках CEPH указано
# выделять под кэширование по 3G оперативы.
# Примерно по 40 дисков HDD, для которых этот параметр равен 1G
# 20% от 128 это 25.6 гигов. Итого, в случае максимальной утилизации памяти,
# для системы останется 2.4G памяти. Чего ей должно хватить чтоб выжить и дождаться
# стука копыт кавалерии - то есть пришествия DevOps который все починит.
vm.dirty_background_ratio=3
# процент системной памяти, который можно заполнить dirty pages до того,
# как фоновые процессы pdflush/flush/kdmflush запишут их на диск
fs.file-max=524288
# Ну и открытых файлов у нас,вероятно, будет сильно больше, чем указано по дефолту.
```
Погружение в CEPH
-----------------
Настройки, на которых хотелось бы задержаться подробнее:
**cat /etc/ceph/ceph.conf**
```
osd:
journal_aio: true # Три параметра, включающие
journal_block_align: true # прямой i/o
journal_dio: true # на журнал
journal_max_write_bytes: 1073714824 # Немного растянем максимальный размер
# разово записываемой операции в журнал
journal_max_write_entries: 10000 # Ну и количество одновременных записей
journal_queue_max_bytes: 10485760000
journal_queue_max_ops: 50000
rocksdb_separate_wal_dir: true # Решили делать отдельный wal
# Даже попытались выбить под это дело
# NVMe
bluestore_block_db_create: true # Ну и под журнал отдельное устройство
bluestore_block_db_size: '5368709120 #5G'
bluestore_block_wal_create: true
bluestore_block_wal_size: '1073741824 #1G'
bluestore_cache_size_hdd: '3221225472 # 3G'
# большой объем оперативы позволяет
# хранить достаточно большие объемы
bluestore_cache_size_ssd: '9663676416 # 9G'
keyring: /var/lib/ceph/osd/ceph-$id/keyring
osd_client_message_size_cap: '1073741824 #1G'
osd_disk_thread_ioprio_class: idle
osd_disk_thread_ioprio_priority: 7
osd_disk_threads: 2 # количество тредов у демона на один диск
osd_failsafe_full_ratio: 0.95
osd_heartbeat_grace: 5
osd_heartbeat_interval: 3
osd_map_dedup: true
osd_max_backfills: 2 # количество одновременных операций заполнения на один ОСД.
osd_max_write_size: 256
osd_mon_heartbeat_interval: 5
osd_op_threads: 16
osd_op_num_threads_per_shard: 1
osd_op_num_threads_per_shard_hdd: 2
osd_op_num_threads_per_shard_ssd: 2
osd_pool_default_min_size: 1 # Особенности жадности. Очень быстро стало
osd_pool_default_size: 2 # нехватать места, потому как временное
# решение приняли уменьшение количество
# реплик данных
osd_recovery_delay_start: 10.000000
osd_recovery_max_active: 2
osd_recovery_max_chunk: 1048576
osd_recovery_max_single_start: 3
osd_recovery_op_priority: 1
osd_recovery_priority: 1 # параметр регулируем по необходимости на ходу
osd_recovery_sleep: 2
osd_scrub_chunk_max: 4
```
Часть параметров, которые тестировались на QA на версии 12.2.12, отсутствуют в версии ceph 12.2.2, к примеру **osd\_recovery\_threads.** Потому в планы было включено обновление на проде до 12.2.12. Практика показала совместимость в одном кластере версий 12.2.2 и 12.2.12, что позволяет сделать rolling update.
### Тестовый кластер
Естественно, для тестирования было необходимо иметь ту-же версию что и на бою, но на момент начала моей работы с кластером в репозитории имелась лишь более новая. Посмотрев, что различите в минорной версии не сильно большое (**1393** строки в конфигах против **1436** в новой версии), решили начать тестировать новую (все равно обновляться, чего ехать на старом хламе)
Единственное, что постарались оставить старой версии — это пакет **ceph-deploy,** поскольку часть утилит (и часть сотрудников) была заточена под её синтаксис. Новая версия достаточно сильно отличалась, но на работу самого кластера никак не влияла, и её оставили версии **1.5.39**
Поскольку команда ceph-disk явно говорит что она deprecated и пользуйтесь-ка, уважаемые, командой ceph-volume — мы начали создавать OSD именно этой командой, не тратя время на устаревшее.
План был таков — создать зеркало из двух SSD дисков, на которых разместим журналы OSD, которые, в свою очередь, располагаются на шпиндельных SASах. Так подстрахуемся от проблем с данными при падении диска с журналом.
Создавать кластер стали по документации
**cat /etc/ceph/ceph.conf**
```
root@ceph01-qa:~# cat /etc/ceph/ceph.conf # положили заранее подготовленный конфиг
[client]
rbd_cache = true
rbd_cache_max_dirty = 50331648
rbd_cache_max_dirty_age = 2
rbd_cache_size = 67108864
rbd_cache_target_dirty = 33554432
rbd_cache_writethrough_until_flush = true
rbd_concurrent_management_ops = 10
rbd_default_format = 2
[global]
auth_client_required = cephx
auth_cluster_required = cephx
auth_service_required = cephx
cluster network = 10.10.10.0/24
debug_asok = 0/0
debug_auth = 0/0
debug_buffer = 0/0
debug_client = 0/0
debug_context = 0/0
debug_crush = 0/0
debug_filer = 0/0
debug_filestore = 0/0
debug_finisher = 0/0
debug_heartbeatmap = 0/0
debug_journal = 0/0
debug_journaler = 0/0
debug_lockdep = 0/0
debug_mon = 0/0
debug_monc = 0/0
debug_ms = 0/0
debug_objclass = 0/0
debug_objectcatcher = 0/0
debug_objecter = 0/0
debug_optracker = 0/0
debug_osd = 0/0
debug_paxos = 0/0
debug_perfcounter = 0/0
debug_rados = 0/0
debug_rbd = 0/0
debug_rgw = 0/0
debug_throttle = 0/0
debug_timer = 0/0
debug_tp = 0/0
fsid = d0000000d-4000-4b00-b00b-0123qwe123qwf9
mon_host = ceph01-q, ceph02-q, ceph03-q
mon_initial_members = ceph01-q, ceph02-q, ceph03-q
public network = 8.8.8.8/28 # адрес изменен, естественно ))
rgw_dns_name = s3-qa.mycompany.ru # и этот адрес измен
rgw_host = s3-qa.mycompany.ru # и этот тоже
[mon]
mon allow pool delete = true
mon_max_pg_per_osd = 300 # больше трехсот плейсмент групп
# на диск не решились
# хотя параметр, естественно, зависит от количества пулов,
# их размеров и количества OSD. Иметь мало но здоровых PG
# тоже не лучший выбор - страдает точность балансировки
mon_osd_backfillfull_ratio = 0.9
mon_osd_down_out_interval = 5
mon_osd_full_ratio = 0.95 # пока для SSD дисков местом для их
# журнала является тот-же девайс что и для ОСД
# решили что 5% от диска (который сам размером 1.2Tb)
# должно вполне хватить, и коррелирует с параметром
# bluestore_block_db_size плюс вариативность на большие
# плейсмент группы
mon_osd_nearfull_ratio = 0.9
mon_pg_warn_max_per_osd = 520
[osd]
bluestore_block_db_create = true
bluestore_block_db_size = 5368709120 #5G
bluestore_block_wal_create = true
bluestore_block_wal_size = 1073741824 #1G
bluestore_cache_size_hdd = 3221225472 # 3G
bluestore_cache_size_ssd = 9663676416 # 9G
journal_aio = true
journal_block_align = true
journal_dio = true
journal_max_write_bytes = 1073714824
journal_max_write_entries = 10000
journal_queue_max_bytes = 10485760000
journal_queue_max_ops = 50000
keyring = /var/lib/ceph/osd/ceph-$id/keyring
osd_client_message_size_cap = 1073741824 #1G
osd_disk_thread_ioprio_class = idle
osd_disk_thread_ioprio_priority = 7
osd_disk_threads = 2
osd_failsafe_full_ratio = 0.95
osd_heartbeat_grace = 5
osd_heartbeat_interval = 3
osd_map_dedup = true
osd_max_backfills = 4
osd_max_write_size = 256
osd_mon_heartbeat_interval = 5
osd_op_num_threads_per_shard = 1
osd_op_num_threads_per_shard_hdd = 2
osd_op_num_threads_per_shard_ssd = 2
osd_op_threads = 16
osd_pool_default_min_size = 1
osd_pool_default_size = 2
osd_recovery_delay_start = 10.0
osd_recovery_max_active = 1
osd_recovery_max_chunk = 1048576
osd_recovery_max_single_start = 3
osd_recovery_op_priority = 1
osd_recovery_priority = 1
osd_recovery_sleep = 2
osd_scrub_chunk_max = 4
osd_scrub_chunk_min = 2
osd_scrub_sleep = 0.1
rocksdb_separate_wal_dir = true
```
```
# создаем мониторы
root@ceph01-qa:~#ceph-deploy mon create ceph01-q
# генерируем ключи для аутентификации нод в кластере
root@ceph01-qa:~#ceph-deploy gatherkeys ceph01-q
# Это если поштучно. Если у нас несколько машин доступны - те, которые описаны в конфиге в секции
# mon_initial_members = ceph01-q, ceph02-q, ceph03-q
# можно запустить эти две команды в виде одной
root@ceph01-qa:~#ceph-deploy mon create-initial
# Положим ключи в указанные в конфиге места
root@ceph01-qa:~#cat ceph.bootstrap-osd.keyring > /var/lib/ceph/bootstrap-osd/ceph.keyring
root@ceph01-qa:~#cat ceph.bootstrap-mgr.keyring > /var/lib/ceph/bootstrap-mgr/ceph.keyring
root@ceph01-qa:~#cat ceph.bootstrap-rgw.keyring > /var/lib/ceph/bootstrap-rgw/ceph.keyring
# создадим ключ для управления кластером
root@ceph01-qa:~#ceph-deploy admin ceph01-q
# и менеджер, плагинами управлять
root@ceph01-qa:~#ceph-deploy mgr create ceph01-q
```
Первое, обо что споткнулся в работе этой версии ceph-deploy с кластером версии 12.2.12 — это ошибка при попытке создать OSD с db на софтверном рейде -
```
root@ceph01-qa:~#ceph-volume lvm create --bluestore --data /dev/sde --block.db /dev/md0
blkid could not detect a PARTUUID for device: /dev/md1
```
Действительно, blkid не кажет PARTUUID, пришлось создавать разделы ручками:
```
root@ceph01-qa:~#parted /dev/md0 mklabel GPT
# разделов будет много,
# без GPT их создать не получится
# размер раздела мы указали в конфиге выше = bluestore_block_db_size: '5368709120 #5G'
# Дисков у меня 20 под OSD, руками создавать разделы лень
# потому сделал цикл
root@ceph01-qa:~#for i in {1..20}; do echo -e "n\n\n\n+5G\nw" | fdisk /dev/md0; done
```
Вроде все готово, пробуем еще раз создать OSD и получаем следующую ошибку (которая, кстати, на бою не воспроизводилась)
при создании OSD типа bluestore без указания пути к WAL, но с указанием db
```
root@ceph01-qa:~#ceph-volume lvm create --bluestore --data /dev/sde --block.db /dev/md0
stderr: 2019-04-12 10:39:27.211242 7eff461b6e00 -1 bluestore(/var/lib/ceph/osd/ceph-0/) _read_fsid unparsable uuid
stderr: 2019-04-12 10:39:27.213185 7eff461b6e00 -1 bdev(0x55824c273680 /var/lib/ceph/osd/ceph-0//block.wal) open open got: (22) Invalid argument
stderr: 2019-04-12 10:39:27.213201 7eff461b6e00 -1 bluestore(/var/lib/ceph/osd/ceph-0/) _open_db add block device(/var/lib/ceph/osd/ceph-0//block.wal) returned: (22) Invalid argument
stderr: 2019-04-12 10:39:27.999039 7eff461b6e00 -1 bluestore(/var/lib/ceph/osd/ceph-0/) mkfs failed, (22) Invalid argument
stderr: 2019-04-12 10:39:27.999057 7eff461b6e00 -1 OSD::mkfs: ObjectStore::mkfs failed with error (22) Invalid argument
stderr: 2019-04-12 10:39:27.999141 7eff461b6e00 -1 ** ERROR: error creating empty object store in /var/lib/ceph/osd/ceph-0/: (22) Invalid argumen
```
При этом если на том-же зеркале (или в другом месте, на выбор) создать еще один раздел под WAL и указать его при создании OSD — то все пойдет гладко (за исключением появления раздельного WAL, который вы, возможно, и не хотели).
Но, поскольку все равно в далеких планах было выносить WAL на NVMe, то практика лишней не оказалась.
```
root@ceph01-qa:~#ceph-volume lvm create --bluestore --data /dev/sdf --block.wal /dev/md0p2 --block.db /dev/md1p2
```
Посоздавали мониторы, менеджеры и OSD. Теперь хочется их погруппировать по разному, ибо в планах иметь диски разных типов — быстрые пулы на SSD и большие, но медленные на блинах SAS.
Будем считать что на серверах по 20 дисков, первая десятка это один тип, вторая — другой.
Первоначальная, дефолтная, карта выглядит так:
**ceph osd tree**root@сeph01-q:~# ceph osd tree
ID CLASS WEIGHT TYPE NAME STATUS REWEIGHT PRI-AFF
-1 14.54799 root default
-3 9.09200 host ceph01-q
0 ssd 1.00000 osd.0 up 1.00000 1.00000
1 ssd 1.00000 osd.1 up 1.00000 1.00000
2 ssd 1.00000 osd.2 up 1.00000 1.00000
3 ssd 1.00000 osd.3 up 1.00000 1.00000
4 hdd 1.00000 osd.4 up 1.00000 1.00000
5 hdd 0.27299 osd.5 up 1.00000 1.00000
6 hdd 0.27299 osd.6 up 1.00000 1.00000
7 hdd 0.27299 osd.7 up 1.00000 1.00000
8 hdd 0.27299 osd.8 up 1.00000 1.00000
9 hdd 0.27299 osd.9 up 1.00000 1.00000
10 hdd 0.27299 osd.10 up 1.00000 1.00000
11 hdd 0.27299 osd.11 up 1.00000 1.00000
12 hdd 0.27299 osd.12 up 1.00000 1.00000
13 hdd 0.27299 osd.13 up 1.00000 1.00000
14 hdd 0.27299 osd.14 up 1.00000 1.00000
15 hdd 0.27299 osd.15 up 1.00000 1.00000
16 hdd 0.27299 osd.16 up 1.00000 1.00000
17 hdd 0.27299 osd.17 up 1.00000 1.00000
18 hdd 0.27299 osd.18 up 1.00000 1.00000
19 hdd 0.27299 osd.19 up 1.00000 1.00000
-5 5.45599 host ceph02-q
20 ssd 0.27299 osd.20 up 1.00000 1.00000
21 ssd 0.27299 osd.21 up 1.00000 1.00000
22 ssd 0.27299 osd.22 up 1.00000 1.00000
23 ssd 0.27299 osd.23 up 1.00000 1.00000
24 hdd 0.27299 osd.24 up 1.00000 1.00000
25 hdd 0.27299 osd.25 up 1.00000 1.00000
26 hdd 0.27299 osd.26 up 1.00000 1.00000
27 hdd 0.27299 osd.27 up 1.00000 1.00000
28 hdd 0.27299 osd.28 up 1.00000 1.00000
29 hdd 0.27299 osd.29 up 1.00000 1.00000
30 hdd 0.27299 osd.30 up 1.00000 1.00000
31 hdd 0.27299 osd.31 up 1.00000 1.00000
32 hdd 0.27299 osd.32 up 1.00000 1.00000
33 hdd 0.27299 osd.33 up 1.00000 1.00000
34 hdd 0.27299 osd.34 up 1.00000 1.00000
35 hdd 0.27299 osd.35 up 1.00000 1.00000
36 hdd 0.27299 osd.36 up 1.00000 1.00000
37 hdd 0.27299 osd.37 up 1.00000 1.00000
38 hdd 0.27299 osd.38 up 1.00000 1.00000
39 hdd 0.27299 osd.39 up 1.00000 1.00000
-7 6.08690 host ceph03-q
40 ssd 0.27299 osd.40 up 1.00000 1.00000
41 ssd 0.27299 osd.41 up 1.00000 1.00000
42 ssd 0.27299 osd.42 up 1.00000 1.00000
43 ssd 0.27299 osd.43 up 1.00000 1.00000
44 hdd 0.27299 osd.44 up 1.00000 1.00000
45 hdd 0.27299 osd.45 up 1.00000 1.00000
46 hdd 0.27299 osd.46 up 1.00000 1.00000
47 hdd 0.27299 osd.47 up 1.00000 1.00000
48 hdd 0.27299 osd.48 up 1.00000 1.00000
49 hdd 0.27299 osd.49 up 1.00000 1.00000
50 hdd 0.27299 osd.50 up 1.00000 1.00000
51 hdd 0.27299 osd.51 up 1.00000 1.00000
52 hdd 0.27299 osd.52 up 1.00000 1.00000
53 hdd 0.27299 osd.53 up 1.00000 1.00000
54 hdd 0.27299 osd.54 up 1.00000 1.00000
55 hdd 0.27299 osd.55 up 1.00000 1.00000
56 hdd 0.27299 osd.56 up 1.00000 1.00000
57 hdd 0.27299 osd.57 up 1.00000 1.00000
58 hdd 0.27299 osd.58 up 1.00000 1.00000
59 hdd 0.89999 osd.59 up 1.00000 1.00000
Создадим свои виртуальные стойки и сервера с блекджеком и прочим:
```
root@ceph01-q:~#ceph osd crush add-bucket rack01 root #создали новый root
root@ceph01-q:~#ceph osd crush add-bucket ceph01-q host #создали новый хост
root@ceph01-q:~#ceph osd crush move ceph01-q root=rack01 #переставили сервер в другую стойку
root@ceph01-q:~#osd crush add 28 1.0 host=ceph02-q # Добавили ОСД в сервер
# Если криво создали то можно удалить
root@ceph01-q:~# ceph osd crush remove osd.4
root@ceph01-q:~# ceph osd crush remove rack01
```
Проблемы, с которыми мы столкнулись в **боевом** кластере, при попытке создать новых хост и передвинуть его в существующую стойку — команда **ceph osd crush move ceph01-host root=rack01** зависала, и мониторы начинали падать по одному. Прерывание команды простым CTRL+C возвращало кластер в мир живых.
Поиск показал такую проблему: <https://tracker.ceph.com/issues/23386>
Решением оказалось сдампить crushmap и удалить оттуда секцию **rule replicated\_ruleset**
```
root@ceph01-prod:~#ceph osd getcrushmap -o crushmap.row #Дампим карту в сыром виде
root@ceph01-prod:~#crushtool -d crushmap.row -o crushmap.txt #переводим в читаемый
root@ceph01-prod:~#vim crushmap.txt #редактируем, удаляя rule replicated_ruleset
root@ceph01-prod:~#crushtool -c crushmap.txt -o new_crushmap.row #компилируем обратно
root@ceph01-prod:~#ceph osd setcrushmap -i new_crushmap.row #загружаем в кластер
```
**Ахтунг:** данная операция может вызвать ребаланс placement group между OSD. У нас это вызвало, но очень небольшой.
А странность, с которой мы столкнулись в тестовом кластере — это то, что после перезагрузки сервера OSD забывали, что их передвинули в новые сервера и стойки, и возвращались в root default.
В итоге, собрав конечную схему, в которой мы создали отдельно root для ssd дисков и отдельно для шпиндельных, мы растащили все ОСД по стойкам а просто удалили default root. После перезагрузки OSD стали оставаться на своих местах.
*Покопавшись позже в документации нашли параметр, который отвечает за это поведение. О нем во второй части*
### Как мы делали различные группы по типам дисков.
Для начала создали два root-а — для ssd и для hdd
```
root@ceph01-q:~#ceph osd crush add-bucket ssd-root root
root@ceph01-q:~#ceph osd crush add-bucket hdd-root root
```
Поскольку физически сервера стоят в разных стойках — для удобства создали стойки и в них уже сервера
```
# Стойки:
root@ceph01-q:~#ceph osd crush add-bucket ssd-rack01 rack
root@ceph01-q:~#ceph osd crush add-bucket ssd-rack02 rack
root@ceph01-q:~#ceph osd crush add-bucket ssd-rack03 rack
root@ceph01-q:~#ceph osd crush add-bucket hdd-rack01 rack
root@ceph01-q:~#ceph osd crush add-bucket hdd-rack01 rack
root@ceph01-q:~#ceph osd crush add-bucket hdd-rack01 rack
# Сервера
root@ceph01-q:~#ceph osd crush add-bucket ssd-ceph01-q host
root@ceph01-q:~#ceph osd crush add-bucket ssd-ceph02-q host
root@ceph01-q:~#ceph osd crush add-bucket ssd-ceph03-q host
root@ceph01-q:~#ceph osd crush add-bucket hdd-ceph01-q host
root@ceph01-q:~#ceph osd crush add-bucket hdd-ceph02-q host
root@ceph01-q:~#ceph osd crush add-bucket hdd-ceph02-q host
```
и пораскидали диски по их типам в разные сервера
```
root@ceph01-q:~# Диски с 0 по 3 это SSD, находятся в ceph01-q, ставим их в сервер
root@ceph01-q:~# ssd-ceph01-q
root@ceph01-q:~#ceph osd crush add 0 1 host=ssd-ceph01-q
root@ceph01-q:~#ceph osd crush add 1 1 host=ssd-ceph01-q
root@ceph01-q:~#ceph osd crush add 2 1 host=ssd-ceph01-q
root@ceph01-q:~#ceph osd crush add 3 1 host=ssd-ceph01-q
root-ceph01-q:~# аналогично с другими серверами
```
Раскидав диски по рутам ssd-root и hdd-root мы оставили root-default пустым, потому можем его удалить
```
root-ceph01-q:~#ceph osd crush remove default
```
Далее надо создать правила распределения, которые мы будем привязывать к создаваемым пулам — в правилах укажем в какие root можно класть данные нашего пула и уровень уникальности реплики — например реплики должны быть обязательно на разных серверах, или в разных стойках (можно даже в разных root, если имеем такое распределение)
Перед тем как выбрать тип лучше почитать документацию:
<http://docs.ceph.com/docs/jewel/rados/operations/crush-map/#crushmaprules>
```
root-ceph01-q:~#ceph osd crush rule create-simple rule-ssd ssd-root host firstn
root-ceph01-q:~#ceph osd crush rule create-simple rule-hdd hdd-root host firstn
root-ceph01-q:~# Мы указали два правила, в которых данные реплицируются
root-ceph01-q:~# между хостами - то есть реплика должна лежать на другом хосте,
root-ceph01-q:~# даже если они в одной стойке
root-ceph01-q:~# В продакшене, если есть возможность, лучше распределить хосты
root-ceph01-q:~# по стойкам и указать распределять реплики по стойкам:
root-ceph01-q:~# ##ceph osd crush rule create-simple rule-ssd ssd-root rack firstn
```
Ну и создаем пулы, в которых мы хотим в будущем хранить образы дисков нашей виртуализации — PROXMOX:
```
root-ceph01-q:~# #ceph osd pool create {NAME} {pg_num} {pgp_num}
root-ceph01-q:~# ceph osd pool create ssd_pool 1024 1024
root-ceph01-q:~# ceph osd pool create hdd_pool 1024 1024
```
И говорим этим пулам какими правилами размещения пользоваться
```
root-ceph01-q:~#ceph osd crush rule ls # смотрим список правил
root-ceph01-q:~#ceph osd crush rule dump rule-ssd | grep rule_id #выбираем ID нужного
root-ceph01-q:~#ceph osd pool set ssd_pool crush_rule 2
```
К выбору количества плейсмент групп надо подходить с заранее имеющимся видением на свой кластер — сколько примерно ОСД там будет, какое количество данных (в процентах от общего объема) будет в пуле, какое количество данных всего.
Суммарно желательно не иметь более 300 плейсмент групп на диск, и проще будет балансировать маленькими плейсмент группами — то есть если весь ваш пул занимает 10 Tb и в нем 10 PG — то балансировать перекидыванием терабайтных кирпичей (pg) будет проблематично — пересыпать песок с маленьким размером песчинок по вёдрам проще и ровнее).
Но надо помнить что чем больше количество PG — тем больше ресурсов тратится на вычисление их расположения — начинает утилизироваться память и ЦПУ.
Примерное понимание может [дать калькулятор](https://ceph.com/pgcalc/), предоставленный разработчиками документации CEPH.
Список материалов:
<https://blog.packagecloud.io/eng/2017/02/06/monitoring-tuning-linux-networking-stack-sending-data>
<http://www.admin-magazine.com/HPC/Articles/Linux-I-O-Schedulers>
<http://onreader.mdl.ru/MasteringCeph/content/Ch09.html#030202>
<https://tracker.ceph.com/issues/23386>
<https://ceph.com/pgcalc/> | https://habr.com/ru/post/456446/ | null | ru | null |
# Практическое применение MSP430 для web-разработчика
На хабре предостаточно статей для начинающих о том, какой волшебный и замечательный этот MSP430 LaunchPad от Texas Instruments. Однако дальше стандартной мигалки светодиодом обычно никто не заходит. Пора исправлять эту ситуацию.
Работая в команде, мы пользуемся старым добрым SVN для контроля версий. Казалось бы, причём тут микроконтроллеры?
Как раз для сигнализации очередного коммита в репозиторий я и приспособил эту дивную штуковину.
##### Идея
Хотелось бы такое устройство, которое будет сигнализировать мелодией об очередном коммите в любой из наших репозиториев. Было бы неплохо, чтобы у каждого разработчика была своя уникальная мелодия, и всем было бы слышно, кто только что сделал очередной коммит.
##### Проект
В качестве веб фронтенда к SVN прикручен WebSVN, закрытый Basic-авторизацией. Таким образом мы можем получить доступ к списку проектов и их ревизиям. В свою очередь, нам необходим процесс, который по расписанию, например раз в минуту будет проверять репозитории проектов на предмет нового коммита. Так как ближе всего к рукам был PHP, решено было писать на нём. Рабочая система — Windows 7 с Apache 2.1 + PHP 5.3.6.
При обнаружении нового коммита, скрипт посылает на COM-порт управляющую команду устройству, о том что надо проиграть мелодию автора коммита.
Итак, у нас есть WebSVN:
Средствами PHP мы парсим список проектов и заглядываем в каждый проект:
**index.php**
```
// Забъём на время выполнения
set_time_limit(0);
// Подключим всякие функции и конфиги
require 'functions.php';
require 'config.php';
// Готовим CURL
$s = curl_init();
curl_setopt($s, CURLOPT_URL, $svnURL);
curl_setopt($s, CURLOPT_USERPWD, $authLogin.':'.$authPass);
curl_setopt($s, CURLOPT_USERAGENT, 'CommitBeep 1.0');
curl_setopt($s, CURLOPT_REFERER, $svnURL);
curl_setopt($s, CURLOPT_RETURNTRANSFER, true);
// Получаем список проектов
$page = curl_exec($s);
$httpCode = curl_getinfo($s, CURLINFO_HTTP_CODE);
curl_close($s);
// Получим ссылки на проекты
$doc = new DOMDocument();
$doc-loadHTML($page);
$links = $doc->getElementsByTagName('a');
foreach ($links as $link) {
$link = dom2array($link);
if (strpos($link['@attributes']['href'], 'listing.php?repname') !== false) {
$projectName = $link['#text'];
checkSVNCommit($projectName);
}
}
```
Для того, чтобы авторизоваться через Basic Auth, воспользуемся функциями библиотеки CURL.
Ещё для разбора HTML воспользуемся DOMDocument и DOM.
Т.к. с DOM из PHP работать довольно муторно, а нам достаточно взять все ссылки, воспользуемся функцией dom2array():
**functions.php dom2array()**
```
/**
* Парсит DOM узел в массив
* @param object $node узел
*/
function dom2array($node) {
$res = array();
if($node->nodeType == XML_TEXT_NODE){
$res = $node->nodeValue;
}
else{
if($node->hasAttributes()){
$attributes = $node->attributes;
if(!is_null($attributes)){
$res['@attributes'] = array();
foreach ($attributes as $index=>$attr) {
$res['@attributes'][$attr->name] = $attr->value;
}
}
}
if($node->hasChildNodes()){
$children = $node->childNodes;
for($i=0;$i<$children->length;$i++){
$child = $children->item($i);
$res[$child->nodeName] = dom2array($child);
}
}
}
return $res;
}
```
У каждого проекта есть своя страничка, в которой указана последняя ревизия и её автор.
Используя всё тот же CURL, выковыриваем номер ревизии и её автора. Парсинг через explode() и strpos() ужасен, но на скорую руку потянет.
**functions.php checkSVNCommit()**
```
/**
* Проверяем ревизию и вызываем бибикало, если что
* @param string $projectName название проекта
*/
function checkSVNCommit($projectName) {
require 'config.php'; // Конфиг у нас тут подключается локально
$old_rev = @file_get_contents('revisions/'.$projectName.'.txt');
$rev = 0;
$user = 'unknown';
// Готовим CURL
$s = curl_init();
curl_setopt($s, CURLOPT_URL, $svnURL.'/listing.php?repname='.urlencode($projectName).'&path=%2F≻=0');
curl_setopt($s, CURLOPT_USERPWD, $authLogin.':'.$authPass);
curl_setopt($s, CURLOPT_USERAGENT, 'CommitBeep 1.0');
curl_setopt($s, CURLOPT_REFERER, $svnURL);
curl_setopt($s, CURLOPT_RETURNTRANSFER, true);
// Получаем список проектов
$page = curl_exec($s);
$httpCode = curl_getinfo($s, CURLINFO_HTTP_CODE);
curl_close($s);
// Весьма топорная реализация, но зато наглядно и быстро
$page = explode("\n", strip_tags($page));
foreach($page as $line) {
if (strpos($line, 'Last modification:') !== false) {
$line = explode(' ', $line);
$rev = $line[3];
$user = $line[5];
}
}
echo "$projectName $rev $user
\n";
// Ревизия поменялась? Бибикаем!
if ($rev != $old_rev) {
beep($comNumber, getMelodyByUser($user));
file_put_contents('revisions/'.$projectName.'.txt', $rev);
}
}
```
Реализация банальная и местами топорная, но прекрасно работает. Читаем из текстового файлика старую ревизию и сравниваем с текущей. Если различаются, записываем и бибикаем.
##### Первые подводные камни
Я был на 146% уверен, что работа с COM-портами не представляет сложности. Как оказалось, старый способ fopen(«COM6:», «w+») на Windows 7 уже не работает. Не хватает каких-то прав доступа. Кроме того даже если в консоли перенаправить вывод в порт, то опять возникнет ошибка доступа. Так что из cmd (bat) — файлов у нас тоже ничего не получится, и через exec() тоже не прокатит.
Крепкое гугление вывело меня на виндовое расширение — PHP Serial.
Подключается как и все расширения, довольно просто и работает как два пальца:
**functions.php beep()**
```
/**
* Посылает сигнал бибикалу
* @param integer $com номер COM-порта
* @param integer $melody номер мелодии
*/
function beep($com = 6, $melody = 1) {
ser_open("COM".$com, 9600, 8, "None", "1", "None");
ser_write("$melody");
ser_close();
}
```
##### Бибикало с микроконтроллером
Настала очередь программировать LaunchPad. Возьмём Energia в качестве среды разработки.
В отличие от Arduino, для MSP430 не так очевидно, как работать с Serial port. Оказывается, сужествует библиотечка TimerSerial, которая является модификацией Arduino-вской базовой библиотеки Serial.
Немного усилий, и можно писать и читать в терминал.
**Пример работы с терминалом**
```
#include
TimerSerial mySerial;
// Начальные установки
void setup() {
mySerial.begin();
mySerial.println("Welcome to CommitBeep 1.0");
}
// Главный цикл
void loop() {
while (mySerial.available()) {
char inChar = (char)mySerial.read();
mySerial.write(inChar);
delay(100);
}
}
```
Эта простенькая программка читает символ и тут же пишет его обратно. Как бы эхо.
##### Подводные камни. Продолжение.
Так, с приёмом-передачей данных разобрались. Теперь бибикало.
Стандартная библиотека Tone, также как-то видоизменена в Energia. И самое неприятное, они никак не дружат с TimerSerial. Вероятно используются общие таймеры или ещё что-то в этом духе, но вместе их использовать не получилось.
Пришлось писать свой велосипед.
**Приручаем бибикало**
```
#define NOTE_G3 196
#define NOTE_A3 220
#define NOTE_C4 262
int speakerPin;
// Начальные установки
void setup() {
speakerPin = 14; // контакт 1.6 (или 14) у нас подключён к бибикалу
pinMode(speakerPin, OUTPUT);
beep();
}
void playTone(int tone, int duration) {
for (long i = 0; i < duration * 1000L; i += tone * 2) {
digitalWrite(speakerPin, HIGH);
delayMicroseconds(tone);
digitalWrite(speakerPin, LOW);
delayMicroseconds(tone);
}
digitalWrite(speakerPin, LOW);
}
// Бибикало
void beep() {
int melody[] = {NOTE_C4, NOTE_G3, NOTE_G3, NOTE_A3, NOTE_G3};
int noteDurations[] = {4,8,8,4,4};
for (int thisNote = 0; thisNote < 4; thisNote++) {
int noteDuration = 1000/noteDurations[thisNote];
playTone(melody[thisNote], noteDuration);
}
}
```
Все заморочки решены, осталось написать код. Вообщем-то остальное довольно просто.
Объединяем и получаем наш скетч:
**commit\_beep.ino**
```
#include
#define NOTE\_B0 31
#define NOTE\_C1 33
#define NOTE\_CS1 35
#define NOTE\_D1 37
#define NOTE\_DS1 39
#define NOTE\_E1 41
#define NOTE\_F1 44
#define NOTE\_FS1 46
#define NOTE\_G1 49
#define NOTE\_GS1 52
#define NOTE\_A1 55
#define NOTE\_AS1 58
#define NOTE\_B1 62
#define NOTE\_C2 65
#define NOTE\_CS2 69
#define NOTE\_D2 73
#define NOTE\_DS2 78
#define NOTE\_E2 82
#define NOTE\_F2 87
#define NOTE\_FS2 93
#define NOTE\_G2 98
#define NOTE\_GS2 104
#define NOTE\_A2 110
#define NOTE\_AS2 117
#define NOTE\_B2 123
#define NOTE\_C3 131
#define NOTE\_CS3 139
#define NOTE\_D3 147
#define NOTE\_DS3 156
#define NOTE\_E3 165
#define NOTE\_F3 175
#define NOTE\_FS3 185
#define NOTE\_G3 196
#define NOTE\_GS3 208
#define NOTE\_A3 220
#define NOTE\_AS3 233
#define NOTE\_B3 247
#define NOTE\_C4 262
#define NOTE\_CS4 277
#define NOTE\_D4 294
#define NOTE\_DS4 311
#define NOTE\_E4 330
#define NOTE\_F4 349
#define NOTE\_FS4 370
#define NOTE\_G4 392
#define NOTE\_GS4 415
#define NOTE\_A4 440
#define NOTE\_AS4 466
#define NOTE\_B4 494
#define NOTE\_C5 523
#define NOTE\_CS5 554
#define NOTE\_D5 587
#define NOTE\_DS5 622
#define NOTE\_E5 659
#define NOTE\_F5 698
#define NOTE\_FS5 740
#define NOTE\_G5 784
#define NOTE\_GS5 831
#define NOTE\_A5 880
#define NOTE\_AS5 932
#define NOTE\_B5 988
#define NOTE\_C6 1047
#define NOTE\_CS6 1109
#define NOTE\_D6 1175
#define NOTE\_DS6 1245
#define NOTE\_E6 1319
#define NOTE\_F6 1397
#define NOTE\_FS6 1480
#define NOTE\_G6 1568
#define NOTE\_GS6 1661
#define NOTE\_A6 1760
#define NOTE\_AS6 1865
#define NOTE\_B6 1976
#define NOTE\_C7 2093
#define NOTE\_CS7 2217
#define NOTE\_D7 2349
#define NOTE\_DS7 2489
#define NOTE\_E7 2637
#define NOTE\_F7 2794
#define NOTE\_FS7 2960
#define NOTE\_G7 3136
#define NOTE\_GS7 3322
#define NOTE\_A7 3520
#define NOTE\_AS7 3729
#define NOTE\_B7 3951
#define NOTE\_C8 4186
#define NOTE\_CS8 4435
#define NOTE\_D8 4699
#define NOTE\_DS8 4978
TimerSerial mySerial;
int speakerPin;
// Начальные установки
void setup() {
speakerPin = 14; // контакт 1.6 (или 14) у нас подключён к бибикалу
mySerial.begin();
mySerial.println("Welcome to CommitBeep 1.0");
pinMode(speakerPin, OUTPUT);
}
void playTone(int tone, int duration) {
for (long i = 0; i < duration \* 1000L; i += tone \* 2) {
digitalWrite(speakerPin, HIGH);
delayMicroseconds(tone);
digitalWrite(speakerPin, LOW);
delayMicroseconds(tone);
}
digitalWrite(speakerPin, LOW);
}
// Бибикало
void beep(int melody) {
switch ((int)melody) {
case '2': {
int mel[] = {NOTE\_C4, NOTE\_G3, NOTE\_G3, NOTE\_A3, NOTE\_G3};
int noteDurations[] = {4,8,8,4,4};
for (int thisNote = 0; thisNote < 4; thisNote++) {
int noteDuration = 1000/noteDurations[thisNote];
playTone(mel[thisNote], noteDuration);
}
break;
}
case '3': {
int mel[] = {NOTE\_C4, NOTE\_G3, NOTE\_G3, NOTE\_A3, NOTE\_G3};
int noteDurations[] = {4,8,8,4,4};
for (int thisNote = 0; thisNote < 4; thisNote++) {
int noteDuration = 1000/noteDurations[thisNote];
playTone(mel[thisNote], noteDuration);
}
break;
}
default: {
int mel[] = {NOTE\_C4, NOTE\_G3, NOTE\_G3, NOTE\_A3, NOTE\_G3};
int noteDurations[] = {4,8,8,4,4};
for (int thisNote = 0; thisNote < 4; thisNote++) {
int noteDuration = 1000/noteDurations[thisNote];
playTone(mel[thisNote], noteDuration);
}
}
}
}
// Главный цикл
void loop() {
while (mySerial.available()) {
char inChar = (char)mySerial.read();
beep(inChar);
delay(100);
}
}
```
Подключаем, заливаем, открываем окошко терминала, пишем туда 1, и слушаем дефолтную мелодию.
##### Планировщик задач
Как ни странно, но мы будем использовать именно планировщик задач для фонового выполнения нашего PHP скрипта.
Напишем CMD-файлик, который вызывает PHP и сам скрипт:
`D:\denwer\usr\bin\php5.exe D:\denwer\home\test\www\commit_beep\index.php`
А чтобы это хозяйство не мозолило глаза чёрным окном консоли, воспользуемся нехитрой утилитой [hidcon](http://code.google.com/p/andrew-grechkin/) от Андрея Гречкина.
**Подключение планировщика:**
##### Последние штрихи
Само по себе всё работает и усердно пищит при каждом коммите. Но на столе выглядит не очень красиво. Осталось обернуть нашу новую железку в приятный пластиковый корпус, поработав чуток канцелярским ножом и изолентой:
##### Итоги
Один день на разработку от идеи до готового устройства. Интересная и увлекательная борьба с подводными камнями и знакомство с Energia и MSP430.
Бюджет проекта ~200-300 руб.
[Исходники на github](https://github.com/gsomgsom/commit_beep).
**Update:** Добавил поддержку RTTTL — мелодий в хардовом режиме UART.
Для того, чтобы включить хардовый режим, надо переткнуть перемычки RT/TX (Спасибо [BoxaShu](https://habrahabr.ru/users/boxashu/)).
Исходники обновил. | https://habr.com/ru/post/151709/ | null | ru | null |
# Расширение и использование Linux Crypto API
[0] Интро
---------
Криптографический *API* в *Linux* введён с версии 2.5.45 ядра. С тех пор *Crypto API* оброс всеми популярными (и не только) международными стандартами:
* симметричного шифрования: *AES*, *Blowfish*, ...
* хэширования: *SHA1/256/512*, *MD5*, ...
* имитозащиты: *hMAC-SHA1/256/512*, *hMAC-MD5*, ...
* [AEAD](https://en.wikipedia.org/wiki/Authenticated_encryption): *AES-GCM*, *ChaCha20-Poly1305*, ...
* генерации псевдослучайных чисел: *FIPS*, ...
* асимметричного шифрования: *RSA*
* согласования ключей: *DH*, *ECDH*
* сжатия: *Deflate*, *ZLIB*
Эта криптография доступна и, в основном, используется различными подсистемами ядра (в *kernel space*): *IPsec*, *dm-crypt* и др. Воспользоваться функциями *Crypto API* из пространства пользователя (*user space*) также возможно через *Netlink*-интерфейс, в который, начиная с версии 2.6.38 ядра, введено семейство \_AF*ALG*, предоставляющее доступ к криптографии ядра из *user space* кода. Однако, существующего функционала иногда недостаточно, таким образом появляется необходимость расширения *Crypto API* новыми алгоритмами.
Так, примерно два года назад передо мной стояла задача встраивания национальной (в Республике Беларусь) криптографии в *IPsec*-реализацию ядра *Linux* (версии 3.13). На тот момент я никогда не занимался программированием в *kernel space* и это было моим первым опытом написания модулей ядра, с чем мне очень помогла книга **Роберта Лава "Ядро Linux. Описание процесса разработки"**. Куда сложнее было разбираться с самим *Crypto API* — в упомянутой книге этот вопрос не освещается в принципе, а в [официальной документации](https://www.kernel.org/doc/html/v4.13/crypto/index.html), хоть и дано достаточно подробное описание архитектуры, практически нет информации о внедрении новых алгоритмов. В своих поисках, в журнале "Хакер" я наткнулся на замечательную [статью](https://xakep.ru/2009/01/20/46840), популярно рассказывающую о том, *как использовать Crypto API*, но, опять же, там нет ни слова о его расширении. В конце концов, за необходимыми мне знаниями я обратился к первоисточнику (к коду ядра), и решил поставленную задачу.
С тех пор уже прошло некторое время и только сейчас, актуализировав свои знания, я взялся за написание этого текста. Он о *Crypto API*. На конкретных примерах мы посмотрим, каким образом в *Crypto API* можно встроить произвольные алгоритмы и как к ним обратиться как из *kernel space*, так и из *user space*. Я уверен, что этот материал будет крайне полезен разработчикам, столкнувшимся со схожими проблемами, но надеюсь, что и случайный читатель сможет найти здесь для себя что-то интересное. Добро пожаловать под кат!
P.S. Компилируемые исходники моих программ, фрагменты которых будут встречаться ниже, доступны на [*github*](https://github.com/HenadziMatuts/linux-crypto-api-tutor). Там же — исходник этой статьи. Весь код был написан и протестирован под десктопной Ubuntu 16.04 LTS с ядром версии 4.13.0-32-generic. Некоторые интерфейсы, которые я использовал в модулях, были введены в 4 версии ядра, поэтому на ядрах 3.\* они точно *НЕ* скомпилируются.
---
[1] Архитектура Crypto API
--------------------------
Прежде чем приступить к написанию кода, поговорим немного о том, как всё устроено в *Crypto API*. Впрочем, до меня об этом подробно рассказали в [документации](https://www.kernel.org/doc/html/v4.13/crypto/architecture.html), я же, в свою очередь, приведу лишь выжимку, которой должно быть достаточно для понимания материала. Сразу оговорюсь, далее речь пойдёт преемущественно о симметричном шифровании, иные виды криптопреобразований, в целом, работают схожим образом, но многочисленные нюансы очень сильно бы всё усложнили.
Итак, из введения мы уже знаем, что криптографическая подсистема ядра включает множество реализаций криптографических алгоритмов и предоставляет к ним интерфейсы, доступные пользователю (здесь и далее — под пользователем и разработчиком имеются ввиду, соответственно, *пользователь API* и *разработчик API*). В терминах *Crypto API*, алгоритмы называются "преобразованиями" (*transformations*), так, различные типы преобразований имеют собственный под-*API*, а дескрипторам (хэндлам) преобразований, как правило, присваивается имя "*tfm*", например:
```
struct crypto_cipher *tfm = crypto_alloc_cipher("aes", 0, 0);
```
Здесь *tfm* — это хэндл некоторого преобразования, в данном случае — шифрования блока данных по алгоритму *AES*. Жизненный цикл хэндла *Crypto API* сводится к трём этапам:
* создание/инициализация хэндла
* выполнение необходимых криптоопераций, досупных через хэндл
* уничтожение хэндла
Независимо от используемого алгоритма, через хэндл типа `crypto_cipher` доступны реализации базовых функций *шифрования одного блока* данных, а соответсвующий ему *API* ([*Single Block Cipher API*](https://www.kernel.org/doc/html/v4.13/crypto/api-skcipher.html#single-block-cipher-api)) предоставляет методы установки ключа и зашифрования/расшифрования блока. В качестве самостоятельного *API* он не представляет большого интереса для пользователя, однако, с точки зрения разработчика, он важен, поскльку с его помощью реализована ключевая концепция *Crypto API* — так называемые "шаблоны" (*templates*). Шаблоны используются в связке с базовыми функциями и реализуют:
* режимы блочного шифрования (*ECB*, *CBC*, *CFB*, *CTR*, ...)
* режим ключезависимого хэширования (*hMAC*)
* *AEAD*-режимы шифрования
* функции, не связанные с непосредственной криптообработкой данных, например — распараллеливание (*pcrypt*)
При создании хэндла (см. пример выше), требуемый алгоритм задётся строкой — именем алгоритма, эта строка имеет следующую семантику:
```
template(single block cipher/message digest)
```
Кроме того, там, где это применимо, шаблоны могут быть "завёрнуты" в другие шаблоны:
```
template_a(template_b(single block cipher/message digest))
```
При этом использование шаблонов без базового алгоритма невозможно. Приведу несколько примеров:
* *aes* — базовый алгоритм шифрования блока *AES*
* *cbc(aes)* — алгоритм шифрования *AES* в режиме сцепления блоков шифра (*CBC*)
* *sha1* — алгоритм хэширования *SHA1*
* *hmac(sha1)* — алгоритм ключезависимого хэширования (имитозащиты) с хэш-функцией *SHA1*
* *authenc(hmac(sha1), cbc(aes))* — *AEAD* с алгоритмом шифрования *AES-CBC* и алгоритмом имитозащиты *hMAC(SHA1)*
Применение симметричных блочных шифров в каком-либо режиме осуществляеся через отдельный *API*. Стоит отметить, что сейчас в ядре существуют три таких *API*, однако два из них объявлены устаревшими (*deprecated*), а актуальным является [*Symmetric Key Cipher API*](https://www.kernel.org/doc/html/v4.13/crypto/api-skcipher.html#symmetric-key-cipher-api). Этот *API* предоставляет пользователю методы установки ключа/синхропосылки и зашифрования/расшифрования данных произвольной длины, он так же является *неблокирующим* (асинхронным) — методы шифрования максимально быстро возвращают управление вызывающему, в то время как запрос на выполнение криптооперации и функция обратного вызова, используемая для оповещения пользователя о завершении операции, передаются системному планировщику. *Symmetric Key Cipher API* будет подробно рассмотрен, когда мы перейдём к созданию модуля ядра, тестирующего встроенный нами алгоритм.
Помимо двух названных, в *Crypto API* существуют под-*API* для:
* *AEAD*-шифрования ([*Authenticated Encryption With Associated Data (AEAD) Cipher API*](https://www.kernel.org/doc/html/v4.13/crypto/api-aead.html#authenticated-encryption-with-associated-data-aead-cipher-api))
* блокирующего хэширования/имитозащиты ([*Synchronous Message Digest API*](https://www.kernel.org/doc/html/v4.13/crypto/api-digest.html#synchronous-message-digest-api))
* неблокирующего хэширования/имитозащиты ([*Asynchronous Message Digest API*](https://www.kernel.org/doc/html/v4.13/crypto/api-digest.html#asynchronous-message-digest-api))
* генерации псевдослучайных чисел ([*Random Number API*](https://www.kernel.org/doc/html/v4.13/crypto/api-rng.html#crypto-api-random-number-api))
* асимметричного шифрования ([*Asymmetric Cipher API*](https://www.kernel.org/doc/html/v4.13/crypto/api-rng.html#crypto-api-random-number-api))
* согласования ключей ([*Key-agreement Protcol Primitives (KPP) Cipher API*](https://www.kernel.org/doc/html/v4.13/crypto/api-kpp.html#key-agreement-protocol-primitives-kpp-cipher-api))
Для разработчика наличие шаблонов в *Crypto API* означает, что, встраивая новый алгоритм симметричного шифрования, достаточно реализовать лишь базовую функцию шифрования блока, которая, затем, может быть инкапсулирована в соответствующие шаблоны для получения требуемых режимов. **Но это не совсем так.** Действительно, если взглянуть на исходный код включенных в ядро алгоритмов (*crypto/aes\_generic.c*, *crypto/blowfish\_generic.c*, ...), то можно увидеть, что там реализованы только базовые функции. Однако, если мы таким же образом реализуем функцию шифрования блока классического *ГОСТ 28147-89*, "завернём" её в режим гаммирования (шаблон *CTR*), а после этого полученный алгоритм проверим на тестовых последовательностях, то мы получим неверный результат! Всё дело в том, что режим гаммирования, описанный в *ГОСТ*, отличается от алгоритма гаммирования, реализованного в шаблоне *CTR*. То же самое касается и других национальных алгоритмов, с которыми я имел дело. В таких случаях необходимо встраивать полноценные блочные шифры в нужных режимах, как это сделано, например, в оптимизированной реализации алгоритма *AES* (*AES-NI* — *arch/x86/crypto/aesni-intel\_glue.c*). Позже мы рассмотрим оба варианта встраивания.
Пожалуй, это всё, что я хотел сказать по поводу архитектуры. Заинтересованным в более подробном описании следует обратиться к [документации](https://www.kernel.org/doc/html/v4.13/crypto/architecture.html), а моего изложения должно быть достаточно, чтобы мы могли двигаться дальше.
---
[2] Подготовка почвы
--------------------
Итак, мы готовы к тому, чтобы начать встраивать в *Crpyto API* какой-нибудь новый алгоритм, с той лишь оговоркой, что у нас пока нет алгоритма, который можно было бы встроить. Для этой статьи я не стал утруждать себя реализацией "настоящего" криптоалгоритма, поскольку едва ли смог бы сделать это качественно (оставьте это криптографам). С другой стороны, делать шифр-"пустышку" (*null cipher*) было бы не так интересно, тем более, что такой в ядре уже есть. Таким образом, мы пойдём на компромисс и напишем реализацию элементарного алгоритма шифрования:
Где:
*  — блок шифртекста
*  — блок открытого текста
*  — ключ
*  — операция "исключающее ИЛИ" (*XOR*)
Размеры блока и ключа для этого алгоритма примем равными 128 битам (16 байт).
Можем приступать к реализации. Определим криптоконтекст нашего алгоритма и функции создания/уничтожения контекста:
```
#define XOR_CIPHER_KEY_SIZE 16
typedef struct xor_cipher_ctx xor_cipher_ctx;
struct xor_cipher_ctx
{
uint8_t key[XOR_CIPHER_KEY_SIZE];
};
xor_cipher_ctx* xor_cipher_allocate()
{
xor_cipher_ctx *cipher = calloc(1, sizeof(xor_cipher_ctx));
return cipher;
}
void xor_cipher_free(xor_cipher_ctx *ctx)
{
memset(ctx->key, 0xFF, XOR_CIPHER_KEY_SIZE);
free(ctx);
}
```
Добавляем методы установки ключа и зашифрования/расшифрования блока:
```
#define XOR_CIPHER_BLOCK_SIZE 16
void xor_cipher_set_key(xor_cipher_ctx *ctx, uint8_t *key)
{
memmove(ctx->m_key, key, XOR_CIPHER_KEY_SIZE);
}
void xor_cipher_crypt_block(xor_cipher_ctx *ctx, uint8_t *dst, uint8_t *src)
{
for (int i = 0; i < XOR_CIPHER_BLOCK_SIZE; i++)
{
dst[i] = src[i] ^ ctx->key[i];
}
}
```
Учитывая обратимость операции "*XOR*", метод `xor_cipher_crypt_block` используется для зашифрования и расшифрования одновременно.
Шифрование блока — это хорошо, но станет ещё лучше, если мы реализуем какой-нибудь из режимов блочного шифрования, например, [режим сцепления блоков шифра (*CBC*)](https://ru.wikipedia.org/wiki/%D0%A0%D0%B5%D0%B6%D0%B8%D0%BC_%D1%81%D1%86%D0%B5%D0%BF%D0%BB%D0%B5%D0%BD%D0%B8%D1%8F_%D0%B1%D0%BB%D0%BE%D0%BA%D0%BE%D0%B2_%D1%88%D0%B8%D1%84%D1%80%D0%BE%D1%82%D0%B5%D0%BA%D1%81%D1%82%D0%B0):
Где:
*  — синхропосылка
* ,  — функция зашифрования и расшифрования блока на ключе  соответственно
Продолжим работу, реализуем методы зашифрования и расшифрования в режиме сцепления блоков шифра.
**Зашифрование**
```
void xor_cipher_encrypt_cbc(xor_cipher_ctx *ctx,
uint8_t *_dst, uint32_t len, uint8_t *_src, uint8_t *_iv)
{
uint32_t blocks = len / XOR_CIPHER_BLOCK_SIZE;
uint32_t leftover = len - (blocks * XOR_CIPHER_BLOCK_SIZE);
uint8_t *dst = _dst, *src = _src, *iv = _iv;
for (uint32_t i = 0; i < blocks; i++)
{
memmove(dst, src, XOR_CIPHER_BLOCK_SIZE);
for (int j = 0; j < XOR_CIPHER_BLOCK_SIZE; j++)
{
dst[j] ^= iv[j];
}
xor_cipher_crypt_block(ctx, dst, dst);
iv = dst;
dst += XOR_CIPHER_BLOCK_SIZE;
src += XOR_CIPHER_BLOCK_SIZE;
}
if (leftover)
{
memmove(dst, src, leftover);
for (uint32_t i = 0; i < leftover; i++)
{
dst[i] ^= iv[i];
dst[i] ^= ctx->key[i];
}
}
}
```
**Расшифрование**
```
void xor_cipher_decrypt_cbc(xor_cipher_ctx *ctx,
uint8_t *_dst, uint32_t len, uint8_t *_src, uint8_t *_iv)
{
uint32_t blocks = len / XOR_CIPHER_BLOCK_SIZE;
uint32_t leftover = len - (blocks * XOR_CIPHER_BLOCK_SIZE);
uint8_t u[XOR_CIPHER_BLOCK_SIZE], iv[XOR_CIPHER_IV_SIZE];
uint8_t *dst = _dst, *src = _src;
memmove(iv, _iv, XOR_CIPHER_IV_SIZE);
for (uint32_t i = 0; i < blocks; i++)
{
memmove(u, src, XOR_CIPHER_BLOCK_SIZE);
xor_cipher_crypt_block(ctx, dst, src);
for (int j = 0; j < XOR_CIPHER_BLOCK_SIZE; j++)
{
dst[j] ^= iv[j];
}
memmove(iv, u, XOR_CIPHER_IV_SIZE);
dst += XOR_CIPHER_BLOCK_SIZE;
src += XOR_CIPHER_BLOCK_SIZE;
}
if (leftover)
{
for (uint32_t i = 0; i < leftover; i++)
{
dst[i] = src[i] ^ ctx->key[i];
dst[i] ^= iv[i];
}
}
}
```
Вот это уже интересней! Теперь, пользуясь данной реализацией, мы можем подготовить тестовые последовательности, на которых, в дальнейшем, проверим реализацию этого же алгоритма в ядре. Под спойлером — значения, которые использовал я.
**Тестовые последовательности**
| Шифрование блока | |
| --- | --- |
| Ключ | `2f 1b 1a c6 d1 be cb a2 f8 45 66 0d d2 97 5c a3` |
| **Тест №1** | |
| Входные данные | `cc 6b 79 0c db 55 4f e5 a0 69 05 96 11 be 8c 15` |
| Выходные данные | `e3 70 63 ca 0a eb 84 47 58 2c 63 9b c3 29 d0 b6` |
| **Тест №2** | |
| Входные данные | `53 f5 f1 ef 67 a5 ba 6c 68 09 b5 7a 24 de 82 5f` |
| Выходные данные | `7c ee eb 29 b6 1b 71 ce 90 4c d3 77 f6 49 de fc` |
| Зашифрование *CBC* | |
| --- | --- |
| Ключ | `ec 8d 93 30 69 7e f8 63 0b f5 58 ec de 78 24 f2` |
| Синхропосылка | `db 02 1f a8 5a 22 15 cf 49 f7 80 8b 7c 24 a1 f3` |
| Открытый текст | `6e 96 50 42 84 d2 7e e8 44 9b 75 1d e0 ac 0a 58 ee 40 24 cc 32 fc 6e c4 e2 fc d1 f5 76 6a 45 9a e4 88 ba d6 12 07 28 86` |
| Шифртекст | `59 19 dc da b7 8e 93 44 06 99 ad 7a 42 f0 8f 59 5b d4 6b 26 ec 0c 05 e3 ef 90 24 63 ea e2 ee 31 53 d1 42 c0 97 75 d5 06` |
| Расшифрование *CBC* | |
| --- | --- |
| Ключ | `ec 8d 93 30 69 7e f8 63 0b f5 58 ec de 78 24 f2` |
| Синхропосылка | `db 02 1f a8 5a 22 15 cf 49 f7 80 8b 7c 24 a1 f3` |
| Шифртекст | `db e9 1d c6 1f 13 1a 5a 34 2b 90 1e c3 b1 6f e9 52 1b 91 7f 8d 8f 6d b4 42 87 ad 85 5f 2d 89 7d` |
| Открытый текст | `ec 66 91 5e 2c 4f f7 f6 76 29 48 79 61 ed ea e8 65 7f 1f 89 fb e2 8f 8d 7d 59 65 77 42 e4 c2 66` |
Исходники реализации алгоритма и программы тестирования доступны [здесь](https://github.com/HenadziMatuts/linux-crypto-api-tutor/samples/xor-cipher), а мы практически готовы к тому, чтобы перейти в *kernel space*, но перед этим я хочу обратить ваше внимание на один важный момент. Дело в том, что многие известные алгоритмы шифрования не предполагают обработку последнего *неполного* блока входных данных. Так, например, реализации алгоритма *ГОСТ 28147-89 ДОЛЖНЫ* возвращать признак ошибки, если размер входных данных не кратен размеру блока, тогда как белорусский *Belt* предусматривает такую обработку. Мой алгоритм также её предусматривает (ключ и текущее значение синхропосылки усекаются до размеров неполного блока). Этот факт сыграет свою роль немного позже, пока стоит просто иметь это в виду.
---
[3] Погружение в ядро
---------------------
Действие переносится в пространство ядра. Программирование в ядре несколько отличается от программирования в пространстве пользователя и, ввиду сложности отладки, является достаточно трудоёмким процессом. Однако, работая над этим материалом, я не ставил перед собой задачу познакомить читателя с основами программирования модулей ядра, ведь об этом и без меня предостаточно написано, в том числе и здесь, на [Хабре](https://habrahabr.ru/post/343828/) ([ещё](https://habrahabr.ru/post/117654/); и [ещё](https://habrahabr.ru/post/138328)). Поэтому, если читатель совершенно не знаком с написанием модулей, то я бы рекомендовал сперва просмотреть те материалы, которые я привёл выше, либо поискать самостоятельно (уверяю, это не займёт много времени). А с теми, кто готов идти дальше, мы приступаем к глубокому изучению *Crypto API*.
Итак, у нас есть алгоритм, и мы хотим встроить его в ядро, но с чего же начать? Разумеется, с документации. К сожалению, раздел, посвящённый [разработке/встраиванию алгоритмов](https://www.kernel.org/doc/html/v4.13/crypto/devel-algos.html), даёт лишь очень общие знания об этом процессе, но, по крайней мере, помогает сориентироваться в правильном направлении. Конкретно, мы узнаём о существовании функций, отвечающих за регистрацию и разрегистрацию алгоритмов в ядре. Давайте разбираться:
```
/* include/linux/crypto.h */
int crypto_register_alg(struct crypto_alg *alg);
int crypto_register_algs(struct crypto_alg *algs, int count);
int crypto_unregister_alg(struct crypto_alg *alg);
int crypto_unregister_algs(struct crypto_alg *algs, int count);
```
Эти функции возвращают отрицательное значение в случае ошибки, и 0 — в случае успешного завершения, а (раз)регистрируемый(ые) алгоритм(ы) описываются структурой `crypto_alg`, заглянем в её определение (*include/linux/crypto.h*):
```
/* include/linux/crypto.h */
struct crypto_alg {
struct list_head cra_list;
struct list_head cra_users;
u32 cra_flags;
unsigned int cra_blocksize;
unsigned int cra_ctxsize;
unsigned int cra_alignmask;
int cra_priority;
atomic_t cra_refcnt;
char cra_name[CRYPTO_MAX_ALG_NAME];
char cra_driver_name[CRYPTO_MAX_ALG_NAME];
const struct crypto_type *cra_type;
union {
struct ablkcipher_alg ablkcipher;
struct blkcipher_alg blkcipher;
struct cipher_alg cipher;
struct compress_alg compress;
} cra_u;
int (*cra_init)(struct crypto_tfm *tfm);
void (*cra_exit)(struct crypto_tfm *tfm);
void (*cra_destroy)(struct crypto_alg *alg);
struct module *cra_module;
} CRYPTO_MINALIGN_ATTR;
```
К счастью, эта структура очень хорошо задокументирована, и нам не придётся гадать о значении того или иного поля:
* **`cra_flags`**: набор флагов, описывающих алгоритм. Флаги определены константами, начинающимися с "`CRYPTO_ALG_`", в *include/linux/crypto.h*, и используются для "тонкой настройки" описания алгоритма
* **`cra_blocksize`**: байтовый размер блока алгоритма. Все типы преобразований, кроме хэширования, возвращают ошибку при попытке обработать данные, размер которых меньше этого значения
* **`cra_ctxsize`**: байтовый размер криптоконтекста. Ядро использует это значение при выделении памяти под контекст
* **`cra_alignmask`**: маска выравнивания для входных и выходных данных. Буферы для входных и выходных данных алгоритма должны быть выровнены по этой маске. Это обязательно для алгоритмов, выполняющихся на "железе", неспособном обращаться к данным по произвольным адресам
* **`cra_priority`**: приоритет данной реализации алгоритма. Если в ядре зарегистрировано больше одного преобразования с одинаковым **`cra_name`**, то, при обращении по этому имени, будет возвращён алгоритм с наибольшим приоритетом
* **`cra_name`**: название алгоритма. Ядро использует это поле для поиска реализаций
* **`cra_driver_name`**: уникальное имя реализации алгоритма. Если в ядре зарегистрировано больше одного преобразования с одинаковым **`cra_name`**, и необходимо запросить алгоритм с меньшим приоритетом, то нужно обращаться по этому имени
* **`cra_type`**: тип криптопреобразования. Указатель на экземпляр структуры типа `crypto_type`, реализующий функции обратного вызова, общие для всех типов преобразований. Доступные варианты: `&crypto_blkcipher_type`, `&crypto_ablkcipher_type`, `&crypto_ahash_type`, `&crypto_rng_type`. Это поле следует оставлять пустым для следующих типов преобразований: шифрования блока (`cipher`), сжатия (`compress`), блокирующего хэширования (`shash`)
* **`cra_u`**: собственно, реализация алгоритма. Одна из структур союза, должна быть заполнена специфическими функциями, определяемыми типом преобразования. Это поле следует оставлять пустым для блокирующего и неблокирующего хэширования (`ahash`)
* **`cra_init`**: функция инициализации экземпляра преобразования. Эта функция вызывается единожды, во время создания экземпляра (сразу после выделения памяти под криптоконтекст). В этой функции следует выполнять различные подготовительные действия, если такие необходимы (например, выделение дополнительной памяти, проверка аппаратных возможностей). В ином случае поле можно оставить пустым
* **`cra_exit`**: деинициализация экземпляра преобразования. В этой функции следует выполнять действия, обратные тем, что были выполнены в **`cra_init`**, если таковые имели место. В ином случае поле можно оставить пустым
* **`cra_module`**: владелец этой реализации преобразования. Следует установить значение `THIS_MODULE`
Недокумментированные оставшиеся поля предназначены для внутреннего использования и не должны заполняться. Вроде бы ничего сложного. Для начала, мы хотим встроить реализацию алгоритма шифрования блока, поэтому взглянем ещё на структуру `cipher_alg` из союза `cra_u`:
```
/* include/linux/crypto.h */
struct cipher_alg {
unsigned int cia_min_keysize;
unsigned int cia_max_keysize;
int (*cia_setkey)(struct crypto_tfm *tfm, const u8 *key,
unsigned int keylen);
void (*cia_encrypt)(struct crypto_tfm *tfm, u8 *dst, const u8 *src);
void (*cia_decrypt)(struct crypto_tfm *tfm, u8 *dst, const u8 *src);
};
```
Тут всё ещё проще и, как мне кажется, не нуждается в разъяснении. Теперь мы готовы к тому, чтобы посмотреть, как всё это работает на практике. Кстати, обратите внимание на то, что сигнатуры функций в структуре `cipher_alg` аналогичны сигнатурам функций из *API* нашего алгоритма из 2 части
Пишем модуль ядра. Определяем криптоконтекст и функцию установки ключа в соответствии с сигнатурой `cipher_alg.cia_setkey`:
```
#define XOR_CIPHER_KEY_SIZE 16
struct xor_cipher_ctx
{
u8 key[XOR_CIPHER_KEY_SIZE];
};
static int xor_cipher_setkey(struct crypto_tfm *tfm, const u8 *key,
unsigned int len)
{
struct xor_cipher_ctx *ctx = crypto_tfm_ctx(tfm);
u32 *flags = &tfm->crt_flags;
if (len != XOR_CIPHER_KEY_SIZE)
{
*flags |= CRYPTO_TFM_RES_BAD_KEY_LEN;
return -EINVAL;
}
memmove(ctx->key, key, XOR_CIPHER_KEY_SIZE);
return 0;
}
```
В *API* нашего алгоритма криптоконтекст передавался функциям напрямую, здесь же функции принимают хэндл алгоритма `tfm`, из которого, затем, контекст извлекается с помощью функции `crypto_tfm_ctx`. Так же, здесь мы проверяем длину переданного ключа. Если длина некорректна, то мы выставляем соответствующий флаг (`CRYPTO_TFM_RES_BAD_KEY_LEN`) и возвращаем код `EINVAL` (22: *Invalid argument*).
Теперь, определяем функцию шифрования блока в соответствии с `cipher_alg.cia_encrypt`:
```
static void xor_cipher_crypt(struct crypto_tfm *tfm, u8 *out, const u8 *in)
{
struct xor_cipher_ctx *ctx = crypto_tfm_ctx(tfm);
int i;
for (i = 0; i < XOR_CIPHER_BLOCK_SIZE; i++)
{
out[i] = in[i] ^ ctx->key[i];
}
}
```
Здесь — ничего нового. Так же, как и в оригинальном *API*, мы не будем определять дополнительную функцию для расшифровки, а указатель `cipher_alg.cia_decrypt` просто проинициализируем функцией `xor_cipher_crypt`.
Наконец, определяем экземпляр структуры `crypto_alg`, заполняем её и вызываем функции регистрации и разрегистрации алгоритма, соответсвенно, после загрузки и перед выгрузкой модуля:
```
static struct crypto_alg xor_cipher = {
.cra_name = "xor-cipher",
.cra_driver_name = "xor-cipher-generic",
.cra_priority = 100,
.cra_flags = CRYPTO_ALG_TYPE_CIPHER,
.cra_blocksize = XOR_CIPHER_BLOCK_SIZE,
.cra_ctxsize = sizeof(struct xor_cipher_ctx),
.cra_module = THIS_MODULE,
.cra_u = {
.cipher = {
.cia_min_keysize = XOR_CIPHER_KEY_SIZE,
.cia_max_keysize = XOR_CIPHER_KEY_SIZE,
.cia_setkey = xor_cipher_setkey,
.cia_encrypt = xor_cipher_crypt,
.cia_decrypt = xor_cipher_crypt
}
}
};
static int __init xor_cipher_init(void)
{
return crypto_register_alg(&xor_cipher);
}
static void __exit xor_cipher_exit(void)
{
crypto_unregister_alg(&xor_cipher);
}
```
Учитывая всё вышесказанное, здесь не должно возникать никаких вопросов. Если, скомпилировав и загрузив такой модуль, выполнить в терминале команду "`cat /proc/crypto`", то в выводимом списке зарегистрированных алгоритмов можно отыскать и свой:
```
name : xor-cipher
driver : xor-cipher-generic
module : xor_cipher
priority : 100
refcnt : 1
selftest : passed
internal : no
type : cipher
blocksize : 16
min keysize : 16
max keysize : 16
```
Неплохо, а? Но это только начало, и сейчас, я, по идее, должен был перейти к написанию модуля, тестирующего наш алгоритм, но всё же, я решил не смешивать вопросы встраивания и использования. Поэтому тестироваться мы будем позже, а в следующей части мы посмотрим, как можно встроить реализацию нашего алгоритма в режиме сцепления блоков шифра.
---
[3.1] "Немного более глубокое" погружение в ядро
------------------------------------------------
Забегу немного вперёд. Внимательный читатель помнит о существовании шаблонов. Так вот, реализовав в прошлой части шифрование блока, мы запросто можем обернуть эту реализацию в шаблон *CBC* и получть реализацию нашего алгоритма в режиме сцепления блоков шифра, но, протестировав её на моих последовательностях, вызов шифрования в режиме *CBC* вернёт нам код ошибки 22 (`EINVAL`). И тут самое время вспомнить, что я говорил по поводу обработки неполного блока входных данных и поля `crypto_alg.cra_blocksize`. Дело в том, что реализация режима *CBC* ядра понятия не имеет о том, как обрабатывать неполный блок. Более того, оборачивая наш алгоритм в режим *CBC*, ядро регистрирует новый алгоритм, размер блока которого равен размеру блока базового алгоритма. После вызова "апишной" функции зашифрования алгоритмом *cbc(xor-cipher)*, размер входных данных проверяется на кратность размеру блока и, если они не кратны, функция возвращает `EINVAL`. Размер тестового вектора для шифрования в режиме *CBC* (40 байт) умышленно выбран не кратным размеру блока. По моему мнению, если стандартом шифрования предусматривается обработка неполного блока, а реализация этого не делает, то такая реализация едва ли пройдёт проверку на соответствие стандарту, даже если реализация даёт корректный результат, когда условие кратности выполняется (в данном случае, это так). Поэтому, сейчас мы сделаем полную реализацию режима сцепления блоков шифра для нашего алгоритма. Когда я занимался этим 2 года назад, я встраивал алгоритмы с расчётом на их использование через устаревший ныне *API* [блокирующего симметричного шифрования](https://www.kernel.org/doc/html/v4.13/crypto/api-skcipher.html#synchronous-block-cipher-api-deprecated), хотя уже тогда предпочтительным считался [неблокирующий *API*](https://www.kernel.org/doc/html/v4.13/crypto/api-skcipher.html#asynchronous-block-cipher-api-deprecated), который, на сегодняшний день, так же устарел. Эту реализацию мы будем делать под актуальный *Symmetric Key Cipher API*.
Изучив документацию и реализации других алгоритмов в ядре своей ОС, я обнаружил, что объявление и регистрация таких алгоритмов существенно отличается от того, как это делалось раньше, и осуществляется при помощи части *Crypto API*, не отражённой в документации. Но, имея под рукой образец (*arch/x86/crypto/aesni-intel\_glue.c*), разобраться, что к чему, оказалось не так уж и сложно. Итак, у нас здесь несколько иные функции для регистрации/разрегистрации алгоритмов:
```
/* include/crypto/internal/skcipher.h */
int crypto_register_skcipher(struct skcipher_alg *alg);
int crypto_register_skciphers(struct skcipher_alg *algs, int count);
void crypto_unregister_skcipher(struct skcipher_alg *alg);
void crypto_unregister_skciphers(struct skcipher_alg *algs, int count);
```
Заглянем в определение структуры `skcipher_alg`:
```
/* include/crypto/skcipher.h */
struct skcipher_alg {
int (*setkey)(struct crypto_skcipher *tfm, const u8 *key,
unsigned int keylen);
int (*encrypt)(struct skcipher_request *req);
int (*decrypt)(struct skcipher_request *req);
int (*init)(struct crypto_skcipher *tfm);
void (*exit)(struct crypto_skcipher *tfm);
unsigned int min_keysize;
unsigned int max_keysize;
unsigned int ivsize;
unsigned int chunksize;
unsigned int walksize;
struct crypto_alg base;
};
```
В отличие от документации, в заголовочном файле *include/crypto/skcipher.h* эта структура задокументирована. Так, эта структура содержит экземпляр уже знакомой нам `struct crypto_alg`, описывающей алгоритм, здесь же, функции `init` и `exit`, по своему назначению аналогичны таковым из `crypto_alg`. Новыми, на данный момент, являются поля `chunksize` и `walksize`:
* **`chunksize`**: по поводу значения этого поля в комментарии к коду сказано, что для всех алгоритмов, за исключением поточных (*stream cipher*), оно должно быть равно размеру блока, а, в случае поточных шифров, оно должно быть равно размеру блока базового (*underlying*) алгоритма. Это, в большей степени, касается блочных алгоритмов в режимах гаммирования. Для таких реализаций фактический размер блока (`skcipher_alg.base.cra_blocksize`) равен единице, а значение поля `chunksize` должно быть равно размеру блока алгоритма, используемого для выработки гаммы
* **`walksize`**: равен значению `chunksize`, за исключением случаев, когда алгоритм может параллельно обрабатывать несколько блоков, тогда `walksize` может быть больше, чем `chunksize`, но обязательно должен быть кратен ему
Ещё одну неопознанную структуру мы видим в аргументах функций `encrypt` и `decrypt`. Структура `skcipher_request` содержит данные, необходимые для выполнения операции симметричного шифрования: указатели на входные/выходные данные и синхропосылку, хэндл криптопреобразования и так далее. Напрямую обращаться к полям этой структуры нет необходимости, поскольку для работы с ней существует отдельный [под-*API*](https://www.kernel.org/doc/html/v4.13/crypto/api-skcipher.html#symmetric-key-cipher-request-handle), но, всё же, в ней есть одна особенность, о которой обязательно нужно упомянуть.
На самом деле, эта особенность касается *Crypto API* в целом. Дело в том, что все под-*API* шифрования данных произвольной длины работают со входными/выходными данными не через привычные указатели на байтовые массивы (как было в *API* шифрования блока), а через структуры типа `scatterlist`. Вот, например, функция зашифрования из *Synchronous Block Cipher API*:
```
/* include/linux/crypto.h */
int crypto_blkcipher_encrypt(struct blkcipher_desc *desc,
struct scatterlist *dst, struct scatterlist *src, unsigned int nbytes);
```
Структура `skcipher_request` так же содержит поля `struct scatterlist *src` и `struct scatterlist *dst` для входных и выходных данных соответственно. Посмотрим на основные элементы структуры `scatterlist`:
```
/* include/linux/scatterlist.h */
struct scatterlist {
/* ... */
unsigned long page_link;
unsigned int offset;
unsigned int length;
/* ... */
};
```
Экземпляр этой структуры можно проинициализировать указателем на некоторые данные. Например, при помощи вызова функции `sg_init_one`:
```
/* include/linux/scatterlist.h */
void sg_init_one(struct scatterlist *sg, const void *buf, unsigned int buflen);
```
Цитируя [отсюда](https://xakep.ru/2009/01/20/46840):
> В этой функции определяется страница памяти, с которой "начинается" buf (`page_link`), и определяется смещение указателя buf относительно адреса начала страницы (`offset`).
Таким образом, криптографическая подсистема работает напрямую со страницами памяти. Но это ещё не всё, посмотрите на следующий пример:
```
struct crypto_blkcipher *tfm;
struct blkcipher_dest desc;
struct scatterlist sg[2];
u8 *first_segment, *second_segment;
/* crypto and data allocation... */
sg_init_table(sg, 2);
sg_set_buf(&sg[0], first_segment, len);
sg_set_buf(&sg[1], second_segment, len);
crypto_blkcipher_encrypt(&desc, &sg, &sg, 2*len);
```
Здесь, `first_segment` и `second_segment` указывают на данные, *несмежные* в памяти. Таким образом, *Crypto API* (при помощи специальных вспомогательных структур) в один вызов способно обработать "цепочку" `scatterlist`-ов, содержащую "рассеянные" (*scattered*) данные. Такой подход был [изначально](https://www.kernel.org/doc/Documentation/crypto/api-intro.txt) заложен в *Crypto API* и обусловлен нуждами подсистемы *IPsec*:
> One of the initial goals of this design was to readily support IPsec, so that processing can be applied to paged [skb's](http://vger.kernel.org/~davem/skb.html) without the need for linearization.
На самом деле, `scatterlist` и связанный с ним *API* ядра являются фундаментальной вещью при организиации ввода/вывода с прямым доступом к памяти (*Direct Memory Access*, *DMA I/O*). Они позволяют эффективно осуществлять операции такого ввода/вывода над непрерывными в виртуальной, но "рассеянными" по физической памяти буферами данных, но, впрочем, [это уже совсем другая история](https://lwn.net/Articles/256368/).
Теперь можем переходить к реализации. Как и в прошлый раз, начинаем с определения функции установки ключа:
```
static int xor_skcipher_setkey(struct crypto_skcipher *tfm, const u8 *key,
unsigned int len)
{
return xor_cipher_setkey(crypto_skcipher_tfm(tfm), key, len);
}
```
Здесь всё просто. Для режима *CBC* мы будем работать с тем же типом криптоконтекста (`struct xor_cipher_ctx`), что и в случае шифрования блока, поэтому мы просто переиспользовали функцию установки ключа, реализованную ранее.
Пишем функции зашифрования и расшифрования.
**Зашифрование**
```
static int cbc_encrypt(struct skcipher_request *req)
{
struct crypto_tfm *tfm = crypto_skcipher_tfm(crypto_skcipher_reqtfm(req));
struct xor_cipher_ctx *ctx = crypto_tfm_ctx(tfm);
struct skcipher_walk walk;
u32 nbytes;
int i, blocks;
u8 *src, *dst, *iv;
skcipher_walk_virt(&walk, req, true);
iv = walk.iv;
while ((nbytes = walk.nbytes) >= XOR_CIPHER_BLOCK_SIZE)
{
src = (u8*)walk.src.virt.addr;
dst = (u8*)walk.dst.virt.addr;
blocks = nbytes / XOR_CIPHER_BLOCK_SIZE;
while (blocks)
{
for (i = 0; i < XOR_CIPHER_BLOCK_SIZE; i++)
{
dst[i] = src[i] ^ iv[i];
}
xor_cipher_crypt(tfm, dst, dst);
iv = dst;
src += XOR_CIPHER_BLOCK_SIZE;
dst += XOR_CIPHER_BLOCK_SIZE;
blocks--;
}
nbytes &= XOR_CIPHER_BLOCK_SIZE - 1;
skcipher_walk_done(&walk, nbytes);
}
if ((nbytes = walk.nbytes))
{
src = (u8*)walk.src.virt.addr;
dst = (u8*)walk.dst.virt.addr;
for (i = 0; i < nbytes; i++)
{
dst[i] = src[i] ^ iv[i];
dst[i] ^= ctx->key[i];
}
skcipher_walk_done(&walk, 0);
}
return 0;
}
```
**Расшифрование**
```
#define XOR_CIPHER_IV_SIZE 16
static int cbc_decrypt(struct skcipher_request *req)
{
struct crypto_tfm *tfm = crypto_skcipher_tfm(crypto_skcipher_reqtfm(req));
struct xor_cipher_ctx *ctx = crypto_tfm_ctx(tfm);
struct skcipher_walk walk;
u8 u[XOR_CIPHER_BLOCK_SIZE], iv[XOR_CIPHER_BLOCK_SIZE];
u32 nbytes;
int i, blocks;
u8 *src, *dst;
skcipher_walk_virt(&walk, req, true);
memmove(iv, walk.iv, XOR_CIPHER_IV_SIZE);
while ((nbytes = walk.nbytes) >= XOR_CIPHER_BLOCK_SIZE)
{
src = (u8*)walk.src.virt.addr;
dst = (u8*)walk.dst.virt.addr;
blocks = nbytes / XOR_CIPHER_BLOCK_SIZE;
while (blocks)
{
memmove(u, src, XOR_CIPHER_BLOCK_SIZE);
xor_cipher_crypt(tfm, dst, src);
for (i = 0; i < XOR_CIPHER_BLOCK_SIZE; i++)
{
dst[i] ^= iv[i];
}
memmove(iv, u, XOR_CIPHER_IV_SIZE);
dst += XOR_CIPHER_BLOCK_SIZE;
src += XOR_CIPHER_BLOCK_SIZE;
blocks--;
}
nbytes &= XOR_CIPHER_BLOCK_SIZE - 1;
skcipher_walk_done(&walk, nbytes);
}
if ((nbytes = walk.nbytes))
{
src = (u8*)walk.src.virt.addr;
dst = (u8*)walk.dst.virt.addr;
for (i = 0; i < nbytes; i++)
{
dst[i] = src[i] ^ ctx->key[i];
dst[i] ^= iv[i];
}
skcipher_walk_done(&walk, 0);
}
return 0;
}
```
Здесь, мы, так сказать, "прогуливаемся" по входным данным при помощи вспомогательной структуры `skcipher_walk` и связанных с ней функций. Сперва, экземпляр `skcipher_walk` инициализируется вызовом `skcipher_walk_virt`, а после этого функция `skcipher_walk_done` пересчитвает для нас указатели на очередную непрерывную "порцию" входных/выходных данных (`walk.src.virt.addr` и `walk.dst.virt.addr`) длины `walk.nbytes`, содержащуюся в цепочке `scatterlist`-ов.
Завершаем заполнением экземпляра структуры `skcipher_alg`, и регистрацией/разрегистрацией алгоритма:
```
static struct skcipher_alg cbc_xor_cipher = {
.base = {
.cra_name = "cbc(xor-cipher)",
.cra_driver_name = "cbc-xor-cipher",
.cra_priority = 400,
.cra_flags = CRYPTO_ALG_ASYNC,
.cra_blocksize = 1,
.cra_ctxsize = sizeof(struct xor_cipher_ctx),
.cra_module = THIS_MODULE,
},
.min_keysize = XOR_CIPHER_KEY_SIZE,
.max_keysize = XOR_CIPHER_KEY_SIZE,
.ivsize = XOR_CIPHER_IV_SIZE,
.setkey = xor_skcipher_setkey,
.encrypt = cbc_encrypt,
.decrypt = cbc_decrypt,
.chunksize = XOR_CIPHER_BLOCK_SIZE,
};
static int __init xor_cipher_init(void)
{
crypto_register_alg(&xor_cipher);
return crypto_register_skcipher(&cbc_xor_cipher);
}
static void __exit xor_cipher_exit(void)
{
crypto_unregister_alg(&xor_cipher);
crypto_unregister_skcipher(&cbc_xor_cipher);
}
```
Обратите внимание на значение поля `cra_blocksize`. Это небольшая хитрость, необходимая для того, чтобы вызов `skcipher_walk_done` "отдавал" нам последний неполный блок, если такой есть.
Скомпилировав и загрузив модуль, находим в `/proc/crypto` наш алгоритм:
```
name : cbc(xor-cipher)
driver : cbc-xor-cipher
module : xor_cipher
priority : 400
refcnt : 1
selftest : passed
internal : no
type : skcipher
async : yes
blocksize : 1
min keysize : 16
max keysize : 16
ivsize : 16
chunksize : 16
```
Готовый модуль (исходники [здесь](https://github.com/HenadziMatuts/linux-crypto-api-tutor/samples/kernel-xor-cipher)) регистрирует в ядре два новых алгоритма: "`xor-cipher`" (алгоритм шифрования блока) и "`cbc(xor-cipher)`" (реализация в режиме сцепления блоков шифра). На этом, по встраиванию, у меня всё. Для дальнейшего изучения этого вопроса могу лишь порекомендовать исходный код реализаций, которые уже есть в ядре (*arch/x86/crypto*), а мы переходим к следующей части.
---
[4] Тестирование
----------------
К сожалению, я не смог придумать более остроумного заголовка для этой части, чем просто "Тестирование", да и, в конце концов, это ведь именно то, чем мы будем здесь заниматься. Хотя, непосредственно, тесты — это лишь форма, за которой стоит суть этого раздела: показать, в целом, как *пользоваться* *Crypto API*. Для этого мы напишем и разберём ещё один модуль и пользовательскую программу, выполняющие серию тестов над нашими, встроенными в ядро, алгоритмами.
Начнём с модуля ядра. Для задания тестовых последовательностей введём структуру `cipher_testvec_t`:
```
typedef enum test_t
{
TEST_BLK_ENCRYPT = 0,
TEST_BLK_DECRYPT,
TEST_CBC_ENCRYPT,
TEST_CBC_DECRYPT,
TEST_END,
} test_t;
struct cipher_testvec_t
{
test_t test;
u32 len;
char *key;
char *iv;
char *in;
char *result;
};
```
Значения полей этой структуры тривиальны: входные данные `in`, длиной `len`, подаются на вход алгоритма шифрования блока (`.test = TEST_BLK_*`) либо шифрования в режиме сцепления блоков шифра (`.test = TEST_CBC_*`), с ключом `key` и, где это необходимо, синхропосылкой `iv`. Полученный резульатат криптопреобразования сравнивается с эталонным значением `result`. Значение `TEST_END` используется для обозначения окончания массива структур `cipher_testvec_t`.
Ниже — функция тестирования алгоритма шифрования блока:
```
static int test_blk(cipher_testvec_t *testvec)
{
struct crypto_cipher *tfm = NULL;
int encrypt = (testvec->test == TEST_BLK_ENCRYPT) ? 1 : 0;
u8 dst[16];
tfm = crypto_alloc_cipher("xor-cipher", 0, 0);
if (IS_ERR(tfm))
{
pr_err("error allocating xor-cipher: %ld\n", PTR_ERR(tfm));
return 0;
}
crypto_cipher_setkey(tfm, (u8*)testvec->key, 16);
if (encrypt)
{
crypto_cipher_encrypt_one(tfm, dst, (u8*)testvec->in);
}
else
{
crypto_cipher_decrypt_one(tfm, dst, (u8*)testvec->in);
}
crypto_free_cipher(tfm);
if (memcmp(dst, testvec->result, 16))
{
pr_err("block %sciphering test failed!\n", encrypt ? "" : "de");
dumpb((u8*)testvec->key, 16, "key");
dumpb((u8*)testvec->in, 16, "in");
dumpb(dst, 16, "result");
dumpb((u8*)testvec->result, 16, "should be");
return 0;
}
return 1;
}
```
Эта функция крайне проста, в ней используются вполне очевидные вызовы из [*Single Block Cipher API*](https://www.kernel.org/doc/html/v4.13/crypto/api-skcipher.html#single-block-cipher-api). Сперва, при помощи функции `crypto_alloc_cipher`, мы создаём хэндл криптографического преобразования с именем "*xor-cpher*". После этого, устанавливаем ключ шифрования (`crypto_cipher_setkey`), и, в зависимости от текущего теста, выполняем операцию зашифрования (`crypto_cipher_encrypt_one`) либо расшифрования (`crypto_cipher_decrypt_one`) блока. В завершение, уничтожаем хэндл (`crypto_free_cipher`) и сравниваем результат выполнения криптооперации с эталоном.
С функцией тестирования алгоритма в режиме CBC всё гораздо интереснее.
**Тестирование режима CBC**
```
static int test_cbc(cipher_testvec_t *testvec)
{
struct scatterlist sg;
struct cb_data_t cb_data;
struct crypto_skcipher *tfm = NULL;
struct skcipher_request *req = NULL;
int encrypt = (testvec->test == TEST_CBC_ENCRYPT) ? 1 : 0;
u32 err;
u8 *buf = NULL;
tfm = crypto_alloc_skcipher("cbc-xor-cipher", 0, 0);
if (IS_ERR(tfm))
{
pr_err("error allocating cbc-xor-cipher: %ld\n", PTR_ERR(tfm));
goto exit;
}
req = skcipher_request_alloc(tfm, GFP_KERNEL);
if (!req)
{
pr_err("error allocating skcipher request\n");
goto exit;
}
buf = kmalloc(testvec->len, GFP_KERNEL);
if (!buf)
{
pr_err("memory allocation error\n");
goto exit;
}
memmove(buf, (u8*)testvec->in, testvec->len);
sg_init_one(&sg, buf, testvec->len);
crypto_skcipher_setkey(tfm, (u8*)testvec->key, 16);
skcipher_request_set_crypt(req, &sg, &sg, testvec->len, (u8*)testvec->iv);
skcipher_request_set_callback(req, 0, skcipher_cb, &cb_data);
init_completion(&cb_data.completion);
err = (encrypt) ? crypto_skcipher_encrypt(req)
: crypto_skcipher_decrypt(req);
switch (err)
{
case 0:
break;
case -EINPROGRESS:
case -EBUSY:
wait_for_completion(&cb_data.completion);
err = cb_data.err;
if (!err)
{
break;
}
default:
pr_err("failed with error: %d\n", err);
goto exit;
}
if (memcmp(buf, testvec->result, testvec->len))
{
pr_err("cbc %sciphering test failed!\n", encrypt ? "" : "de");
dumpb((u8*)testvec->key, 16, "key");
dumpb((u8*)testvec->iv, 16, "iv");
dumpb((u8*)testvec->in, testvec->len, "in");
dumpb(buf, testvec->len, "result");
dumpb((u8*)testvec->result, testvec->len, "should be");
goto exit;
}
skcipher_request_free(req);
crypto_free_skcipher(tfm);
kfree(buf);
return 1;
exit:
if (buf)
{
kfree(buf);
}
if (req)
{
skcipher_request_free(req);
}
if (tfm)
{
crypto_free_skcipher(tfm);
}
return 0;
}
```
Самое главное: сейчас мы работает с *неблокирующим* *API* ([*Symmetric Key Cipher API*](https://www.kernel.org/doc/html/v4.13/crypto/api-skcipher.html#symmetric-key-cipher-api)), отсюда несколько иной подход к организации процесса.
Смотрим на функцию `test_cbc`:
* в объявлениях мы видим уже знакомые по прошлым разделам структуры, кроме одной новой: `cb_data_t`, но о ней чуть позже
* выполнение функции начинается с создания ключевых объектов: хэндла алгоритма "*cbc-xor-cipher*" (`crypto_alloc_skcipher`) и экземпляра `skcipher_requset` (`skcipher_request_alloc`)
* затем мы готовим буфер для входных/выходных данных: выделяем участок динамической памяти (`kmalloc`) размером не менее, чем размер входного вектора, и копируем последний в свежевыделенную память; указателем на эту память инициализируем экземпляр `scatterlist` (`sg_init_one`)
* устанавливаем ключ шифрования (`crypto_skcipher_setkey`) и инициализируем экземпляр `skcipher_requset` (`skcipher_request_set_crypt`). Второй и третий параметр функции `skcipher_request_set_crypt` это, соответственно, входные и выходные данные. В качестве аргумента этих параметров мы используем один и тот же экземпляр `scatterlist`, таким образом, шифрование будет выполнено "на месте", а результат криптооперации будет доступен по указателю `buf`
* устанавливаем функцию обратного вызова, для оповещения о завершении криптооперации (`skcipher_request_set_callback`)
Вот с этого момента поподробнее. Поскольку мы имеем дело с неблокирующим *API*, то мы можем оказаться в ситуации, когда вызов функции шифрования вернёт управление раньше, чем данные будут непосредственно обработаны. В этом случае, для оповещения о завершении криптооперации, будет вызана функция обратного вызова, предоставленная пользователем. Эта функция и передаваемые ей произвольные пользовательские данные устанавливаются с помощью вызова `skcipher_request_set_callback`. В нашем примере пользовательские данные имеют тип `cb_data_t`, а функция обратного вызова (`skcipher_cb`) определена следующим образом:
```
struct cb_data_t
{
struct completion completion;
int err;
};
static void skcipher_cb(struct crypto_async_request *req, int error)
{
struct cb_data_t *data = req->data;
if (error == -EINPROGRESS)
{
return;
}
data->err = error;
complete(&data->completion);
}
```
Структура `completion` и связанные с ней функции служат для синхронизации выполнения функции `test_cbc` и, непосредственно шифрования. В конце концов, нам необходимо дождаться окончания обработки, и только после этого возвращать управление из `test_cbc`. Разобравшись с этим, возвращаемся к месту в `test_cbc`, на котором мы остановились:
* инициализируем экземпляр `completion` (`init_completion`), передаваемый функции обратного вызова
* в зависимости от текущего теста, вызываем функцию зашифрования (`crypto_skcipher_encrypt`) или расшифрования (`crypto_skcipher_decrypt`)
* анализируем код возврата функции шифрования:
* + 0 означает, что непосредственно шифрование завершилось успешно
* + коды `-EINPROGRESS` и `-EBUSY` указывают на то, что операция шифрования ещё выполняется. В этом случае, о завершении нас уведомит изменение состояния экземпляра `completion` (`complete` и `wait_for_completion`), переданного функции обратного вызова
* + любой другой код возврата означает ошибку выполения функции `crypto_skcipher_encrypt`
Код после `switch`-a в пояснении не нуждается. На этом всё. Иходный код данного модуля доступен [здесь](https://github.com/HenadziMatuts/linux-crypto-api-tutor/samples/kernel-testmgr), скомпилировав и загрузив этот модуль (при условии, что загружен модуль с самими алгоритмами), в терминале вы получите что-то вроде:
```
insmod: ERROR: could not insert module xor_cipher_testing.ko: Operation not permitted
```
А в журнале ядра (`dmesg`) появится такая запись:
```
[---] done 4 tests, passed: 4, failed: 0
```
Кстати, в [документации](https://www.kernel.org/doc/html/v4.13/crypto/api-samples.html) есть подобный пример использования *SK Cipher API*, но он недостаточно подробно прокомментирован. Ещё пример — в упомянутой мной в самом начале статье из "Хакера", но там описан *Asynchronous Block Cipher API*, ныне устаревший. И всё-таки, это уже что-то, и заинтересованному читателю есть, где разгуляться.
---
[4.1] Возвращение в *user-space*
--------------------------------
Пришло время посмотреть, как можно воспользоваться криптографией ядра в пользовательском пространстве. Насчёт этого в документации есть отдельный [раздел](https://www.kernel.org/doc/html/v4.13/crypto/userspace-if.html), и, в принципе, его прочтения оказывается достаточно для того, чтобы начать применять эти возможности в своих программах, но это при условии, что вы уже знакомы с интерфейсом сокетов в *Linux*. За примером документация отсылает к библиотеке [*libkcapi*](http://www.chronox.de/libkcapi.html), написанной одним из разработчиков *Crypto API* (и соавтором самой документации). Для "общения" с ядром эта библиотека использует *Netlink*-интерфейс, она "заворачивает" низкоуровневую работу с *Netlink* в удобный пользовательский *API*. Если, в своих приложениях, у вас есть необходимость в криптографии ядра, то я бы рекомендовал использовать именно эту библиотеку, тем более, что она до сих пор поддерживается (текущая версия 1.0.3).
Но мы с вами проделали весь этот путь не ради того, чтобы просто воспользоваться библиотекой. Поэтому, дальше мы посмотрим, каким образом код пользовательского пространства, на самом низком уровне (не ниже системных вызовов), взаимодействует с *Crypto API*. Свой пример я сделал на основе плагина *af\_alg* из *Strongswan*, его [код](https://github.com/strongswan/src/libstrongswan/plugins/af_alg) я также рекомендую к ознакомлению.
Итак, поехали. В целом, в тестовой программе я использовал ту же архитектуру, что и в тестовом модуле. Однако, здесь не будет тестирования алгоритма шифрования блока, поскольку существующий интерфейс позволяет обратиться лишь к полноценным блочным шифрам. Таким образом, у нас остаётся только функция `test_cbc`.
**Тестирование режиме CBC в user-space**
```
static int test_cbc(cipher_testvec_t *testvec)
{
uint8_t dst[testvec->len];
int encrypt = (testvec->test == TEST_CBC_ENCRYPT) ? 1 : 0;
struct af_alg_skcipher *tfm = NULL;
tfm = af_alg_allocate_skcipher("cbc-xor-cipher");
if (!tfm)
{
fprintf(stderr, "error allocating \"cbc-xor-cipher\"\n");
goto err;
}
if (!af_alg_skcipher_setkey(tfm, (uint8_t*)testvec->key, XOR_CIPHER_KEY_SIZE))
{
fprintf(stderr, "can't set \"cbc-xor-cipher\" key\n");
goto err;
}
if (!af_alg_skcipher_crypt(tfm, encrypt, dst,
testvec->len, (uint8_t*)testvec->in,
(uint8_t*)testvec->iv, XOR_CIPHER_IV_SIZE))
{
goto err;
}
af_alg_free_skcipher(tfm);
if (memcmp(dst, (uint8_t*)testvec->result, testvec->len))
{
fprintf(stderr, "cbc %sciphering test failed!\n", encrypt ? "" : "de");
dumpb((uint8_t*)testvec->key, XOR_CIPHER_KEY_SIZE, "key");
dumpb((uint8_t*)testvec->iv, XOR_CIPHER_IV_SIZE, "iv");
dumpb((uint8_t*)testvec->in, testvec->len, "in");
dumpb(dst, testvec->len, "result");
dumpb((uint8_t*)testvec->result, testvec->len, "should be");
return 0;
}
return 1;
err:
if (tfm)
{
af_alg_free_skcipher(tfm);
}
return 0;
}
```
Логика этой функции не должна вызвать вопросов. Мы, как и несколько раз до этого, создаём хэндл, устанавливаем ключ, шифруем данные, уничтожаем хэндл и сравниваем резульат с эталоном. Всё интересное здесь скрыто за структурой `af_alg_skcipher` и связанными с ней функциями `af_alg_*`. Смотрим дальше.
**Создание хэндла**
```
struct af_alg_skcipher
{
int sockfd;
};
static struct af_alg_skcipher* af_alg_allocate_skcipher(char *name)
{
struct af_alg_skcipher *tfm = NULL;
struct sockaddr_alg sa = {
.salg_family = AF_ALG,
.salg_type = "skcipher",
};
strncpy((char*)sa.salg_name, name, sizeof(sa.salg_name));
tfm = calloc(1, sizeof(struct af_alg_skcipher));
if (!tfm)
{
errno = ENOMEM;
goto err;
}
tfm->sockfd = socket(AF_ALG, SOCK_SEQPACKET, 0);
if (tfm->sockfd == -1)
{
goto err;
}
if (bind(tfm->sockfd, (struct sockaddr*)&sa, sizeof(sa)) == -1)
{
goto err;
}
return tfm;
err:
if (tfm->sockfd > 0)
{
close(tfm->sockfd);
}
if (tfm)
{
free(tfm);
}
return NULL;
}
```
Идём по коду:
* заполняем экземпляр структуры `sockaddr_alg` (поясню чуть позже)
* выделяем память под новый хэндл (`calloc`)
* открываем сокет к *Crypto API* (`socket`)
Первый параметр системного вызова `socket` определяет семейство протоколов, которые могут быть использованы для "общения" через открытый сокет. Семейство *AF\_ALG* предназначено для взаимодействия с *Crypto API*. Константа *AF\_ALG*, обычно, определена в заголовочном файле *sys/socket.h*, если это не так, то её можно определить самостоятельно:
```
#ifndef AF_ALG
#define AF_ALG 38
#endif
```
* устанавливаем алгоритм, с которым мы будем взаимодействовать через открытый сокет (`bind`)
Конкретный алгоритм задаётся заполненим экземпляра структуры `sockaddr_alg`, указатель на этот экземпляр передаётся вторым аргументом системного вызова `bind`:
```
/* sys/socket.h */
int bind(int sockfd, const struct sockaddr *addr, socklen_t addrlen);
```
Структура `sockadr` определена следующим образом:
```
struct sockaddr {
sa_family_t sa_family;
char sa_data[14];
}
```
Эта структура нужна лишь для подавления предупреждения компилятора, на самом же деле, её реальный вид определяется семейством протоколов (`sa_family`), для *AF\_ALG* это:
```
/* linux/if_alg.h */
struct sockaddr_alg {
__u16 salg_family;
__u8 salg_type[14];
__u32 salg_feat;
__u32 salg_mask;
__u8 salg_name[64];
};
```
Мы заполняем три поля:
* **`salg_family`**: см. выше
* **`salg_type`**: тип запрашиваемого криптопреобразования: "`skcipher`" — шифрование, "`hash`" — хэширование и имитовставка, "`aead`" — очевидно, *AEAD*, "rng" — генерация псевдослучайных чисел
* **`salg_name`**: имя алгоритма в ядре (`cra_name` или `cra_driver_name`)
Если запрашиваемый алгоритм не зарегистрирован в ядре, то `bind` вернёт -1, а в переменную `errno` будет помещён код ошибки `ENOENT`.
Таким образом, результатом выполнения функции `af_alg_allocate_skcipher` является открытый сокет, через который можно взаимодействовать с конкретным алгоритмом в ядре. Функция уничтожения хэндла тривиальна и я не буду здесь её приводить.
Теперь посмотрим на функцию установки ключа:
```
static int af_alg_skcipher_setkey(struct af_alg_skcipher *tfm,
uint8_t *key, uint32_t keylen)
{
return (setsockopt(tfm->sockfd, SOL_ALG, ALG_SET_KEY, key, keylen) == -1) ? 0 : 1;
}
```
Ключ устанавливается при помощи системного вызова `setsockopt`, подробнее о параметрах этого вызова можно узнать на соответствующей [*man*-странице](https://linux.die.net/man/2/setsockopt). Я лишь отмечу, что константы `SOL_ALG` и `ALG_SET_KEY`, обычно, определены в файлах *sys/socket.h* и *linux/af\_alg.h* соответсвенно, если, на вашей системе, это не так, то их можно определить самостоятельно:
```
#ifndef SOL_ALG
#define SOL_ALG 279
#endif
#ifndef ALG_SET_KEY
#define ALG_SET_KEY 1
#endif
```
Наконец, переходим к самому главному.
**Шифрование**
```
static int af_alg_skcipher_crypt(struct af_alg_skcipher *tfm, int encrypt,
uint8_t *_dst, uint32_t _len, uint8_t *_src,
uint8_t *iv, uint32_t ivlen)
{
int type = encrypt ? ALG_OP_ENCRYPT : ALG_OP_DECRYPT;
struct msghdr msg = {};
struct cmsghdr *cmsg;
struct af_alg_iv *ivm;
struct iovec iov;
char buf[CMSG_SPACE(sizeof(type)) +
CMSG_SPACE(offsetof(struct af_alg_iv, iv) + ivlen)];
int op = 0;
ssize_t len, remainig = _len;
uint8_t *src = _src, *dst = _dst;
op = accept(tfm->sockfd, NULL, 0);
if (op == -1)
{
goto end;
}
memset(buf, 0, sizeof(buf));
/* fill in af_alg cipher controll data */
msg.msg_control = buf;
msg.msg_controllen = sizeof(buf);
/* operation type: encrypt or decrypt */
cmsg = CMSG_FIRSTHDR(&msg);
cmsg->cmsg_level = SOL_ALG;
cmsg->cmsg_type = ALG_SET_OP;
cmsg->cmsg_len = CMSG_LEN(sizeof(type));
memmove(CMSG_DATA(cmsg), &type, sizeof(type));
/* initialization vector */
cmsg = CMSG_NXTHDR(&msg, cmsg);
cmsg->cmsg_level = SOL_ALG;
cmsg->cmsg_type = ALG_SET_IV;
cmsg->cmsg_len = CMSG_LEN(offsetof(struct af_alg_iv, iv) + ivlen);
ivm = (void*)CMSG_DATA(cmsg);
ivm->ivlen = ivlen;
memmove(ivm->iv, iv, ivlen);
/* set data stream (scatter/gather list) */
msg.msg_iov = &iov
msg.msg_iovlen = 1;
while (remainig)
{
iov.iov_base = src;
iov.iov_len = remainig;
len = sendmsg(op, &msg, 0);
if (len == -1)
{
if (errno == EINTR)
{
continue;
}
goto end;
}
while (read(op, dst, len) != len)
{
if (errno != EINTR)
{
goto end;
}
}
src += len;
remainig -= len;
/* no iv for subsequent data chunks */
msg.msg_controllen = 0;
}
/* done */
close(op);
return 1;
end:
if (op > 0)
{
close(op);
}
return 0;
}
```
Функция относительно велика, и я опишу её лишь в общих чертах. Здесь есть много структур, наверняка знакомых тем, кто занимается сетевым кодом, но, даже если это не о вас, общая логика происходящего должна быть понятной. В целом, её можно разделить на 3 блока:
* в первом блоке, с помощью системного вызова `accept`, мы создаём ещё один сокет, через который, в дальнейшем, наш код и ядро будут обмениваться данными
* во втором блоке, мы формируем сообщение (`msghdr`), содержащее некоторую управляющую информацию (`cmsghdr`) и, непосредственно, указатели на входные/выходные данные (`iovec`)
Управляющая информация включает в себя тип выполняемой операции (`ALG_SET_OP`): зашифрование (`ALG_OP_ENCRYPT`) или расшифрование (`ALG_OP_DECRYPT`), и синхропосылку (`ALG_SET_IV`, `af_alg_iv`). Опять же, отмечу, что приведённые константы должны быть определены в файле *linux/if\_alg.h*, и, если это не так, то их можно определить следующим образом:
```
#ifndef ALG_SET_IV
#define ALG_SET_IV 2
#endif
#ifndef ALG_SET_OP
#define ALG_SET_OP 3
#endif
#ifndef ALG_OP_DECRYPT
#define ALG_OP_DECRYPT 0
#endif
#ifndef ALG_OP_ENCRYPT
#define ALG_OP_ENCRYPT 1
#endif
```
* наконец, в третьем блоке, используя системные вызовы `sendmsg` и `read`, с сокетом, открытым вызовом `accept`, мы, соответсвенно, отправляем в ядро данные на зашифрование/расшифрование и читаем результат
Вот и всё. Исходники этой тестовой программы доступны [здесь](https://github.com/HenadziMatuts/linux-crypto-api-tutor/samples/user-testmgr). Скомпилировав и запустив её, вы увидите следующее сообщение:
```
done 2 tests, passed: 2, failed: 0
```
Но это — при условии, что загружен наш модуль ядра.
---
[5] Что дальше?
---------------
Изначально, я планировал разбить эту статью на две части, но, начав работать, оказалось, что объём материала, который я планировал на вторую часть, значительно меньше того, что я подготовил для первой. И всё же, там были довольно интересные вещи, о которых я хотел бы рассказать. Поэтому после заключения я в виде своеобразных заметок кратко расскажу об этих вещах.
А по основной части — у меня всё. Надеюсь, эта статья оказалась для вас полезным или, по крайней мере, увлекательным чтением. Конечно, это далеко не полное руководство по *Crypto API*. В принципе, по статье можно написать о каждом из существующих под-*API*, при этом в некоторые из них я ещё даже не заглядывал. Но, с другой стороны, этого должно быть достаточно для того, чтобы продолжить изучение самостоятельно, если в этом есть необходимость.
Буду рад, если вы поможете мне сделать этот материал лучше: своё мнение, замечания и предложения оставляйте здесь, в комментариях, отравляйте мне на почту или в личные сообщения. Ещё лучше, если свои исправления вы будете предлагать мне прямо на [github](https://github.com/HenadziMatuts/linux-crypto-api-tutor). Спасибо за внимание!
---
### Используем шаблоны
Я столько раз говорил о том, что алгоритмы в ядре можно "заворачивать" в шаблоны, но так и не рассказал — *КАК* это сделать. Самое время это исправить! На самом деле всё очень просто. Допустим, в ядре зарегистрирован наш *xor-cipher*, тогда, что бы воспользоваться этим алгоритмом в шаблонном режиме *CBC*, нужно сделать следующий вызов (для *SK Cipher API*, для других — аналогично):
```
struct crypto_skcipher *tfm = crypto_alloc_skcipher("cbc(xor-cipher)", 0, 0);
```
В результате мы получаем хэндл алгоритма *xor-cipher*, завёрнутого в стандартный режим сцепления блоков шифра (*crypto/cbc.c*).
"Но постой! — скажете вы. — А что, если наш модуль регистрирует реализацию с именем *cbc(xor-cipher)*?". "Хорошй вопрос", — отвечу я. В этой ситуации ядро вернёт нам алгоритм из нашего модуля, и всё же мы можем получить шаблонную реализацию.
Когда ядро ищет алгоритм по имени, оно поступает следующим образом:
* ищет уже зарегистрированный алгоритм с таким именем
* если такого алгоритма нет, то пытается найти и загрузить модуль ядра с таким именем
* если и это не удалось, то ядро пытается "на лету" сконструировать подходящий алгоритм
На третьем шаге ядро перебирает зарегистрированные шаблоны и алгоритмы. На каждой итерации такого перебора ядро пытается "собрать" новый алгоритм из очередного шаблона и алгоритма. Например, для шаблона "*cbc*", если имена нашего алгоритма:
```
.cra_name = "xor-cipher";
.cra_driver_name = "xor-cipher-generic";
```
То ядро создаст и зарегистрирует алгоритм с именами:
```
.cra_name = "cbc(xor-cipher)";
.cra_driver_name = "cbc(xor-cipher-generic)";
```
В третьей части, когда мы изучали структуру `crypto_alg`, я упоминал о том, что `cra_driver_name` выбирается *уникальным* для каждой реализации, и по нему также можно запросить алгоритм. Для конкретно этого случая это означает, что, если `cra_driver_name` отлично от "*cbc(xor-cipher-generic)*", то шаблонную реализацию можно получить вызовом:
```
struct crypto_skcipher *tfm = crypto_alloc_skcipher("cbc(xor-cipher-generic)", 0, 0);
```
---
### Больше тестов
Кстати, мои тестовые программы и модули выглядят так, как они выглядят, не просто потому что мне так захотелось. Разумеется, в *Crypto API* есть модуль, отвечающий за тестирование, и свои я сделал по его образу и подобию.
Этот модуль называется *tcrypt* (*crypto/tcrypt.c*) и с ним есть одна проблема. Дело в том, что точка входа и тестирование скорости находятся прямо в *crypto/tcrypt.c*, а вот реализация тестов известного ответа расположена отдельно, в файле *crypto/testmgr.c*. В процессе сборки ядра, *testmgr* чаще всего компилируется статично в ядро и лишь экспортирует в глобальное пространство имён функцию, отвечающую за тестирование (а на моей системе тестирование вовсе отключено в конфигурации ядра).
Из сказанного следует, что просто так добавить свои тесты в *tcrypt* не получится. Поэтому я немного "подшаманил" исходники *tcrypt* и *testmgr*, вынес их из дерева ядра и написал *Makefile*, компилирующий их в один модуль — *tcryptext (tcrypt External)*. Это добро можно забрать у меня на [гите](https://githib.com/HenadizMatuts/tcryptext).
Если вы хотите протестировать свой алгоритм в ядре через *tcryptext* (тоже самое работает и с *tcrypt*, только с пересборкой ядра), то просто добавьте соответствующий код в исходники модуля по аналогии с каким-либо алгоритмом того же типа, что и ваш. После этого скомпилируйте и загрузите модуль с нужными параметрами (о параметрах в *README.md*, в репозитории).
Файл *testmgr.c* также рекомендую как пример использования всех видов преобразований в *Crypto API*.
---
### Домик на дереве
Допустим, вы разрабочик *Linux-based* операционной системы и вы поддерживаете собственную кастомную ветку ядра. Тогда свою криптографию (если она у вас есть) вы бы также могли поддерживать внутри дерева каталогов исходных кодов ядра.
И с этим нет никаких проблем. Просто разместите файлы с исходным кодом вашего криптографического модуля внутри папки "*crypto*" и добавьте соответствующие записи в файлы *crypto/Kconfig* и *Makefile*. Например, если в *crypto* мы поместили файл *xor\_cipher.c*, то в файл *crypto/Kconfig* (под строкой *comment "Ciphers"*) добавим нечто вроде:
```
...
config CRYPTO_XOR_CIPHER
tristate "XOR cipher algorithm"
help
Custom XOR cipher algorithm.
...
```
А в файл *crypto/Makefile*:
```
...
obj-$(CONFIG_CRYPTO_XOR_CIPHER) += xor_cipher.o
...
```
После этого в меню кофнигурации ядра (раздел "*Cryptographic API*") появится пункт для выбора нашего алгоритма. Это также позволит выбрать для него вариант статичной компиляции в образ ядра, что разумно в ряде случаев.
И не забудьте позаботиться о добавлении соответствующих тестов в *tcrypt* и *testmgr*.
---
### Полезные ссылки
Литература:
* [Authenticated encryption](https://en.wikipedia.org/wiki/Authenticated_encryption)
* [Linux Kernel Crypto API](https://www.kernel.org/doc/html/v4.13/crypto/index.html)
* [Crypto API в ядре Linux](https://xakep.ru/2009/01/20/46840)
* [Режим сцепления блоков шифротекста](https://ru.wikipedia.org/wiki/%D0%A0%D0%B5%D0%B6%D0%B8%D0%BC_%D1%81%D1%86%D0%B5%D0%BF%D0%BB%D0%B5%D0%BD%D0%B8%D1%8F_%D0%B1%D0%BB%D0%BE%D0%BA%D0%BE%D0%B2_%D1%88%D0%B8%D1%84%D1%80%D0%BE%D1%82%D0%B5%D0%BA%D1%81%D1%82%D0%B0)
* [Пишем простой модуль ядра Linux](https://habrahabr.ru/post/343828/)
* [Работаем с модулями ядра в Linux](https://habrahabr.ru/post/117654/)
* [Учимся писать модуль ядра (Netfilter) или Прозрачный прокси для HTTPS](https://habrahabr.ru/post/138328)
* [Scatterlist Cryptographic API](https://www.kernel.org/doc/Documentation/crypto/api-intro.txt)
* [How SKBs work](http://vger.kernel.org/~davem/skb.html)
* [The chained scatterlist API](https://lwn.net/Articles/256368/)
* [libkcapi — Linux Kernel Crypto API User Space Interface Library](http://www.chronox.de/libkcapi.html)
* [setsockopt(2) — Linux man page](https://linux.die.net/man/2/setsockopt)
Git:
* [Эта статья и примеры](https://github.com/HenadziMatuts/linux-crypto-api-tutor)
* [tcryptext](https://github.com/HenadziMatuts/tcryptext)
* [Strongswan af\_alg plugin](https://github.com/strongswan/src/libstrongswan/plugins/af_alg)
* [Linux kernel](https://github.com/torvalds/linux) | https://habr.com/ru/post/348552/ | null | ru | null |
# JavaScript библиотека Webix глазами новичка. Часть 3. Модули, диаграммы, древовидные таблицы
Я — начинающий front-end разработчик. Сейчас я учусь и стажируюсь в одной минской IT компании. Изучение основ web-ui проходит на примере JS библиотеки Webix и я хочу поделиться своим скромным опытом и сохранить его в виде небольшого учебного пособия по этой интересной UI библиотеки.
#### Третья задача
Я продолжаю развивать функционал приложения созданного при помощи библиотеки Webix. В прошлых статьях я разбирался как [создавать интерфейс](https://habr.com/ru/post/483558/) приложения и как [взаимодействовать с формой](https://habr.com/ru/post/484310/). В этой статье я рассматриваю следующие задачи:
* разделение проекта на модули;
* [вкладки и переключение](https://docs.webix.com/desktop__multiview.html) между ними;
* настройка [таблицы](https://docs.webix.com/datatable__index.html);
* отрисовка [списка](https://docs.webix.com/desktop__list.html) и [диаграммы](https://docs.webix.com/desktop__chart.html);
* создание [древовидной таблицы](https://docs.webix.com/desktop__treetable.html).
Работа виджетов List и [Layout](https://docs.webix.com/api__refs__ui.layout.html) была описана в предыдущих статьях.
Скачать исходники можно по [ссылке](https://github.com/sashko-web/webix/tree/master/webix%20sourses%20for%203%20article).
С готовым приложением можно ознакомиться [тут](https://snippet.webix.com/3hsddw9w).
### Шаг 1. Разделение проекта на модули
Чтобы избежать путаницы в коде, проект надежнее разбить на модули. Для этого я создам следующие файлы и перенесу в них код виджетов:
* header.js — виджет *[Toolbar](https://docs.webix.com/desktop__toolbar.html)*;
* aside.js — виджет *[List](https://docs.webix.com/desktop__list.html)*;
* table.js — виджет *[Datatable](https://docs.webix.com/datatable__index.html)*;
* form.js — виджет *[Form](https://docs.webix.com/desktop__form.html)*;
* footer.js — элемент с текстом: “The software is ...”.
В новых файлах описание конфигураций виджета происходит в переменной…
```
const footer = {
height: 30,
template:"The software is provided by [webix.com](#). All rights reserved (c)",
css:"bottom-link"
}
```
Созданные файлы подключаются в файле index.html в следующем порядке:
```
```
Полученные модули комбинируются в файле script.js, который теперь содержит простой и лаконичный код инициализации приложения.
```
webix.ui({
rows:[
header,
{
cols:[
aside, {view: "resizer"}, table, form
]
},
footer
]
});
```
### Шаг 2. Вкладки и переключение между ними
В случаях когда свободного места на странице не хватает, либо требуется тематически разделить содержимое приложения — логично использовать вкладки.
Переключение между вкладками осуществляется компонентом [Multiview](https://docs.webix.com/desktop__multiview.html). Этот компонент позволяет создать в приложении необходимое количество вкладок и отображает только одну в определенный момент времени.
Мультивью создам в файле aside.js:
```
const multi = {
view: "multiview",
cells:[
{ id:"dashboard", cols:[table, form ] },
{ id:"users", template:"Users" },
{ id:"products", template:"Products" }
]
}
```
В массиве cells находится код вкладок. Каждой вкладке нужно добавить id, чтобы к ней можно было обратиться и отобразить. Сейчас Multiview содержит три вкладки, в первую из которых перемещены, созданные до этого, таблица и форма.
В файле script.js виджеты Table и Form я заменяю на модуль Multi.
```
webix.ui({
rows:[
header,
{
cols:[
aside, {view: "resizer"}, /*table, form*/multi
]
},
footer
]
});
```
Роль переключателя между вкладками исполняет виджет [List](https://docs.webix.com/api__refs__ui.list.html). Мне нужно, чтобы по клику на его элементы открывалась соответствующая вкладка.
Для удобства работы, элементам виджета *List* я задам те же id, что и вкладкам мультивью.
```
const aside = {
view: "list",
id:"mylist",
scroll:false,
select:true,
width:200,
css:"list_color",
data:[
{value:"Dashboard", id:"dashboard"},
{value:"Users", id:"users"},
{value:"Products", id:"products"}
],
on:{
onAfterSelect:function(id){
$$(id).show();
}
}
}
```
При клике на элемент виджета *List* срабатывает [onAfterSelect](https://docs.webix.com/api__selectionmodel_onafterselect_event.html), внутри обработчика которого мы получаем id выбранного элемента и показываем одноименную вкладку, обращаясь к ней по id — они, как вы помните, совпадают.
Пример:
> Важно!
>
> Дальнейшие действия с данными будут осуществляться с запущенным локальным сервером.
>
>
### Шаг 3. Вкладка “Dashboard” — настройка таблицы
До этого момента в проекте использовалась таблица, поля которой генерировались автоматически. В случае когда требуется удалить колонку, либо добавить новую, используются настройки таблицы. Для этого в виджете *Datatable* свойство *autoConfig:true* нужно заменить на массив [columns](https://docs.webix.com/api__ui.datatable_columns_config.html) c настройками для каждой колонки.
```
const table = {
view:"datatable",
id:"film_list",
scroll:"y",
select:true,
url:"data/data.js",
hover:"myhover",
columns:[
{ id:"rank", header:"", width:50, css:"rank"},
{ id:"title", header:"Film title", fillspace:true},
{ id:"year", header:"Released", width:100},
{ id:"votes", header:"Votes", width:100},
{ id:"rating", header:"Rating", width:100}
]
}
```
* Значение свойства id указывает на поле элемента данных, которое будет отображено в данной колонке;
* свойство *header* в элементе — это заголовок столбца;
* всем колонкам задана фиксированная ширина, но во второй из них используется свойство fillspace, которое позволяет колонке title занять все свободное пространство.
В таблице использованы пользовательские CSS настройки: для строк установлен hover а первой колонке изменен фон. Все настройки заранее определены в файле style.css и нужно только вставить название классов.
Также мне для таблицы понадобится больше данных, поэтому я загружу их из data/data.js указав к нему путь с помощью свойства [url](https://docs.webix.com/desktop__data_loading.html).
Результат:
### Шаг 4. Вкладка “Users” — отрисовка списка и диаграммы
Во второй вкладке я создам список и диаграмму. Для этого во втором элементе Multiview я укажу название модуля — “users”.
```
const multi = {
view: "multiview",
cells:[
{ id:"dashboard", cols:[table, form ] },
{ id:"users", rows:[users] },
{ id:"products", template:"Products" }
]
}
```
Для самих виджетов я создам новый файл *users\_module.js*.
**Список**. Под списком понимается виджет *[List](https://docs.webix.com/api__refs__ui.list.html)*, ранее он был использован при создании меню. Строки списка должны состоять из имен пользователей и названий стран.
Код виджета List:
```
const users = {
rows:[
{
view: "list",
id:"user_list",
select:true,
url:"data/users.js",
template:"#name# from #country#"
},
{
template:"Chart"
}
]
}
```
Массив rows использован для разделения рабочей области на две части. Вторая часть будет использована для диаграммы.
В свойстве template, между знаками # указывается поле, значение которого берется из элемента данных, который подгружается из файла users.js.
Результат:
**Диаграмма**. Библиотека поддерживает распространенные типы [диаграмм](https://docs.webix.com/desktop__chart_types.html): линия, круг, радар, пончик, столбец и пр. Все они создаются виджетом "[chart](https://docs.webix.com/api__refs__ui.chart.html)". То как диаграмма будет выглядеть определяет свойство **type**.
Заменяю настройку `template:”Chart”` на код виджета:
```
const users = {
rows:[
{
view: "list",
id:"user_list",
select:true,
url:"data/users.js",
template:"#name# from #country#"
},
{
view:"chart",
type:"bar",
value:"#age#",
url:"data/users.js",
xAxis:{
template:"#age#",
title:"Age"
}
}
]
}
```
* Настройка `type: "bar"` задает линейчатый тип диаграммы;
* в value передаётся имя поля, и указывается оно обязательно в `#...#`. Это особенность виджета Chart;
* настройка xAxis определяет какая информация будет отображена под диаграммой по оси X;
* template указывает на то, что под линиями диаграммы буду цифры возраста;
* title содержит название диаграммы — `"Age"`.
Результат отрисовки списка и диаграммы:
### Шаг 5. Вкладка “Products” — древовидная таблица
Для инициализации этого компонента я создам файл *products\_module.js*, а в третьем элементе виджета Multiview укажу название модуля “products”.
```
const multi = {
view: "multiview",
cells:[
{ id:"dashboard", cols:[table, form ] },
{ id:"users", rows:[users] },
{ id:"products", rows:[products] }
]
}
```
Для построения древовидной таблицы используется виджет [Treetable](https://docs.webix.com/desktop__treetable.html). Одна из колонок виджета должна содержать обязательный шаблон — [{common.treetable()}](https://docs.webix.com/datatree__node_templates.html), иначе мы получим стандартную таблицу вместо древовидной. Шаблон позволяет сразу отрисовать характерные элементы:
* активную иконку для того, чтобы свернуть/развернуть вложенные записи;
* иконки “файл/папка”;
* отступы в зависимости от уровня записей.
```
const products = {
view:"treetable",
scrollX:false,
columns:[
{ id:"id", header:"", width:50 },
{ id:"value", header:"Title", fillspace:true,
template:"{common.treetable()} #title#" },
{ id:"price", header:"Price", width:200 }
],
select:"row",
url:"data/products.js"
}
```
Компонент treetable заполняется иерархическими данными, которые я получу из файла products.js.
Результат:
С получившимся приложением можно ознакомиться [тут](https://snippet.webix.com/wfx663tz).
### Обобщение
Шаг за шагом приложение дополняется новыми функциями. Важной стадией было разделение кода на модули. Разделение помогло избежать путаницы в коде и помогло организовать мультистраничный интерфейс. Интересным было освоение новых виджетов Webix в виде диаграмм и свободно редактируемых списков и таблиц. Всё также было просто, всё также гармонично. | https://habr.com/ru/post/486050/ | null | ru | null |
# mov Программирование на Ассемблере без знаний Ассемблера, habr
Самый короткий мультфильм про программирование. **Пролог**
Решил поделиться своими мыслями и кратким двухдневным опытом написания **(собирания по частям)** программы на Ассемблере без чтения учебников, больших статей и в целом без опыта программирования на этом языке. На одном из форумов я набрёл на задачу вывода десятичного числа в консоль. Если на языке C или PHP эта операция совершенно элементарна, то на Ассемблере всё не так просто, как может показаться на первый взгляд. Для решения задачи я выбрал nasm (правда, выбора и не было), немножко поигравшись предварительно с вставками nasm (синтаксис AT&T) в код C (ссылка на форум с моими опытами в конце статьи).
**Философское отступление**
Остановись, дорогой читатель! И прежде чем читать дальше, задай себе вопрос: *возможно ли начать ковать без обучения кузнечному делу?!*
Я оставлю этот вопрос без ответа. Только скажу, что в нём нет ни капли иронии, издёвки, намёка на назидательность и т.д. Это вопрос без какого-либо дополнительного подтекста.
**Поиски**
Информации по Ассемблеру в Интернете очень много и заблудиться в разных видах Ассемблера (для различных систем) крайне просто. Я не единственный задавался вопросом в поиске **«how to print a number in asm».** Ответы на разных диалектах языка относительно легко можно найти на **Stack Overflow**, однако это совершенно не означает, что будет легко запустить найденный код на своей машине. Велика вероятность того, что что-нибудь не сойдётся. Научиться отличать **синтаксис AT&T и intel** можно за несколько минут, а вот с узнаванием **tasm, fasm, masm, nasm** - несколько сложнее. Единственное, что можно предположить и (почти) не прогадать: базовые инструкции во всех Ассемблерах имеют (почти) одинаковые мнемоники.
**Ассоциации и первые впечатления**
*Если хотите, чтобы ваши соседи переехали, убедите себя в том, что играть на скрипке легко...*
Самая распространённая операция - сдвиг одного регистра в другой - лично у меня ассоциируется с перемещением фигур на шахматной доске.
В этом смысле язык кажется лёгким, даже очень лёгким или лучше сказать, - удобным.
Хотя, как известно, и правила шахмат нельзя назвать слишком сложными, но играть бывает крайне трудно.
**Итак, задача:**
Собрать программу, печатающую на **стандартный вывод (stdout)** число.
**Реализация**
Принцип (его надо мысленно прокрутить в голове и понять, тогда можно считать, что мы не списываем):
1. Число делится на 10.
2. **В** регистр **edx** заносится **остаток,** **в eax** **остальная часть**.
3. Остаток в цикле записывается **в буфер (stroka)**, начиная **с конца,** **используется декремент,** затем выводится
4. Дополнительно: при использовании инкремента можно напечатать строку в обратном порядке.
**Код nasm (собран на архитектуре 64b,** с моими и чужими комментариями)
```
section .data
stroka db 4;буфер для вывода
section .text
global _start ;must be declared for using gcc
_start: ;tell linker entry point
push rbp ;Работа со стеком
mov rbp, rsp
mov eax, 311 ; 311 - делимое
mov edi, 3 ; Переменная цикла.
loop: ; Начало цикла
dec edi
; Декремент, чтобы записать все значения остатка в stroka
mov ebx, 10 ; Делитель. Запишем в цикл, чтобы вернуть ему значение на новой итерации.
; Можно использовать для делителя только часть регистра ebx, а именно bx
xor edx, edx ; Обнулим остаток
div ebx ; Делим
add edx, 30h ; Добавим в остаток 0, равносильно add edx, '0'
mov [stroka + edi], dl ; Пишем в строку остаток в обратном порядке.
cmp edi, 0 ; Выходим
jne loop ; Возврат в цикл
; Собрали строку и далее выводим
mov ecx, stroka ; Кладём
mov edx, 4 ; Длина выводимой строки 4 (видимо, в байтах)
mov ebx, 1 ; file descriptor (stdout)
mov eax, 4 ; system call number (sys_write)
int 0x80 ; call kernel
mov eax, 1 ;system call number (sys_exit)
int 0x80 ;call kernel
```
**Команда для сборки, линковки и выполнения**
`nasm -f elf64 print_num.asm -o print_num.o; ld -o print_num print_num.o; ./print_num`
* \*\*\* Для остатка можно использовать только часть регистра edx, а именно dx. Это же верно и для делителя - можно использовать bx, так как число 10 умещается в 2 байта (16 бит).
* \*\*\* Для счётчика цикла, наверное, лучше использовать регистр ecx (как более канонический вариант), а остановку цикла осуществлять, когда в ax будет 0.
Оставлю для таких же как я дополнительную задачку и подсказку.
Задача: **изменить программу так, чтобы число печаталось наоборот.**
**Подсказка**
Hidden textМенять нужно mov edi, 3; dec edi; cmp edi, 0
Дополнительно: **как сделать из нашего** "**hello world" что-нибудь полезное?**
Если немножко почитать про стек, а также регистры rsp, rbp и поиграть со смещением, то можно быстро переделать программу в генератор псевдослучайных чисел:
```
mov rbp, rsp
mov eax, [rbp +17] ; Забираем из стека по адресу 17 значение
add eax, [rbp +18] ; И ещё сместимся на 1 (видимо,1 байт) и добавим в eax
```
**Далее самописный псевдогенератор**
```
section .data
stroka db 4 ;буфер для вывод
section .text
global _start ;must be declared for using gcc
_start: ;tell linker entry point
push rbp ;Работа со стеком
mov rbp, rsp
mov eax, [rbp +17] ; Забираем из стека по адресу 17 значение
add eax, [rbp +18] ; И ещё сместимся 1 одно значение, добавим в eax
mov edi, 3 ; Переменная цикла.
loop: ; Начало цикла
dec edi
;Декремент, чтобы записать все значения остатка в stroka
mov ebx, 10 ; Делитель. Запишем в цикл, чтобы вернуть ему значение на новой итерации
xor edx, edx ; Обнулим остаток
div ebx ; Делим
add edx, 30h ; Добавим в остаток 0, равносильно add edx, '0'
mov [stroka + edi], dl ; Пишем в строку остаток в обратном порядке.
cmp edi, 0 ; Выходим
jne loop ; Возврат в цикл
; Собрали строку и далее выводим
mov ecx, stroka ; Кладём
mov edx, 4 ; Длина выводимой строки 4 (видимо, в байтах)
mov ebx, 1 ; file descriptor (stdout)
mov eax, 4 ; system call number (sys_write)
int 0x80 ; call kernel
mov eax, 1 ;system call number (sys_exit)
int 0x80 ;call kernel
```
**Источники:**
1) <https://acm.mipt.ru/twiki/bin/view/Asm/PrintIntFunction>
2) <http://av-assembler.ru/asm/afd/asm-cpu-registers.htm>
3) <https://wasm.in/>
4) <https://codetown.ru/assembler/delenie-umnozhenie/> (про умножение, деление и регистры)
Темы с моими опытами:
<https://wasm.in/threads/vyvod-desjatichnogo-chisla.34675/>
<https://wasm.in/threads/assmembler-vstavkami.34672/>
**Интересное**
**Бонус:** ссылка на интересный репозитарий, в нём ОС с линковщиком (из трёх файлов: загрзчик, линковщик, ядро,):
<https://github.com/cirosantilli/x86-bare-metal-examples/blob/master/c_hello_world/run>
**Update:**
Добавлю решённый мной пример поиска и замены значения в массиве (для таких же как я, на примере можно понять ветвления прогрммы (пропуски, переходы)): <https://gitflic.ru/project/dcc0/mix-c-89-php/blob?file=search_and_change_in_array.asm>
Данной заметкой цикл статей для хабра завершаю.
Всем спасибо. C наступающим 2023 годом!
Новогодняя микросистема для запуска в qemu:
<https://gitflic.ru/project/dcc0/mix-c-89-php/blob?file=cat_on_boot.asm>
<https://www.youtube.com/watch?v=YGRambq6kXs> | https://habr.com/ru/post/707862/ | null | ru | null |
# Полное сокрытие полей свойствами в C#
Сперва я подумал, что стоит начать статью с описания основного назначения свойств в языке C#, но потом понял, что с этим можно на самом деле “развернуться” на целую статью. Поэтому, чтобы не затягивать со вступительной частью, я начну сразу с конкретной задачи.
#### Постановка задачи
Как известно, в подавляющем большинстве случаев свойства применяются, чтобы скрыть private или protected поле класса. То есть свойства в данном случае помогают реализовать инкапсуляцию данных и методов работы с ними. Рассмотрим простой пример.
> `1. class Car
> 2. {
> 3. const double MINIMAL\_SPEED = 0d;
> 4.
> 5. const double MAX\_KNOWN\_CAR\_SPEED = 1229.78d;
> 6.
> 7. private double maxSpeed;
> 8.
> 9. public double MaxSpeed
> 10. {
> 11. get { return maxSpeed; }
> 12. set
> 13. {
> 14. if (value < MINIMAL\_SPEED || value > MAX\_KNOWN\_CAR\_SPEED)
> 15. throw new ArgumentOutOfRangeException("MaxSpeed");
> 16. maxSpeed = value;
> 17. }
> 18. }
> 19. }
> \* This source code was highlighted with Source Code Highlighter.`
В данном примере определён класс Car, который накладывает ограничение на поле maxSpeed с тем, чтобы оно имело значение лишь в определённом диапазоне. У этого кода есть довольно существенная проблема. К сожалению, свойство MaxSpeed защищает поле maxSpeed только от присвоения некорректной скорости извне класса Car. Другие методы и свойства класса Car могут осуществить присвоение произвольного значения полю maxSpeed. Иногда это нормально, а иногда это опасно. Посмотрите на следующий (опасный) фабричный метод в классе Car:
> `1. class Car
> 2. {
> 3. // ...
> 4. public static Car CreateRandomCar()
> 5. {
> 6. return new Car()
> 7. {
> 8. maxSpeed = (new Random()).NextDouble() \* double.MaxValue,
> 9. };
> 10. }
> 11. }
> \* This source code was highlighted with Source Code Highlighter.`
Очевидно, этот метод может создать машину с максимальной скоростью большей, чем значение константы MAX\_KNOWN\_CAR\_SPEED. Таким образом, задача состоит в том, чтобы переменную maxSpeed скрыть как от кода внешнего по отношению к Car, так и от самого класса Car. Пусть даже сам класс осуществляет доступ к этому полю, используя метод. А уже метод обеспечит гарантии корректности присваимового значения. Печально, но заставить всех участников проекта использовать свойство MaxSpeed вместо поля maxSpeed невозможно. Да и сам я замечал, что забываю о такого рода проблемных полях.
#### Решение
Люди, практикующие тру-ООП программирование скажут, что задача не стоила рассмотрения, потому что решение её простое — инкапсулировать maxSpeed в отдельный класс Speed и всего делов. Однако, на мой взгляд, в части случаев это напоминает стрельбу из пушки по воробьям и заводить отдельный класс на каждое подобное свойство это стиль на любителя. Хотя, я согласен, что идеологически такой подход наиболее чистый.
Мы же с коллегой нашли другое решение. У решения есть свои недостатки и некоторые ограничения. Итак, ниже представлен класс, который позволит легко описывать свойства, инкапсулирующие такие “проблемные” поля:
> `1. public class HidingProperty
> 2. {
> 3. public delegate T1 Getter(ref T1 currentValue);
> 4. public delegate void Setter(ref T2 currentValue, T2 newValue);
> 5.
> 6. private T \_storedValue;
> 7. private Getter \_getter;
> 8. private Setter \_setter;
> 9.
> 10. public HidingProperty(Getter getter, Setter setter)
> 11. : this(default(T), getter, setter) { }
> 12.
> 13. public HidingProperty(T initialValue, Getter getter, Setter setter)
> 14. {
> 15. \_storedValue = initialValue;
> 16. \_getter = getter;
> 17. \_setter = setter;
> 18. }
> 19.
> 20. public void Set(T newValue)
> 21. {
> 22. \_setter(ref \_storedValue, newValue);
> 23. }
> 24. public T Get()
> 25. {
> 26. return \_getter(ref \_storedValue);
> 27. }
> 28. }
> \* This source code was highlighted with Source Code Highlighter.`
А вот и пример описания проблемного поля и свойства:
> `1. private HidingProperty<double> NewMaxSpeed = new HidingProperty<double>(
> 2. (ref double currentValue) => { return currentValue; },
> 3. (ref double currentValue, double newValue) =>
> 4. {
> 5. if (newValue < MINIMAL\_SPEED || newValue > MAX\_KNOWN\_CAR\_SPEED)
> 6. throw new ArgumentOutOfRangeException("NewMaxSpeed");
> 7. currentValue = newValue;
> 8. }
> 9. );
> \* This source code was highlighted with Source Code Highlighter.`
Работать с новым полем придётся, используя методы Get() и Set():
var currentSpeed = mazda.NewMaxSpeed.Get()
mazda.NewMaxSpeed.Set(currentSpeed + 10d);
Да, коллеги. Это, конечно, не супер сексуальный код. Пример работы с полем напоминает мне програмиирование на Java. Однако, основная задача решена, причём относительно малой кровью. Теперь при обращению к NewMaxSpeed как извне Car, так и внутри него, будет осуществляться одна и та же проверка на вхождения нового значения в заданный диапазон.
#### Недостатки, ограничения, побочные эффекты
Признаюсь, мне бы хотелось видеть возможность полного сокрытия поля свойством в самом языке. Мой коллега видит себе примерно такой синтаксис для этого дела:
> `1. public double Speed
> 2. {
> 3. double speed;
> 4. get { // Код геттера }
> 5. set { // Код сеттера }
> 6. }
> \* This source code was highlighted with Source Code Highlighter.`
Тот же вариант, что был приведён мной, заставляет работать с полем через противные методы Get, Set, не допуская прямых присвоений. Преодолеть этого мне так и не удалось. Если описать оператор неявного приведения, позволящий писать double x = car.MaxSpeed; довольно просто, то вот реализовать возможность использования car.MaxSpeed = 10d; оказалось невозможно.
Ещё одна гадость, связанная с предложенным решением заключается в невозможности указания разных модификаторов доступа для геттера и сеттера, что, разумеется, является большим минусом.
Вопрос сериализации таких полей/свойств я даже не рассматривал. Полагаю, тут могут возникнуть сложности. Хотя не исключаю, что простого “навешивание” атрибута Serializable на класс HidingProperty может оказаться достаточно.
#### Выводы
Пока мне трудно сказать как часто в пределах нашего проекта мы с коллегой будем обращаться к этому решению. Однако я не очень привередлив к стилю кода и в домашних работах класс применять буду.
Спасибо за внимание! Буду признателен за критику решения и новые мысли. | https://habr.com/ru/post/116234/ | null | ru | null |
# Создаем html5 мини-бродилку на CraftyJS
Хочу раcсказать, как без особых сложностей сделать свою первую мини игру на html5 (если точнее: js, html5, css).
Суть игры будет в следующем: человечек ходит по полю, между камнями и собирает цветочки, у каждого цветочка есть 1 охранник. Количество цветов с каждым уровнем увеличивается, карты создаются в случайном порядке.
Выглядит это все будет так:
### Подготовка каркаса
Итак, для нашей задачи я буду использовать js библиотеку [craftyjs](http://craftyjs.com/). Так как для того, что бы нарисовать самостоятельно sprites, у меня руки не оттуда растут, я позаимствую sprites из примера на сайте, все остальное будем делать с нуля, да и взятый sprite мы дополним врагами в красных шапочках и футболках:
Теперь пора сделать каркас приложения, у меня он выглядит вот так:
Так же, давайте сразу создадим:
/index.html
> `DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN"
>
> "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
>
> <html xmlns="http://www.w3.org/1999/xhtml">
>
> <head>
>
> <script type="text/javascript" src="js/jquery.js">script>
>
> "text/javascript"</font> src=<font color="#A31515">"js/crafty.js"</font>>
>
>
>
> "text/javascript"</font> src=<font color="#A31515">"js/objects/flower.js"</font>>
>
> "text/javascript"</font> src=<font color="#A31515">"js/objects/bush.js"</font>>
>
> "text/javascript"</font> src=<font color="#A31515">"js/objects/grass.js"</font>>
>
> "text/javascript"</font> src=<font color="#A31515">"js/objects/unit.js"</font>>
>
> "text/javascript"</font> src=<font color="#A31515">"js/objects/player.js"</font>>
>
> "text/javascript"</font> src=<font color="#A31515">"js/objects/fourway\_ai.js"</font>>
>
> "text/javascript"</font> src=<font color="#A31515">"js/objects/monster.js"</font>>
>
>
>
> "text/javascript"</font> src=<font color="#A31515">"js/scenes/loading.js"</font>>
>
> "text/javascript"</font> src=<font color="#A31515">"js/scenes/main.js"</font>>
>
> "text/javascript"</font> src=<font color="#A31515">"js/scenes/win.js"</font>>
>
> "text/javascript"</font> src=<font color="#A31515">"js/scenes/lose.js"</font>>` | https://habr.com/ru/post/125857/ | null | ru | null |
# Объектно ориентированный подход на функциях в Scheme
Привет. В данной статье хотелось бы еще разок осветить вопрос объектного программирования на языке Scheme, так, как его рассматривают в книге «Структура и интерпретация компьютерных программ».
Далее предлагаю тем, кто еще ни когда не программировал на Scheme скачать [DrRacket](http://racket-lang.org/download/) и попробовать по шагам пройтись по примерам из данной статьи. Опытные программисты Scheme, Racket… эта статья будет очень скучна, так как написана для новичков и людей, желающих «потрогать» racket.
И так по порядку. Разомнемся для начала в DrRacket IDE.
Создадим новый файл программы. Сохраним его.
Вставим в начале файла директиву указывающую на язык:
```
#lang racket
```
Определим функцию:
```
(define (func1 x) x) ; принимает на вход x, возвращает x
```
Использовать функцию можно так:
```
(func1 10) ; результат будет 10
```
Теперь определим другую функцию:
```
(define (func2) "func2")
```
А теперь попробуем определить переменную такую, что она применяет первую функцию ко второй и возвращает вторую функцию:
```
(define x (func1 func2)) ; теперь x - это объект экземпляра функции func2
```
Использовать x нужно как функцию:
```
(x) ; вернет стоку "func2"
```
Тут мы использовали возможность того, что функция может возвращать функции, а их результат можно определить как переменные.
Далее давайте создадим объект, инкапсулирующий в себе внутренние переменные и другие функции:
```
(define (MyObject field1 field2) ; объект у которого при конструировании будут две переменные field1 и field2
(let ((f1 field1) ; инициализация внутренней переменной f1, с помощью field1
(f2 field2)) ; ...
(define (get-f1) f1) ; вернуть значение внутреннего поля f1
(define (get-f2) f2) ; ...
(define (set-f1 x) (set! f1 x)) ; присваиваем f1 значение x
(define (set-f2 x) (set! f2 x)) ; ...
; далее идет самое интересное
(define (dispatch m) ; функция диспетчирования функций в нашем объекте
(cond ((eq? m 'get-f1) get-f1) ; если m равно get-f1, то возвращается функция get-f1
((eq? m 'set-f1) set-f1) ; ...
((eq? m 'get-f2) get-f2) ; ...
((eq? m 'set-f2) set-f2) ; ...
)
)
dispatch)) ; тут мы в функции MyObject возвращаем функцию диспетчирования
```
Ну вот объект определен, теперь сделаем экземпляр объекта MyObject:
```
(define Obj1 (MyObject " Hello " " world!!! ")) ; теперь Obj1 экземпляр
```
Далее просто используем экземпляр так как захотим:
```
(display ((Obj1 'get-f1))) ; тут ф-ия display что-то типа printf, а двойные скобки
; в ((Obj1 'get-f1)) надо писать для того, чтобы вычислялась функция get-f1
(display ((Obj1 'get-f2))) ; аналогично
(newline) ; переход на новую строку
; результатом будет " Hello world!!! "
```
Создадим новый экземпляр того же объекта:
```
(define Obj2 (MyObject " Hello " " habra!!! ")) ;
; результат: "Hello Hello habra!!! world!!!"
```
Попробуем выполнить:
```
(display ((Obj1 'get-f1)))
(display ((Obj1 'get-f2)))
(newline)
(display ((Obj2 'get-f1)))
(display ((Obj2 'get-f2)))
(newline)
; результатом будет "Hello world!!!"
; и "Hello habra!!!"
```
Что меня поразило — каждый экземпляр возвращает одни и теже функции, но их поведение не одинаковое.
То есть в Scheme, в отличие от С++, функции берут переменные и функции для вычисления из своего экземпляра.
Данная особенность сильно помогает организации списков функций для изменения внутренних состояний разных экземпляров одного или нескольких объектов:
```
(define func-list (list (Obj1 'get-f1) (Obj2 'get-f1) (Obj2 'get-f2) (Obj1 'get-f2)))
```
Распечатаем выполнения каждой функции из этого списка так:
(map (lambda (x) (display (x))) func-list)
; результат: «Hello Hello habra!!! world!!!» | https://habr.com/ru/post/144598/ | null | ru | null |
# DEF CON CTF 22 Final
С 7 по 10 августа в Лас-Вегасе (США) прошла крупнейшая конференция по информационной безопасности — DEF CON. Мероприятие проходит уже 22 год. Мы принимали участие в финальном этапе DEF CON CTF. На самой конференции народу очень много. Сначала я слышал что-то про 6 тысяч человек, потом — про 15. Переходы между залами для докладов днем были похожи на переходы в московском метро. Но обо всем по порядку.
*Коридор за час до начала конференции*
#### DEF CON CTF
Традиционно во время конференции проводятся [командные соревнования по информационной безопасности](https://ru.wikipedia.org/wiki/%D0%97%D0%B0%D1%85%D0%B2%D0%B0%D1%82_%D1%84%D0%BB%D0%B0%D0%B3%D0%B0#.D0.9A.D0.BE.D0.BC.D0.BF.D1.8C.D1.8E.D1.82.D0.B5.D1.80.D0.BD.D0.B0.D1.8F_.D0.B1.D0.B5.D0.B7.D0.BE.D0.BF.D0.B0.D1.81.D0.BD.D0.BE.D1.81.D1.82.D1.8C) DEF CON CTF. Вообще данный CTF состоит из 2 этапов: В Лас-Вегасе проходит финал, а перед ним проводится отборочный онлайн-тур, по итогам которого отбирается 12 лучших команд. Победитель прошлого года автоматически получает место в финале, а также на финал можно попасть, выиграв один из 7-ми других престижных CTF в течении года. Так, наша команда попала на финал, заняв третье место на Positive Hack Days CTF в мае этого года (победитель PHDays CTF к тому времени уже прошел на финал за счет другого CTF, а команда int3pids, занявшая второе место, отказалась от приглашения).
Команда, которая проводит DEF CON CTF, меняется раз в 3 года. В этом году свой второй дефкон проводит команда [Legitimate Business Syndicate](https://legitbs.net/).
Вот такие бэйджи получают все посетители конференции и участники CTF:
Про саму конференцию могу сказать лишь, что было:
* много докладов
* много мастер классов
* Social Engineering Village
* Lockpick Village
* Hardware Hacking Village
* Wireless Village
* Packet Hacking Village (с традиционной Wall Of Sheep)
* многое другое
В зале для вендоров стоял электрокар Tesla, который даже можно было попробовать хакнуть:
*На фото [d0znpp](https://habrahabr.ru/users/d0znpp/), взято у [SadieSv](https://habrahabr.ru/users/sadiesv/)*
Но ни на доклады, ни к Тесле, мы, к сожалению, не попали. так как…
#### Capture The Flag
Финал DEF CON CTF проходит в формате Attack/Defense (он же Service-based). Команды получают одинаковые сервера с набором предустановленных сервисов. В сервисах заложена определенная функциональность, которая постоянно проверяется ботами организаторов. Также в сервисы заложены уязвимости, которые нужно найти и желательно устранить. Эксплуатируя уязвимости в сервисах на серверах других команд, нужно получать так называемые «флаги». Флаги — это, как правило, какая-то секретная информация в контексте сервиса. Допустим, сервис — почтовый сервер. Флаги лежат в почтовых ящиках, созданных ботами организаторов. Если вы научились читать чужие письма, то можете искать флаги и сдавать их.
Флаги обновляются каждый раунд. Раунд длится 5 минут. Флаги имеют ограниченное время жизни (обычно 1-2 раунда). То есть, если вы в конце игры прочитаете все флаги с сервера соперника, то результативно сдадите только 1-2 из них. За остальные очков начислено не будет.
Когда с уязвимого сервиса получен флаг, команды, сдавшие этот флаг, получают 19 очков, которые распределяются поровну в зависимости от числа таких команд. Пострадавшая команда, соответственно, теряет 19 очков. В начале игры все команды имеют по 2500 очков.
Если ваш сервис выключен или заложенная в него функциональность нарушена, сервис оказывается в статусе Offline, и у команды падает показатель SLA. SLA — доля игрового времени, в течение которого сервис корректно работал. Обычно этот показатель умножается на количество очков, чтобы сформировать окончательный счет. Честно говоря, как именно считался окончательный рейтинг на финале DEF CON CTF мы так и не поняли. Четкого набора правил с формулами организаторы командам не давали. Полагаю, что это одна из фишек дефкона, т.к. на финале PHDays CTF, к примеру, все правила были четко прописаны и предоставлены командам за несколько дней до соревнований. Даже была excel-таблица, в которой продемонстрирован подсчет очков для разных сценариев развития событий.
#### Команда
Наша команда называется [BalalaikaCr3w](http://ctfcrew.org). Большая часть наших участников — студенты и выпускники МИФИ, часть — МГТУ им. Баумана, один выпускник МФТИ и один выпускник БГТУ (Брянск). На фото не все участники, а только те, кто поехал на DEF CON. Образовалась команда чуть более полутора лет назад. Как образовалась и как развивалась — это отдельная история, когда-нибудь напишу отдельную статью об этом, если такая информация может быть интересна.
На финале DEF CON CTF максимальное число участников одной команды составляет 8 человек. Нас на финале оказалось всего 7, т.к. в силу финансовых проблем или проблем с получением визы несколько человек не смогли поехать.
#### Виза
Приняв приглашение для участия в финале, первой проблемой стало получение визы в США. Людям нашей профессии получить американскую визу не совсем просто, особенно в сжатые по времени сроки. Приглашение на финал DEF CON CTF мы получили в конце июня, лететь в США нужно было в начале августа, а у нас еще и поездка в Корею на финал SECUINSIDE CTF в июле. Итог по визам следующий: из 10 попыток было получено 6 виз. При этом одна виза получена со второй попытки, а еще одна только после дополнительной проверки. Один из наших участников со второй попытки попал на дополнительную проверку и не успел ее пройти, а кому-то просто отказали. У одного из участников команды уже была действующая виза, но и она была получена ранее только после дополнительной проверки.
В чем подвох? Как только офицер в посольстве понимает, что ваша деятельность (и/или образование) связана с информационной безопасностью (ровно как и с некоторыми другими критически важными для государства областями науки и техники), он отправлет вас на дополнительную проверку. Проверка может длиться до одного года. Ну и помимо проверок офицер может просто сказать вам «отказано» по итогам собеседования, выдать какую-то разъяснительную бумажку и попрощаться с вами без объяснения причин.
#### Обеспечение
Организаторы DEF CON CTF предоставляют участникам 2 номера на 3 ночи в отеле Rio All-Suite Hotel & Casino, в котором и проходит DEF CON. В каждом номере 2 большие кровати и диван. За 30 баксов в день можно заказать дополнительную кровать вроде раскладушки (хотя она кстати комфортнее дивана). Все остальные расходы команды оплачивают самостоятельно: перелет, дорога, питание (даже во время CTF), оборудование и т.д.
*Вот так выглядит CTF зона*
Получается, что участие в финале DEF CON CTF является самым дорогостоящим среди всех финалов для российских команд. К примеру, бюджеты поездок на финал Facebook CTF в Барселону или SECUINSIDE CTF в Сеул колеблются в диапазоне от 100 до 200 тысяч рублей. Для поездки на DEF CON только на билеты нужно порядка 450-500 тысяч. Посему вопрос привлечения денежных средств встал довольно остро для нашей команды — все-таки поездок за год немало, а большая часть из нас только что закончили ВУЗ.
#### Спонсорство
Мы обращались в несколько самых крупных российских компаний, занимающихся информационной безопасностью, с просьбой в той или иной мере поддержать нашу команду и с предложением сотрудничества, чтобы взаимодействие оказалось выгодно обеим сторонам. Но, увы, кто-то сразу отказался, кто-то проявил заинтересованность и затем отказался чуть более вежливо, а кто-то начал в очень положительном ключе, а потом все равно отказался. Оказалось, что небольшая поддержка команды русских хакеров никому не интересна. Ну да, мы же не команда Формулы-1, какая от нас может быть польза ИБ-компаниям.
Забавно, что в Германии все наоборот. Volkswagen выделил немецкой CTF-команде StratumAuhuur 20 тысяч долларов для поездки на финал DEF CON CTF. Вот уж действительно, что русскому хорошо, то немцу смерть.
Однако, стоит поблагодарить за посильную поддержку некоторых участников нашей команды их работодателями: [компанией «Актив»](http://aktiv-company.ru/) и [ФГУП «ГлавНИВЦ»](http://www.grcc.ru). Спасибо!
Если у кого-то есть желание и возможность сотрудничать с нашей командой, то, милости просим, пишите на info (at) ctfcrew.org, мы в долгу не останемся.
#### Основной процесс
Финал DEF CON CTF разбит на 3 дня. Каждой комаде выделено:
* несколько столов, составленных прямоугольником, чтобы можно было сесть рядом. Честно говоря, было тесновато. Мы видели как тем, кто приехал в полном составе, приходилось раздвигать столы, чтобы можно было сидеть никого не задевая
* один Ethernet кабель с доступом к игровой сети (у каждой команды своя подсеть 10.5.N.0/24) и сети Интернет
* одна розетка для подключения к электрической сети (переходники на европейские вилки и удлинители тоже надо было везти с собой)
##### Расписание:
* 9:00 — команды запускают в CTF зону, начинается setup
* 9:30 — команды получают доступ к своим серверам
* 10:00 — открывается сеть между сегментами команд. Можно подключаться к чужим серверам и атаковать их
* 20:00 — сеть закрывается. Команды должны собрать вещи и покинуть CTF зону. В третий день сеть закрылась в 14:00 и CTF зону можно было не покидать, т.к было afterparty
Каждый новый день команды сажают за разные столы в разных частях CTF зоны.
В первый день был доступен скорборд с абсолютным количеством очков. Правда ночью организаторы его пересчитали, потому что у двух команд (одна из которых наша) сгорела карта памяти в сервере, и, пока сервер заменяли, он, разумеется, был недоступен. На второй день скорборд был доступен, но количество очков не отображалось, только места команд в рейтинге.
Вообще факапов со стороны организаторов было немало. На второй день, например, один парень с эксцентричной красной прической тупо вырубил наш сервер. Или не тупо. Но когда мы жаловались, что сервер уже 15 минут недоступен, товарищ извинялся и говорил, что это его вина, он случайно так сделал. В общем, я за 3 дня раз 10 слышал, что SLA будет исправлен, а рейтинг — пересчитан.
Некоторые команды устраивали DoS, который запрещен правилами, за что получали наказание в виде понижения показателя SLA. В итоге после финала организаторы почти неделю не выкладывали окончательные результаты, т.к. все пересчитывали.
#### Задания
В качестве серверов использовались [ODROID-U3+](http://www.vesalia.de/e_odroidu3.htm). Хотя после соревнований мы видели, что внешне наш сервер отличался от других (его ведь меняли в первый день после того, как сгорела карта памяти), так что не исключено, что у других команд была другая железка.
Сервера были установлены у организаторов. Команды получали доступ по ssh. При этом рутового доступа не было, что является очередной фишкой дефкона. То есть, трафик слушать возможности нет. Раз в 5 минут на sftp организаторы выкладывают для каждой команды дамп трафика с сервера команды. Задержка между моментом, когда игра началась, и, когда доступен первый дамп, составляет 15 минут. Все IP адреса в дампе рандомизированы, кроме адресов из подсети команды. Определить по адресам, с кем конкретно было установлено то или иное соединение (одна из команд или бот организаторов), невозможно.
Еще одна фишка — все сервисы даются в бинарном виде. Никаких исходников, никаких скриптов. Только binary, только hardcore. Может быть, когда-то и бывали исключения, но не в этот раз.
Архитектура процессора заранее не анонсируется. Можно было по прошлому году предположить, что будет ARM (в том году он был на DEF CON впервые), но достоверно это стало известно только в 9:30 первого дня.
Всего было заявлено 7 сервисов, но организаторы по ходу соревнований выложили только 5.
В начале первого дня на серверах команд было по 2 сервиса:
* eliza: изначально ELF 32-bit LSB shared object, Intel 80386, version 1 (SYSV), dynamically linked (uses shared libs), for GNU/Linux 2.6.24, not stripped. Запускался на машине на ARM ~~по-наркомански~~ через qemu-i386-aslr. Затем организаторы все-таки решили пересобрать и залили: ELF 32-bit LSB shared object, ARM, version 1 (SYSV), dynamically linked (uses shared libs), for GNU/Linux 2.6.32, not stripped.
* wdub: изначально ELF 32-bit LSB executable, ARM, version 1 (SYSV), statically linked, for GNU/Linux 2.6.32, stripped. Позже ELF 32-bit LSB executable, ARM, version 1 (SYSV), dynamically linked (uses shared libs), for GNU/Linux 2.6.32, stripped. Сервис представлял из себя веб-сервер.
Через несколько часов появился третий:
* imap: ELF 32-bit LSB shared object, ARM, version 1 (SYSV), dynamically linked (uses shared libs), for GNU/Linux 2.6.32, stripped. Сервис представлял из себя почтовый IMAP-сервер.
*CTF зона под конец первого дня*
Начальные уязвимости были достаточно простые. Например, для сервиса wdub можно было прочитать флаг запросом вроде этого:
`GET /../../../home/wdub/flag HTTP/1.0\r\n\r\n`
А в imap было достаточно хотя бы на один байт переполнить параметр команды SELECT. Тогда команда LIST отрабатывала на директорию выше, чем должна, и можно было увидеть все ящики (LIST "" \*) и сообщения (LIST "" \*/\*), а затем прочитать их с помощью FETCH.
Затем каждая команда получила вот такой бэйдж:
прошивку к нему и скрипт для заливки прошивки на бэйдж. Все бэйджи в CTF зоне общаются друг с другом по радиоканалу и пересылают сообщения, в числе которых флаги, которые заливают организаторы (как потом выяснилось, сообщения пересылались в открытом виде).
Цель, как и во всех других сервисах: найти уязвимость, закрыть ее у себя, проэксплуатировать на чужих бэйджах, прочитать флаги и сдать их. Если бэйдж выключен или в режиме отладки, то сервис считается в дауне, и SLA падает. К концу второго дня/началу третьего большинство команд забили на бэйдж, но команда [Routards добила его до конца](https://twitter.com/LegitBS_CTF/status/498865815215947776). Жаль, что они научились тащить флаги только к последнему раунду. Это реально круто.
**upd**: команда PPP на второй день написала эксплоит для бэйджа, но из-за ошибки организаторов получить очков с помощью него им не удалось:
*We would like to apologize to the two-year champions, PPP. An off-by-one error in our badger backend code made it impossible for team id 0 (PPP) to score correctly. They had a working exploit before the end of day 2, but were unable to score any points because of this.*
Во второй день появился еще один сервис:
* justify: ELF 32-bit LSB shared object, ARM, version 1 (SYSV), dynamically linked (uses shared libs), for GNU/Linux 2.6.32, stripped.
Организаторы обещали выложить все сервисы и прочий stuff типо проверяющей системы в сентябре. Для тех, кто заинтересовался, выкладываем [исходные версии бинарников](http://ctfcrew.org/sites/default/files/tools/services.tar_.gz).
#### Атмосфера
Атмосфера — что надо. Свет приглушен, лишних людей в помещении довольно мало, журналистов запускают пару раз в день сессиями по 15 минут, предварительно оповестив об этом все команды. На больших экранах организаторы постоянно включают всякие трэшовые клипы вроде:
* [DJ Snake & Lil Jon — Turn Down for What](https://www.youtube.com/watch?v=HMUDVMiITOU)
* [Major Lazer — Bubble Butt](https://www.youtube.com/watch?v=hR-NXv5Tma0)
* много [Lonely Island](https://www.youtube.com/user/thelonelyisland)
* много [Die Antwoord](https://www.youtube.com/channel/UC6DicDItkLQ7N4ag1JS5mqg)
* другие странные видео и песни и даже рэп от самого [Геохота](https://www.youtube.com/watch?v=Rba7qjb0378), пока он тащил за PPP!
На центральном экране сначала показывали scoreboard, а затем простенькую [визуализацию атак](https://www.youtube.com/watch?v=1UT3qXHduts) команд друг на друга.
В общем, время пролетало незаметно.
Небольшое видео, снятое в последние минуты CTF:
#### Результаты
| Place | Team | Score |
| --- | --- | --- |
| 1 | Plaid Parliament of Pwning | 11263 |
| 2 | HITCON | 7833 |
| 3 | Dragon Sector | 4421 |
| 4 | Reckless Abandon | 4020 |
| 5 | blue-lotus | 3233 |
| 6 | (Mostly) Men in Black Hats | 2594 |
| 7 | raon\_ASRT | 2281 |
| 8 | StratumAuhuur | 1529 |
| 9 | [CBA]9447 | 1519 |
| 10 | KAIST GoN | 1334 |
| 11 | Routards | 1262 |
| 12 | More Smoked Leet Chicken | 1248 |
| 13 | Binja | 1153 |
| 14 | CodeRed | 997 |
| 15 | w3stormz | 987 |
| 16 | [SEWorks]penthackon | 979 |
| 17 | BalalaikaCr3w | 937 |
| 18 | Gallopsled | 921 |
| 19 | shellphish | 899 |
| 20 | HackingForChiMac | 546 |
Мы закончили на 17-ом месте. Это, конечно, слабый результат, но пусть он станет отправной точкой для наших следующих финалов DEF CON CTF. Сделано много выводов, какие из наших внутренних инструментов нужно допилить, и каких инструментов нам не хватает.
Наши более опытные соотечественники More Smoked Leet Chicken (MSLC) заняли 12 место. Полагаю, что ребята собой тоже не очень довольны, ведь в том году они финишировали на четвертом.
Выигрывают второй год подряд американцы из команды Plaid Parliament of Pwning (PPP), которые традиционно для DEF CON выступают вместе с известным хакером Джорджем Хотцом (geohot), который знаменит своим опытом взлома iPhone (автор первых jailbreak'ов и unlock'ов) и судебными разбирательствами с Sony за jailbreak приставки PlayStation. Кому как не ему тащить на CTF, где все задания, кроме одного, на бинарную эксплуатацию под ARM. Хотя в июле он в составе своей комады tomcr00se выиграл финал SECUINSIDE CTF в Сеуле. Справедливости ради стоит подчеркнуть, что команда tomcr00se состоит из одного человека.
#### Впечатления
Исключительно положительные. На следующий год обязательно будем стараться пройти в финал и однозначно поедем, если пройдем. DEF CON CTF уникален. Это самый продолжительный по времени, самый престижный и, пожалуй, самый сложный CTF среди всех существующих. Я бы сравнил его с Олимпийскими играми для спортсменов. Это тот уровень, к которому нужно стремиться, и победа в DEF CON CTF — высшее из возможных достижений.
Было приятно увидеть старых знакомых и пообщаться с новыми.
За информацией по поводу следующего DEF CON CTF рекомендую следить на сайте [LegitBS](https://legitbs.net/).
Информация о предстоящих CTF и вообще обо всех событиях в CTF мире — на главном ресурсе всех команд [CTF TIME](https://ctftime.org/). | https://habr.com/ru/post/234191/ | null | ru | null |
# Герои прошлого и наши дни: тестирование AGP-видеокарты на более современной системе
— А ведь у меня есть такая плата, настоящий динозавр! — написал один из читателей предыдущей статьи, — поддержка 2-ядерных процессоров, 4 слота DDR-2 и уже исчезнувший в наше время порт AGP, — может быть, посадим на него твой HD3850 и попробуем покорить новые вершины?
В прошлый раз нам удалось запустить топовую видеокарту 10-летней давности на вышедшем уже из обихода интерфейсе AGP и протестировать в современных играх. ATI Radeon HD 3850, самая последняя и самая быстрая из вышедших видеокарт для этого разъема, была мечтой геймера в 2008 году. Предложенная читателем материнская плата имеет недостижимые для тех времен характеристики, и при всем при этом, она на 2 года младше видеокарты и была выпущена аж в 2006 году. Что же получится, если их соединить и протестировать в современных играх?
В прошлой статье [мы протестировали HD3850 AGP в приложениях и поиграли в игры](https://geektimes.ru/post/298621/). Я уже подумывал положить ее на хранение на полку, и мне было жалко, что у нас так и не получилось раскрыть весь ее потенциал.
А уже после один из читателей написал, что у него хранится как раз одна из экзотических плат, работающих сразу и с двухъядерным процессором, и AGP. Это настоящий Франкенштейн своего времени! Посудите сами: сокет AM2+, до 8 Гб памяти DDR-2 и при всем при этом имеющая порт AGP. Мне сразу стало интересно, как она покажет себя в связке с AGP Radeon HD 3850 512 Mb.
Вот так удача! Попробуем?
Предлагаю пройти весь путь максимального апгрейда и настройки невероятной системы 12-летней давности в связке самой быстрой из существующих AGP-видеокарт и попробовать ее в играх!
В поисках идеального «железа» для апгрейда
------------------------------------------
Когда, перед написанием прошлой статьи, мне в руки попала топовая из существующих AGP-видеокарт, HD 3850 512 Mb, я стал искать информацию о материнских платах, позволяющих запустить что-то современное и имеющих на своем борту интерфейс AGP. Поиски навели меня на несколько моделей, я в своей статье протестировал карту на одной из них, а уже в комментариях [WebFlyer написал](https://geektimes.ru/post/298621/#comment_10646655):
> ASRock выпускал франкенштейнов с поддержкой AGP — Одни из последних AM2NF3-VSTA под AMD Soket AM2+ (До Phenom II X4 Deneb включительно) и 775Dual-VSTA Под Intel LGA775 (до Conroe Core2Duo включительно)
Конечно, хорошо было бы достать одну из таких и посмотреть на работу HD 3850 с максимальной мощностью!
И вот, другой пользователь, [SunUp](https://geektimes.ru/users/SunUp/) и стал тем читателем (с аккаунтом Read and Comment), который предоставил на время свою материнскую плату **AM2NF3-VSTA**, за что ему большое спасибо!
Это материнская плата производства ASRock с сокетом AM2+, 4 слотами для оперативной памяти DDR2, чипсетом NVIDIA nForce3 250 и с портом AGP 8X.
Вот ее характеристики с официального сайта:
*Поддержка Socket AM2+ / AM2 процессоров: AMD Phenom FX / Phenom / Athlon 64 FX / Athlon 64 X2 Dual-Core / Athlon X2 Dual-Core / Athlon 64 / Sempron
Чипсет NVIDIA nForce3 250
Технологии Hyper-Transport и AMD Cool 'n' Quiet
Поддержка двухканальной DDR2 1066/800/667/533 (4 x DIMM) non-ECC, не буферизованная, максимальный объем — 16 Гб
ASRock AM2 Boost: Патентованная технология ASRock для увеличения производительности памяти до 12.5%
Untied Overclocking: более широкие допуски для FSB при оверклокинге благодаря фиксации шин AGP/ PCI
Hybrid Booster — технология безопасного оверклокинга ASRock
1 x AGP 8X*
Поддержка 2-ядерных процессоров Athlon X2!
### Комплект поставки из 2006 года
Когда SunUp дал мне эту плату, она была прямо в коробке.
В коробке лежали: диск с драйверами, плата, заглушка к ней и книжка с инструкцией.
Повторюсь, это модель 2006 года, вдумайтесь, как бережно он ее хранил!
К тому же, в придачу к плате прилагался процесор AMD Athlon 64 X2 6000+, то, что надо!
Попробуем повысить быстродействие до максимума
----------------------------------------------
Что можно собрать на ее основе? У нас уже имеется видеокарта для нее. Добавим прилагающийся процессор. Стоп… Давайте еще раз обратим внимание на характеристики из списка поддерживаемых процессоров.
У некоторых плат с AM2+ есть поддержка работы с процессорами уже на сокете AM3. Так оказалось и в этот раз — несмотря на то, что на главной странице в ее описании это не указано, плата может работать с четырехъядерными процессорами Athlon 2 X4 и Phenom 2 X4.
У AMD есть такая фишка — обратная совместимость сокетов, когда некоторые процессоры более старшей модели могут работать на материнских платах с процессорным разъемом предыдущего поколения.
Поэтому, побродив по просторам Авито, я нашел к ней процессор AMD Athlon 2 X4 с частотой 3000 МГц. Уже лучше! Поищем память. Я нашел у себя 4 модуля DDR2 по 2 Гб. Итак, процессор, память и жесткий есть, начнем сборку.
Сборка тестовой системы
-----------------------
Ставим процессор, 8 Гб памяти, видеокарту. В качестве ОС для начала я выбрал Windows 7.
Устанавливаем систему… Все ок, все драйвера уже есть на прилагаемом диске. Осталось установить драйвер для HD 3850.
*Признаки старой платы*
У материнской платы разъем питания — еще 20 pin, а не 20+4, как сейчас.
При нажатии кнопки включения на радио раздаются помехи в FM-диапазоне. Если вы слушаете в этот момент радио, оно, скорее всего, будет заглушаться. Новые платы уже этим не грешат.
У платы всего 2 разъема SATA первого поколения.
*Первое препятствие*
Сколько я не пытался найти драйвер для Windows 7, у меня это не получилось. Драйвера нигде не было, от XP не подходил. Windows работал в режиме 800х600 и показывал ошибку 43.
Я стал искать информацию, как же обойти ошибку 43, и наткнулся на [форум](https://forums.overclockers.ru/viewtopic.php?p=7699286), где один из пользователей привел ссылку на особенности поддержки видеокарт этой материнкой:
[www.asrock.com/support/note/AM2NF3-VSTA.html](http://www.asrock.com/support/note/AM2NF3-VSTA.html)
> ATI AGP Card (Windows XP 64-bit / Vista 32-bit / Vista 64-bit):
>
> Under Windows Vista 32-bit / Vista 64-bit OS, this motherboard does not support ATI AGP card because NVIDIA does not provide nForce3 250 relevant driver for Windows Vista OS.
>
> \* AGP texture acceleration will be disable under Windows XP 64-bit OS.
Что в переводе значит:
> AGP-карты ATI (Windows XP 64-bit / Vista 32-bit / Vista 64-bit):
>
> Под OC Windows Vista 32-bit / Vista 64-bit материнская плата не поддерживает AGP-карты ATI, потому что NVIDIA не предоставила подобающий драйвер для чипсета nForce3 250 для ОС Windows Vista.
>
> \*Аппаратное ускорение текстур AGP под Windows XP 64-bit будет отключено.
Пожалуйста! Покупайте нашу супер крутую материнскую плату, но половину хороших видеокарт вы в нее поставить не сможете. И об этом нет ни одного упоминания на главной странице с описанием платы на сайте производителя. Однако, NVIDIA, не сделав поддержку в Windows Vista (а, следовательно, и в последующих) для видеокарт ATI, снабдила ее поддержкой своих собственных видеокарт.
Надо сказать, что тогда был пик противостояния ATI и NVidia. Тогда у них случались жестокие схватки, как за сердца покупателей, так и громкие разборки в судах за патенты. Я думаю, это отголосок событий того времени.
Да и под Windows XP устанавливаются через небольшой танец с бубном: сначала надо установить драйвер NVidia GART, а только потом уже драйвер видеокарты. При установке же этого дополнительного драйвера на Windows 7, ОС «сваливается» в синий экран.
То есть, в остатке получается, что с этой и моим Radeon можно пользоваться только под Windows XP, даже не 64-битной. В XP максимальная версия DirectX — 9c, поэтому фокуса с запуском GTA 5, как в предыдущей статье, тут не получится.
*(зацените музыку в видео)*
Но как же 8 гигабайт оперативной памяти? Плата абсолютно не приспособлена для комфортной работы с любыми из видеокарт ATI!
### Как же добиться нужной производительности?
Я стал размышлять. Видеокарта у меня ATI, поддержки Vista нет. Значит, не будет DirectX 10. Нет поддержки 64-битных систем, а это только 3.5 Гб оперативки из тех 8, что у меня есть.
В комментариях [x86d0cent писал по этому поводу](https://geektimes.ru/post/298621/#comment_10648003):
> В общем случае не обязательно — это решается также при помощи PAE. Т.е. можно поставить Linux (как минимум Left4Dead 2 и Team Fortress 2 точно есть под SteamOS) или Win2003, либо прикрутить к XP.
PAE — это уже один вариант. Но хотелось бы протестировать 64-битную операционную систему. Постойте, а ведь в ограничениях на сайте производителя ничего не сказано про Windows 2000 и 2003 Server! Что если попробовать на них?
Выбираем операционную систему
-----------------------------
### Windows XP
Для того, чтобы система «увидела» все 8 Гб оперативки, вначале я попробовал, прокатит ли расширение физических адресов PAE в Windows XP. Сколько я не пытался, но Windows ХР, хоть и писал в свойствах системы про PAE, отказывался видеть больше 3Гб памяти.
Позже я наткнулся на статью о том, как добавить PAE в Windows XP, вот она:
<https://geektimes.ru/post/202406/>
Если вкратце, то для этого нужно заменить несколько файлов, архив там прилагается.
Я сделал все, как в ней было написано, скачал файлы, заменил, но в моем случае получался только неизбежный Blue Screen.
#### Еще один вариант
Вторым вариантом, по комментариям к той же статье, было создание из неиспользуемой памяти виртуального диска и перенос на него файла подкачки. Я установил SuperSpeed RamDisk Plus и пробовал это сделать.
Однако все, что меня ждало — только все тот же синий экран. Возможно, с другими программами и получилось бы, но на попытки у меня и так ушло уже слишком много времени. Про 8 гигабайт на Windows XP придется забыть.
#### Тест производительности
**3D Mark 06**
<https://www.3dmark.com/3dm06/18027499>
**3D Mark 03**
<https://www.3dmark.com/3dm03/6537093>
**Aida64**
CPU Queen
CPU PhotoWorxx
CPU Hash
### Windows 2000 Server
Следующей я попробовал Windows 2000. Здесь я включил PAE без проблем, просто дописал в Boot.ini
```
/PAE
```
ОС увидела 7.339 Гб оперативной памяти. Однако установить драйвер на видеокарту не удалось: ни один из существующих не подходил.
Когда я стал устанавливать драйвер для видеокарты, то понял, насколько система Windows 2000 устарела: даже с последним обновлением под ней не запускаются почти никакие современные программы.
Никакой софт не запускаются, видеокарту не установишь, Windows 2000 нам не подходит.
### Windows 2003 Server
Когда-то, во время выхода Windows XP мне эта система понравилась гораздо больше, чем сам XP: в ней не было ненужных украшательств, к тому же, она работала стабильнее, без непонятных сбоев, которыми грешили XP первых версий, и, как мне казалось, быстрее. Поэтому я ей пользовался как основной ОС на своем компьютере.
Для этого компьютера я скачал облегченную сборку 2003 Lopatkin с уже включенным PAE.
Система увидела уже все 8 гигов. Поставил предварительный драйвер GART, затем стал устанавливать драйвер видеокарты, для этого я подставил видеодрайвер от ХР. Получилось.
Итого, у нас есть система с работающей видеокартой, одним из топовых четырехъядерных процессоров для этой платы и 8 гигабайтами оперативки.
А теперь сделаем то, что я так давно мечтал сделать в то время, но не мог из-за системных ограничений: отключаем SWAP-файл. Быстродействие становится значительно выше, наконец-то исчезают эти нескончаемые обращения к жесткому диску!
Если эту операционную систему настроить должным образом, то она занимает меньше оперативной памяти, чем XP. Всего лишь нужно было удалить ненужные в повседневном использовании компоненты и отключить неиспользуемые службы, а еще я обычно отключал все графические элементы интерфейса, чтобы работало побыстрее. К тому же, не все знают, но на этой серверной ОС можно и играть в 3D-игры. Для этого, правда, придется поменять некоторые настройки.
> После установки видеодрайвера в Свойствах экрана, во вкладке Дополнительно, надо включить аппаратное ускорение на «Полное». Затем перезагрузить компьютер, в командной строке набрать DxDiag и там, во вкладке Экран включить ускорение DirectDraw. Также,
>
> в Windows 2003 иногда необходимо включить службу звука, а без этого звука не будет,
>
> и регулятор громкости в трее будет неактивным.
Теперь можно запускать трехмерные приложения.
#### Тест производительности
Попробуем для начала **FurMark**. Вот результат теста:
Под Windows XP результат почти ничем не отличается.
**3DMark 06**
<https://www.3dmark.com/3dm06/18029130>
Когда эта видеокарта только вышла, я ходил по радиорынкам и наблюдал, как работает 3DMark 2006 на разных видеокартах прямо у продавцов за витринами. И я нигде не видел, чтобы у кого-то в то время 3DMark работал так плавно, как на моей системе сегодня.
**Geekbench 2**
<http://browser.geekbench.com/geekbench2/2653859>
Почему-то Windows 2003 определяется как Windows XP, впрочем, в 3DMark 06 тоже.
А что если попробовать 64-битную Windows 2003? А вдруг...?
Устанавливаем.
### Windows 2003 64-бит
Характеристики процессора под 64-битной Windows 2003
**Для сравнения с процессорами из предыдущих тестов этой видеокарты**
**Pentium D 3.4 ГГц**
**Pentium 4 524, разогнанный до 3.74 ГГц**
Ставим предварительный драйвер, затем подменяем драйвер видеокарты на драйвер от 64-битной XP — вроде бы, ставится. Видеокарта определилась, устанавливаем человеческое разрешение.
Про 64-битную систему в описании производителя, как я уже написал, сказано:
> \*Аппаратное ускорение текстур AGP под Windows XP 64-bit будет отключено.
Включаем аппаратное ускорение в Свойствах экрана, ставим DirectX. И вуаля!
Видимо, производитель забыл отключить поддержку HD3850 в 64-битных Windows 2003. В списке ограничений именно эта модель карты не указана. Правда, толку от этого все равно мало. Производительность 3D-приложений в 64-битной системе оказалась гораздо ниже, чем в 32-битной.
#### Тест производительности
**3DMark 06**
<https://www.3dmark.com/3dm06/18029308>
А может, заработает и в 64-битной XP?
Я установил Windows XP 64-bit, и там все повторилось. 8Гб видятся, драйвера ставятся, но вот только производительность опять низкая, точно такая же, как и в 64-битной 2003 Server.
### SteamOS
SteamOS просто не установилась. Не получилось ее установить ни с флешки, ни с компакт-диска. Установка просто останавливалась или зависала.
Что ж, для тестирования нашей системы в играх остановимся на 32-битной Windows 2003 с включенным режимом PAE.
В итоге у нас получилась довольно современная система:
*Процессор: AMD Athlon 2 X4 3000 МГц
Оперативная память: 8 Гб DDR2 в двухканальном режиме
Видеокарта: Radeon HD3850 512Mb AGP
Жесткий диск: SSD 16 Гб (я брал несколько жестких дисков для установки на них разных ОС)
Блок питания: 500 Вт*
Правда ОС устаревшая, только лишь Windows 2003 Server.
Тестирование в играх
--------------------
#### Left4Dead 2
Даже на максимальных настройках FPS доходит до 60, и играть вполне комфортно!
В Team Fortress 2, который тоже сделан на движке Source, ситуация такая же, но FPS на максимальных возможных настройках доходит до 40-45. Тоже вполне комфортно играть. Напомню, на предыдущей материнской плате частота кадров в секунду была существенно ниже. Сказалась более высокая скорость процессора.
#### World of Tanks версии «Обновление 1.0»
Игра запускается, но Windows XP поддерживает только DirectX 9, поэтому стандартные настройки графики «Улучшенные» и «Освещение и постобработка» заблокированы.
*Второе препятствие*
Игру можно запустить только на настройках «Стандартные». В прошлой статье у нас работал DirectX 10, и поэтому все настройки там работали.
Покопавшись в Сети, я наткнулся на одну статью, где кто-то уже выходил из этой ситуации. Для этого он установил игру на современный компьютер выставил в игре нужные настройки графики, скопировал из нее файл «preferences.xml» и подменил его на своей системе. Я проделал то же самое, и все получилось.
Настройка «Улучшенная» затемнена. Ну и ладно, потестируем игру с такими параметрами на высоких настройках.
Игра показывает 35-55 FPS, что вполне играбельно! В обновлении внедрено отличное улучшение графики, и быстродействие на высоте. У игры неплохая оптимизация, и она неплохо шевелится даже для не очень быстрых игровых системах.
#### Kerbal Space Program
Все вполне играбельно на средних настройках
В открытом космосе, при отсутствии других поверхностей и предметов, FPS довольно высокий.
Во все эти игры можно вполне комфортно играть на средних и высоких настройках. 3D-приложения больше всего тормозят при включении опции Antialiasing. Правда, честно говоря, особой разницы после включения этого параметра я своим глазом не вижу. Мне кажется, что в игре как будто просто снижается быстродействие, при почти полном отсутствии визуальных изменений. Ребята, скажите, вы действительно в DirectX 9 и 10 визуально отличаете Antialiasing X4 от X8 или это просто такая моя особенность? Хотя, в то время все старались купить видеокарту с поддержкой сглаживания X4 или X8 и утверждали, эта опция вносила разительные изменения в графику.
Дополнительные тесты, которые запускаются только на 64-битных ОС
----------------------------------------------------------------
Из «новой» материнской платы, процессора и Radeon HD 3850 получилась игровая система начального уровня и неплохой рабочий компьютер.
А вот [еще мнение](https://geektimes.ru/post/298621/#comment_10648533), как можно применить эту видеокарту:
> У меня в старом компе стоит HIS Radeon HD 4670 IceQ AGP (1Gb). Всё время считал что это самая быстрая карта с AGP. Кстати, насколько я помню, в свое время эта карта была даже в списке рекомендованных для майнинга биткоинов, причём единственная с AGP.
На Windows XP ни одна программа для майнинга не запустилась, но я специально для этого поставил ее на старую материнскую плату и Pentium-D, установил Windows 7 64-бит и попробовал помайнить.
К сожалению, как я ни пытался комбинировать драйверы, компоненты системы и т. д., мне не удалось включить поддержку OpenCL, хотя в характеристиках этой карты и указана поддержка OpenCL 1.0. Поэтому все майнеры или не запускаются, или показывают отсутствие поддержки OpenCL. Однако майнер MinerGate запустился и вот что он показал.
GPU Mining, как и в других, «Not supported device»
В дополнение я приведу несколько тестов и игр, для которых пришлось также нужен только Windows 64-бит, начиная с Windows Vista. Все это запущено на процессоре Pentium D 3.4 ГГц.
### Игры на материнской плате с Pentium D 3.4
#### Subnautica версии 2018 года
На минимальных настройках и 1920х1080 вполне играбельна, но показывает нехватку системных ресурсов (еще бы, плата с Pentium D поддерживает всего 2 Гб оперативной памяти)
#### Metro 2033 Last Light Redux
Разрешение 1280х800, настройки графики минимальные.
FPS примерно 20-35
На открытых местностях FPS проседает, а в коридорах с ним все в порядке
#### Тест производительности
**3DMark 06 на Pentium D**
<https://www.3dmark.com/3dm06/18028389>
**Passmark 9**
<https://www.passmark.com/baselines/V9/display.php?id=99559517724>
**Geekbench 4**
<https://browser.geekbench.com/v4/cpu/7534268>
Что же в итоге?
---------------
В итоге у нас получился игровой компьютер начального уровня. Не все игры запускаются, но в те, которые на нем идут, можно играть вполне комфортно. Эх, если бы не ограничение с драйверами под ОС выше Windows XP! Из этого я могу сделать вывод, что в то время топовую видеокарту было очень сложно «раскрыть». Или приходилось ограничиваться одноядерными процессорами, или 2 гигабайтами оперативной памяти, или же, как в моем случае, только лишь устаревшими операционными системами.
Поэтому желающим поковыряться с такой видеокартой можно посоветовать делать это чисто из спортивного интереса.
Или же, если хотите попытаться…
То вам придется столкнуться с:
1. Отсутствием драйверов для подобного оборудования для новых ОС
2. Поиском подходящего вам дополнительного «железа»
3. Поиском всевозможных переходников для нужных разъемов
4. Отсутствием ПО для устаревших операционных систем типа Windows XP и 2003 Server: например, Google Chrome на них уже не установится, Skype тоже, и придется искать его старую версию и так далее. Новое ПО будет постоянно показывать ошибки во время установки и работы.
5. Бесконечным поиском нужных компонентов и установкой обновлений для операционных систем при установке современного ПО
6. К смене системы охлаждения, смазке ее компонентов и замене термопасты везде, где только можно
7. Возможно, что-то из решений, найденных в этой статье, вам поможет. И воспользуйтесь советом мудреца из предыдущей статьи
**Мудрость шамана**
Однажды, когда одному из индейцев нужно было срочно сделать разметку земли для всех жителей своей деревни, он сел за свой ноутбук, подаренный его мамой два года назад. Однако ноутбук работал медленно, а индеец не успевал выполнить работу до восхода луны.
— Что же делать? — спросил он у соседей по деревне. — Я не хочу покупать новый ноутбук в нашем деревенском магазине. Ведь ему еще не так много зим! Это обдиралово.
— Иди к шаману, — сказали соседи, — Он познал мудрость, позволяющую довольствоваться малым.
Пришел индеец к шаману и взмолился:
— Подскажи, как мне сделать работу в срок, не покупая новый ноутбук!
Подумал шаман, нахмурил брови и сказал:
— Ты пробовал ставить SSD?
— Нет.
— Поставь, и можешь пользоваться своим ноутбуком, пока самому не надоест!
Пошел индеец в магазин и выменял там SSD-диск всего на пять килограмм шерсти своей альпаки. Он остался доволен работой своего компьютера, пользовался им еще много лет и хвалил мудрость шамана их деревни.
При оживлении подобных устаревших компонентов всегда нужно набраться терпения, взять бубен и приготовиться к неустанным танцам. | https://habr.com/ru/post/410805/ | null | ru | null |
# Новые директивы HTTP для кеширования с учётом CDN
[](https://xkcd.com/1854/)*(с) [xkcd](https://xkcd.com/1854/)*
В данный момент на рассмотрении IETF находятся два стандарта. Это новые поля в заголовке ответа HTTP: **[Cache-Status](https://datatracker.ietf.org/doc/draft-ietf-httpbis-cache-header/)** и **[таргетированный Cache-Control](https://datatracker.ietf.org/doc/draft-ietf-httpbis-targeted-cache-control/)**.
Новые поля должны упростить разработку веб-приложений, а именно: упорядочить кеширование статического контента. Сейчас с этим небольшой бардак, поскольку кеширование происходит в нескольких системах на нескольких уровнях, почти как в этом ↑ комиксе. А синхронизировать все уровни непросто, ведь текущие стандарты разрабатывались в те времена, когда ещё не существовало CDN.
Владелец любого сайта с более-менее приличным трафиком знает, что кеширование *кардинально* улучшает производительность. Кеш и CDN стоят перед сервером и быстро отбивают большинство запросов, не трогая бэкенд. Это решает массу проблем. Во-первых, сглаживаются скачки трафика, потому что статический кеш масштабируется проще, чем сервер приложения. Во-вторых, на порядок уменьшается количество обращений к серверу, и они поступают пачками, а не по одному. Наконец, в CDN контент физически распределяется по всему миру, уменьшая задержку для пользователей из любого региона.
Кеш снимает с сервера до 99% нагрузки. В результате стоимость хостинга может упасть до смехотворной величины. Например, известный специалист по безопасности Трой Хант платит за облачный хостинг своего популярного сайта [Pwned Passwords](https://haveibeenpwned.com/Passwords) (базы утёкших паролей) [меньше 3 центов в день](https://www.troyhunt.com/serverless-to-the-max-doing-big-things-for-small-dollars-with-cloudflare-workers-and-azure-functions/), а у него 19 ГБ файлов и 34,4 млн запросов к API в неделю (правда, это статистика за 2018 год, с тех пор размер баз наверняка вырос). Как видно на скриншоте, из 32 408 715 запросов к API только 122 566 пошли на сервер, а остальные 99,62% получили результат из кеша.
Конечно, такой высокий результат во многом объясняется спецификой сайта. Здесь исключительно статичный контент, а большинство запросов приходит через API от приложений, куда встроена проверка паролей на предмет утечки, чтобы оперативно информировать пользователей.
Кроме количества запросов, CDN на порядок снижает трафик с сервера. В данном случае общий трафик за неделю составил 477,63 ГБ, в том числе оплаченный трафик с облака — всего 945,96 МБ. Теперь понятно, почему хостинг обходится ему так дёшево.
Уровни кеширования
------------------
Так в чём проблема? Казалось бы, существующие механизмы кеширования работают отлично, на порядок ускоряют загрузку контента пользователям и экономят кучу денег на хостинге.
Но проблема в *сложности* существующих технологий. Кеширование по факту происходит в несколько уровней и осуществляется по-разному для различных путей поступления запроса.
Скажем, непосредственно перед бэкендом обычно работает какой-то балансировщик нагрузки, обратный прокси или гейт для обработки API-запросов с собственным кешем. В то же время сам сервер на бэкенде тоже кеширует некоторые внутренние данные.
Дополнительно на дальнем уровне обычно работает CDN-провайдер типа Cloudflare, который раздаёт контент пользователям через свою сеть серверов. Свои кеширующие прокси могут стоять также у интернет-провайдера или в корпоративной сети.
Наконец, кешированием занимаются и многие клиенты, особенно браузеры, зачастую с несколькими уровнями кеширования у себя внутри, как сервис-воркеры, что только добавляет путаницы.
Кто-то может сказать, что чем больше разных кешей — тем лучше. Ведь даже на системном уровне есть три уровня кешей процессора, кеш в памяти, на SSD и так далее. На каждом уровне свои кеши. Всё правильно, но в веб-сервисах иногда получается так, что эти кеши находятся *на одном уровне*, дублируют и мешают друг другу, затрудняя настройку сбалансированной системы. Каждому кешу нужна отдельная конфигурация, а головная боль разработчика — инвалидация кеша, чтобы максимально быстро доставить новый контент к пользователю, «пробив» все уровни кешей.
Проблемы с инвалидацией кеша
----------------------------
Инвалидация или очистка кеша — удаление всех закешированных объектов, связанных с изменениями в состоянии модели. Наиболее распространённый тип инвалидации — прямое удаление объектов. Но если мы имеем дело с пятью или десятью уровнями кеша на пути от бэкенда к конечным пользователям, то гарантировать инвалидацию не так просто.
Тут поджидает целый ряд скрытых угроз: из-за некорректной инвалидации мы можем просто поломать механизм кеширования, так что ничего не будет кешироваться вообще — и 100% запросов хлынут на бэкенд (как вариант, контент будет сохраняться только в локальном кеше, но не в CDN). Или, наоборот, ответы сохранятся там дольше, чем положено, а пользователям будет отгружаться устаревший контент. Из-за нескольких уровней кеширования может получиться так, что клиенты начнут получать смесь из новой и старой информации.
И главное, что сама конфигурация кеша из заголовка [Cache-Control](https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Cache-Control) тоже кешируется, что может привести к большим трудностям в инвалидации.
Новые стандарты призваны всё это исправить.
Итак, что же предлагает Марк Ноттингем с соавторами новых спецификаций? Если кто-то не знает, Марк Ноттингем — очень авторитетный специалист, один из самых известных разработчиков инфраструктуры современного веба, входил в группу технической архитектуры W3C и в настоящее время является членом Совета по архитектуре Интернета.
Cache-Status
------------
Спецификация [Cache-Status](https://datatracker.ietf.org/doc/draft-ietf-httpbis-cache-header/) определяет новое поле заголовка ответа HTTP со стандартизированным синтаксисом и семантикой для всех уровней кеширования, упомянутых выше.
Это поле показывает, каким образом система кеширования обработала данный ответ и соответствующий ему запрос. Синтаксис по стандарту [RFC8941](https://www.rfc-editor.org/rfc/rfc8941) (структурированные поля для HTTP, то есть точка с запятой между параметрами, запятая между кешами) и представляет собой список:
```
Cache-Status = sf-list
```
Каждый член списка — это одна из систем кеширования, которая обработала пакет по ходу его маршрута. Все они перечислены в порядке от бэкенда до пользователя (возможно, включая кеш самого агента пользователя, если он добавляет значение).
Примеры из [спецификации](https://datatracker.ietf.org/doc/draft-ietf-httpbis-cache-header/):
```
Cache-Status: OriginCache; hit; ttl=1100,
"CDN Company Here"; hit; ttl=545
```
(два уровня кеша, где OriginCache ответил на предыдущий запрос с сохранённым значением, а CDN сохранил этот ответ и повторно использовал его для ответа на текущий запрос)
```
Cache-Status: Nginx; hit
Cache-Status: CDN; fwd=uri-miss; collapsed; stored
Cache-Status: BrowserCache; fwd=uri-miss
```
(здесь три уровня, два из которых пропустили запрос мимо кеша из-за отсутствия данного URI, а Nginx ответил из кеша)
Для каждого кеша спецификация предусматривает ряд параметров:
> `* **hit** — параметр означает, что данный ответ пришёл из кеша, а оригинальный запрос дальше не передаётся
> * **fwd='reason'** — это значит, что запрос передан дальше, с указанием причины (bypass, miss, uri-miss, vary-miss и другие, подробнее см. раздел 2.2 в спецификации)
> * **fwd-status='status'** — указывает код fwd от предыдущего сервера
> * **ttl** — оставшееся время жизни ответа
> * **stored** — при наличии параметра fwd указывает, сохранён ли этот ответ на будущее
> * **collapsed** — при наличии параметра fwd указывает, был ли запрос объединён с другим запросом, в случае положительного статуса можно повторно использовать ответ
> * **key** — специфический ключ кеша, для внутренней реализации в разных приложениях
> * **detail** — дополнительная информация, которая не охвачена другими параметрами в строке`
Согласно спецификациям, каждый кеш самостоятельно определяет, добавить ли ему поле заголовка `Cache-Status`. Некоторые могут добавлять его во все ответы, а другие могут делать это только тогда, когда специально настроены на это или когда запрос содержит поле заголовка, активирующее режим отладки.
Стирать предыдущие строки запрещено, чтобы можно было отладить всю цепочку кешей, обрабатывающих запрос.
Зачем это нужно?
Поле `Cache-Status` вносит ясность и порядок во всю систему многочисленных кешей на пути HTTP-ответа. Сразу видно, пакет идёт от сервера или из кеша. Если из кеша, то из какого именно, как долго там будет храниться этот контент. Если не из кеша, то почему произошёл промах и сохранился ли в кеше этот новый ответ.
Это поле рассказывает всю историю пакета и всех кешей, через которые он прошёл, что исключительно полезно при отладке.
### Таргетированный Cache-Control
Второй предлагаемый стандарт гораздо проще. Это улучшенная версия существующего заголовка `[Cache-Control](https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Cache-Control)`, который был разработан 20 лет назад и уже не удовлетворяет требованиям времени.
`Cache-Control` — это список прямых инструкций кеширования, которые задаются сервером для запросов и ответов. Например, список инструкций для запросов:
```
Cache-Control: max-age=<секунд>
Cache-Control: max-stale[=<секунд>]
Cache-Control: min-fresh=<секунд>
Cache-Control: no-cache
Cache-Control: no-store
Cache-Control: no-transform
Cache-Control: only-if-cached
Cache-Control: immutable
Cache-Control: stale-while-revalidate=
```
Инструкции для ответов:
```
Cache-Control: must-revalidate
Cache-Control: no-cache
Cache-Control: no-store
Cache-Control: no-transform
Cache-Control: public
Cache-Control: private
Cache-Control: proxy-revalidate
Cache-Control: max-age=<секунд>
Cache-Control: s-maxage=<секунд>
```
… и другие.
Все они хорошо известны разработчикам. Проблема в том, что эти инструкции «слепые» и направлены *всем* кешам одновременно, что в наше время не очень эффективно.
[Таргетированный Cache-Control](https://datatracker.ietf.org/doc/draft-ietf-httpbis-targeted-cache-control/) просто указывает, какой конкретно системе предназначены инструкции. Например, можно обновлять контент только для запросов во внутренний балансировщик нагрузки, но не в CDN. Или включить кеширование объекта только в CDN, но в других внешних системах. Естественно, все они должны поддерживать эти новые спецификации, чтобы выполнять таргетированные инструкции.
Небольшое отличие в синтаксисе. Здесь предлагается использовать синтаксис структурированных полей (`;` и `,`), такой же, как в предыдущем поле.
Примеры:
```
Cache-Control: max-age=60, s-maxage=120
CDN-Cache-Control: max-age=600
```
(инструкция для CDN: считать ответ свежим 600 секунд, другим общим кешам — 120 секунд, а всем остальным — 60 секунд)
```
CDN-Cache-Control: max-age=600
Squid-Cache-Control: max-age=60
Cache-Control: no-store
```
(разрешение на кеширование *только* в CDN и Squid, больше никому)
В данном виде спецификация предусматривает только одну «цель» для таргетирования — это CDN. То есть директива `CDN-Cache-Control` относится ко всем CDN. Но в будущем в спецификации могут добавить другие классы систем. Например, ISP-провайдеров, браузеры или корпоративные сети.
Разумеется, выполнять директиву `CDN-Cache-Control` может только тот CDN, который понимает эту спецификацию.
Принятие индустрией
-------------------
Черновики этих стандартов были опубликованы только в июле и августе 2021 года, они ещё совсем свежие. В ближайшее время посмотрим, как индустрия их примет. Пока [есть](https://github.com/squid-cache/squid/commit/5fdc549054b11eb8bbc7e9640d6d071fa1ef742b) только [первые](https://github.com/caddyserver/cache-handler#readme) [примеры](https://gist.github.com/mnot/74ba8ed638a3d85659aa2868b9240d50) поддержки `Cache-Status`.
Кроме того, Cloudflare и Akamai поддерживают общий для них `CDN-Cache-Control`, а также отдельные `Akamai-Cache-Control` и `Cloudflare-CDN-Cache-Control`. То есть это уже работает.
По идее, `Cache-Status` должен объединить в себе поля ответа HTTP всех существующих провайдеров, которые зачастую несовместимы между собой, такие как [X-Cache-Status](https://support.cpanel.net/hc/en-us/articles/4402904983703-How-to-add-the-X-Cache-Status-header-to-NGINX-to-assist-with-optimizing-and-troubleshooting-cache-settings) от Nginx, [CF-Cache-Status](https://developers.cloudflare.com/cache/about/default-cache-behavior#cloudflare-cache-responses) от Cloudflare, [X-Served-By](https://developer.fastly.com/reference/http/http-headers/X-Served-By/) и [X-Cache](https://developer.fastly.com/reference/http/http-headers/X-Cache/) от Fastly и другие. Будем надеяться, что все они постепенно перейдут на `Cache-Status` и мы не получим ситуацию как в [другом комиксе xkcd](https://xkcd.com/927/) со стандартами.
*Обсуждение `Cache-Status` и [таргетированного Cache-Control](https://datatracker.ietf.org/doc/draft-ietf-httpbis-targeted-cache-control/) продолжается. Можно вносить предложения в [гитхабе](https://github.com/httpwg/http-extensions/blob/main/draft-ietf-httpbis-targeted-cache-control.md) рабочей группы IETF HTTP.*
---
НЛО прилетело и оставило здесь промокоды для читателей нашего блога:
— [15% на все тарифы VDS](https://firstvds.ru/?utm_source=habr&utm_medium=article&utm_campaign=product&utm_content=vds15exeptprogrev) (кроме тарифа Прогрев) — **HABRFIRSTVDS**.
— [20% на выделенные серверы AMD Ryzen и Intel Core](https://1dedic.ru/?utm_source=habr&utm_medium=article&utm_campaign=product&utm_content=coreryzen20#server_configurator) — **HABRFIRSTDEDIC**.
Доступно до 31 декабря 2021 г. | https://habr.com/ru/post/592301/ | null | ru | null |
# Разработка команды запроса данных из базы — часть 4, завершающая
Это продолжение истории, которая началась [здесь](https://habr.com/ru/post/436228/), а продолжалась [здесь](https://habr.com/ru/post/436348/) и [здесь](https://habr.com/ru/post/436546/).
В прошлой части я написал интеграционный тест, демонстрирующий процесс инициализации и выполнения полного набора обработчиков, извлекающих данные из базы. Но поскольку от написания этого теста, до его запуска, может пройти слишком длительное время, необходимое для кодирования не только обработчика, но и правил настройки для всех необходимых запросов к базе, то сегодня я решил реализовать его модульную версию, расчитанную на конфигурирование и запуск всего одного обработчика. Выглядит это тест вот как:
```
describe('requestHandler', () => {
const createStore = require('redux').createStore;
const reducers = require('../../src/reducers.js');
const DbMock = require('../mocks/DbMock');
const db = new DbMock();
const rules = require('../../src/rules');
const dbRequest = require('../../src/storage/dbRequest');
let request = null,
store = null,
context = null;
beforeEach(() => {
store = createStore(reducers);
context = {
db,
store,
rules
};
request = dbRequest.bind(context, [ 'user' ]);
expect(store.getState().user).toBeNull();
expect(store.getState().error).toEqual([]);
});
it('should get user from database', (done) => {
const assert = checkUser.bind(context, [ done ]);
store.subscribe(assert);
store.dispatch({type: 'NOTE', note: { Id: 1, UserRecordId: 1 }});
request();
});
function checkUser(args) {
const state = store.getState();
if(state.user === null)
return;
const user = state.user;
expect(user.Id).toEqual(1);
expect(user.Name).toEqual('Jack');
const checkIsCompleted = args[0];
checkIsCompleted();
}
});
```
Запускаю тесты и получаю сообщение о том, что модуль с правилами не найден. Еще раз, что нужно будет обработчику извлекать из правил?
1. Наименование ключа свойства контейнера состояния, к которому будет привязываться полученная из базы данных запись
2. Наименование таблицы базы данных, из которой нужно будет извлечь запись
3. Метод, формирующий запрос, который нужно будет послать базе данных, чтобы получить ответ
4. Метод-диспетчер, отправляющий полученную из базы запись хранилищу контейнера состояния.
5. Метод-диспетчер, отправляющий ошибку, если таковая произойдет, хранилищу контейнера состояния. Я решил сначала консолидировать ошибки в контейнере состояния, а потом уже разбираться с ними.
Набор правил представляется мне словарем (`Map`), в котором ключом будет имя свойства контейнера состояния и я пожалуй сформулирую первый модульный тест:
```
describe('rules', () => {
const rules = require('../src/rules');
it('should contain user rules', () => {
const rule = rules.get('user');
expect(rule.table).toEqual('users');
});
});
```
Запускаю тесты и `Jasmine` сообщает мне что теперь у меня два невыполняющихся теста. Чтобы не усложнять задачу, начну с простейшего правила, которое сообщает мне что для присвоения значения ключу `user` контейнера состояния, моему запросу следует обращаться за данными в таблицу `users`. Вроде бы все логично. Напишу как мне кажется немного кода.
```
const makeRules = () => {
const rules = new Map();
rules.set('user', { table: 'users' });
return rules;
};
module.exports = makeRules();
```
Запускаю тесты, и вижу что падает лишь тест для моего обработчика, хотя ошибка сейчас другая. Впрочем к этому тесту я вернусь позже, когда у меня будет готово хотя бы одно полное правило в моем словаре.
Немного доработаю тест словаря правил. Добавлю код, который проверяет наличие метода-диспетчера, обрабатывающего ошибку выполнения запроса к базе:
```
describe('rules', () => {
const rules = require('../src/rules');
it('should contain user rules', () => {
const rule = rules.get('user');
expect(rule.table).toEqual('users');
expect(rule.onError.name).toEqual('dispatchError');
expect(typeof rule.onError).toEqual('function');
});
});
```
Выполняю тесты, убеждаюсь что у меня снова два неисправных теста, и возвращаюсь к доработке кода фабричного метода для генерации словаря правил. Добавляю в литерал объекта первого правила функцию:
```
const makeRules = () => {
const rules = new Map();
rules.set('user', {
table: 'users',
onError: function dispatchError(error, store) {
const action = { type: 'ERROR', error };
store.dispatch(action);
}
});
return rules;
};
module.exports = makeRules();
```
Снова запускаю тесты. Новый фрагмент правила успешно проходит тест, так что я решаю добавить проверки для всех оставшихся правил:
```
describe('rules', () => {
const rules = require('../src/rules');
it('should contain user rules', () => {
const rule = rules.get('user');
expect(rule.table).toEqual('users');
expect(rule.onError.name).toEqual('dispatchError');
expect(typeof rule.onError).toEqual('function');
expect(rule.onSuccess.name).toEqual('dispatchUser');
expect(typeof rule.onSuccess).toEqual('function');
expect(rule.query.name).toEqual('getUserQuery');
expect(typeof rule.query).toEqual('function');
});
});
```
Запускаю тесты. Тестовый набор для словаря правил опять выдает ошибку. Пишу код:
```
const makeRules = () => {
const rules = new Map();
rules.set('user', {
table: 'users',
onError: function dispatchError(error, store) {
const action = { type: 'ERROR', error };
store.dispatch(action);
},
onSuccess: function dispatchUser(user, store) {
const action = { type: 'USER', user };
store.dispatch(action);
},
query: function getUserQuery(store) {
const state = store.getState();
if(state.note === null)
return null;
return { Id: state.note.UserRecordId };
}
});
return rules;
};
module.exports = makeRules();
```
Запускаю тесты. Тест набора правил опять успешно выполняется и как мне кажется я могу теперь взяться за написание кода для собственно новой версии запроса данных из базы. В этот раз я не буду пользоваться синтаксисом классов, потому что не вижу никаких преимуществ от его использования. Кода будет много сразу, потому что оттестированную его часть я безжалостно скопирую из существующей реализации запроса, дополнив ее проверкой, на случай если запись из базы уже была извлечена и помещена в контейнер состояния. Итак код:
```
function dbRequest(args){
const key = args[0];
const getQuery = this.rules.get(key).query;
const dispatchUser = this.rules.get(key).onSuccess;
const dispatchError = this.rules.get(key).onError;
const tableName = this.rules.get(key).table;
const table = this.db.Model.extend({
tableName: tableName
});
const state = this.store.getState();
if(state[key] !== null)
return;
const query = getQuery(this.store);
if(query === null)
return;
table.where(query).fetch().then((item) => {
dispatchUser(item, this.store);
}).catch((error) => {
dispatchError(error, this.store);
});
}
module.exports = dbRequest;
```
Запускаю тесты… барабанная дробь! И вижу строчку зеленых точек. Все тесты успешно выполнились. И поэтому я добавлю в набор еще один тест, проверяющий корректность обработки ошибок, пока я еще не забыл что чтобы моя псевдобазаданных `DbMock` вернула ошибку, надо попросить у нее запись с `Id` равным *555*:
```
it('should add error in store state', (done) => {
const assert = checkErrorHasBeenAdded.bind(context, [ done ]);
store.subscribe(assert);
store.dispatch({type: 'NOTE', note: { Id: 1, UserRecordId: 555 }});
request();
});
function checkErrorHasBeenAdded(args){
const state = store.getState();
if(state.error.length === 0)
return;
const error = state.error;
expect(Array.isArray(error)).toBeTruthy();
expect(error.length).toEqual(1);
expect(error[0].message).toEqual('Something goes wrong!');
const checkIsCompleted = args[0];
checkIsCompleted();
}
```
Запускаю тесты еще раз. Все работает так, как ожидается. Можно считать что правильный прототип команды запроса к базе готов и возвращаться к рефакторингу и разработке правил конфигурирования запросов ибо уже сейчас видно что код генерации набора правил перестанет быть читабельным после добавления буквально еще пары правил в таком же формате. | https://habr.com/ru/post/436654/ | null | ru | null |
# Определяем Phantom-ных ботов
» Перевод статьи [Detecting PhantomJS Based Visitors](http://engineering.shapesecurity.com/2015/01/detecting-phantomjs-based-visitors.html) | Неплохое обсуждение статьи на [Hacker News](https://news.ycombinator.com/item?id=8901117)
Статья старая, помидорами не кидайтесь — лучше делитесь опытом в комментариях.
В наши дни во многих инцидентах по безопасности используется автоматизация (со стороны злоумышленников). Web-scraping, повторное использование паролей, click-fraud — все это совершается злоумышленниками в попытках (зачастую успешных) замаскироваться под обычного пользователя, то есть по сути выглядеть для сервера как броузер обычного пользователя. Как владелец сайта, вы наверно хотите быть уверены в том что обслуживаете людей а не бездушные железки, а как поставщик сервиса вы наверно хотите еще и доступ дать к своему контенту через api, а не через тяжелый и глючный web-интерфейс.
Предположим что у вас уже есть простенькая проверка для cUrl и ему подобных посетителей, и она достаточно эффективна. Следующим шагом ожидаемо будет поставить проверку на то что ваши клиенты настоящие и пользуются настоящим броузером, с тупым и глючным UI, а не боты на поделках типа [PhantomJS](http://phantomjs.org/) или [SlimerJS](http://slimerjs.org/).
В этой статье мы рассмотрим пару приемов для определения фантомных ботов. Я рассматриваю только фантом, так как он более популярен, но многие моменты могут быть использованы и для SlimerJS и ему подобных.
**Важно!** Рассматриваемые методы применимы к обоим веткам фантома (1.x и 2.x), если явно не оговорено иное.
Для начала: можно ли определить фантома даже не отвечая ему (то есть исключительно по его http запросу)?
### HTTP-стек
Вы, должно быть, знаете что фантом построен на [QT фрейворке](http://www.qt.io/qt-framework/). Так вот, Qt реализует HTTP стек несколько иначе, чем другие современные броузеры.
Для начала давайте взглянем на простенький http запрос Хрома:
```
GET / HTTP/1.1
Host: localhost:1337
Connection: keep-alive
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,*/*;q=0.8
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10_9_5) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/39.0.2171.95 Safari/537.36
Accept-Encoding: gzip, deflate, sdch
Accept-Language: en-US,en;q=0.8,ru;q=0.6
```
А теперь этот же запрос в фантоме:
```
GET / HTTP/1.1
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X) AppleWebKit/534.34 (KHTML, like Gecko) PhantomJS/1.9.8 Safari/534.34
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8
Connection: Keep-Alive
Accept-Encoding: gzip
Accept-Language: en-US,*
Host: localhost:1337
```
Обратите внимание, хедеры фантома отличаются от хрома (как и от большинства современных броузеров):
* Host хедер идет последним (у хрома первым)
* значение хидера Connection (обратите внимание на регистр)
* Accept-Encoding у фантома только gzip
* User-Agent содержит “PhantomJS”
Проверка на различие этих хедеров на стороне сервера может помочь определить фантомный заход.
Но насколько безопасно доверять такой проверке? Если злоумышленник использует прокси для перезаписи этих хедеров то в общем то ему не составит труда мимикрировать под нормальный броузер.
Похоже что такое решение проблемы не тянет на серебряную пулю. Ок, давайте взглянем, что мы можем сделать на клиенте используя фантомные особенности JavaScript окружения.
### Проверка User-Agent на клиенте
мы можем не верить полученному в запросе User-Agent, но что насчет значения в клиенте?
```
if (/PhantomJS/.test(window.navigator.userAgent)) {
console.log("PhantomJS environment detected.");
}
```
К сожалению это так же легко поменять как хедер в запросе, так что этого явно не достаточно.
### Плагины
navigator.plugins содержит массив плагинов установленных в броузере. Обычно он содержит что то вроде Flash, ActiveX, поддержку для java апплетов или [Default Browser Helper](http://apple.stackexchange.com/questions/111665/whats-firefoxs-default-browser-helper-plugin) который указывает на то что этот броузер — дефолтный в OS X. Наши исследования показывают что большинство установок «с нуля» общераспространенных броузеров содержат хотя бы один дефолтный плагин — даже на мобилах.
Этим и отличается PhantomJs — он не ставит никаких плагинов и более того — не дает никаких возможностей их установить ( [PhantomJS API](http://phantomjs.org/api/)).
Следующая проверка может быть вполне полезной:
```
if (!(navigator.plugins instanceof PluginArray) || navigator.plugins.length == 0) {
console.log("PhantomJS environment detected.");
} else {
console.log("PhantomJS environment not detected.");
}
```
С другой стороны — крайне просто подменить массив navigator.plugins исполняя js код ДО подгрузки страницы ([как здесь](https://github.com/ikarienator/phantomjs_hide_and_seek/blob/master/1.spoofPlugins.js)).
Также никакого труда не составляет создать кастомную сборку с настоящими установленными плагинами. Это гораздо легче чем кажется потому что QT, на котором построен фантом, предоставляет [возможности](https://trac.webkit.org/wiki/QtWebKitPlugins) для подключения npapi плагинов.
### Timing
Другой интересный момент — это то как PhantomJS рубит JavaScript диалоги:
```
var start = Date.now();
alert('Press OK');
var elapse = Date.now() - start;
if (elapse < 15) {
console.log("PhantomJS environment detected. #1");
} else {
console.log("PhantomJS environment not detected.");
}
```
После нескольких проверок можно предположить что если диалог закрывается меньше чем за 15 милисекунд, то скорее всего броузер не контролируется человеком. Но использование этой техники предполагает некоторый негатив со стороны реальных пользователей, которые вынуждены будут закрывать непонятные окошки. (на самом деле этот момент можно обойти, привязавшись к каким либо действиям пользователя, например предлагая что либо при наведении на какой либо элемент — тот момент когда пользователь говорит «нет, спасибо». Тоже немного навязчиво, но по крайней мере хоть какой то смысл в происходящем с точки зрения пользователя — прим. перевод.)
### Глобалы
PhantomJS 1.x предоставляет два вида глобалов:
```
if (window.callPhantom || window._phantom) {
console.log("PhantomJS environment detected.");
} else {
console.log("PhantomJS environment not detected.");
}
```
Но это часть [экспериментальной](http://phantomjs.org/api/webpage/handler/on-callback.html) технологии, так что все еще может поменяться.
### Фишки JavaScript движка
PhantomJS 1.x и 2.x используют не самые свежие версии WebKit, что подразумевает отсутствие новых модных плюшек, внедренных уже в последние версии броузеров. Это автоматически распространяется и на JS движок, то есть некоторые свойства и методы ведут себя иначе или вообще отсутствуют в PhantomJS (тут правда непонятно чем это все отличается от просто старого броузера — прим. перев.)
Один из таких методов — Function.prototype.bind, отсутствующий в PhantomJS 1.x и старше. Следующий пример проверяет — есть ли bind у прототипа функции и если есть — то точно ли он нативный а не зашимленный.
```
(function () {
if (!Function.prototype.bind) {
console.log("PhantomJS environment detected. #1");
return;
}
if (Function.prototype.bind.toString().replace(/bind/g, 'Error') != Error.toString()) {
console.log("PhantomJS environment detected. #2");
return;
}
if (Function.prototype.toString.toString().replace(/toString/g, 'Error') != Error.toString()) {
console.log("PhantomJS environment detected. #3");
return;
}
console.log("PhantomJS environment not detected.");
})();
```
Если вам этот код кажется слегка непонятным, можно взглянуть на небольшое объяснение в деталях [здесь (видео)](https://www.youtube.com/watch?v=95sydbXK_7k).
### Stack Traces
Ошибки которые генерит JavaScript код обработанные PhantomJS через команду [evaluate](http://phantomjs.org/api/webpage/method/evaluate.html) содержат уникальный стек по которому можно определить «безголовый» броузер.
Предположим что PhantomJS вызывает обработку в следующем коде:
```
var err;
try {
null[0]();
} catch (e) {
err = e;
}
if (indexOfString(err.stack, 'phantomjs') > -1) {
console.log("PhantomJS environment detected.");
} else {
console.log("PhantomJS environment is not detected.");
}
```
Обратите внимание — здесь у нас кастомная indexOfString() функция, (реализацию мы оставили за скобками предполагая что у читателя не вызовет никаких затруднений реализовать ее) так как нативная String.prototype.indexOf может быть подменена PhantomJS (пользовательским скриптом) и возвращать отрицательный результат. (что в общем то тоже нетрудно проверить — прим. перевод.).
Так, а как теперь PhantomJS заставить исполнить этот код? Одна из техник — переписать наиболее часто используемые DOM функции которые с большой вероятностью будут вызваны. Например код ниже переписывает document.querySelectorAll что бы перехватить stack trace броузера:
```
var html = document.querySelectorAll('html');
var oldQSA = document.querySelectorAll;
Document.prototype.querySelectorAll = Element.prototype.querySelectorAll = function () {
var err;
try {
null[0]();
} catch (e) {
err = e;
}
if (indexOfString(err.stack, 'phantomjs') > -1) {
return html;
} else {
return oldQSA.apply(this, arguments);
}
};
```
### Итого
В этой статье мы рассмотрели 7 разных техник определения PhantomJS как на сервере так и на клиенте. Комбинируя результаты проверки с обратной связью (например замеряя скорость рендеринга или ломая сессионную куку) можно в принципе устроить сложностей PhantomJS посетителям. Но держите в голове что эти техники не являются строгими и безошибочными (по факту на кастомных сборках ни одна не работает — прим. перевод.) и продвинутый противник может прорвать оборону. Для углубления в тему мы рекомендуем к просмотру нашу [презентацию (видео, слайды)](https://www.youtube.com/watch?v=95sydbXK_7k). Есть также [GitHub репа](https://github.com/ikarienator/phantomjs_hide_and_seek) с примерами и возможными путями обхода проверок.
Спасибо за внимание и удачной охоты! | https://habr.com/ru/post/303378/ | null | ru | null |
# Оконные функции своими руками
В цифровой обработке сигналов оконные функции широко используются для ограничения сигнала во времени и их названия хорошо известны всем, кто так или иначе сталкивался с дискретным преобразованием Фурье: Ханна, Хэмминга, Блэкмана, Харриса и прочие. Но являются ли они достаточными, можно ли придумать что-то новое и есть ли в этом смысл?
В этой статье мы рассмотрим вывод оконной функции с новыми свойствами, используя Wolfram Mathematica. Предполагается также, что читатель имеет общие представления о цифровой обработке сигналов в контексте обсуждаемого вопроса и как минимум знаком со [статьёй из википедии](https://en.wikipedia.org/wiki/Window_function).
Введение
--------
Исторически первые оконные функции появлялись в процессе попыток улучшить их спектральные свойства снижением амплитуды боковых лепестков — поскольку при умножении сигнала на оконную функции происходит свёртка их спектров, что вносит некоторые ограничения для анализа. В то время, 50-ые года 20 века, вычислительные мощности не позволяли легко и непринужденно манипулировать символьными вычислениями, и подбор оптимальных параметров представлял достаточную сложность. Это одна из причин, по которой функции названы разными именами — они, а точнее, их спектральные свойства, изучались разными исследователями в течении достаточно длительного времени. Побочным эффектом от этого стало то, что сложившийся набор именованных оконных функций воспринимается как некоторый «стандартный набор», за пределами которого ничего найти уже не возможно; при этом названия этих окон не несут никакой информации о свойствах и предполагают их отдельное изучение и зазубривание.
Классификация
-------------
Все оконные функции получаются произведением некоторой функции на прямоугольную, что гарантированно обеспечивает её ограничение во времени. Поэтому в первую очередь их можно классифицировать по функциям, которые в них используются:
1. сумма косинусов. Наиболее обширный класс по причине того, что их спектр легко вычислим и представляет из себя сумму взвешенных sinc-функций. Сюда входят Hann, Hamming, Blackman, Harris ...
2. кусочно-непрерывные полиномиальные. Получаются в результате свёртки простых функций — например, прямоугольной и треугольной. Их спектры при этом перемножаются и их нахождение так же не представляет особых сложностей. Сюда входят Dirichlet, Triangular, Parzen, Welch...
3. все прочие — с использованием экспонент, гауссиан, sinc и других, выбор конкретных функций в которых носит скорее идейный характер, нежели конкретно спектральные свойства.
Также их можно поделить по свойствам на краях:
1. отсутствие разрывов на краях — равенство нулю значений. Разрывы имеют Dirichlet, Hamming, Blackman-Harris. Не имеют — Triangular, Hann, Nuttal
2. отсутствие разрывов 1-ой и прочих производных
Отдельного упоминания стоят ещё две оконные функции:
1. Кайзера, позволящей задавать ширину главного лепестка;
2. Дольфа-Чебышева, все боковые лепестки которой равны заданной амплитуде.
Обе они имеют разрывы на краях как значений, так и производных, а вычисления их сопряжены с некоторыми сложностями — функция Кайзера считается через специальную функцию (Бесселя), а Дольфа-Чебышева определяется в частотной области и считается через обратное дискретное преобразование Фурье. Особую сложность также представляет нахождение их аналитических первообразных.
**Исследовать оконные функции на разрывы можно следующим простым кодом:**
```
wins = {DirichletWindow, HammingWindow, BlackmanWindow,
BartlettHannWindow, BartlettWindow, BlackmanHarrisWindow,
BlackmanNuttallWindow, BohmanWindow, ExactBlackmanWindow,
FlatTopWindow, KaiserBesselWindow, LanczosWindow, NuttallWindow};
Table[{f,
Table[Limit[D[f[x], {x, k}], x -> 1/2,
Direction -> "FromBelow"], {k, 0, 4}]}, {f, wins}]
↓
Plot[Evaluate[Through[wins[x]]], {x, -1, 1}, PlotRange -> {-0.25, 1},
GridLines -> {{-0.5, -0.25, 0.25, 0.5, 1}}, AspectRatio -> 5/8,
PlotLegends -> "Expressions"]
```
↓
Реверс инжиниринг
-----------------
Посмотрим на определения функций Блэкмана и Наттела:
```
BlackmanWindow[x] // FunctionExpand
```
↓
```
NuttallWindow[x] // FunctionExpand
```
↓
Они представляют из себя суммы из 3-х и 4-х косинусоид с чётными частотами (начиная с нуля) и некоторыми коэффициентами. Откуда взялись эти коэффициенты? Вряд ли они были подобраны вручную, по крайней мере, каждый по отдельности — ведь существуют граничные условия, которым окна должны соответствовать вне зависимости от их спектральных свойств — как минимум, равенство единице в центре.
Попробуем «изобрести» функцию Блэкмана самостоятельно. Для этого определим функцию с пока ещё неизвестными коэффициентами
```
f = Function[x, a + b Cos[2 Pi x] + c Cos[4 Pi x]];
```
и составим систему уравнений, определяющих граничные условия — равенства единице в центре, нулю на краях, и равенства нулю производных на краях:
```
ss = Solve[{
f[0] == 1,
f[1/2] == 0,
f'[1/2] == 0
}, {a, b, c}]
```
↓
Решение нашлось, но не одно, а множество — в зависимости от коэффициента *a*, о чём Wolfram нас учтиво предупредил. Теперь из найденного решения зададим новую функцию, зависящую от неизвестного коэффициента:
`hx = Function[{x, a},
Piecewise[{{f[x] /. ss[[1]], -1/2 < x < 1/2}}, 0] // Evaluate]`
↓
Легко видеть, что при *a*=0.42 получим функцию Блэкмана. Но почему именно 0.42?
Для ответа на этот вопрос нам нужно построить её спектр. Аналитическое преобразование Фурье — не самая простая задача, но Wolfram справляется и с ней, избавляя нас от рутинной работы.
```
hw = Function[{w, a},
FourierTransform[hx[x, a], x, w] // #/Limit[#, w -> 0] & //
Simplify // Evaluate]
```
↓
**примечание**
В отличие от многих других операций, в команде FourierTransform нужно указывать не одну переменную, а две — в том числе и для того, чтобы не путаться, в какой области находится определение функции — временном или частотном. Традиционно для частотной области используется переменная *w*. Здесь мы заодно нормировали функцию к единице в центре координат — но не прямой подстановкой нуля в *w*, поскольку это вызывает деление на ноль, а через нахождение предела.
В таком виде график функции пока ещё мало информативен, поскольку спектр удобнее анализировать в логарифмическом масштабе. Добавив соответствующее преобразование в децибелы , получим тот самый привычный график спектра оконных функций:
**код**
```
Manipulate[
Plot[{
hw[w, a],
hw[w, 0.42]
} // Abs // 20 Log[10, #] & // Evaluate
, {w, -111, 111}, PlotRange -> {-120, 0}, GridLines -> Automatic,
PlotStyle -> {Default, Thin}, PlotPoints -> 50]
, {{a, 0.409}, 0.3, 0.5}]
↓
```
В процессе изменения параметра мы будем наблюдать нечто подобное:
В зависимости от параметра *a* меняется уровень боковых лепестков, и при *a*=0.42 он боле-менее минимальный и равномерный. При *а*=0.409 мы можем получить результат чуточку лучше, если под «лучше» понимать минимально возможный уровень боковых лепестков.
**примечание**
Здесь можно вспомнить, что во времена становления теории ЦОС никаких Вольфрамов с интерактивными графиками не было и все эти вычисления и поиск оптимальных параметров производился вручную, ручкой на бумаге.
Развитие
--------
Очевидно подобная микрооптимизация вовсе не стоила затраченных усилий. Можно ли качественно улучшить свойства этого окна, не изменяя исходных данных?
[Ранее](https://habr.com/ru/post/430536/) мы рассматривали вывод оконных функций, суммирующихся в единицу, что позволяет восстанавливать исходный сигнал. Попробуем применить эту технику для нашего окна и посмотрим, как она отразится на спектре.
Определим вспомогательную функцию для построения перекрывающихся окон с учётом границ изменения аргумента в диапазоне от -1/2 до 1/2:
Находим первообразную, смещаем её к центру координат и масштабируем к единице:
↓
выводим её на график:
Как видим, Wolfram здесь тоже справился самостоятельно и нам не пришлось вручную задавать кусочно-непрерывное определение первообразной. Теперь вид нашего окна зависит не только от переменной *a*, но от степени перекрытия — и по мере его увеличения будет стремится к форме производной:
**код**
```
Manipulate[
Plot[
OverlapShape[hsx, x, a, t]
, {x, -1, 1}, PlotRange -> All, GridLines -> Automatic]
, {{a, 0.404}, 0.4, 0.5}, {{t, 4}, 3, 11}]
```
↓
И последний штрих — найти аналитическую функцию для спектра, чтобы определить оптимальное значение параметра *a*.
Здесь, если мы попробуем вычислить преобразование непосредственно, как в прошлый раз — то вгоним Wolfram в глубокую задумчивость. Есть несколько способов ускорить этот процесс:
— использовать дискретное преобразование вместо аналитического — наиболее простое. Но настоящий математик не будет применять численные методы там, где можно найти чисто аналитическое решение — и мы (пока) не будем; к тому же у него есть очевидные ограничения (по разрешению и ограничению спектра);
— передавать в качестве параметра перекрытия конкретные значения и, глядя на результаты, попытаться увидеть закономерность и обобщить их. Вполне работающий вариант, но требующих дополнительных умственных и творческих усилий. Оставим его на крайний случай.
— производить вычисления непосредственно в частотном домене. Это возможно благодаря следующим свойствам преобразования Фурье:
1) оно линейно, т.е. сумма образов равно образу суммы;
2) интегрирование во временном домене равносильно делению на *i w* в частотном.
3) смещение во времени равносильно модуляцией комплексной синусоидой.
(подробнее в [википедии](https://ru.wikipedia.org/wiki/%D0%9F%D1%80%D0%B5%D0%BE%D0%B1%D1%80%D0%B0%D0%B7%D0%BE%D0%B2%D0%B0%D0%BD%D0%B8%D0%B5_%D0%A4%D1%83%D1%80%D1%8C%D0%B5#%D0%A1%D0%B2%D0%BE%D0%B9%D1%81%D1%82%D0%B2%D0%B0) или [тут](http://ru.dsplib.org/content/fourier_transform_prop/fourier_transform_prop.html)).
Таким образом, имея спектр hw произвольной оконной функции, мы можем получить из него спектр hwo суммирующейся в единицу функции с перекрытием *t*:
↓
Теперь можно посмотреть, как меняется спектр в динамике:
Здесь изменение параметра перекрытия уже будет влиять на спектр окна несколько по-другому:
Немного поигравшись с параметрами легко заметить, что «больше — не значит лучше», и оптимальная степень перекрытия для той функции находится в районе четырёх. Конкретно, для *t*=4 и *a*=0.404 мы получаем уровень боковых лепестков, не превышающий -80 дБ. Это очень даже неплохой результат — особенно учитывая, что функция приподнятого косинуса, традиционно используемая для суммируемых в единицу окон, даёт уровень лепестков примерно в -30 дБ. Ну а выписанная явном образом наша новая оконная функция будет выглядеть так:
**код**
```
OverlapShape[hsx, x, 404/1000, 4] // PiecewiseExpand // FullSimplify
```
↓
Дальнейшее развитие
-------------------
Что ещё можно сделать, чтобы ещё более снизить уровень боковых лепестков? Можно взять косинусы не с чётными, а с нечётными частотами (здесь для компактности решение системы уравнений внедрено непосредственно в определение функции):
**код**
```
hx1 = Function[{x, a},
a Cos[1 Pi #] + b Cos[3 Pi #] + c Cos[5 Pi #] & // #[x] /. Solve[{
#[0] == 1,
#[1/2] == 0,
#'[1/2] == 0,
#''[1/2] == 0
}, {a, b, c}][[1]] & // # UnitBox[x] & // Evaluate]
```
↓
и после интегрирования с параметрами *a*=0.6628 и уровнем перекрытия 4.5 получить подавление в -90 дБ:
В явном виде:
Можно добавить ещё один косинус и увеличить количество нулевых производных:
**код**
```
hx2 = Function[{x, a},
a Cos[1 Pi #] + b Cos[3 Pi #] + c Cos[5 Pi #] +
d Cos[7 Pi #] & // #[x] /. Solve[{
#[0] == 1,
#[1/2] == 0,
#'[1/2] == 0,
#''[1/2] == 0,
#'''[1/2] == 0,
#''''[1/2] == 0
}, {b, c, d}][[1]] & // # UnitBox[x] & // Evaluate]
```
↓
и после интегрирования с параметрами *a*=0.5862 и уровнем перекрытия 6.4 получить подавление в -110 дБ:
В явном виде:
Ещё более значительного снижения уровня боковых лепестков можно добиться, возведя Фурье-образ в квадрат и тем самым снизив уровень боковых лепестков сразу в 2 раза. Это позволяет избавится от увеличения количества параметров для их ручного подбора, но добавляет сложности в вычислении свёртки во временном домене.
**код**
```
hx3 = Function[{x, a},
Convolve[hx1[x, a], hx1[x, a], x, y] /. y -> 2 x
// FullSimplify // Evaluate]
```
↓
и здесь уже можно добиться подавления свыше 160 дБ:
Формулу в явном виде приводить не будем из-за её внушительного размера.
Гипергеометрические оконные функции
-----------------------------------
Для обеспечения нужного количества нулей на границах нашей функции мы использовали поиск через решение системы уравнений с последующим интегрированием. Это не очень удобно — ведь нужно каждый раз менять количество уравнений. Может, есть более просто и красивое решение? Есть! И поможет нам в этом гипергеометрическая функция.
**вкратце о гипергеометрических функциях**
Из курса матанализа нам известно, что практически любую функцию можно разложить в степенной ряд. Гипергеометрические функции решают прямо противоположную задачу — определяют функцию через её степенной ряд, задавая конечный набор некоторых коэффициентов и правило вычисления произвольного члена ряда в зависимости от них. Это позволяет оперировать большим количеством функций без задания им явных имён — в том числе и уже известными.
Наше решение будет выглядеть следующим образом:
где 
Она состоит из суммы двух частей: первообразная от функции , нормированной по амплитуде к точке (1,1) и функцией со свободными параметрами, помноженных на ту же  для того, чтобы сохранить необходимое количество нулевых производных:
От того, какую именно функцию мы выберем для корректировки формы, будут зависеть точность настройки и их влияние на распределение боковых лепестков — тут возможны варианты, требующие отдельных исследований. В данном случае функция  даёт вполне приемлемый вариант — и за счёт двух параметров позволяет делать более точную настройку.
Сама же формула интересна (и удобна) тем, что при чётных n упрощается до полинома, а при нечётных — до суммы полинома с арксинусом и квадратным корнем — что делает итоговую формулу более компактной и более простой для вычислений.
Подбирать параметры здесь уже проще (и быстрее) через дискретное преобразование Фурье. Нам также потребуется дополнительное определение overlap-функции для работы с тремя параметрами:
В качестве примера, после подстановки параметров с картинки наша функция упростится до
**код**
↓
### Инверсное окно Кайзера
Если задача суммирования окон в единицу не стоит, то наиболее оптимальным окном является окно Кайзера, позволяющее плавно регулировать ширину основного лепестка. Однако у него есть недостаток — поскольку оно [выражается через функцию Бесселя](https://en.wikipedia.org/wiki/Kaiser_window), считать его за пределами математических пакетов несколько затруднительно. Можно, конечно, отдельно реализовать функцию Бесселя — а можно и поискать аппроксимацию через элементарные функции. И неожиданно оказалось, что используя для этого функцию спектра окна Кайзера (ограниченного во времени) можно получить результат даже чуточку лучше —
**примечание**
В точках  функция имеет особую точку, которая находится через предел и равна .
Расплатой за такое хитрое решение оказалось невозможность выразить её спектр чисто аналитически — но это не так и важно, поскольку на практике мы в любом случае оперируем и анализируем данные в дискретном виде используя дискретное же преобразование Фурье. Ниже на графике можно сравнить их спектры, где красным — оригинальное окно Кайзера, зелёным — его аппроксимация:
**код**
↓
При той же ширине основного лепестка уровень боковых лепестков получается несколько ниже. А для удобства использования можно составить таблицу с ориентировочными значениями параметра *k* для получения необходимого уровня подавления боковых лепестков:
Отдельной интересной задачей остаётся нахождение аппроксимации первообразной инверсного окна Кайзера. Пока что удалось только выразить его через степенной ряд, который довольно медленно сходится:
Возможно, специалисты в математике смогут подсказать более лучшее решение в комментариях.
Заключение
----------
Несмотря на то, что цифровая обработка сигналов является вполне себе сформировавшейся дисциплиной, в ней есть ещё куда развиваться и находить что-то новое — как минимум в существующей специальной и научной литературе вопросы построения суммирующихся в единицу оконных функций не рассматривается; а возможности современных систем компьютерной алгебры позволяют переосмыслить накопленные знания на качественно новом уровне.
Исходный документ Wolfram Mathematica со всеми вычислениями доступен [на GitHub](https://github.com/Refridgerator/Wolfram/blob/master/%D0%9F%D1%80%D0%BE%D0%B5%D0%BA%D1%82%D0%B8%D1%80%D0%BE%D0%B2%D0%B0%D0%BD%D0%B8%D0%B5%20%D0%BE%D0%BA%D0%BE%D0%BD%D0%BD%D1%8B%D1%85%20%D1%84%D1%83%D0%BD%D0%BA%D1%86%D0%B8%D0%B9.nb). | https://habr.com/ru/post/514170/ | null | ru | null |
# Экономим на RAID-контроллере, или как накормить Варю иопсами
 В наш век облачных сервисов, AWS Lambda и прочих ~~шаред хостингов~~ абсолютно неосязаемых вычислительных ресурсов иногда хочется немножко своего. Кроме желания, иногда бывают и потребности вдумчиво покрутить тот или иной программный продукт с минимальными затратами на платформу. Найти какие-то излишки матчасти можно почти всегда, иногда даже получается собрать всё вместе и включить. Если излишки эти представляют собой CPU хотя бы на 4-6 ядер и памяти от 64ГБ — вообще отлично, можно брать ESXi и работать с чем угодно. Одна проблема: с дисковой ёмкостью на бытовом железе у VMWare — совсем никак. Производительность локальных одиночных HDD невысокая, а уж утратить содержимое отдельно взятого, сферического в вакууме винта в 21м веке — это как здрасьте. Попробуем подключить что-нибудь по сети.
TL;DR> объединение, балансировка, rr limit, вот это вот всё.
Собственно, текст далее не про то, что это вообще возможно или ноу-хау какое-то. Интернет полон статьями для чайников (вот здесь ставим галочки, затем Next, Next, Done) о том, как подать дисковую ёмкость по iSCSI. Пишу как раз для того, чтобы исключить «ошибки выживших» и поделиться моментами, когда «всё пойдёт не так» (а оно пойдёт, Мерфи был прав), и при попытке нагрузить решение оно просто падает.
Итак, мы попробуем раздушить наш «бытовой гипервизор» внешним дисковым массивом, подключенным по сети. Поскольку у нас всё крутится вокруг «недорого», пусть это будет FreeNAS и 4 SATA-диска, которые обслуживает средненький 3 ГГц 45-нм проц. Смотрим на Ebay, и за сравнимые с б/у RAID-контроллером деньги тащим оттуда пару сетевых карточек i350-T4. Это четырёхпортовые гигабитные адаптеры от Intel. По ним и будем связывать хранилку с гипервизором.
Немножко посчитаем. Средняя скорость передачи данных среднего SATA диска — 160-180 МБ/сек при ширине интерфейса в 6 Гбит/с. Фактически, реальная скорость передачи данных с HDD не превышает 2 Гбит/с. Не такая уж большая цифра, учитывая, что связь мы планируем по 4м гигабитным портам (как именно превратить 4x1Гбит в 4 Гбит — обсудим далее). Намного хуже все со скоростями произвольного доступа — здесь всё падает чуть ли не до уровня дискет.
Учитывая, что профиль дисковой нагрузки от множества гостевых ОС — далёк от линейного, хотелось бы видеть более веселые цифры. Для исправления ситуации в файловой системе гипервизора ( VMFS v6) размер блока составляет 1 МБ, что способствует уплотнению множества случайных операций и ускоряет доступ к данным на виртуальных дисках. Но даже с этим одного физического диска будет недостаточно для обработки операций ввода-вывода от всех «гостей».
Сразу оговорюсь — всё дальнейшее имеет смысл, если у вас адаптеров для «сети хранения» больше двух. ESXi с бесплатной однопроцессорной лицензией умеет подключаться, кроме локальных дисков, к хранилищам двух типов — NFS и iSCSI. NFS предполагает доступ файлового уровня и тоже по-своему хорош. На нем можно развернуть гостей, нетребовательных к дисковой производительности. Бэкапить их — одно удовольствие, т.к. можно открыть эту же NFS шару ещё куда-либо и копировать снапшоты вм. В общем, с одним сетевым интерфейсом (если это не 10GE, конечно) — NFS ваш выбор.
У iSCSI есть ряд преимуществ перед NFS. Для того, чтобы реализовать их в полной мере, мы уже подготовились — заложив для сети хранения аж 4 гигабитных порта. Как обычно происходит расширение пропускной способности сети при известной скорости интерфейсов? Правильно, агрегацией. Но для полной утилизации агрегированного канала нужен целый ряд условий, и это подходит больше для связи коммутаторов между собой либо для сетевого аплинка гипервизора. Реализация протокола iSCSI предусматривает такую функцию, как multipathing (дословно, много путей) — возможность подключения одного и того же тома через разные сетевые интерфейсы. Само собой, про возможность балансировки нагрузки там тоже есть, хотя основное назначение — отказоустойчивость сети хранения. (Справедливости ради, NFSv4.1 поддерживает session trunking на базе совершеннейшей магии типа RDMA и MPTCP, но это попытка переложить проблемы файлового доступа ~~с больной головы на здоровую~~ на нижние уровни.)
Итак, для начала опубликуем наш таргет. Считаем, что FreeNAS установлен, IP-адрес управления исправно отгружает нам web-интерфейс, массив и zvol на нём мы нарезали в полном соответствии с нашими внутренними убеждениями. В нашем случае это 4 х 500ГБ диска, объединённых в raidz1 (что даёт всего 1,3 ТиБ эффективной ёмкости), и zvol размером в 1 ТБ ровно. Настроим сетевые интерфейсы i350, для простоты принимаем, что все будут принадлежать разным подсетям.
Затем настраиваем iSCSI-шару методом «Next, Next, Done». При настройке портала не забываем добавить туда все сетевые интерфейсы, выделенные для iSCSI. Выглядеть должно примерно так, как на картинках.
Чуть больше внимания потребуется уделить настройке extent — при презентации тома необходимо форсировать размер блока 512 байт. Без этого инициатор ESXi вообще отказывался опознавать презентованные тома. Для верности лучше отключить проброс размеров физ блока (которого на zvol нет и быть не может) и включить режим поддержки Xen.
С FreeNAS пока всё.
На стороне ESXi немного сложнее с настройкой сети. Опять же, считаем, что сам гипервизор установлен и также управляется по отдельному порту. Потребуется выделить 4 интерфейса VM Kernel, принадлежащих 4м разным порт-группам в 4х разных виртуальных коммутаторах. Каждому из этих коммутаторов выделяем свой физический порт аплинка. Адреса vmk# берём, разумеется, в соответствующих подсетях, аналогично настройке портов хранилища. Порядок настройки адресов, в общем случае, важен — либо мы соединяем карточки «порт-в-порт» без коммутатора, либо отдаём разные линки в разные сети (ну, это если по-взрослому), поэтому физическое соответствие портов имеет значение.
Особое внимание при настройке сети под iSCSI уделяем параметру MTU. Это как раз тот случай, когда «размер имеет значение» — берём максимум, который позволяют установить все компоненты сети. Если карточки соединены напрямую, можно указать mtu 9000 на обоих сторонах, на ESXi и FreeNAS. Впрочем, нормальные коммутаторы это значение поддержат. Пингуем, видим, что сеть у нас в норме, и пакеты требуемого размера проходят. Отлично. Поджигаем инициатор.
Включаем iSCSI, добавляем IP-адреса в динамическую секцию настройки (Storage -> Adapters -> Configure iSCSI -> Dynamic targets). После сохранения будет выполнен опрос iSCSI порталов по этим адресам, инициатор определит, что за каждым из них стоит один и тот же том, и подключится к нему по всем доступным адресам (тот самый multipath). Дальше нам потребуется создать datastore на появившемся устройстве.
После этого можно раскатать виртуальную машинку и замерить, что у нас получилось.
Не такие уж впечатляющие результаты. Открываем консоль хранилища, выводим текущее состояние сети и запускаем тесты.
`root@freenas:~ # systat -ifstat`
**Что видим?**
```
/0 /1 /2 /3 /4 /5 /6 /7 /8 /9 /10
Load Average
Interface Traffic Peak Total
lo0 in 0.319 KB/s 0.893 KB/s 3.041 MB
out 0.319 KB/s 0.893 KB/s 3.041 MB
alc0 in 0.478 KB/s 1.233 KB/s 3.934 MB
out 0.412 KB/s 1.083 KB/s 2.207 MB
igb3 in 0.046 KB/s 0.105 KB/s 181.434 KB
out 0.073 KB/s 0.196 KB/s 578.396 KB
igb2 in 0.046 KB/s 0.105 KB/s 120.963 KB
out 0.096 KB/s 0.174 KB/s 517.221 KB
igb1 in 4.964 MB/s 121.255 MB/s 10.837 GB
out 6.426 MB/s 120.881 MB/s 3.003 GB
igb0 in 0.046 KB/s 0.105 KB/s 139.123 KB
out 0.073 KB/s 0.210 KB/s 869.938 KB
```
Утилизирован лишь один сетевой порт из четырёх (igb1). Происходит это потому, что механизм балансировки, предусмотренный по умолчанию для multipath, с каждым пакетом данных выбирает один и тот же адаптер. Нам же надо задействовать из все.
Подключаемся к гипервизору по SSH и командуем.
Для начала глянем, какой ID у луна с multipath, и как он работает:
`[root@localhost:~] esxcfg-mpath -b
naa.6589cfc000000b478db42ca922bb9308 : FreeNAS iSCSI Disk (naa.6589cfc000000b478db42ca922bb9308)
[root@localhost:~] esxcli storage nmp device list -d naa.6589cfc000000b478db42ca922bb9308 | grep PSP
Path Selection Policy: VMW_PSP_MRU`
Политика выбора путей — MRU, то бишь most recently used. Все данные идут в один и тот же порт, перевыбор пути происходит только при недоступности сетевого соединения. Меняем на round-robin, при которой все интерфейсы меняются по очереди после какого-то числа операций:
`[root@localhost:~] esxcli storage nmp device set -d naa.6589cfc000000b478db42ca922bb9308 -P VMW_PSP_RR`
Перезагружаем ESXi, открываем мониторинг, запускаем тесты. Видим, что нагрузка распределяется по сетевым адаптерам равномерно (как минимум, пиковые значения, лишнее поскипано), результаты теста тоже повеселее.
```
Interface Peak
igb3 in 43.233 MB/s
out 46.170 MB/s
igb2 in 42.806 MB/s
out 45.773 MB/s
igb1 in 43.495 MB/s
out 45.489 MB/s
igb0 in 43.208 MB/s
out 46.079 MB/s
```
Есть некоторые отклонения по портам, это возникает из-за лимитов Path Selection Policy — числа операций либо байт, после которого происходит переключение на другой порт. По умолчанию 1000 IOPS, то есть если обмен данными уложился в 999 операций — он пройдет через один сетевой порт. Можно менять, сравнивать и подбирать подходящее значение. Можно не менять, дефолта достаточно для большинства задач.
Делаем замеры, тестируем, работаем. Полученные результаты ощутимо превосходят возможности одиночного диска, так что теперь наши виртуальные машинки могут не толкаться локтями на операциях ввода-вывода. Итоговые значения скоростей и отказоустойчивость массива будут зависеть от железа и того, как выполнена конфигурация тома. | https://habr.com/ru/post/423513/ | null | ru | null |
# Расширяем возможности процедурных макросов с помощью WASM
В рамках продолжения своих исследований различных аспектов процедурных макросов хочу поделиться подходом к расширению их возможностей. Напомню, что процедурные макросы позволяют добавить в язык элемент метапрограммирования и тем самым существенно упростить рутинные операции, такие как сериализация или обработка запросов. По своей сути макросы являются плагинами к компилятору, которые компилируются до сборки крейта, в котором они используются. У таких макросов есть некоторые существенные недостатки.
* Сложность с поддержкой таких макросов в IDE. По сути дела нужно как-то научить анализатор кода самостоятельно компилировать, загружать и исполнять эти самые макросы с учетом всех особенностей. Это весьма нетривиальная задача.
* Так как макросы самодостаточные и ничего не знают друг о друге, то нет никакой возможности делать композицию макросов, что иногда могло бы быть полезным.
По поводу решения первой проблемы сейчас ведутся [эксперименты](https://github.com/dtolnay/watt) с компиляцией всех процедурных макросов в WASM модули, что позволит в будущем вообще отказаться от их компиляции на целевой машине, а заодно и решить проблему с их поддержкой в IDE.
Что касается второй проблемы, то в этой статье я как раз собираюсь рассказать о своем подходе к решению данной проблемы. По сути дела нам необходим такой макрос, который бы мог с помощью атрибутов подгружать какие-то дополнительные макросы и объединять их в конвейер. В простейшем случае можно просто представить нечто в роде такого:
Пусть у нас имеется некоторый макрос `TextMessage`, который выводит для заданного типа трейты `ToString` и `FromStr` используя в качестве текстового представления некоторый кодек. У разных типов сообщений может быть различный кодек, причем их полный список со временем может расширятся, а у каждого кодека может быть свой уникальный набор атрибутов.
```
#[derive(Debug, Serialize, Deserialize, PartialEq, TextMessage)]
#[text_message(codec = "serde_json", params(pretty))]
struct FooMessage {
name: String,
description: String,
value: u64,
}
```
Чтобы сделать такой макрос возможным, мы должны динамически подгружать реализации кодеков в процессе выполнения макроса. Можно вынести кодеки в подключаемую библиотеку и просто загружать их через [libloading](https://crates.io/crates/libloading), но это очень неудобно и еще больше отдалит нас от возможности поддержки макросов в IDE. Вместо этого теоретически возможно написать такой вот кодек на динамическом языке типа Питона, но тогда нам придется писать для Питона аналоги [`syn`](https://crates.io/crates/syn) и [`quote`](https://crates.io/crates/quote), что будет больше напоминать Сизифов труд, чем реальное решение проблемы.
Наиболее же простым и удобным видится вариант скомпилировать кодек в WASM модуль, объединив плюсы обоих подходов. Именно таким путем я и предлагаю пойти.
Выбираем подход к реализации
----------------------------
На первый взгляд кажется, что проблема уже решена в рамках [watt](https://github.com/dtolnay/watt) и можно просто использовать его для загрузки и выполнения WASM модулей, но у этого подхода есть один весьма неприятный недостаток. Для своей работы [watt](https://github.com/dtolnay/watt) использует модифицированный крейт [`proc-macro2`](https://crates.io/crates/proc-macro2), что частенько приводит к непонятным или трудноуловимым проблемам. Например, у меня не компилировался `darling` или если я забывал подменять `proc-macro2`, то получал в рантайме неочевидные ошибки.
В результате я решил, что лучше уж пользоваться ванильным [`proc-macro2`](https://crates.io/crates/proc-macro2), а в качестве WASM
рантайма взять какой-нибудь из самых популярных. В результате, мой субъективный выбор пал на [wasmtime](https://wasmtime.dev), этот рантайм разрабатывается сообществом [bytecodealliance](https://bytecodealliance.org/), в состав которого входят такие гиганты, как Mozilla, Intel и RedHat. И хотя [wasmtime](https://wasmtime.dev) сейчас выглядит еще достаточно сырым, в нем не хватает документации, хороших примеров, но развивается он очень быстро и улучшается прямо на глазах
Взаимодействие между хостом и таргетом
--------------------------------------
***Disclaimer**: в wasmtime есть процедурный макрос, который позволяет генерировать
[интерфейс модуля](https://github.com/bytecodealliance/wasmtime/tree/master/crates/misc/rust) при помощи макросов, но сейчас он основательно сломан и пока неясны перспективы, когда же его починят. Поэтому мы пойдем другой дорогой через низкоуровневую работу с WASM модулями, что позволит нам лучше понять принципы работы с ними.*
Погнали!
Напомню, что хостом в данном случае называется вызывающая сторона, предоставляющая нативные методы, а таргетом является WASM модуль, предоставляющий функциональность. И нам нужно определить интерфейс вызова функций таргета со стороны хоста.
В самом простом виде интерфейс плагина для нашего процедурного макроса должен представлять из себя вариацию на тему:
```
pub fn implement_codec(input: TokenStream) -> TokenStream;
```
Но мы не можем передавать произвольные объекты между таргетом и хостом, нам необходимо их сериализовать в универсальное представление, которое не будет зависеть от особенностей хоста. По счастью `TokenStream` можно преобразовывать в обычную строку и обратно, поэтому в реальности мы будем использовать нечто в таком духе:
```
pub fn implement_codec(input: &str) -> String;
```
К великому сожалению, вот так просто взять и передать хостовую строчку, а уж тем более
передать строчку от таргета к хосту, не получится и на то есть серьезные причины:
В целях обеспечения безопасности ~~и большей стабильности, Республика будет реорганизована нами в первую Галактическую Империю, во имя сохранности и во имя блага общества!~~ память WASM рантайма отделена от хостовой, с точки зрения хоста это просто плоский массив байт, в котором находится код программы, глобальные переменные, стек и куча.
Есть возможность сделать так, чтобы память была расширяемой, то если если при очередном выделении памяти нам не хватает места, то верхняя граница памяти автоматически увеличивается. Индекс ячейки в этом самом массиве используется в качестве указателя внутри таргета, но мы не можем просто взять и записать строчку в случайный участок памяти и отдать таргету индекс его начала, потому что снаружи мы не знаем то, как таргет в реальности использует память, где у него находится стек, а где куча. Но мы можем пойти на хитрость: с хоста обратиться к менеджеру памяти таргета и попросить у него выделить нам участок памяти.
```
#[no_mangle]
pub unsafe extern "C" fn toy_alloc(size: i32) -> i32 {
let size_bytes: [u8; 4] = size.to_le_bytes();
let mut buf: Vec = Vec::with\_capacity(size as usize + size\_bytes.len());
// Первые 4 байта - это длина общая куска памяти, она нам еще понадобится в
// дальнейшем.
buf.extend(size\_bytes.iter());
to\_host\_ptr(buf)
}
unsafe fn to\_host\_ptr(mut buf: Vec) -> i32 {
let ptr = buf.as\_mut\_ptr();
// Просто забываем о выделенном участке памяти, позволяя ему "утечь", таким
// образом мы передаем его во владение хосту.
mem::forget(buf);
ptr as \*mut c\_void as usize as i32
}
#[no\_mangle]
pub unsafe extern "C" fn toy\_free(ptr: i32) {
let ptr = ptr as usize as \*mut u8;
let mut size\_bytes = [0u8; 4];
ptr.copy\_to(size\_bytes.as\_mut\_ptr(), 4);
// Вычитываем общую длину куска памяти для того, чтобы корректно выполнить
// его очистку.
let size = u32::from\_le\_bytes(size\_bytes) as usize;
// Собираем вектор, о котором мы ранее "забыли" в методе `to\_host\_ptr` и
// таким образом даем его деструктору вызваться нормальным образом и очистить
// ранее выделенный участок памяти.
Vec::from\_raw\_parts(ptr, size, size);
}
```
В принципе, ничего хитрого на самом деле в этом нет, примерно этим же занимается [`wasm_bindgen`](https://habr.com/en/post/353230/).
Теперь попробуем создать свой первый WASM модуль для нашего процедурного макроса. Для этого создадим крейт с единственной публичной функцией, она будет принимать указатель на начало строчки и длину строчки в байтах.
```
#[no_mangle]
pub unsafe extern "C" fn implement_codec(
item_ptr: i32,
item_len: i32,
) -> i32 {
let item = str_from_raw_parts(item_ptr, item_len);
let item = TokenStream::from_str(&item).expect("Unable to parse item");
// Здесь уже вызывается типичная функция, реализующая процедурный макрос.
// `fn(item: TokenStream) -> TokenStream`
let tokens = codec::implement_codec(item);
let out = tokens.to_string();
to_host_buf(out)
}
pub unsafe fn str_from_raw_parts<'a>(ptr: i32, len: i32) -> &'a str {
let slice = std::slice::from_raw_parts(ptr as *const u8, len as usize);
std::str::from_utf8(slice).unwrap()
}
```
Код хостовой части состоит из двух основных компонент, первым из которых является загрузчик WASM модуля.
```
pub struct WasmMacro {
module: Module,
}
impl WasmMacro {
// Конструктор нашего макроса расширения.
pub fn from_file(file: impl AsRef) -> anyhow::Result {
// Загружаем и компилируем WASM модуль, находящийся по заданному пути.
let store = Store::default();
let module = Module::from\_file(&store, file)?;
Ok(Self { module })
}
// Вызываем метод с именем `fun` внутри нашего модуля, в котором содержится
// основная логика преобразования входного TokenStream в выходной.
pub fn proc\_macro\_derive(
&self,
fun: &str,
item: TokenStream,
) -> anyhow::Result {
// Как уже описывалось ранее, чтобы передавать TokenStream между средами,
// нам необходимо преобразовать его в строку.
let item = item.to\_string();
// Создаем конкретный экземпляр модуля, с которым и будем работать.
let instance = Instance::new(&self.module, &[])?;
// Получаем указатель на нужную нам функцию, в данном случае это
// описанная выше `implement\_codec`.
let proc\_macro\_attribute\_fn = instance
.get\_export(fun)
.ok\_or\_else(|| anyhow!("Unable to find `{}` method in the export table", fun))?
.func()
.ok\_or\_else(|| anyhow!("export {} is not a function", fun))?
.get2::()?;
// Для передачи данных строки внутрь WASM модуля используем специальную
// обертку, о которой я подробнее расскажу ниже.
let item\_buf = WasmBuf::from\_host\_buf(&instance, item);
// Получим из обертки указатель на начало строки и ее длину в байтах
let (item\_ptr, item\_len) = item\_buf.raw\_parts();
// А теперь вызываем искомый метод и в результате получаем указатель
// на начало строки с выходным TokenStream.
let ptr = proc\_macro\_attribute\_fn(item\_ptr, item\_len).unwrap();
// Оборачиваем сырой указатель и читаем получившуюся строку.
let res = WasmBuf::from\_raw\_ptr(&instance, ptr);
let res\_str = std::str::from\_utf8(res.as\_ref())?;
// В заключительном этапе парсим строку в TokenStream и возращаем выше.
TokenStream::from\_str(&res\_str)
.map\_err(|\_| anyhow!("Unable to parse token stream"))
}
}
```
Теперь давайте чуть подробнее рассмотрим `WasmBuf` модуль: по сути дела это умный указатель,
который владеет некоторой частью памяти, выделенной при помощи `toy_alloc`. Рассмотрим
самые интересные его части, а остальной код можно посмотреть в репозитории.
```
struct WasmBuf<'a> {
// Индекс начала выделенного буфера, проще говоря, указатель на его начало.
offset: usize,
// Длина буфера в байтах.
len: usize,
// Ссылка на инстанс модуля, в котором выделялась память
instance: &'a Instance,
// Ссылка на всю память, связанную с этим инстансом.
memory: &'a Memory,
}
const WASM_PTR_LEN: usize = 4;
impl<'a> WasmBuf<'a> {
// Самый простой конструктор буфера: мы просто при помощи `toy_alloc`
// запрашиваем искомое число байт.
pub fn new(instance: &'a Instance, len: usize) -> Self {
let memory = Self::get_memory(instance);
// Выделяем память и получаем на нее указатель.
let offset = Self::toy_alloc(instance, len);
Self {
offset: offset as usize,
len,
instance,
memory,
}
}
// Намного удобнее не просто запрашивать буфер, а потом руками заполнять его,
// а сразу передать ссылку на байты, которые мы хотим в него записать.
pub fn from_host_buf(instance: &'a Instance, bytes: impl AsRef<[u8]>) -> Self {
let bytes = bytes.as_ref();
let len = bytes.len();
let mut wasm_buf = Self::new(instance, len);
// Копируем байты с хостового буфера в буфер таргета.
wasm_buf.as_mut().copy_from_slice(bytes);
wasm_buf
}
// Если же буфер был выделен внутри таргета, то все становится несколько
// сложнее. Так как получить мы можем лишь указатель на начало буфера и
// непонятно каким же образом мы получим размер выделенной памяти.
// Но мы не зря написали `toy_alloc` таким образом, чтобы первые его 4
// байта содержали размер выделенного буфера.
pub fn from_raw_ptr(instance: &'a Instance, offset: i32) -> Self {
let offset = offset as usize;
let memory = Self::get_memory(instance);
let len = unsafe {
// Получаем сырой указатель на память инстанса.
let buf = memory.data_unchecked();
let mut len_bytes = [0; WASM_PTR_LEN];
// Читаем байты с размером выделенного буфера.
len_bytes.copy_from_slice(&buf[offset..offset + WASM_PTR_LEN]);
u32::from_le_bytes(len_bytes)
};
Self {
offset,
len: len as usize,
memory,
instance,
}
}
// Методы для чтения и записи данных являются весьма тривиальными.
// Важно лишь помнить про то, что нужно читать со смещением в 4 байта.
pub fn as_ref(&self) -> &[u8] {
unsafe {
let begin = self.offset + WASM_PTR_LEN;
let end = begin + self.len;
&self.memory.data_unchecked()[begin..end]
}
}
pub fn as_mut(&mut self) -> &mut [u8] {
unsafe {
let begin = self.offset + WASM_PTR_LEN;
let end = begin + self.len;
&mut self.memory.data_unchecked_mut()[begin..end]
}
}
}
```
Важно не забывать вызывать деструктор, который будет очищать выделенную память.
```
impl Drop for WasmBuf<'_> {
fn drop(&mut self) {
Self::toy_free(self.instance, self.len);
}
}
```
Собираем все вместе
-------------------
И вот теперь мы можем спокойно написать наш искомый процедурный макрос, который будет
использовать WASM модули для расширения функциональности, без необходимости перекомпиляции.
```
#[proc_macro_derive(TextMessage, attributes(text_message))]
pub fn text_message(input: TokenStream) -> TokenStream {
let input: DeriveInput = parse_macro_input!(input);
let attrs = TextMessageAttrs::from_raw(&input.attrs)
.expect("Unable to parse text message attributes.");
// Для простоты будем грузить модули из директории codecs, которые имеют
// особым образом сформированное имя.
let codec_dir = Path::new(&std::env::var("CARGO_MANIFEST_DIR")
.unwrap())
.join("codecs");
let plugin_name = format!("{}_text_codec.wasm", attrs.codec);
let codec_path = codec_dir.join(plugin_name);
let wasm_macro = WasmMacro::from_file(codec_path)
.expect("Unable to load wasm module");
wasm_macro
.proc_macro_derive(
"implement_codec",
input.into_token_stream().into(),
)
.expect("Unable to apply proc_macro_attribute")
}
```
В [репозитории](https://github.com/alekseysidorov/proc-macro-plugin/tree/master) есть готовый пример с демонстрацией работы. Вы можете убедиться, что кодек действительно загружается из WASM модуля, а не компилируется вместе с макросом.
```
#[derive(Debug, Serialize, Deserialize, PartialEq, TextMessage)]
// Что особенно хорошо, каждый WASM плагин может иметь свои произвольные атрибуты.
#[text_message(codec = "serde_json", params(pretty))]
struct FooMessage {
name: String,
description: String,
value: u64,
}
fn main() {
let msg = FooMessage {
name: "Linus Torvalds".to_owned(),
description: "The Linux founder.".to_owned(),
value: 1,
};
let text = msg.to_string();
println!("{}", text);
let msg2 = text.parse().unwrap();
assert_eq!(msg, msg2);
}
```
Выводы
------
Пока это больше похоже на троллейбус из буханки хлеба, но с другой стороны это небольшая, но прекрасная демонстрация самого принципа. Такие макросы становятся открытыми для расширения. У нас больше нет необходимости в переписывании исходного процедурного макроса, чтобы изменить или расширить его поведение. А если же воспользоваться [реестром модулей](https://wapm.io/) для WASM, то можно будет распространять подобные модули подобно крейтам cargo. | https://habr.com/ru/post/497916/ | null | ru | null |
# Resharper и IoC контейнеры: теперь знакомы! или плагин Agent Mulder
Доброго времени,
Как известно, [Resharper](http://www.jetbrains.com/resharper/) решает много проблем по работе с кодом, но все-таки не все.
Одной из такой, не очень решенной, проблемой является навигация по зарегистрированным в IoC контайнерах классам.
Рассмотрим простой пример (используется IoC контейнер [Unity](http://unity.codeplex.com/) от Microsoft).
````
IUnityContainer container = new UnityContainer();
container.RegisterType();
container.RegisterType();
````
В этом примере Resharper «не знает» где используется конструктор MovieFinder и выдает сообщение (по команде Find Usages) *«Usages of 'MovieFinder(...)' was not found»*.
````
public class MovieFinder: IMovieFinder
{
readonly IMovieRepository repository;
public MovieFinder(IMovieRepository repository)
{
this.repository = repository;
}
...
}
````
Еще хуже обстоит дело, если в регистрации не используется имя класса. В этом случае класс будет показан Resharper-ом как не используемый.
Но, для того чтобы «познакомить» Resharper и IoC контайнеры нашлось решение.
Видимо пользуюясь известной фразой "[пусть все будет, но чего то не хватает](http://www.youtube.com/watch?v=3zDtR6oM3eQ)", разработчики Resharper-а добавили возможность написания плагинов.
Этим то и воспользовался [Igal Tabachnik](https://github.com/hmemcpy).
[Плагин Agent Mulder](http://hmemcpy.github.com/AgentMulder/) анализирует контейнеры и обеспечивает удобную навигацию между классами и их регистрацией.
Итак, плагин обеспечивает 3 главные возможности:
1. Помечает классы, зарегистрированные в контейнере, специальной иконкой:
2. Обеспечивают навигацию от определения класса к месту регистрации.
3. И обратно, навигацию от регистрации до определения классов.
Работает все быстро и точно, но, к сожалению, иногда (VS2010 + Reshaper 6.1) навигация работает не так идеально, как хотелось бы. Надеюсь эти недостатки будут быстро устранены, потому что вещь полезная в хозяйстве.
Все что вокруг самого плагина (сайт, документация, инсталляция) сделаны хорошо и работают без проблем.
Сайт плагина: <http://hmemcpy.github.com/AgentMulder/> содержит простое, но ясное описание. Имеется [видео](http://vimeo.com/41113265), которое объясняет еще проще.
Плагин уже попал на [сайт Resharper](http://www.jetbrains.com/resharper/plugins/index.jsp#Agent_Mulder)-а. Я там насчитал 17 плагинов, из них 4 агента.
Список поддерживаемых контейнеров может быть найден тут <https://raw.github.com/hmemcpy/AgentMulder/master/WhatsNew.txt>.
Кстати, по хорошему надо написать систему плагинов для этого плагина, что бы добавлять свои IoC контейнеры :).
Детальное видео "[Дмитрий Нестерук. ReSharper: Архитектура и Расширения](http://vimeo.com/19273009)" от [mezastel](https://habrahabr.ru/users/mezastel/) может послужить введением в мир плагинов от решарпера.
Игорь. | https://habr.com/ru/post/145958/ | null | ru | null |
# «Переезжаем» в офлайн: Web Storage, Application Cache и WebSQL
Чтобы делать приложения, которые могут работать в полностью автономном режиме, нам нужно познакомиться со следующими технологиями: HTML5 Application Cache, Web Storage и WebSQL.
Мной уже были опубликованы вводные статьи, касающиеся [Web Storage](http://dev.opera.com/articles/view/web-storage/) и [HTML5 Application Cache](http://dev.opera.com/articles/view/offline-applications-html5-appcache/). Рекомендую их к прочтению если вы еще не знакомы с основными понятиями. В данной статье будут пересмотрены эти технологии, в том числе и WebSQL, и описаны варианты их совместного эффективного использования. Все эти технологии поддерживаются настольной версией браузера Opera 11.10, Opera Mobile 11, браузерами на движке WebKit (в iOS и Google Android).
| |
| --- |
| **Примечание:** Все примеры, описанные ниже, доступны в [этом архиве](http://dev.opera.com/articles/view/taking-your-web-apps-offline-web-storage-appcache-websql/offline-web-apps.zip). Вы можете скачать архив и смотреть примеры, попутно читая статью (естественно, находясь в офлайне). |
Зачем вообще нужен «офлайн-режим»?
==================================
В настоящее время веб-страницы представляют собой не просто текст. Интернет получает всё более широкое распространение, и веб-приложения, соответственно, тоже, становясь всё более сложными и совершенными. И наша зависимость от них только растёт. Мы можем видеть всё больше и больше примеров, когда веб-приложения успешно заменяют традиционные настольные приложения, чьим основным преимуществом всегда была их возможность спокойно работать в автономном режиме. Дать такую же возможность веб-приложениям не позволяло отсутствие необходимых технологий и инструментов.
~~Но всё меняется, когда приходят они...~~
Но теперь это не проблема! С появлением таких технологий, как HTML5 Application Cache, Web Storage и WebSQL мы наконец получили способ заставить веб-приложения работать в офлайне:
* Application Cache позволяет держать копию HTML, CSS и других элементов нашего веб-приложения в автономном режиме, которые будут использоваться, когда сеть будет недоступна.
* Web Storage основывается на механизмах хранения, подобных cookies, представляя собой их более гибкую и более мощную реализацию.
* WebSQL реализует полномерную SQL-базу данных внутри вашего браузера, которая может хранить копии данных веб-приложения для автономной работы, позволяя пользователям продолжить работу с данными даже при потере соединения с сетью. Данные синхронизируются с сервером при последующем подключении к сети.
Существует множество причин потери соединения с сетью: отключение питания, проблемы сетевым оборудованием, отсутствующий (или слабый) сигнал в случае работы через сотовый телефон. Как разработчики, мы хотим быть уверенными, что даже в подобных ситуациях наши веб-приложения будут работать корректно (по крайней мере, в разумных пределах).
Кэш: грузимся и при отсутствии сети
===================================
В общем случае, если мы не в сети, то при загрузке или перезагрузке страниц сайта мы получим ошибку. Первое, что нужно сделать — убедиться, что наши пользователи могу видеть страницы и работать с веб-приложением даже при отсутствующем подключении, т.е. все картинки, CSS, JavaScript и сама HTML-страница должны корректно загружаться в этом режиме.
Достигается это путем использования технологии Application Cache (называемую также AppCache). Чтобы её использовать, нужно для начала объявить manifest-файл, в котором указать имена файлов, которые необходимы приложению для работы офлайн.
Пример файла *demo.manifest*:
```
CACHE MANIFEST
CACHE:
logo.png
style.css
script.js
jquery.js
index.htm
```
Какие бы ссылки ни содержал этот manifest-файл, соответствующее содержимое помещается в кэш, и впоследствии к этому содержимому уже будет доступ. Объявить manifest-файл очень просто — нужно использоваться атрибут *manifest* элемента :
```
```
Все файлы, объявленные в этом файле, будут помещены в кэш вашего браузера. Даже если человек не в сети и пытается загрузить страницу, то все ресурсы, указанные в этом файле, загрузятся браузером.
Более подробную информацию об этом вы можете найти в статье про [HTML5 Application Cache](http://dev.opera.com/articles/view/offline-applications-html5-appcache).
Что насчет данных?
==================
AppCache решает задачу доступности некоторых элементов сайта в офлайне, но, возможно, нам захочется хранить некоторый объём пользовательских данных или, например, его последние поисковые запросы. В другом случае, может быть, вам захочется хранить более структурированные данные. В любом случае, Web Storage и WebSQL будут лучшим решением.
### Используем Web Storage
Web Storage прекрасно подходит для хранения небольших объемов информации, нежели огромных таблиц с данным, о чём кратко и поговорим в этой статье, рассмотрим примеры. Более подробную информацию вы можете узнать в отдельной [статье, посвящённой Web Storage](http://dev.opera.com/articles/view/web-storage/).
Существует очень много мест, где частое отключение электричества — обычное явление («Чубайс, привет! :)», — от переводчика). Пользователю приходится сидеть и ждать, когда он сможет продолжить свою работу в Интернете, пока не включат электричество. А представьте, если кто-то оказался в подобной ситуации, заполняя многостраничную форму на каком-либо сайте, набирая большую статью для блога или важного электронного письма. Во время отключения питания (или сядут аккумуляторы) пользователь потеряет все эти данные. Не будет ли лучше, если после входа в сеть, ему будут доступны все несохраненные им записи, с которыми он продолжит работу?
Давайте посмотрим, что можно сделать на странице, содержащей обычное текстовое поле ? Страница должна сохранять всё, что мы набираем, в локальное хранилище каждые несколько секунд, а в случае её перезагрузки или закрытия, страница должна загружать последний сохранённый в поле текст.
Допустим, наша страница содержит поле с *id* «draft»:
```
...
...
```
Напишем простую функцию, которая будет сохранять в локальное хранилище содержимое :
```
function saveMessage(){
var message = document.getElementById("draft");
localStorage.setItem("message", message.value)
}
```
Установим интервал сохранения в полсекунды:
```
setInterval(saveMessage, 500);
```
| |
| --- |
| **Примечание:** здесь мы использовали *setInterval()* для простоты, чтобы сохранять сообщение в локальное хранилище каждые полсекунды. (Вы могли бы улучшить эту процедуру, например, сохраняя содержимое текстового поля только в том случае, если пользователь в него что-то ввёл). |
Также нужно убедиться, что каждый раз, когда страница открывается или перезагружается, в текстовое поле загружалось последнее сохранённое содержимое из локального хранилища (*localStorage*):
```
window.addEventListener("DOMContentLoaded", loadMessage, false);
function loadMessage() {
var textbox = document.getElementById("draft");
var message = localStorage.getItem("message");
if (!message) {
textbox.value = "";
}else {
textbox.value = message;
}
}
```
Посмотрите пример [работы с Web Storage](http://people.opera.com/shwetankd/webstorage/webstoragedemo.htm). Это вообще шикар
ная вещь, если вам нужно сохранять локально небольшие кусочки информации.
### Работаем в автономном режиме
Для перехода в автономный режим нужно его, собственно, активировать (в браузере Opera: «Меню» → «Настройки» → «Работать автономно» либо «Файл» → «Работать автономно»). Свойство *navigator.onLine* имеет значение *false* в случае, если браузер находится в автономном режиме, в противном случае оно имеет значение *true*. Однако, во многих случаях лучше было бы использовать события. Когда пользователь переключается в автономный режим, срабатывает событие *offline*, когда переключается обратно — соответственно *online*. Можно воспользоваться этим для вывода небольшого сообщения о переходе в автономный режим.
Получится что-то типа этого:
```
...
window.addEventListener( "offline", function(){showWarningDiv("on")}, false);
window.addEventListener( "online", function(){showWarningDiv("off")}, false);
...
function showWarningDiv(status){
var warningdiv = document.getElementById("warning");
if (status == "on"){
warningdiv.innerHTML = "Right now you are in offline mode. This message is saved and will be sent to the server the next time you are online.
";
} else {
warningdiv.innerHTML = "";
}
}
```
| |
| --- |
| **Примечание:** в настоящее время поддержка автономного режима реализована только в Opera и Firefox. |
Имеет смысле убедиться, что формы не пытаются отправить данные в то время, когда пользователь работает в автономном режиме. Чтоб проверить это, можем сделать так:
```
...
window.addEventListener( "submit", submitForm, false);
...
function submitForm(){
saveMessage();
if (!navigator.onLine){
return false;
}
}
```
При отправке данных формы срабатывает событие *submit*, которое вызывает функцию *submitForm()*. Эта функция сначала сохранит сообщение в локальном хранилище, затем, если пользователь работает в автономном режиме, данные никуда не отправятся.
Вы можете усовершенствовать этот пример, чтобы он сохранял копию на сервер каждые несколько секунд, чтобы там она была доступна на тот случай, если пользователь случайно удалит данные у себя. Это особенно важно в тех случаях работы, например, с конфиденциальной информацией: вы, скажем, хотите, чтобы информация о вашей кредитной карте хранилась только у вас — в локальном хранилище.
Посмотрите также [более продвинутый пример](http://people.opera.com/shwetankd/webstorage/demofolder/webstorage_advanced.zip), который использует для хранение информации *sessionStorage*. Если вы не закрываете страницу (даже в случае её перезагрузки) текст, введённый в текстовое поле, там и останется. Страница также будет отправлять содержимое этого поля на сервер каждые несколько секунд и, соответственно, обновлять время последнего сохранения. Данный подход может использоваться в блоговых движках и сервисах электронной почты для периодического сохранения «черновиков», что позволит продолжить работу в случае проблем с подключением.
### WebSQL: еще «глужбе» в офлайн
Web Storage прекрасно подходит для хранения небольших объемов информации, а что если мы захотим хранить целую базу данных? Как насчёт того, чтобы веб-приложение могло делать различные запросы к базе данных, поиск по ней?
Здесь Web Storage уже не позволит развернуться — нужно что-то более надёжное. А именно — WebSQL. WebSQL представляет собой локальную SQLite базу данных, в которой вы можете хранить свои данные, используя комбинацию Javascript и SQL.
##### Работа с WebSQL-базами данных
Перво-наперво нужно убедиться, поддерживает ли браузер WebSQL? Сделать это можно через свойство *window.openDatabase*:
```
if (window.openDatabase){
//rest of your code
} else{
alert("It seems your browser does not have support for WebSQL. Please use a browser which does, otherwise parts of this application may not run as intended."); //or any other similar message
}
```
##### Создание и открытие базы данных
Создать и открыть базу данных можно, используя команду *openDatabase*, так:
```
var db = openDatabase("food_db", "1.0", "Web SQL Storage Demo Database", 1*1024*1024); // creates a database called 'food_db' with version number 1.0, description as 'Web SQL Demo Database' and a size of 1MB.
```
Мы только что создали базу данных *food\_db* «версии» 1.0, с описанием *«Web SQL Storage Demo Database»*, размером 1 МБ. Переменная *db* представляет собой указатель на объект базы данных, который мы и будем в дальнейшем использовать.
| |
| --- |
| **Примечание:** размер базы данных устанавливается в байтах. Поэтому мы определили размер в формате 1\*1024\*1024, что составляет 1 МБ. Если нужно установить размер, например, 4 МБ, следует указывать величину 4\*1024\*1024 соответственно. |
##### Работа с базой данных
Мы создали и открыли базу данных. Теперь можно выполнять различные операции над ней, используя SQL-команды. Операции мы будем производить, вызывая функцию *transaction()* объекта базы данных (в нашем случае это *db*). Её вызов возвращает объект в качестве указателя, над которым мы будем выполнять различные команды, используя *executeSQL()*. Синтаксис этой команды следующий:
```
executeSql(sqlStatement, arguments, callback, errorCallback);
```
Из параметров только *sqlStatement* является обязательным, остальные — необязательные.
Так, например, если мы хотим создать таблицу, нужно будет написать следующее:
```
...
db.transaction(
function(t){ // This is the callback with "t" as the transaction object
t.executeSql("CREATE TABLE IF NOT EXISTS cal_list (food_name TEXT PRIMARY KEY, calories REAL, servings TEXT)");
}
);
...
```
Этот код создаст таблицу *cal\_list* (если её не существовало) с полями *food\_name*, *calories* и *servings*.
##### Добавление записей в таблицу
Выполнять запросы на добавление записей в таблицу — простая задача для WebSQL. Рассмотрим пример:
```
var food_name = "pizza";
var amount_of_calories = 320;
var serving_size = "one slice";
db.transaction(
function(t){
t.executeSql("INSERT INTO cal_list VALUES (?, ?, ?)", [food_name, amount_of_calories, serving_size]);
}
);
```
Первый знак вопроса экранирует параметр *food\_name*, второй — *amount\_of\_calories*, а третий — *serving\_size*. Этот код добавляет запись в таблицу *cal\_list* со значениями: *pizza*, *320* и *one slice* соответствующие столбцы.
Выполним другой запрос — на получение данных:
```
var min_cal_amount = 300;
...
t.executeSql("SELECT * FROM cal_list WHERE calories > ?", [min_cal_amount]);
```
Этот код выполнит запрос на выборку всех строк со значением *calories* больше 300: знак вопроса экранирует переменную *min\_cal\_amount*.
##### Обработка результатов запроса
Ну, вот, мы создали базу данных с таблицами, в которые записали данные, теперь мы хотим сделать запрос и вывести полученные результаты. Обычно, мы получаем кучу результатов для одного SQL-запроса и нам нужно как-то обработать эти результаты, чтобы вывести их в виде таблицы или каком-то другом структурированном виде на странице. Третий параметр функции executeSQL() определяет успешность выполнения запроса. Ниже приведён пример обработки результатов:
```
var list = document.getElementById("thelist");
var food;
var min_cal_amount = 400;
var serving_size;
db.transaction(
function(t){
t.executeSql("SELECT food_name AS food, calories AS amount_of_calories, servings as serving_size FROM cal_list where calories > ?" ,[min_cal_amount], function(t,r){
for (var i=0; i < r.rows.length; i++){
food = r.rows.item(i).food;
amount_of_calories = r.rows.item(i).amount_of_calories;
serving_size = r.rows.item(i).serving_size;
list.innerHTML +="- "+food+" has "+amount\_of\_calories+" KCAL worth of calories.
";
}
},
function(t,e) {alert(e.message);})
}
);
```
Сначала мы определяем количество элементов в результате запроса через *r.rows.length* и пробегаемся от 0 до этого значения. Каждый элемент доступен по *r.rows.item(i)*, где i — номер строки. Названия столбцов можно получить так же. Для получения получения значения столбца *food* используем *r.rows.item(i).food* и так далее для других столбцов.
Используем всё и сразу
======================
Не исключено, что вам захочется использовать Web Storage, Application Cache и WebSQL вместе. Это возможно, всё зависит от задач, которые нужно решить. Например, если вы хотите хранить всего лишь некоторые пользовательские настройки, будет излишеством использовать WebSQL. Для подобных целей лучше подойдёт Web Storage.
Однако, если у вас большой объём данных, и нужно их как-то обрабатывать, то логичнее было бы использовать WebSQL.
Посетите страницу с примером про калории, на которой [используются вместе все три технологии](http://people.opera.com/shwetankd/websql/combineddemo.htm): база данных хранится в Web Storage, так что вы сможете искать даже если закроете или перезагрузите страницу, AppCache и WebSQL используются для предоставления возможности работать в автономном режиме.
| |
| --- |
| **Примечание:** вы можете самостоятельно получить информацию о том, какие базы данных используются в Opera и управлять ими, перейдя по ссылке **opera:webdatabases**. А получить информацию о доменах, которые хранят свои данные в браузере, используя Web Storage, и управлять ими, перейдя по ссылке **opera:webstorage**. |
Подождите… разве спецификации WebSQL утверждены?
================================================
Ещё не окончательно. Но вы уже можете применять эту технологию на приведённом списке браузеров и устройств. Чего нельзя сказать о IndexedDB, у которой нет такой кросс-платформенной поддержки. Осталось только дождаться утверждения спецификации, что и произойдёт в скором времени.
Важно также отметить, что некоторые настольные версии браузеров, такие как Firefox и Internet Explorer, не будут поддерживать WebSQL, они будут работать с IndexedDB. В этом случае, первое, где можно применить WebSQL — автономное хранилище данных для смартфонов: поддерживаются браузеры Opera Mobile 11, а также браузеры на движке WebKit для платфом Android и iOS.
Хорошая новость о WebSQL заключается в том, что он предлагает удобный инструмент для создания автономной базы данных в браузере. Он лёгок в изучении и применении и позволяет быстро разработать автономное веб-приложение, которое будет сразу работать в нескольких браузерах.
Заключение
==========
Веб-приложения теперь получили возможность работать в полностью автономном режиме, используя такие технологии, как Application Cache, Web Storage и WebSQL базы данных. Application Cache нам нужен для кэширования файлов, чтоб исползовать их в автономном режиме; Web Storage — для хранения небольших объёмов информации, ну а WebSQL будет удобным инструментом для работы с большими объёмами данных. Разработчики в зависимости от потребностей могут использовать различное сочетание этих технологий, для создания автономных приложений.
---
Технология перспективная. И, как обычно, будут гонки… WebSQL и IndexedDB, упоминания о которой уже [были на хабре](http://habrahabr.ru/tag/indexeddb/). Пусть они сделают мир лучше :)
###### p.s. Все замечания по переводу, как обычно, принимаются в личку.
p.p.s. где-то я, видимо, плавно переехал с «web storage» на «локальное хранилище». Что лучше оставить-то? ;) | https://habr.com/ru/post/117123/ | null | ru | null |
# Шпаргалка => Cross Domain AJAX. Dynamic script Tag Hack
Так сложилось исторически (из-за соображений безопасности), что Javascript-обьект *XMLHttpRequest*, который лежит в основе AJAX, не может делать кросс-доменные вызовы. Это бесполезное ограничение: для злоумышленников не представляет особой проблемы, а для разработчиков создает некоторое неудобство. В следующих поколениях браузеров эту проблему обещали решить, но не раньше чем W3C хотя бы одобрит новые стандарты.
Есть море хаков чтобы обойти это ограничение, но самый популярный это *Dynamic Script Tag Hack*. Именно через этот хак организован доступ к многим API современных веб-приложений.
#### Суть
*XMLHttpRequest* не используется вовсе. На странице динамически создается тег *и указывается целевой адрес на другом домене. Браузер в фоновом режиме подргузит и исполнит содержание удаленного скрипта. Сам удаленный скрипт передает JSON данные и представляет из себя обычный вызов функции вида:
*callback\_function(json\_data);*
Функция `callback\_function` должна находиться на странице и быть видна глобально. Она и будет обрабатывать возвращенные в JSON данные. Имя этой callback функции должно быть или же заранее известно как на стороне клиента, так и на стороне сервера, или передано GET параметром, например:
*`src="http://example.com/api.js.php?callback_func=mycallback"`*
Соответственно, удаленный скрипт, который выдает JSON данные должен выглядеть приблизительно так
*php print $\_GET['callback\_func']. '('. json\_encode($somedata). ')'; ?*
#### «Заключение»
Сам хак очень прост в использовании, тем не менее некоторые девелоперы не могут его понять слёту.
Разбирать JSON данные на клиентской стороне очень удобно. Если нужна дополнительная инфа, вот неплохая статья: [An Introduction to JavaScript Object Notation (JSON)](http://www.webreference.com/programming/javascript/rg5/)
**Перенесено из личного блога как только набрал достаточно кармы*** | https://habr.com/ru/post/63353/ | null | ru | null |
# Qt: работа с Vkontakte API и Phonon
Статья описывает взаимодействие Qt c такими программными интерфейсами как Vkontakte API и Phonon, в реальных примерах и подробным описанием.
В конце статьи ссылка на репозиторий с исходным кодом который Вы можите свободно скачать и запустить.
Сразу хотелось бы отметить что я не гуру, а программный код можно, было бы, реализовать лучше. Я с удовольствием приму Ваши поправки, комментарии и критику.
Что бы не дублировать информацию — буду указывать ссылки на Wiki.
Так же, наверное, нужно отметить что программа тестировалась и разрабатывалась на платформе Gnu/Linux/Gentoo (KDE) и я не проверял ее под другими платформами и дистрибутивами но должно работать.
##### Общий алгоритм:
1. Авторизация в соц сети через Vkontakte API (далее ВК).
2. Получение списка избранных аудиозаписей.
3. Создание списка треков из полученного списка для Phonon.
4. Реализация возможности скачивания выбранной песни.
##### Авторизация
Согласно [документации](http://vkontakte.ru/developers.php?id=-1_21239305&s=1), для авторизации необходимо добавить компонент который позволил бы нам просматривать веб страницы. Для этого у Qt есть [WebKit](http://ru.wikipedia.org/wiki/WebKit). В компонент необходимо загрузить страницу [vkontakte.ru/login.php](http://vkontakte.ru/login.php) на которой пользователь сможет пройти процедуру авторизации. При успешной авторизации — ВК сделает перенаправление на страницу /login\_success.html и в [URL](http://ru.wikipedia.org/wiki/URL) допишет необходимые для нас данные, такие как идентификатор сессии, соль и идентификатор пользователя, который нам нужно будет достать (спарсить) из ссылки.
Подключаем к проекту необходимые модули:
`QT += webkit \
network \
xml \
phonon`
Так как ВК возвращает данные в XML (или JSON) нам необходимо подключить модуль XML что бы упростить себе жизнь и не изобретать велосипедов.
Модуль network позволит загрузить необходимую песню с ВК и вообще работать с сетью.
Модуль [Phonon](http://ru.wikipedia.org/wiki/Phonon) позволит нам проиграть нашу видеозапись локально или из сети. Так же он поддерживает проигрывание видео файлов. Работать с этим программным интерфейсом одно удовольствием но о нем чуть позже.
Для работы с ВК у меня отвечает класс VKAuth в конструктор которого я передаю свой идентификатор приложения. Его можно получить [зарегистрировав](http://vkontakte.ru/apps.php?act=add) Ваше приложение в ВК.
> 1. #include
> 2. #include
> 3. #include "mainwindow.h"
> 4. #include "VKAuth.h"
> 5.
> 6. int main(int argc, char\*\* argv)
> 7. {
> 8. QApplication app(argc, argv);
> 9.
> 10. QApplication::setApplicationName("VKaudio");
> 11. QApplication::setApplicationVersion("0.01a");
> 12.
> 13. MainWindow window;
> 14. VKAuth vkAuth("2169954"); //my application id
> 15.
> 16. QObject::connect(&vkAuth, SIGNAL( unsuccess() ),
> 17. &app , SLOT( quit() )
> 18. );
> 19. QObject::connect(&vkAuth, SIGNAL( success(QStringList) ),
> 20. &window, SLOT( slotSuccess(QStringList) )
> 21. );
> 22. vkAuth.show();
> 23. return app.exec();
> 24. }
>
Класс VKAuth высылает сигнал success при успешной авторизации и как аргумент передает список ссылок на песни и сигнал unsuccess если пользователь отказывается от авторизации.
Сигнал об успешной авторизации соединяться со слотом главного окна приложение (самого плеера) который добавляет переданный список в список аудиозаписей, подробней этот процес будет описан позже. Сигнал отказа пользователя от авторизации соединяться со слотом завершения работы программы (выход).
> 1. VKAuth::VKAuth(QString app,QWidget\* parent) : QWebView(parent)
> 2. {
> 3.
> 4. QObject::connect(this, SIGNAL( urlChanged(QUrl) ),
> 5. SLOT( slotLinkChanged(QUrl) )
> 6. );
> 7. m\_app = app;
> 8. loadLoginPage();
> 9. }
>
Как я уже писал выше, в конструктор передается идентификатор приложения и указатель на объект предка. Класс унаследован от QWebView который реализует работу с WebKit и позволяет нам отображать пользователю необходимую веб-страницу. У QWebView есть сигнал который высылается каждый раз при смене адреса страницы. Так как в случай успешной авторизации ВК делает перенаправление (смену адреса) именно этот сигнал нам очень хорошо подходит что бы отловить этот момент. Как аргумент он передает новую ссылку, которую мы и будем [парсить](http://wiki.searchengines.ru/index.php/%D0%9F%D0%B0%D1%80%D1%81%D0%B8%D1%82%D1%8C).
Метод loadLoginPage() реализует загрузку необходимой страницы для авторизации
> 1. void VKAuth::loadLoginPage(){
> 2. QUrl url("[vkontakte.ru/login.php"](http://vkontakte.ru/login.php));
> 3.
> 4. url.addQueryItem("app" , m\_app );
> 5. url.addQueryItem("layout" , "popup" );
> 6. url.addQueryItem("type" , "browser");
> 7. url.addQueryItem("settings", "8");
> 8.
> 9. load(url);
> 10. }
>
Класс QUrl делает работу со ссылками очень и очень удобной.
QUrl разбивает ссылку на части.
Метод addQueryItem добавляет GET параметры в ссылку, где первый аргумент — имя параметра, а второй — его значение.
Таблица со параметром и возможных значениями:
Значение settings нужно нам для того что бы пользователь разрешил нам доступ к его аудио записям.
Сгенерированный URL мы передаем в метод класса QwebView::load() он и загрузит страницу для авторизации.
Допустим пользователь прошел авторизацию- ВК делает перенаправление, высылается сигнал с новым адресом и передается управление слоту slotLinkChanged который отвечает за обработку сигнала о смене адреса.
> 1. void VKAuth::slotLinkChanged(QUrl url)
> 2. {
> 3. if("/api/login\_success.html" == url.path()){
> 4. QRegExp regexp("\"mid\":([^,]+),\"secret\":\"([^,]+)\",\"sid\":\"([^,]+)\"");
> 5. QString str= url.fragment();
> 6.
> 7. if( -1 != regexp.indexIn(str) ){
> 8.
> 9. m\_mid = regexp.cap(1);
> 10. m\_secret = regexp.cap(2);
> 11. m\_sid = regexp.cap(3);
> 12.
> 13. QUrl request("[api.vkontakte.ru/api.php?"](http://api.vkontakte.ru/api.php?));
> 14. QString sig(getSig(m\_mid, m\_secret,"api\_id=" + m\_app +"method=audio.get"+"uid=" + m\_mid +"v=3.0"));
> 15.
> 16. request.addQueryItem("api\_id",m\_app);
> 17. request.addQueryItem("method", "audio.get" );
> 18. request.addQueryItem("uid",m\_mid);
> 19. request.addQueryItem("v","3.0");
> 20. request.addQueryItem("sig",sig);
> 21. request.addQueryItem("sid",m\_sid);
> 22.
> 23.
> 24. QNetworkAccessManager \*manager = new QNetworkAccessManager(this);
> 25. m\_http = manager->get(QNetworkRequest(request));
> 26. QObject::connect(m\_http,SIGNAL(finished()),this, SLOT(slotDone()));
> 27.
> 28. }
> 29. }else if("/api/login\_failure.html" == url.path()){
> 30. emit unsuccess();
> 31. }
> 32. }
> 33. QByteArray VKAuth::getSig(QString mid,QString secret, QString params = ""){
> 34. QString str;
> 35.
> 36. str.append(mid);
> 37. if(!params.isEmpty())
> 38. str.append(params);
> 39. str.append(secret);
> 40.
> 41. return QCryptographicHash::hash( str.toUtf8(), QCryptographicHash::Md5 ).toHex();
> 42. }
>
В слоте мы проверяем куда же нас перенаправили, если перенаправление было на login\_success.html тогда авторизация прошла успешно (согласно [документации](http://vkontakte.ru/developers.php?id=-1_21239305&s=1)).
Создаем [регулярное выражение](http://ru.wikipedia.org/wiki/%D0%A0%D0%B5%D0%B3%D1%83%D0%BB%D1%8F%D1%80%D0%BD%D1%8B%D0%B5_%D0%B2%D1%8B%D1%80%D0%B0%D0%B6%D0%B5%D0%BD%D0%B8%D1%8F) которое поможет нам получить необходимые данные для дальнейшей работы с ВК, а именно:
mid, secret, sid.
Для получения списка аудиозаписей нам необходимо вызвать метод [audio.get](http://vkontakte.ru/developers.php?o=-1&p=audio.get).
Класс Qhttp упростить работу с высокоуровневым протоколом [HTTP](http://ru.wikipedia.org/wiki/HTTP).
Передаем необходимые параметры как GET параметры и создаем хеш (метод — getSig).
Сигнал Qhttp::done который высылается при завершении запроса (получении ответа) соединяться со слотом slotDone.
> 1. void VKAuth::slotDone(bool error){
> 2. if(error)
> 3. emit unsuccess();
> 4. else{
> 5. QStringList list; //list with mp3
> 6.
> 7. QDomDocument dom;
> 8. dom.setContent(m\_http->readAll());
> 9. QDomElement root = dom.firstChildElement(); // root element
> 10. QDomNode audioElement = root.firstChildElement(); //
> 11.
> 12. while(!audioElement.isNull()){
> 13. QString url = audioElement
> 14. .toElement()
> 15. .elementsByTagName("url")
> 16. .item(0)
> 17. .toElement() //
> 18. .text();
> 19. list.append(url);
> 20. audioElement = audioElement.nextSibling(); //next element
> 21. }
> 22. emit success(list); // load player window with playlist
> 23. hide(); //hide this window
> 24. }
> 25.
> 26. m\_http->close();
> 27. }
>
Слот VKAuth::slotDone считывает полученный XML и создает список из ссылок на mp3 песни после чего высылает сигнал success с этим же списком, закрывает соединенее и прячет окно. Авторизация пройдена список песен получен.
##### Phonon
C Phonon работать очень просто, необходимо создать мета объект (класс MediaObject), создать аудио (и/или видео) вывод и объединить их через Phonon::createPath.
В методе MainWindow::appendToList() — мы добавляем получениый список на mp3 файлы к списку.
> 1. void MainWindow::appendToList(){
> 2. if (VKAudioList.isEmpty())
> 3. return;
> 4.
> 5. int index = sources.size();
> 6. foreach (QString string, VKAudioList) {
> 7. Phonon::MediaSource source(string);
> 8.
> 9. sources.append(source);
> 10. }
> 11. if (!sources.isEmpty())
> 12. metaInformationResolver->setCurrentSource(sources.at(index));
> 13. }
>
##### Скачивание выбранной песни
Для скачивания песни ее нужно выделить и нажать Download в верхней части окна программы, появиться диалог в котором необходимо выбрать место для загрузки файла, естественно у вас должны быть права на создание (запись) файла.
Сигнал клика по кнопке соединен со слотом MainWindow::slotDownload().
> 1. void MainWindow::slotDownload(){
> 2. QString path = QFileDialog::getExistingDirectory(this,"Save to...");
> 3.
> 4. if(!path.isEmpty()){
> 5. m\_file = new QFile;
> 6. int item = musicTable->currentRow();
> 7. Phonon::MediaSource src = sources.at(item);
> 8. m\_pSrcUrl = new QUrl(src.url());
> 9. m\_file->setFileName(path + "/" + musicTable->item(item,musicTable->currentColumn())->text() + ".mp3");
> 10.
> 11. if(m\_file->open(QIODevice::ReadWrite)){
> 12. m\_pTcpSocket = new QTcpSocket(this);
> 13.
> 14. m\_pTcpSocket->connectToHost(m\_pSrcUrl->host(), 80,QIODevice::ReadWrite);
> 15. connect(m\_pTcpSocket, SIGNAL(connected()),this, SLOT(slotConnected()));
> 16. connect(m\_pTcpSocket, SIGNAL(readyRead()),this, SLOT(slotReadyRead()));
> 17. connect(m\_pTcpSocket, SIGNAL(error(QAbstractSocket::SocketError)),
> 18. this, SLOT(slotDownloadError(QAbstractSocket::SocketError))
> 19. );
> 20. connect(m\_pTcpSocket,SIGNAL(disconnected()),this,SLOT(slotDisconnected()));
> 21. }else
> 22. QMessageBox::warning(this,"Warning","File open Err !");
> 23. }
> 24.
> 25. }
>
После выбора директории и успешного открытия (создания) файла еще не скачаной песни, необходимо отправить запрос на сервер ВК что бы от «отдал» нам песню. В этом нам поможет QtcpSocket который реализует и очень упрощает работу с TCP/IP. После успешного соеденения с сервером ВК- отправляем ему HTTP запрос:
> 1. void MainWindow::slotConnected(){
> 2. m\_pTcpSocket->write(QString("GET " + m\_pSrcUrl->path() + "\r\n").toAscii());
> 3. }
>
На что он выдает нам содержимое песни которое и нужно записать в файл:
> 1. void MainWindow::slotReadyRead(){
> 2. m\_file->write(m\_pTcpSocket->read(m\_pTcpSocket->bytesAvailable()));
> 3. }
>
После того как ВК отдаст все содержимое песни он закроет соединенее, а нам остается закрыть файл.
> 1. void MainWindow::slotDisconnected(){
> 2. m\_file->close();
> 3. m\_pTcpSocket->close();
> 4. }
>
Как и обещал, в начале статьи, ссылка на репозиторий ([Mercurial](http://ru.wikipedia.org/wiki/Mercurial)): <https://bitbucket.org/denis_medved/vkaudio>
Огромное спасибо Максу Шлее и издательству bhv за замечательную книгу «Qt 4.5: Профессиональное программирование на С++» и конечно же всему открытому сообществу.
**upd**:
Вместо устарелого QHttp и QTcpSocket используется QNetworkAccessManager. | https://habr.com/ru/post/115397/ | null | ru | null |
# Wi-Fi is over: вычисляем нарушителей беспроводного эфира
Для выявления атак и аномалий беспроводного эфира можно использовать высокотехнологичные решения (как правило дорогие), которые позволяют контролировать беспроводные сети и выявлять попытки атак. В этой статье я расскажу о двух бесплатных утилитах, которые позволят вам контролировать беспроводной эфир и оперативно реагировать на вторжения злоумышленников.
С точки зрения обеспечения безопасности отслеживание беспроводных устройств позволяет незамедлительно информировать о том, в какую точку необходимо направить сотрудников отдела безопасности. Существует масса угроз безопасности сети, которые не обнаруживаются традиционными системами IDS/IPS, поскольку их можно обнаружить только на радиочастотном уровне. В число таких угроз входят беспроводные мосты, функционирующие в соответствии с проприетарными протоколами, и устройства, функционирующие в соответствии с более ранними стандартами, например, 802.11FH, которые могут стать точкой вторжения в сеть.
К этим угрозам также относятся WiFi-устройства злоумышленников, работающие на нестандартных рабочих частотах или использующие нестандартную модуляцию. И кроме того, всегда существуют атаки типа «отказ в обслуживании», которые могут исходить от устройств подавления беспроводной сети.
Для выявления атак и аномалий беспроводного эфира можно использовать высокотехнологичные решения (как правило дорогие), которые позволяют контролировать беспроводные сети и выявлять попытки атак. К таким решениям можно отнести Cisco CleanAir. Мы же будем использовать два бесплатных решения — waidps и nzyme.
Важное замечание: для работы утилит необходимо чтобы ваш Wi-Fi адаптер мог работать в режиме монитора.
Waidps
------
Для обнаружения аномалий беспроводного эфира в “домашних” условиях можно использовать утилиту waidps. Это многоцелевой инструмент, созданный для аудита (тестирования на проникновение) сетей, обнаружения беспроводного вторжения (атаки WEP/WPA/WPS) а также предотвращения вторжения (остановка связи станции с точкой доступа). Кроме этого, программа будет собирать всю WiFi информацию в округе и сохранять в базах данных.
Waidps способна выявлять массовые деаутентификации, которые могут сигнализировать о возможной атаке на WPA (для перехвата хендшейка), выявлять атаки с использованием ARP запросов, с помощью Rogue AP и Evil\_Twin, возможных атак перебором WPS-пина и многое другое.
Утилита сама поднимает необходимые ей интерфейсы и начитает мониторить эфир. Интересной особенностью является, что утилиту можно использовать не только для обнаружения атаки, но так же с ее помощью можно провести аудит интересующей нас AP.
Для работы утилиты необходимо дополнительно установить пакет aircrack-ng и wireshark.
Утилита мониторит беспроводной эфир и сигнализирует об аномалиях — распространенных атаках на беспроводную сеть, а также о появлении подложных точек доступа — RogueAP.
Хотя утилита и не обновлялась с 2014 года, до недавнего времени ей не было альтернатив. С помощью нескольких точек waidps можно настроить мониторинг периметра, выверив по уровню сигнала до каждой станции физическое месторасположение — для того чтобы выявлять примерное место дислокации нарушителя.
Оптимальный вариант — запустить утилиту на несколько часов чтобы снять «чистую» картину эфира для сравнения.
→ [Скачать утилиту](https://github.com/SYWorks/waidps)
nzyme
-----
Nzyme собирает фреймы 802.11 непосредственно из эфира и отправляет их в систему управления журналом Graylog (с открытым исходным кодом), что позволяет использовать ее в качестве IDS WiFi, мониторинга и реагирования на инциденты. Для этого требуется только JVM и WiFi-адаптер, поддерживающий режим мониторинга.
Отличительной особенностью данного инструмента является изначальная «заточенность» на запуск на слабых машинах, например на Raspberry Pi. Также есть возможность запуска nzyme «из коробки» на MacBook.
Для начала необходимо сконфигурировать систему для работы, установив deb пакет или воспользовавшись jar файлом. Также необходимо настроить конфиг файл для соединения с Graylog:
`nzyme_id = nzyme
channels = en0:1,2,3,4,5,6,8,9,10,11
channel_hop_command = sudo /System/Library/PrivateFrameworks/Apple80211.framework/Versions/Current/Resources/airport {interface} channel {channel}
channel_hop_interval = 1
graylog_addresses = %graylog IP%:12000
beacon_frame_sampling_rate = 0`
Для отображения используется [Graylog](https://www.graylog.org/) (можно использовать в виде виртуальной машины), что позволяет выводить информацию в красивом интерфейсе:
Несомненным плюсом утилиты является возможность просмотра устройств, вероятно скомпрометированных злоумышленниками — nzyme покажет, какие устройства имели неосторожность подключится к подложной точке доступа.
→ [Скачать утилиту](https://github.com/lennartkoopmann/nzyme)
### Заключение
Эти утилиты ни в коей мере не заменят «профессиональных» решений по защите беспроводного эфира, но тем не менее смогут дать информацию о его «чистоте».
Современное оборудование позволяет проводить постоянное активное прослушивание по всем каналам, осуществлять проверку появившихся точек по различным критериям позволяет быстро выявлять точки злоумышленников. После обнаружения генерируются соответствующие уведомления. Технология Management Frame Protection (MFP) нейтрализует атаки типа Evil Twin, так как при ее использовании в каждый беспроводной фрейм вставляется специальная подпись, и клиент с поддержкой этой фичи просто не станет аутентифицироваться на точке доступа злоумышленника.
Кроме того, можно включить активный режим сдерживания (Active Rogue Containment) и тогда при обнаружении точки злоумышленника на нее будут массово отправляться пакеты de-authentication, что не позволит к ней никому подключиться.
Для обнаружения новых точек подключенных непосредственно в локальную сеть предприятия, необходимо использовать технологию switchport tracing, в результате работы которой обнаруживается и блокируется порт на коммутаторе и точка злоумышленника теряет доступ в локальную сеть.
Также, кроме встроенного базового IDS существуют так же и адаптивные wIPS. wIPS умеют обнаруживать в том числе и использование инструментов (karma, aircrack), всплески трафика в нерабочее время, DHCP серверы атакующих, подбор ключей WEP и т.д.
Дополнение: в данный момент неизвестно, умеет ли профессиональное оборудование детектировать новый вид атак — Key Reinstallation Attacks. | https://habr.com/ru/post/339270/ | null | ru | null |
# Создаем свой язык на Groovy
Основная проблема императивных языков программирования — их низкая приближенность к естественным языкам.
ООП эту проблему частями решил, упорядочив данные и логику по классам объектов, но все равно это выглядит сложно для понимания. Основная проблема здесь в том, что императивные языки не приспособлены для работы с иерархиями объектов и вложенными вызовами методов.
Например, у меня есть иерархия классов работы с заказами на продукты для клиентов:
```
// Клиент
class Customer {
int inn
String name
String address
String phone
}
// Клиенты
class Customers {
Customer findByInn(inn)
void add(Customer customer)
}
// Продукт
class Product {
String article
String name
double price
}
// Продукты
class Products {
Product findByArticle(article)
void add(Product product)
}
// Заказ
class Order {
int num
Customer customer
List details = []
OrderDetail findByPos(pos)
void add(OrderDetail detail)
}
// Товар заказа
class OrderDetail {
int pos
Product product
def count = 1
def getSum() { count \* product.price }
}
// Заказы
class Orders {
Order findByNum(num)
void add(Order order)
}
```
Сама бизнес логика описания работы будет выглядеть вот так:
```
// Списки бизнес-сущностей
def customers = new Customers()
def products = new Products()
def orders = new Orders()
// Добавление клиента
customers.add(new Customer(inn: 1234, name: "Клиент", address: "Россия",
phone: "+74951002030"))
// Добавление продукта
products.add(new Product(article: "a100", name: "Товар 1", price: 100.00))
products.add(new Product(article: "a200", name: "Товар 2", price: 200.00))
// Добавление заказа
def order = new Order(num: 1, customer: customers.findByInn(1234))
order.add(new OrderDetail(pos: 1,
product: products.findByArticle("a100"), count: 1))
order.add(new OrderDetail(pos: 2,
product: products.findByArticle("a200"), count: 1))
orders.add(order)
```
Благодаря изяществу Groovy, код достаточно простой и читабельный. Но и пример не сложный. В реальной жизни, при написании сложной бизнес логики управления объектами, код будет выглядеть громоздко и плохо читаться. Получается, я имею некий API, который управляется только из кода, сложно пишется и нелегко читается.
В Groovy есть возможность упростить свою жизнь, написав собственный декларативный язык разметки для легкого описания выполнения нужных действий. Вот как будет выглядеть на языке разметки аналог вышеописанной бизнес логики:
```
AddCustomer(inn: 1234, name: "Клиент", address: "Россия", phone: "+74951002030")
AddProduct(article: "a100", name: "Товар 1", price: 100.00)
AddProduct(article: "a200", name: "Товар 2", price: 200.00)
AddOrder(num: 1, customer: 1234) {
Detail(pos: 1, product: "a100", count: 1)
Detail(pos: 2, product: "a200", count: 1)
}
```
Такой код вообще не нуждается в комментариях — он имеет высокую читабельность.
Для реализации этого языка потребуется написать билдер на Groovy. У Groovy есть абстрактный класс BuilderSupport, от которого нужно наследоваться, чтобы создать свой билдер. В наследуемом классе потребуется перекрыть ряд методов, которые Groovy будет автоматически вызывать при разборе языка разметки в коде. Вот как будет выглядеть класс билдера:
```
public class MyBuilder extends BuilderSupport {
public Customers customers
public Products products
public Orders orders
// Назначение ноде родительской ноды
protected void setParent(Object parent, Object child) {
}
// Создать ноду без параметров
protected Object createNode(Object name) {
if (name != "call")
throw new Exception("Node required parameters")
new Node(null, name);
}
// Создать ноду с привязанным к ней объектом
protected Object createNode(Object name, Object value) {
throw new Exception("Node required parameters")
}
// Создать ноду с параметрами
protected Object createNode(Object name, Map attributes) {
// Получаем родительскую текущую ноду
Node parent = getCurrent()
def result
// Анализируем имя ноды
switch (name) {
case "AddCustomer":
result = addCustomer(attributes)
break
case "AddProduct":
result = addProduct(attributes)
break
case "AddOrder":
result = addOrder(attributes)
break
case "Detail":
if (parent == null ||
parent.name() != "AddOrder")
throw new Exception(
"Detail must be specified with only AddOrder")
result = addOrderDetail(parent.value(), attributes)
break
defailt:
throw new Exception("Unknown node ${name}")
}
new Node(null, name, attributes, result);
}
// Создать ноду с параметрами и привязанным к ней объектом
protected Object createNode(Object name, Map attributes, Object value) {
throw new Exception("Node ${name} can not support objects")
}
// Добавляем клиента
def addCustomer(Map params) {
def customer = new Customer(inn: params.inn, name: params.name,
address: params.address, phone: params.phone)
customers.add(customer)
println "Added customer ${customer.inn}: ${customer.name}"
customer
}
// Добавляем продукт
def addProduct(Map params) {
def product = new Product(article: params.article, name: params.name,
price: params.price)
products.add(product)
println "Added product ${product.article}: ${product.name}"
product
}
// Добавляем заказ
def addOrder(Map params) {
def order = new Order(num: 1, customer: customers.findByInn(params.customer))
orders.add(order)
println "Added order ${order.num} from customer ${order.customer.name}"
order
}
// Добавляем строку заказа
def addOrderDetail(Order order, Map params) {
def count = params.count?:1
def detail = new OrderDetail(pos: params.pos,
product: products.findByArticle(params.product),
count: count)
order.add(detail)
println "Added into order ${order.num} detail pos ${detail.pos} " +
"with product ${detail.product.name}"
detail
}
}
```
В этом классе перекрыто два абстрактных метода setParent и createNode. setParent вызывается при назначении дочерней ноде родителя и в моей логике не используется. А вот в createNode как раз и вызывается на каждый элемент разметки. В зависимости от синтаксиса описания ноды разметки, вызывается один из четырех перегруженных методов createNode. Моей синтаксис предполагает, что у элементов всегда есть параметры. Поэтому я прописал необходимую функциональность в нужный метод и добавил исключения во все остальные методы createNode. Это позволит проконтролировать и исключить неправильный синтаксис описания вызова методов. Единственное исключение было сделано для рутовой метки call, которая автоматически создается первой при запуске билдера без параметров. Класс билдера я расширил конструктором, в который передаются созданные объекты списков клиентов, продуктов и заказов. Так же описал в классе методы добавления бизнес сущностей. Ничего сложного — все замечательно видно в коде и по комментариям в нем.
А вот конечный код пользования созданным языком разметки с проверкой результатов:
```
// Списки бизнес-сущностей
def customers = new Customers()
def products = new Products()
def orders = new Orders()
// Создать объект билдера
def myApi = new MyBuilder(customers: customers, products: products, orders: orders)
// Вызвать билдер
myApi {
AddCustomer(inn: 1234, name: "Клиент", address: "Россия", phone: "+74951002030")
AddProduct(article: "a100", name: "Товар 1", price: 100.00)
AddProduct(article: "a200", name: "Товар 2", price: 200.00)
AddOrder(num: 1, customer: 1234) {
Detail(pos: 1, product: "a100", count: 1)
Detail(pos: 2, product: "a200", count: 1)
}
}
// Печать результатов
println "\n*** Result ***"
println "Customers:"
println customers
println "Products:"
println products
println "Orders:"
println orders
```
Результат:
> Added customer 1234: Клиент
>
> Added product a100: Товар 1
>
> Added product a200: Товар 2
>
> Added order 1 from customer Клиент
>
> Added into order 1 detail pos 1 with product Товар 1
>
> Added into order 1 detail pos 2 with product Товар 2
>
>
>
> \*\*\* Result \*\*\*
>
> Customers:
>
> {inn=1234, name=Клиент, address=Россия, phone=+74951002030}
>
> Products:
>
> {article=a100, name=Товар 1, price=100.0}
>
> {article=a200, name=Товар 2, price=200.0}
>
> Orders:
>
> {num=1, customer=Клиент,
>
> detail={pos=1, product=Товар 1, count=1, sum=100.0};
>
> {pos=2, product=Товар 2, count=1, sum=200.0}}
>
>
Все работает :)
Резюмируя можно сказать, что область применения у билдеров большая. Я, например, сейчас на его основе разрабатываю язык описания трансформации данных для своего open source проекта GETL (ETL на базе Groovy). С помощью билдера можно легко разработать синтаксис, который позволит собирать SQL запросы в коде или выводить информацию в иерархическом собственном форматированном виде. Да и штатные XML/JSON маркеры думаю теперь не представляют из себя тайны. Язык разметок можно использовать не только в коде программ на Groovy, но и как блоки описания объектов и действий, которые вынесены в отдельные файлы. Блоки описания можно прямо в runtime считывать из файлов и выполнять с помощью метода EVAL. Так как блоки хорошо формализованы, то для них можно легко написать собственный GUI разработки бизнес логики обычными пользователями.
Примеров можно привести множество. Но самое главное, не стоит забывать — все вышесказанное замечательно без каких либо усилий работает на Java! Никто не мешает в Groovy обвязать любые Java классы и методы своим языком разметки, на котором писать бизнес логику, которая дальше используется в Java приложениях. Эти возможности стоят того, чтобы начать использовать в Java волшебный Groovy :)
Скачать полные тексты используемых в статье классом можно [отсюда](http://sourceforge.net/projects/getl/files/builderexample.zip/download). | https://habr.com/ru/post/174683/ | null | ru | null |
# Визуальный редактор логики для Unity3d. Часть 2
Введение
--------
Здравствуйте уважаемые читатели, в сегодняшней статье я хотел бы осветить тему архитектуры ядра визуального редактора логики для **Unity3d**. Это вторая часть из серии. Предыдущую вы можете прочитать [здесь](https://habr.com/ru/post/448190/). Итак, о чем пойдет речь? В основе визуального редактора лежит базовое ядро, которое позволяет запускать, загружать и хранить данные логики. В свою очередь ядро использует, о чем было сказано в предыдущей статье, **ScriptableObject**, как базовый класс для работы с компонентами логики. Рассмотрим подробнее все эти аспекты.
Статьи в серии:
→ [Визуальный редактор логики для Unity3d. Часть 1](https://habr.com/ru/post/448190/)
→ [Визуальный редактор логики для Unity3d. Часть 3](https://habr.com/ru/post/595009/)
Почему ScriptableObject?
------------------------
Перед тем, как приступать к разработке, я долго думал о том, вокруг чего построить систему. В самом первом виде — это были **MonoBehaviour**, но от этой идеи пришлось отказаться, поскольку эти скрипты должны висеть на **GameObject**, в качестве компонентов. Следующим шагом стала идея использовать свой класс, который не является наследником **UnityEngine.Object**. Но и этот вариант не прижился, хотя он и был вполне рабочим, однако тянул за собой, написание своего сериализатора, инспектора, сборщика мусора и т. п. В итоге единственным разумным выходом осталось использование **ScriptableObject**, цикл жизни которого схож с **MonoBehaviour**, если создание происходит в ходе работы приложения через **ScriptableObject.CreateInstance**. Помимо, этого автоматом решался вопрос с использованиeм **JsonUtility** (правда сейчас уже и это не является проблемой) и инспектора **Unity**.
Архитектура
-----------
Ниже представлена обобщенная схема того, из чего состоит ядро **uViLEd**.
Рассмотрим подробнее каждый элемент.
### Контроллер
Контроллер — это главный элемент ядра, представляющий из себя **MonoBehavior** скрипт (единственный во всей системе). Класс контроллера является синглетоном и доступен всем компонентам логики. Что делает данный класс:
1. Хранит ссылки на объекты **Unity**
2. Запускает логики на старте сцены
3. Представляет доступ к методам для запуска логики из внешних источников
4. Обеспечивает работу **Mono**-методов в компонентах
**Базовый код класса контроллера**
```
namespace uViLEd.Core
{
public partial class LogicController : MonoBehaviour
{
private static LogicController _instance;
public static LogicController Instance
{
get
{
_instance = _instance ?? FindObjectOfType();
return \_instance;
}
}
[Serializable]
public class SceneLogicData
{
public string Name;
public TextAsset BinaryData => \_data;
public string Id => \_id;
[SerializeField] private string \_id;
[SerializeField] private TextAsset \_data;
public SceneLogicData(string id, string name, TextAsset binaryData)
{
\_id = id;
\_data = binaryData;
Name = name;
}
}
[HideInInspector]
public List SceneLogicList = new List();
void Awake()
{
\_instance = this;
foreach (var sceneLogic in SceneLogicList)
{
RunLogicInternal(LogicStorage.Load(sceneLogic.BinaryData));
}
}
}
}
```
**Примечание**: в каждой сцене присутствует свой контроллер и свой набор логик.
**Примечание**: подробнее о загрузке данных логики и ее запуске будет рассказано отдельно.
### Основные элементы ядра uViLEd
#### Компонент
В первой части я уже говорил, что компонент это **ScriptableObject**. Все компоненты являются наследниками класса **LogicComponent**, который в свою очередь банально прост.
```
namespace uViLEd.Core
{
public abstract class LogicComponent : ScriptableObject
{
protected MonoBehaviour coroutineHost => _logicHost;
private MonoBehaviour _logicHost;
public virtual void Constructor() { }
}
}
```
Здесь **coroutineHost** — это ссылка на контроллер логики, которая введена просто для удобства и используется, как можно понять из названия, для работы с короутинами. Применение данной абстракции необходимо для того, чтобы отделить компоненты от другого кода присутствующего в проекте **Unity**.
#### Переменные
Переменные, как упоминалось в прошлой статье, это специализированные компоненты для хранения данных, ниже представлен код для них.
**Код реализации переменных**
```
namespace uViLEd.Core
{
public abstract class Variable : LogicComponent { }
public abstract class Variable : Variable
{
public delegate void Changed();
public delegate void Set(T newValue);
public event Changed OnChanged;
public event Set OnSet;
public T Value
{
get
{
return \_value;
}set
{
var changed = false;
if (\_value == null && value != null || (\_value != null && !\_value.Equals(value)))
{
changed = true;
}
\_value = value;
if (changed)
{
OnChanged?.Invoke();
}
OnSet?.Invoke(\_value);
}
}
[SerializeField] private T \_value;
public virtual void OnDestroy()
{
if(OnSet != null)
{
foreach (var eventHandler in OnSet.GetInvocationList())
{
OnSet -= (Set)eventHandler;
}
}
if(OnChanged != null)
{
foreach (var eventHandler in OnChanged.GetInvocationList())
{
OnChanged -= (Changed)eventHandler;
}
}
}
}
}
```
Здесь **Variable** — это базовый абстрактный класс для всех переменных, он необходим для того, чтобы отделить их от обычных компонентов. Основной класс — это **generic**, который хранит собственно данные и обеспечивает работу событий для установки значения и его изменения.
#### Связи
Что такое связи, я рассказывал в прошлой статье. Коротко — это виртуальная сущность, которая позволяет компонентам использовать методы друг друга, а также ссылаться на переменные логики. Для программиста эта связь является мягкой и не видна в коде. Все связи формируются в процессе инициализации (об этом читай ниже). Рассмотрим классы, которые позволяют формировать связи.
**Входная точка**
```
namespace uViLEd.Core
{
public class INPUT_POINT
{
public Action Handler;
}
public class INPUT\_POINT
{
public Action Handler;
}
}
```
**Выходная точка**
```
namespace uViLEd.Core
{
public class OUTPUT_POINT
{
private List> \_linkedInputPoints = new List>();
public void Execute(T param)
{
foreach(var handler in \_linkedInputPoints)
{
handler(param);
}
}
}
public class OUTPUT\_POINT
{
private List \_linkedInputPoints = new List();
public void Execute()
{
foreach (var handler in \_linkedInputPoints)
{
handler();
}
}
}
}
```
**Ссылка на переменную**
```
namespace uViLEd.Core
{
public class VARIABLE_LINK
{
public T Value
{
get => \_variable.Value;
set => \_variable.Value = value;
}
private Variable \_variableProperty
{
get => \_variable;
set
{
\_variable = value;
VariableWasSet = true;
InitializeEventHandlers();
}
}
public bool VariableWasSet { get; private set; } = false;
private Variable \_variable;
private Variable.Set \_automaticSetHandler;
private Variable.Changed \_automaticChangedHandler;
public void AddSetEventHandler(Variable.Set handler)
{
if (VariableWasSet)
{
\_variable.OnSet += handler;
}else
{
\_automaticSetHandler = handler;
}
}
public void RemoveSetEventHandler(Variable.Set handler)
{
if (VariableWasSet)
{
\_variable.OnSet -= handler;
}
}
public void AddChangedEventHandler(Variable.Changed handler)
{
if (VariableWasSet)
{
\_variable.OnChanged += handler;
}else
{
\_automaticChangedHandler = handler;
}
}
public void RemoveChangedEventHandler(Variable.Changed handler)
{
if (VariableWasSet)
{
\_variable.OnChanged -= handler;
}
}
private void InitializeEventHandlers()
{
if (\_automaticSetHandler != null)
{
\_variable.OnSet += \_automaticSetHandler;
}
if (\_automaticChangedHandler != null)
{
\_variable.OnChanged += \_automaticChangedHandler;
}
}
}
}
```
**Примечание**: здесь стоит пояснить один момент, автоматические обработчики событий установки и изменения значения переменной используются только в случае, когда они задаются в методе **Constructor**, поскольку на тот момент ссылки на переменные еще не установлены.
### Работа с логикой
#### Хранение
В первой статье о визуальном редакторе логики, упоминалось, что логика представляет собой набор переменных, компонентов и связей между ними:
```
namespace uViLEd.Core
{
[Serializable]
public partial class LogicStorage
{
public string Id = string.Empty;
public string Name = string.Empty;
public string SceneName = string.Empty;
public ComponentsStorage Components = new ComponentsStorage();
public LinksStorage Links = new LinksStorage();
}
}
```
Данный класс как видно является сериализуемым, однако для сериализации не используется **JsonUtility** от **Unity** . Вместо этого используется бинарный вариант, результат работы которого сохраняется в виде файла с расширением **bytes**. Почему так сделано? В целом, основная причина – безопасность, т. е. для варианта загрузки логики из внешнего источника возможно зашифровать данные, да и в целом десериализовать байтовый массив сложнее, чем открытый **json**.
Рассмотрим подробнее класс **ComponentsStrorage** и **LinksStorage**. Для глобальной идентификации данных в системе используется **GUID**. Ниже приведен код класса, который является базовым для контейнеров данных.
```
namespace uViLEd.Core
{
[Serializable]
public abstract class Identifier
{
public string Id { get; }
public Identifier()
{
if (!string.IsNullOrEmpty(Id)) return;
Id = System.Guid.NewGuid().ToString();
}
}
}
```
Рассмотрим теперь код класса **ComponentsStorage**, который как видно из названия хранит данные о компонентах логики:
```
namespace uViLEd.Core
{
public partial class LogicStorage
{
[Serializable]
public class ComponentsStorage
{
[Serializable]
public class ComponentData : Identifier
{
public string Type = string.Empty;
public string Assembly = string.Empty;
public string JsonData = string.Empty;
public bool IsActive = true;
}
public List Items = new List();
}
}
```
Класс достаточно простой. По каждому компоненту хранится следующая информация:
1. Уникальный идентификатор (строка **GUID**), который находится в **Identifier**
2. Имя типа
3. Имя сборки, в которой находится тип компонента
4. Json-строка с данными сериализации (результат работы **JsonUtility.ToJson**)
5. Флаг активности (состояния) компонента
Теперь посмотрим на класс **LinksStorage**. Данный класс хранит информацию о связях между компонентами, а также о ссылках на переменные.
```
namespace uViLEd.Core
{
public partial class LogicStorage
{
[Serializable]
public class LinksStorage
{
[Serializable]
public class LinkData : Identifier
{
public bool IsVariable;
public bool IsActive = true;
public string SourceComponent = string.Empty;
public string TargetComponent = string.Empty;
public string OutputPoint = string.Empty;
public string InputPoint = string.Empty;
public string VariableName = string.Empty;
public int CallOrder = -1;
}
public List Items = new List();
}
}
```
В принципе в данном классе тоже нет ничего сложного. Каждая связь содержит следующую информацию:
1. Флаг показывающий, что данная связь — это ссылка на переменную
2. Флаг активности связи
3. Идентификатор (строка **GUID**) компонента с выходной точкой
4. Идентификатор (строка **GUID**) компонента с входной точкой
5. Имя выходной точки компонента источника связи
6. Имя входной точки целевого компонента связи
7. Имя поля класса для установки ссылки на переменную
8. Порядок вызова связи
#### Запуск из хранилища
Прежде чем вдаваться в подробности кода, для начала хочу остановиться на описании последовательности того, как контроллер запускает логику:
1. Инициализация стартует в методе Awake контроллера
2. По списку логик сцены происходит загрузка и десериализация данных логики из бинарного файла (**TextAsset**)
3. По каждой логике происходит:
* Создание компонента
* Сортировка связей по **CallOrder**
* Установка связей и ссылок на переменные
* Сортировка **Mono**-методов компонентов по **ExecuteOrder**
Рассмотрим подробнее каждый аспект этой цепочки.
**Сериализация и десериализация в бинарном формате**
```
namespace uViLEd
{
public class Serialization
{
public static void Serialize(object data, string path, string fileName)
{
var binaryFormatter = new BinaryFormatter();
if (!Directory.Exists(path))
{
Directory.CreateDirectory(path);
}
using (var fs = new FileStream(Path.Combine(path, fileName), FileMode.OpenOrCreate))
{
binaryFormatter.Serialize(fs, data);
}
}
public static object Deserialize(TextAsset textAsset)
{
var binaryFormatter = new BinaryFormatter();
using (var memoryStream = new MemoryStream(textAsset.bytes))
{
return binaryFormatter.Deserialize(memoryStream);
}
}
}
}
```
**Загрузка данных логики из текстового ассета (бинарный файл)**
```
namespace uViLEd.Core
{
public partial class LogicStorage
{
public static LogicStorage Load(TextAsset textAsset) => Serialization.Deserialize(textAsset) as LogicStorage;
}
}
```
**Запуск логики**
```
private void RunLogicInternal(LogicStorage logicStorage)
{
var instances = new Dictionary();
foreach (var componentData in logicStorage.Components.Items)
{
CreateComponent(componentData, instances);
}
logicStorage.Links.Items.Sort(SortingLinks);
foreach (var linkData in logicStorage.Links.Items)
{
CreateLink(linkData, instances);
}
foreach (var monoMethods in \_monoBehaviourMethods.Values)
{
monoMethods.Sort(SortingMonoMethods);
}
}
```
**Создание компонента**
```
private void CreateComponent(LogicStorage.ComponentsStorage.ComponentData componentData,
IDictionary instances,
IList disposableInstance,
IDictionary> monoMethods)
{
if (!componentData.IsActive) return;
var componentType = AssemblyHelper.GetAssemblyType(componentData.Assembly, componentData.Type);
var componentInstance = ScriptableObject.CreateInstance(componentType) as LogicComponent;
JsonUtility.FromJsonOverwrite(componentData.JsonData, componentInstance);
componentInstance.name = componentData.InstanceName;
componentType.GetFieldRecursive(\_LOGIC\_HOST\_STR).SetValue(componentInstance, this
as MonoBehaviour);
componentInstance.Constructor();
instances.Add(componentData.Id, componentInstance);
if(componentInstance is IDisposable)
{
disposableInstance.Add((IDisposable)componentInstance);
}
SearchMonoBehaviourMethod(componentInstance, monoMethods);
}
```
Итак, что происходит в данной функции:
1. Проверяется флаг активности компонента
2. Происходит получение типа компонента из сборки
3. Создается экземпляр компонента по типу
4. Происходит десериализация параметров компонента из **json**
5. Устанавливается ссылка в **сoroutineHost**
6. Вызывается метод **Constructor**
7. Сохраняется временная копия на экземпляр компонента
8. Если компонент имплементирует интерфейс IDisposable, то ссылка на него сохраняется в соответствующем списке
9. Происходит поиск **Mono**-методов в компоненте
**Создание связей**
```
private void CreateLink(LogicStorage.LinksStorage.LinkData linkData, Dictionary instances)
{
if (!linkData.IsActive) return;
var sourceComponent = instances.ContainsKey(linkData.SourceComponent) ? instances[linkData.SourceComponent] : null;
if (sourceComponent == null) return;
var targetComponent = instances.ContainsKey(linkData.TargetComponent) ? instances[linkData.TargetComponent] : null;
if (targetComponent == null) return;
if (linkData.IsVariable)
{
var variableLinkFieldInfo = sourceComponent.GetType().GetField(linkData.variableName);
if (variableLinkFieldInfo != null)
{
var variableLinkFieldValue = variableLinkFieldInfo.GetValue(sourceComponent);
var variableLinkVariablePropertyInfo = variableLinkFieldInfo.FieldType.GetProperty(\_VARIABLE\_PROPERTY\_STR, BindingFlags.NonPublic | BindingFlags.Instance);
variableLinkVariablePropertyInfo.SetValue(variableLinkFieldValue, targetComponent, null);
}
}
else
{
object handlerValue;
MethodInfo methodListAdd;
object linkedInputPointsFieldValue;
Type outputPointType;
object outputPoint;
var outputPointParse = sourceComponent as IOutputPointParse;
var inputPointParse = targetComponent as IInputPointParse;
if (outputPointParse != null)
{
var outputPoints = outputPointParse.GetOutputPoints();
if (outputPoints.ContainsKey(linkData.OutputPoint))
{
outputPoint = outputPoints[linkData.OutputPoint];
if (outputPoint is FieldInfo)
{
outputPoint = sourceComponent.GetType().GetField(linkData.OutputPoint).GetValue(sourceComponent);
}
outputPointType = outputPoint.GetType();
var linkedInputPointsFieldInfo = outputPointType.GetField(\_LINKED\_INPUT\_POINTS\_STR, BindingFlags.NonPublic | BindingFlags.Instance);
linkedInputPointsFieldValue = linkedInputPointsFieldInfo.GetValue(outputPoint);
methodListAdd = linkedInputPointsFieldInfo.FieldType.GetMethod(\_ADD\_STR);
}
}
else
{
var outputPointFieldInfo = sourceComponent.GetType().GetField(linkData.OutputPoint);
outputPoint = outputPointFieldInfo.GetValue(sourceComponent);
if (outputPoint != null)
{
outputPointType = outputPoint.GetType();
var linkedInputPointsFieldInfo = outputPointFieldInfo.FieldType.GetField(\_LINKED\_INPUT\_POINTS\_STR, BindingFlags.NonPublic | BindingFlags.Instance);
linkedInputPointsFieldValue = linkedInputPointsFieldInfo.GetValue(outputPoint);
methodListAdd = linkedInputPointsFieldInfo.FieldType.GetMethod(\_ADD\_STR);
}
}
if (inputPointParse != null)
{
var inputPoints = inputPointParse.GetInputPoints();
if (inputPoints.ContainsKey(linkData.InputPoint))
{
var inputPoint = inputPoints[linkData.InputPoint];
if (inputPoint is FieldInfo)
{
inputPoint = targetComponent.GetType().GetField(linkData.InputPoint).GetValue(targetComponent);
}
var inputPointType = inputPoint.GetType();
var inputPointHandlerFieldInfo = inputPointType.GetField(\_HANDLER\_STR);
handlerValue = inputPointHandlerFieldInfo.GetValue(inputPoint);
}
}
else
{
var inputPointFieldInfo = targetComponent.GetType().GetField(linkData.InputPoint);
var inputPointFieldValue = inputPointFieldInfo.GetValue(targetComponent);
if (inputPointFieldValue != null)
{
var inputPointHandlerFieldInfo = inputPointFieldInfo.FieldType.GetField(\_HANDLER\_STR);
handlerValue = inputPointHandlerFieldInfo.GetValue(inputPointFieldValue);
}
}
var handlerParsedAction = GetParsedHandler(handlerValue, outputPoint);
methodListAdd.Invoke(linkedInputPointsFieldValue, new object[] { handlerParsedAction });
}
}
private object GetParsedHandler(object handlerValue, object outputPoint)
{
var inputPointType = handlerValue.GetType();
var outputPointType = outputPoint.GetType();
if (inputPointType.IsGenericType)
{
var paramType = inputPointType.GetGenericArguments()[0];
if (paramType == typeof(object) && outputPointType.IsGenericType)
{
var parsingActionMethod = outputPointType.GetMethod(\_PARSING\_ACTION\_OBJECT\_STR, BindingFlags.NonPublic | BindingFlags.Instance);
return parsingActionMethod.Invoke(outputPoint, new object[] { handlerValue });
}
else
{
return handlerValue;
}
}
else
{
if (outputPointType.IsGenericType)
{
var parsingActionMethod = outputPointType.GetMethod(\_PARSING\_ACTION\_EMPTY\_STR, BindingFlags.NonPublic | BindingFlags.Instance);
return parsingActionMethod.Invoke(outputPoint, new object[] { handlerValue });
}
else
{
return handlerValue;
}
}
}
```
Создание связи, один из самых по сути сложных моментов во всей системе, рассмотрим каждый этап:
1. Проверяется флаг активности связи
2. Во временном списке созданных компонентов ищутся, компонент источник связи и компонент цель
3. Проверяется тип связи:
* Если тип связи — это ссылка на переменную, то с помощью рефлексии устанавливаются нужные значения
* Если связь обычная, то также с помощью рефлексии устанавливаются нужные значения для методов выходных и входных точек
4. Для обычной связи, для начала проверяется наследует ли компонент интерфейсы **IInputPointParse** и **IOutputPointParse**.
5. В зависимости от результатов предыдущего пункта происходит получение через рефлексию поля **LinkedInputPoints** в компоненте источнике и метода обработчика в компоненте цели.
6. Получение метода обработчики происходит через конверсию вызова метода минуя **MethodInfo.Invoke** в простой вызов `Action`. Однако получение такой ссылки через рефлексию слишком сложное, поэтому в классе `OUTPUT_POINT` заведены специальные методы, которые позволяют это сделать. Для не **generic** варианта этого класса, таких действий не требуется.
```
private Action ParsingActionEmpty(Action action)
{
Action parsedAction = (value) => action();
return parsedAction;
}
private Action ParsingActionObject(Action action)
{
Action parsedAction = (value) => action(value);
return parsedAction;
}
}
```
Первый метод используется, когда входная точка не принимает никаких параметров. Второй метод, соответственно для входной точки с параметром.
7. Через рефлексию в поле **LinkedInputPoints** (которое как было показано выше, является списком) добавляется ссылка на **Action** – обработчик
**Работа с Mono-методами**
```
private void SearchMonoBehaviourMethod(LogicComponent component, IDictionary> monoBehaviourMethods)
{
var type = component.GetType();
var methods = type.GetMethods(BindingFlags.Public | BindingFlags.Static | BindingFlags.NonPublic | BindingFlags.Instance);
foreach (var method in methods)
{
if (\_monoMethods.Keys.Contains(method.Name))
{
var priorityAttributes = method.GetCustomAttributes(typeof(ExecuteOrderAttribute), true);
var priority = (priorityAttributes.Length > 0) ? ((ExecuteOrderAttribute)priorityAttributes[0]).Order : int.MaxValue;
monoBehaviourMethods[method.Name].Add(new MonoMethodData(method, component, priority, \_monoMethods[method.Name]));
}
}
}
```
Каждый метод сохраняется в словаре через ссылку на специальный класс, через который и происходит вызов. Этот класс автоматически конвертирует метод в ссылку на **Action**. Таким образом происходит значительное ускорение вызовов **Mono**-методов по сравнению с обычным **MethodInfo.Invoke**.
```
private class MonoMethodData
{
public int Order { get; private set; }
private Action _monoMethodWrapper;
private Action \_monoMethodParamWrapper;
public MonoMethodData(MethodInfo method, object target, int order, bool withParam)
{
if (!withParam)
{
\_monoMethodWrapper = (Action)Delegate.CreateDelegate(typeof(Action), target, method.Name);
}
else
{
\_monoMethodParamWrapper = (Action)Delegate.CreateDelegate(typeof(Action), target, method.Name);
}
Order = order;
}
public void Call() =>\_monoMethodWrapper();
public void Call(bool param) => \_monoMethodParamWrapper(param);
}
```
**Примечание**: перегрузка метода **Call** с параметром **bool** используется для **Mono**-методов типа **ApplicationPause** и т.п.
#### Внешний запуск логики
Внешний запуск логики, это запуск во время работы приложения, такая логика не задается в сцене и на нее нет ссылки. Её можно загрузить из бандла, либо из ресурсов. В целом запуск извне мало чем отличается от запуска на старте сцены, за исключением работы с **Mono**-методами.
**Код метода для внешнего (отложенного) исполнения логики**
```
public void RunLogicExternal(LogicStorage logicStorage)
{
var instances = new Dictionary();
var runMonoMethods = new Dictionary>();
foreach (var monoMethodName in \_monoMethods.Keys)
{
runMonoMethods.Add(monoMethodName, new List());
}
foreach (var componentData in logicStorage.Components.Items)
{
CreateComponent(componentData, instances, \_disposableInstances, runMonoMethods);
}
logicStorage.Links.Items.Sort(SortingLinks);
foreach (var linkData in logicStorage.Links.Items)
{
CreateLink(linkData, instances);
}
foreach (var monoMethods in runMonoMethods.Values)
{
monoMethods.Sort(SortingMonoMethods);
}
if (runMonoMethods.ContainsKey(\_START\_STR))
{
CallMonoBehaviourMethod(\_START\_STR, runMonoMethods, true);
}
foreach (var monoMethodName in runMonoMethods.Keys)
{
\_monoBehaviourMethods[monoMethodName].AddRange(runMonoMethods[monoMethodName]);
}
foreach (var monoMethods in \_monoBehaviourMethods.Values)
{
monoMethods.Sort(SortingMonoMethods);
}
}
```
Как видно, здесь происходит сохранение всех ссылок на **Mono**-методы в локальном словаре, после чего происходит запуск методов **Start** и затем все остальные методы добавляются в общий словарь.
#### Запуск логики как экземпляра
В ходе работы приложения может понадобиться запустить определенную логику на определенное время, либо пока она не выполнит свою задачу. Предыдущие варианты запуска логики не позволяются этого сделать, поскольку логика запускается на все время жизни сцены.
Для запуска логики как экземпляра, происходит сохранение ссылок на все экземпляры компонентов и т.п данные, которые после завершения работы, можно удалить, тем самым очистив память.
Код класса хранилища данных экземпляра логики:
```
private class InstanceLogicData
{
public readonly IList ComponentInstances = new List();
public readonly IDictionary> MonoBehaviourMethods = new Dictionary>();
public readonly IList DisposableInstances = new List();
}
```
**Сам запуск логики похож на внешний запуск описанный ранее.**
```
public string RunLogicInstance(LogicStorage logicStorage, object data)
{
var id = Guid.NewGuid().ToString();
var logicInstanceData = new InstanceLogicData();
var instances = new Dictionary();
\_logicInstances.Add(id, logicInstanceData);
foreach (var componentData in logicStorage.Components.Items)
{
CreateComponent(componentData, instances, logicInstanceData.DisposableInstances, logicInstanceData.MonoBehaviourMethods);
}
logicStorage.Links.Items.Sort(SortingLinks);
foreach (var linkData in logicStorage.Links.Items)
{
CreateLink(linkData, instances);
}
foreach (var monoMethods in logicInstanceData.MonoBehaviourMethods.Values)
{
monoMethods.Sort(SortingMonoMethods);
}
return id;
}
```
Из кода видна, что после создания логики, данные о ней сохраняются в экземпляре специализированного класса, а после запуска возвращается уникальный идентификатор экземпляра логики.
**Данный идентификатор нужен, чтобы вызвать функцию остановки и очистки памяти.**
```
public void StopLogicInstance(string instanceId)
{
if (!_logicInstances.ContainsKey(instanceId)) return;
var logicInstance = _logicInstances[instanceId];
foreach (var disposableInstance in logicInstance.DisposableInstances)
{
disposableInstance.Dispose();
}
foreach (var componentInstance in logicInstance.ComponentInstances)
{
Destroy(componentInstance);
}
logicInstance.ComponentInstances.Clear();
logicInstance.DisposableInstances.Clear();
logicInstance.MonoBehaviourMethods.Clear();
_logicInstances.Remove(instanceId);
}
```
#### Завершение работы сцены и очистка памяти
При создании **ScriptableObject** в работающей сцене через **ScriptableObject.CreateInstance**, экземпляр ведет себя также, как и **MonoBehaviour**, т. е. по выгрузке из сцены, для каждого будет вызван **OnDestroy** и он будет удален из памяти. Однако как было сказано в прошлой статье, компонент может наследовать **IDisposable**, поэтому очистку я произвожу в методе **OnDisable**:
```
void OnDisable()
{
foreach (var disposable in _disposableInstances)
{
disposable.Dispose();
}
_disposableInstances.Clear();
_monoBehaviourMethods.Clear();
foreach (var logicInstance in _logicInstances.Values)
{
foreach (var disposableInstance in logicInstance.DisposableInstances)
{
disposableInstance.Dispose();
}
logicInstance.DisposableInstances.Clear();
logicInstance.ComponentInstances.Clear();
logicInstance.MonoBehaviourMethods.Clear();
}
_logicInstances.Clear();
_instance = null;
}
```
**Примечание**: как видно, в случае, если экземпляры логики существуют на момент выгрузки сцены, то происходит очистка и в них.
### Проблема и решение с объектами Unity
В первой части статьи о визуальном редакторе, я упоминал о проблеме, связанной с сохранением ссылок на объекты сцены, которая связана с невозможностью восстановить сериализованные данные. Это связано с тем, что уникальный идентификатор объектов сцены при каждом запуске сцены разный. Решением данный проблемы является единственный вариант — это перевести хранение ссылок в сцену. С этой целью в контроллере логики было добавлено специализированное хранилище и класс-обертка, через которую компоненты логики получают ссылки на объекты **Unity**, в том числе ресурсы, префабы и другие ассеты.
**Код для хранилища**
```
[Serializable]
private class ObjectLinkData
{
public string Id => _id;
public UnityEngine.Object Obj => _obj;
[SerializeField] private string _id = string.Empty;
[SerializeField] private UnityEngine.Object _obj;
public ObjectLinkData(string id, UnityEngine.Object obj)
{
_id = id;
_obj = obj;
}
}
[SerializeField] [HideInInspector] private List \_objectLinks = new List();
public UnityEngine.Object GetObject(string id)
{
var linkData = \_objectLinks.Find(link =>
{
return string.Compare(link.Id, id, StringComparison.Ordinal) == 0;
});
return linkData?.Obj;
}
```
Здесь:
1. **Id** – уникальный идентификатор ассета или объекта сцены
2. **Obj** – ссылка на ассет или объекты сцены
Как видно по коду, ничего сверхсложного.
**Теперь рассмотрим класс-обертку для объектов Unity**
```
[Serializable]
public class VLObject
{
public string Id => _id;
public UnityEngine.Object Obj
{
get
{
if (_obj == null && !_objNotFound)
{
_obj = Core.LogicController.Instance.GetObject(Id);
if (_obj == null)
{
_objNotFound = true;
}
}
return _obj;
}
}
private UnityEngine.Object _obj;
[SerializeField] private string _id;
private bool _objNotFound;
public VLObject() { }
public VLObject(UnityEngine.Object obj)
{
_obj = obj;
}
public T Get() where T : UnityEngine.Object
{
return Obj as T;
}
}
```
**Примечание**: флаг **\_objNotFound** необходим, чтобы не производить поиск в хранилище каждый раз, если объекта в нем нет.
Производительность
------------------
Теперь, я думаю, стоит остановиться на таком вопросе как производительность. Если внимательно посмотреть на весь код выше, то можно понять, что в уже запущенном приложении система никак не влияет на скорость, т.е. все будет работать как обычно приложение **Unity**. Я сравнивал **Update** обычного **MonoBehaviour** и через **uViLEd** и не смог достичь хоть какой-либо разницы, которую можно было здесь указать, все цифры паритетны вплоть до 1000 вызовов за кадр. Единственное узкое место — это скорость загрузки сцены, но и тут значимых цифр у меня не удалось получить, хотя между платформами (я проверял **Android** и **iOS**) разница большая. В логике на 70 компонентов и порядка 150 связей (включая ссылки на переменные) цифры получились следующие:
1. **Android** (очень посредственный MediaTek 8-ядерный)
— На старте приложения — ~750мс
— Запуск сцены в запущенном приложении ~250мс
2. **iOS** (iPhone 5s)
— На старте приложения — ~100мс
— Запуск сцены в запущенном приложении ~50мс
Заключение
----------
Архитектура ядра системы **uViLEd** довольно-таки проста и незамысловата, использовать ее опосредовано от визуального редактора не целесообразно, хотя не исключаю, что какие-то решения для кого-то окажутся полезными. Тем не менее данная статья важна для общего понимания принципа работы системы, последней важной частью которой остался сам редактор. И этому будет посвящена последняя заключительная часть серии, которая будет самой насыщенной.
PS: написание статьи сильно затянулось, о чем прошу прощения. Изначально я планировал выпустить сразу все оставшиеся части, однако выход новых версий Unity 3d, а также жизненные (приятные и не очень) потрясения изменили планы.
→ [Визуальный редактор логики для Unity3d. Часть 1](https://habr.com/ru/post/448190/)
→ [Визуальный редактор логики для Unity3d. Часть 3](https://habr.com/ru/post/595009/)
Плагины в Asset Store:
[Визуальный редактор логики uViLEd (для ознакомления)](https://assetstore.unity.com/packages/tools/visual-scripting/uviled-visual-logic-editor-137517)
[Визуальный редактор логики uViLEd (полный исходный код)](https://assetstore.unity.com/packages/slug/208860) | https://habr.com/ru/post/466187/ | null | ru | null |
# Использование сервера очередей beanstalkd для распределения нашей почтовой рассылки
В нашей системе (сервис покупок за рубежом [Shopozz.RU](http://shopozz.ru/) и бесплатный mail forwarding в США [Shopozz.COM](http://shopozz.com)), как и во многих других, присутствует множество почтовых рассылок разного содержания. Безусловно, такие электронные письма должны доходить до конечного пользователя крайне оперативно, тем паче, что контент большинства из них подразумевает оперативную доставку по умолчанию. Когда же суммарное время отправления очередной рассылки перевалило за 24 часа, стало понятно, что нужно как-то оптимизировать этот процесс.
**Итак, задача:** есть over 200 000 пользователей, для которых необходимо сгенерировать и доставить сообщение за максимально короткий срок. Решение задачи — под катом.
Первая же мысль, которая приходит на ум – правильно, увеличить число каналов. Однако, в дело вступает старая добрая синхронизация – на генерацию и отправку одного сообщения уходит приблизительно 0.5 – 1 секунда, а если за дело будут браться сразу несколько отправителей, нужно не дать им взяться за одного и того же пользователя дважды.
Дабы не нагружать лишний раз ни базу, ни сервер, было принято решение в роли распределителя ресурсов использовать сервер очереди [beanstalkd](http://kr.github.io/beanstalkd/).
Выбор пал именно на этот сервер во многом из-за простоты внедрения. Вeanstalkd прост и без излишеств. Подробнее про очереди сообщений уже написано [тут](http://habrahabr.ru/post/44907/) и [тут](http://habrahabr.ru/company/mailru/blog/216363/).
Общая схема отправки сообщений выглядит следующим образом:
Список получателей образуется обычным запросом к базе и преобразовывается в набор job’ов — сообщений для beanstalkd.
Следует учесть, что в beanstalkd’е ограничен максимальный размер job’а и по дефолту составляет 256 байт текста (максимальный размер можно указать другой). Кроме того, не следует выделять на каждого пользователя отдельный job, потому что получение и парсинг данных из beanstalkd'а также занимают ресурсы сервера.
Методом подбора мы пришли к цифре 100 пользователей на job.
Worker в данной схеме – это php-скрипт, который постоянно прослушивает канал сервера на наличие новых job’ов, получает из них список пользователей и отправляет сообщения.
**Алгоритм работы worker’а:**
```
while(1)
{
$ci = get_instance();
$ci->load->model('shared/queue_model');
$ci->load->model('shared/sendmail_model');
if ($ci->queue_model->watch_jobs())
{
// Действия, выполняемые по завершению job'а
print 'Memory usage = ' . intval(memory_get_peak_usage() / 1024) . ' KB' . PHP_EOL;
}
unset($ci);
}
```
**Код модели queue\_model:**
```
class Queue_model extends CI_Model
{
private $_pheanstalk;
public function __construct()
{
$this->_pheanstalk = new Pheanstalk_Pheanstalk('XX.XX.XX.XX:XX');
$this->tube = (ENVIRONMENT === 'production') ? 'www.shopozz.ru' : 'default';
}
public function watch_jobs()
{
@$job = $this->_pheanstalk->watch($this->tube)->reserve();
if ( ! isset($job) OR ! $job)
{
return FALSE;
}
$job_data = json_decode($job->getData());
if ( ! isset($job_data->type))
{
$this->_pheanstalk->release($job);
return FALSE;
}
if ($this->email_messages_model->can_send($job_data->mail))
{
print date('H:i:s ') . 'START JOB!' . PHP_EOL;
$data = $job->getData();
$this->_pheanstalk->delete($job);
$this->_send_email($data);
$time = round(microtime(true) - $start, 2);
print date('H:i:s') . 'JOB DONE! Time=' . $time . PHP_EOL;
return TRUE;
}
$this->_pheanstalk->release($job);
return FALSE;
}
```
Здесь важно помнить, что метод
```
$this->_pheanstalk->watch($this->tube)->reserve();
```
помечает текущий активный элемент в очереди, как зарезервированный, чтобы другие worker’ы не могли получить к нему доступ. После этого, если задача выполнена, ее необходимо удалить, а если это не представляется возможным – обязательно вернуть в предыдущий статус через
```
_pheanstalk->release($job);
```
Метод
```
$this->email_messages_model->can_send
```
проверяет не остановлена ли рассылка. Благодаря этой проверке можно остановить отправку сообщений в любой момент (например, если в тексте рассылки найдена ошибка). В этом случае каждый job будет считываться, но не будет выполнен, и, как следствие, не будет удален, а просто вернется в состояние активного ожидания.
Остался последний штрих – поскольку worker’ы находятся в состоянии постоянного зацикленного запуска, они не смогут корректно получать изменения в коде. Для этого добавим в цикл проверку на время последнего изменения в файле:
```
class Restarter
{
/**
* Время изменения файла воркера
* @var integer
*/
private $_changed_time;
/**
* Путь до файла со скриптом воркера
* @var type
*/
private $_self_file;
public function __construct()
{
$this->_self_file = __FILE__;
$this->_changed_time = $this->_get_changed_time();
}
/**
* Получает время последнего изменения файла скрипта воркера
* @return type
*/
private function _get_changed_time()
{
$fp = fopen($this->_self_file, "r");
$fstat = fstat($fp);
$res = $fstat['mtime'];
return $res;
}
/**
* Завершает работу воркера, если его код был изменен
*/
public function check_changed_time()
{
$time = $this->_get_changed_time();
if ($time !== $this->_changed_time)
{
echo "File has been changed!";
exit(1);
}
}
}
```
Теперь, если в файле произошли изменения, скрипт вызовет завершение со статусом «1», после чего будет автоматически перезапущен.
В итоге, поставленная наверху поста задача решена: теперь наши пользователи получают рассылку максимально быстро. С увеличением количества пользователей, что естественно, сервис не испытывает каких-либо проблем с конечным временем доставки электронного письма до получателя — все решается банальным увеличением каналов.
Напоминаем, что вы читаете блог компании Shopozz.com – абсолютно бесплатного сервиса mail forwarding'а в США с гарантированными сроками доставки. Подписывайтесь на [наш блог](http://habrahabr.ru/company/shopozzcom/), [регистрируйтесь на нашем сервисе](http://shopozz.com/) и экономьте еще больше на покупках за рубежом.
[](http://shopozz.com/) | https://habr.com/ru/post/240483/ | null | ru | null |
# Коран по поискам дублей в Google Spreadsheet
Доброго времени суток, дорогие читатели.
Помните ли вы [овцу Долли](http://en.wikipedia.org/wiki/Dolly_(sheep))? При работе с документами google, особенно со spreadsheet (MS Excel) таблицами для решения многих нетипичных задач, таких как: специальное форматирование по множеству условий или удаление дубликатов, необходимо было научится пользоваться JavaScript, так как не все можно исполнить с помощью стандартных функций, а по формулам есть ограничения, которые раскроем в следующем выпуске. Теперь же представляем ликбез по поиску дублей ссылок и текста в Google Spreadsheet.
Поэтому начнем писать скрипты для Google Spreadsheet. Если вы знаете несколько языков программирования хотя бы поверхностно, вам, конечно, будет легче. На JavaScript я начал писать без проблем, но работал в основном с VBA, Visual basic, C/C++, C#. Как говорится, всего понемногу и везде по чуть-чуть. Ежели знания языков программирования хромают, то добро пожаловать на наш ликбез.
**Введение**
Для того чтоб вам был понятен пример, мы будем изучать скрипт на примере удаления дубликатов в таблицах документа google spreadsheet. Писать мы будем с нуля, поэтому приступаем.
**Поставим задачу**
Поставим задачу — найти в текстовом списке дубликаты и удалить их, создав резервную копию списка.
Создадим новый документ и назовем его “Поиски дублей”, страницу назовем так же. Искать дубликаты будем по 1-й колонке. Для того, чтобы было удобнее, пропишем название столбцов и закрепим их. Для того, чтобы закрепить строку или столбец, нужно потянуть за соответствующую жирную линию, при этом она переместится на 1 строку вниз или на 1 столбец вправо (Рисунок 1).
Рисунок 1. Закрепление столбцов и строк.
Так как обычно нам нужно использовать несколько столбцов, а в силу привычки мы обычно удаляем все лишние, мы добавим их заново (столбцы B:D). Если у вас новый лист, то соответственно там столбцы есть и добавлять их не нужно, а удалить все, что после, будет только приветствоваться. Так как чистота залог порядка.
Создадим еще 2 листа “Рабочая страница” на которой мы будем проводить манипуляции с данными. “Копия” — лист для копии начальных данных, в случае неправильной работы скрипта или потери данных (Рисунок 2).
Рисунок 2. Создание 2-х листов.
Приступаем к написанию кода. Нажимаем в верхнем ниспадающем меню Инструменты -> Редактор скриптов (Рисунок 3).
Рисунок 3. Открытие редактора скриптов в Google Spreadsheet.
Перед нами в новом окне откроется редактор скриптов с вариантами создания скриптов
(Рисунок 4)
Рисунок 4. Варианты создания скриптов в Редакторе скриптов.
Если вы выберете любой из пунктов слева (создание соответствующего скрипта для Диска, Почты и т.д.), то увидите вступительный скрипт с подробными объяснениями каким образом работать с тем или иным скриптом, Но это только показательные скрипты. Но мы выберем “Пустой проект” и увидим только начало всех скриптов
```
function myFunction(){}
```
.
Стандартное название проекта — это “Проект без названия”, я же поменял название кликнув на эти слова (верхняя строка на рисунке) и назвал его “Поиски дубликатов” (Рисунок 5). Это для того, чтобы потом при наличии 10 и более скриптов, можно было их различать и без особых усилий находить нужный нам скрипт.
Рисунок 5. “Пустой проект” с первыми стандартными строками кода и измененным названием
В фигурных скобках и будем писать наш скрипт.
Углубляться в изучение JavaScript мы особо не будем, но чтобы понял даже новичок, по ходу написания кода, я буду подробно комментировать происходящее.
**Пишем алгоритм**
Перед тем, как приступить к написанию любого автоматизирующего скрипта (задачи), нам нужно нарисовать для себя алгоритм действий. И пусть многим это может показаться бредом и тратой лишнего времени и, возможно, вы посчитаете данные действия лишними, но это очень важный этап работы. При работе с большими проектами это очень важно, так как запутаться можно и в 3-х соснах — алгоритм решает данную проблему. Это касается не только JavaScript, это касается абсолютно любого языка, да и вообще любых действий. Для понимания приведем пример на основе получения чашки чая (Рисунок 6).
Рисунок 6. Алгоритм действий получения чашки чая (пример).
Надеюсь, вы заварили чашечку :) и с хорошим настроением читаете дальше.
Нарисуем алгоритм для нашего скрипта по поиску дубликатов (Рисунок 7), он будет более подробный чем пример с чашкой чая.
Рисунок 7. Алгоритм для задачи по поиску дубликатов
Внесу небольшое пояснение, это уже окончательный вид алгоритма, поэтому в нем присутствуют 2 блока которые, возможно не сразу будут понятны для обычного пользователя.
Блок 2 — касается удаления контента и комментариев со страницы, на странице, которая, только что создана и совсем ничего не содержит. Этот блок нужен при повторном использовании скрипта, поэтому мы сразу закладываем данную функцию в скрипт. Об этом более подробно будет написано ниже.
Блок 5 — создание массива и конвертация, об этом будет рассказано подробно ниже. Сейчас же скажу, что созданный массив будет основным элементом обработки данных.
**Кодин**
Объявим переменные для наших листов, чтобы программа знала, как к ним обращаться.
Для объявления переменной в текущей области видимости используется ключевое слово var. Причем, особенностью языка javascript, как впрочем, и многих других, таких как php, является то, что не нужно специально объявлять тип переменной (как например, в C#: число объявляется integer; строка — string и т.д.).
Для того, чтобы описывать строки кода внутри самого кода, мы будем использовать комментарий в виде текста, который начинается с двух прямых слешей “//”. В разных языках программирования теги комментариев выглядят по разному и представляют из себя последовательность некоторых символов, вот несколько из них: (см. Таблицу 1.)
Таблица 1. Сравнительная таблица тегов комментариев в некоторых языках
При написании программ в редакторах языков, либо при применении правильного синтаксиса, например, в программе notepad++, текст программы будет подсвечиваться соответствующими цветами, которые прописаны для этого языка по умолчанию. Цвет текста комментариев, например, будет зеленый для большинства языков по умолчанию, но на самом деле, в программах для кодинга обычно присутствует возможность настраивать уветовую гамму, хотя и не везде. В google JS цвет комментария будет коричневый.
Рисунок 8. Иллюстрация подсветки синтаксиса кода.
Объявим три переменные для наших листов:
переменная sheet\_work\_page для страницы с названием “Рабочая страница”, сюда мы будем помещать текст для поиска и после работы получать результат.
переменная sheet\_find\_dubles для страницы с названием “Поиск дубликатов”, на этой странице будет проходить обработка дубликатов.
переменная sheet\_copy для страницы с названием “Копия”, создается копию данных перед началом обработки, так как никогда не знаешь, когда понадобится оригинал.
```
var sheet_work_page = SpreadsheetApp.getActiveSpreadsheet().getSheetByName('Рабочая страница');
var sheet_find_dubles = SpreadsheetApp.getActiveSpreadsheet().getSheetByName('Поиск дубликатов');
var sheet_copy = SpreadsheetApp.getActiveSpreadsheet().getSheetByName('Копия');
А также переменные для работы.
var i,Page_Last_Row,k,archurls;
переменные i, k - счетчики циклов, так как имена не несут большую смысловую нагрузку, не будем им присваивать имена покрасивее.
переменная Page_Last_Row - последняя строка листа, для которого, эта переменная будет объявлена.
переменная archurls - массив для хранения и перебора значений.
Для каждой новой обработки нам необходимо удалять контент и комментарии со страниц “Рабочая страница” и “Копия”, так как наш скрипт будет оперировать с комментариями. Это операция предотвращает попадание в конечный результат данных, которые могли остатся от предыдущих использований скрипта. Например: Вы, сначала работали с 1000 строк, а потом перешли на 20 строк, не удалив предыдущий результат, Вы в итоге получите 1000 строк, а не 20. Эту операцию на страницах можно выполнить так: удалить содержимое, нажав клавишу delete, а комментарии через контекстное меню соответствующей командой. При простом удалении, например, при нажатии клавиши delete, комментарии остаются.
Также можно воспользоватся клавиатурой:
Встать на вторую строку, нажать клавиши Shift + Space(пробел) так мы выделим всю строку, далее Shift+Ctrl+Arrow_Down (стрелка вниз) (выделить все до конца листа) и через контекстное меню "Удалить строки". Получаем девственно чистый лист с шапкой.
Рисунок 9 Правильно удаляем примечания.
Для удаления Нам необходимо знать границы диапазона где производится операция чистки. Это нужно для того чтобы, например, оставить шапку в документе нетронутой, либо если нам необходимо затронуть лишь часть данных, а также это необходимость формулировки языков программирования - знать рабочий диапазон.
Для нашего диапазона за основу берем диапазон ячеек “A2:D номер последней строки”
Номер последней строки - количество строк листа “Поиски дубликатов”.
Диапазон начинается с ячейки A2 так как первая строка или ячейка A1 находится в закреплении для обозначения шапки листа. А работать с закрепленной областью скритп не умеет. Также вид A2:Dномер последней строки можно записать как (2,1,номер последней строки,4) от этого ничего не поменяется, подробнее об этом Вы можете прочитать здесь.
[на русском языке](”http://habrahabr.ru/post/157933/”)
[на английском языке](”http://webhostingw.com/google-spreadsheet-formulas/”)
Напишем код для всего, что было сказано выше об удалении примечаний и содержимого, это всего лишь 4 строки.
sheet_work_page.getRange("A2:D" + sheet_find_dubles.getLastRow()).clearContent();
sheet_work_page.getRange("A2:D" + sheet_find_dubles.getLastRow()).clearComment();
sheet_copy.getRange("A2:D" + sheet_find_dubles.getLastRow()).clearContent();
sheet_copy.getRange("A2:D" + sheet_find_dubles.getLastRow()).clearComment();
```
Опишем немного подробнее:
*sheet\_work\_page* — символьное имя, которое мы присвоили листу “Рабочая страница”.
*getRange(первая строка, первый столбец, последняя строка, последний столбец)* — указание диапазона для совершения дальнейших действий.
*clearContent()* — удаление содержимого в ячейках, указанных в диапазоне.
*clearComment()* — удаление примечаний в ячейках, указанных в диапазоне.
Создаем переменную datatocopy и выделяем диапазон ячеек с данными A2:D последняя строка в листе “Поиск дубликатов” и копируем на страницы “Рабочая страница” и “Копия”.
Особенность данной операции в том, что вставить скопированый диапазон можно только при выделении соответствующего диапазона.
```
var datatocopy = sheet_find_dubles.getRange("A2:D" + sheet_find_dubles.getLastRow()).getValues();
sheet_work_page.getRange(2,1,sheet_find_dubles.getLastRow()-1,4).setValues(datatocopy);
var datatocopy1 = sheet_find_dubles.getRange("A2:D" + sheet_find_dubles.getLastRow()).getValues();
sheet_copy.getRange(2,1,sheet_find_dubles.getLastRow()-1,4).setValues(datatocopy1);
```
переменной Page\_Last\_Row присваиваем значение последней строки страницы “Поиск дубликатов”
```
Page_Last_Row = sheet_find_dubles.getLastRow();
```
В объявленный ранее массив archurls присваиваем все данные из первой колонки листа “Поиск дубликатов”.
```
archurls = sheet_find_dubles.getRange(2, 1, Page_Last_Row-1, 1).getValues();
```
и конвертируем 2-х мерный массив в одномерный. Это нужно для того, чтобы переконвертировать все записи в столбце в символы, так как поиск у нас происходит посимвольно.
```
for (i=0; i
```
Чтобы лучше понять механизм действий и составить правильное представление, рассмотрим скриншот “Как выглядят данные в массиве archurls” рисунок 8
Рисунок 8 Как выглядит массив со значениями изнутри.
Переменной i, которая в данном случаем будет использоваться для порядкового номера проверяемой строки листа “Рабочая страница”, присваиваем значение 2-й строки, так как 1-я у нас является названиями столбцов, i = 2;
И переходим к написанию главного цикла по поиску дубликатов. Объявляем цикл while (цикл, условие которого проверяется перед началом операций всего цикла) и в нем перебираем построчно значения из листа “Рабочая страница”, сравнивая со значениями листа “Поиск дубликатов”.
```
while (i <= sheet_work_page.getLastRow())
{
k = archurls.indexOf(sheet_work_page.getRange(i, 1).getValue());
if (k >= 0)
{
if ((k+2)==i)
{
sheet_work_page.getRange(i, 4).setComment('Найдено совпадение со строкой ' + (k+1) + ' архива');
i++;
continue;
}
else
{
sheet_work_page.getRange("A" + i + ":C" + i).clearContent();
i++;
delete_count++;
continue;
}
}
}
```
В итоге, на рабочей странице получаем список без 100% дубликатов.
**Учтите, что если ссылка А содержит кириллицу но визуально она похожа на ссылку B, написанную латиницей, то эти ссылки будут разными.**
Сортируем, если есть такая необходимость.
Описание: Лист.sort(номер колонки, true/false) true — от А до Я, false — от Я до А
```
sheet_work_page.sort(3, true);
```
Для того, чтобы нам не приходилось каждый раз для запуска скрипта заходить в редактор, мы выведем отдельную кнопку на панели меню.
Код функции для кнопки прост.
```
function onOpen()
{
SpreadsheetApp.getActiveSpreadsheet().addMenu("Поиск дубликатов?", [{name: "Удалить дубликаты!", functionName: "check_duplicates_one_sheet"}]);
}
```
Добавляем меню с названием “Копаем?” указываем название подменю “Копаем!” и присваиваем кнопке выполнение функции той, что мы написали выше:check\_duplicates\_one\_sheet (рисунок 9)
Рисунок 9
Можете зайти в наш документ описанный в этой статье.
**Дополнение:**
“А если необходимо просто удалить дубликаты из колонки А, быстренько и без глупостей?”, — спросите вы.
Что ж напишем более скоростной скрипт.
```
function removeDuplicates() {
//объявим наш листик.
var sheet = SpreadsheetApp.getActiveSpreadsheet().getSheetByName("Ускоренная чистка дублей для одной колонки");
//получаем массив данных из нашего листа.
var data = sheet.getDataRange().getValues();
//объявим новый массив для результатов.
var newdata = new Array();
//проверяем на дубли
for(i in data){
var row = data[i];
var duplicate = false;
for(j in newdata){
if(row[0] == newdata[j][0]){
duplicate = true;
}
}
//обновляем строку
if(!duplicate){
newdata.push(row);
}
}
//очищаем содержимое ячеек с исходного листа
sheet.clearContents();
//вставляем в лист новый отчищенный массив
sheet.getRange(1, 1, newData.length, newData[0].length).setValues(newData);
//сортируем по возрастанию
sheet.sort(1, true);
}
```
В итоге, у нас быстродействующий скрипт по удалению дубликатов.
Проверенно на 400 000 записях.
До новых встреч! Ваш покорный слуга.
Также можете посетить наши предыдущие статьи:
Талмуд по формулам в Google SpreadSheet
Рассылка писем в Google Docs (Drive)
ждите наши следующие выпуски. | https://habr.com/ru/post/198898/ | null | ru | null |
# Минимальные API в .NET 6
Создание REST API является основной частью многих проектов разработки. Выбор для создания таких проектов широк, но если вы разработчик на C#, варианты будут весьма ограничены. API на основе контроллеров были наиболее распространенными в течение долгого времени, но .NET 6 меняет эту ситуацию, предлагая новую возможность.
**Как это произошло?**
Присоединение компьютеров было проблемой с первых шагов распределенных вычислений около пятидесяти лет назад (см. Рисунок 1). Удаленные вызовы процедур были так же важны, как и API в современной разработке. Благодаря REST, OData, GraphQL, GRPC и т.п. у нас появилось множество возможностей для создания способов взаимодействия между приложениями.
Рисунок 1: История APIХотя многие из этих технологий процветают, использование REST как основного способа коммуникации по-прежнему остается неизменным в современном мире разработки. На протяжении многих лет у Microsoft было несколько решений для создания REST API, но в течение последнего десятилетия основным инструментом являлся Web API. Основанный на фреймворке ASP.NET MVC, Web API был предназначен для того, чтобы рассматривать глаголы и существительные архитектуры REST как граждан первого класса. Возможность создать класс, представляющий поверхностную область (часто связанную с "существительным" в контексте REST), которая связана с библиотекой маршрутизации, по-прежнему является жизнеспособным способом создания API в современном мире.
Одним из недостатков фреймворка Web API (например, контроллеров) является то, что для небольших API (или микросервисов) требуется определенная церемония. Например, контроллеры — это классы, которые представляют один или несколько возможных вызовов API:
```
[Route("api/[Controller]")]
[Authorize(AuthenticationSchemes = JwtBearerDefaults.AuthenticationScheme)]
public class OrdersController : Controller
{
readonly IDutchRepository _repository;
readonly ILogger \_logger;
readonly IMapper \_mapper;
readonly UserManager \_userManager;
public OrdersController(
IDutchRepository repository,
ILogger logger,
IMapper mapper,
UserManager userManager)
{
\_repository = repository;
\_logger = logger;
\_mapper = mapper;
\_userManager = userManager;
}
[HttpGet]
public IActionResult Get(bool includeItems = true)
{
try
{
var username = User.Identity.Name;
var results = \_repository
.GetOrdersByUser(username, includeItems);
return Ok(\_mapper
.Map>(results));
}
catch (Exception ex)
{
\_logger.LogError($"Failed : {ex}" );
return BadRequest($"Failed");
}
}
...
```
Этот код типичен для контроллеров Web API. Но значит ли это, что он плох? Нет. Для больших API и тех, которые имеют расширенные потребности (например, полноценная аутентификация, авторизация и версионирование), такая структура работает отлично. Но для некоторых проектов действительно необходим более простой способ создания API. Отчасти это обусловлено влиянием других фреймворков, в которых создание API кажется более компактным, а также желанием иметь возможность быстрее разрабатывать/прототипировать API.
Данная потребность не так уж нова. На самом деле, [фреймворк Nancy](https://github.com/NancyFx/Nancy) был решением на C# для маппинга вызовов API еще раньше (хотя сейчас он устарел). Даже более новые библиотеки, такие как [Carter](https://github.com/CarterCommunity/Carter), пытаются достичь того же самого. Наличие эффективных и простых способов создания API — это необходимый принцип. Не стоит воспринимать минимальные API (Minimal API) как "правильный" или "неправильный" способ создания API. Вы должны рассматривать его как еще один инструмент.
**Что такое минимальные API?**
Основная идея Minimal API заключается в том, чтобы устранить некоторые из церемоний при создании простых API. Это означает определение лямбда-выражений для отдельных вызовов API. Например:
```
app.MapGet("/", () => "Hello World!");
```
Этот вызов указывает маршрут (например, "/") и обратный вызов для выполнения после совпадения запроса, соответствующего маршруту и глаголу. Метод `MapGet` предназначен для маппирования HTTP GET с функцией обратного вызова. Большая часть этого волшебства заключается в том, что происходит определение типа. Когда мы возвращаем строку (как в этом примере), он оборачивает ее в возвращаемый результат 200 (OK, например).
Данные методы маппинга являются открытыми. Это методы расширения в интерфейсе `IEndpointRouteBuilder`. Интерфейс раскрывается классом `WebApplication`, который используется для создания нового приложения Web-сервера в .NET 6. Не буду углубляться в эту тему, пока не расскажу о том, как работает новый алгоритм Startup в .NET 6.
> Основная идея Minimal APIs заключается в том, чтобы убрать некоторые церемонии создания простых API.
>
>
### Новый способ использования Startup
Многое уже было написано о желании убрать бойлерплейт из процедуры начального запуска в C# в целом. С этой целью Microsoft добавила в C# 10 так называемые "утверждения верхнего уровня". Это означает, что `program.cs`, с помощью которого вы запускаете свои веб-приложения, не нуждается в `void Main()` для загрузки приложения. Все это подразумевается. До появления C# 10 запуск приложения выглядел примерно так:
```
using Microsoft.AspNetCore.Hosting;
using Microsoft.Extensions.Hosting;
namespace Juris.Api
{
public class Program
{
public static void Main(string[] args)
{
CreateHostBuilder(args).Build().Run();
}
public static IHostBuilder
CreateHostBuilder(string[] args) =>
Host.CreateDefaultBuilder(args)
.ConfigureWebHostDefaults(webBuilder =>
{
webBuilder.UseStartup();
});
}
}
```
Необходимость в классе и методе `void Main`, который выполняет загрузку хоста для запуска сервера, — это то, как мы уже несколько лет пишем ASP.NET в .NET Core. С помощью утверждений верхнего уровня они хотят упростить этот бойлерплейт, как показано ниже:
```
var builder = WebApplication.CreateBuilder(args);
// Setup Services
var app = builder.Build();
// Add Middleware
// Start the Server
app.Run();
```
Вместо класса `Startup` с местами для настройки сервисов и связующего ПО, все делается в данной очень простой программе верхнего уровня. Какое отношение это имеет к Minimal API? Приложение, создаваемое объектом builder (строитель), поддерживает интерфейс `IEndpointRouteBuilder`. Так что в нашем случае настройка API — это просто связующее ПО:
```
var builder = WebApplication.CreateBuilder(args);
// Setup Services
var app = builder.Build();
// Map APIs
app.MapGet("/", () => "Hello World!");
// Start the Server
app.Run();
```
Давайте поговорим об отдельных функциях.
### Маршрутизация
Первое, что бросается в глаза — паттерн для маппинга вызовов API очень похож на паттерн соответствия контроллеров MVC. Это означает, что Minimal API очень похожи на методы контроллера. Например:
```
app.MapGet("/api/clients", () => new Client()
{
Id = 1,
Name = "Client 1"
});
app.MapGet("/api/clients/{id:int}", (int id) => new Client()
{
Id = id,
Name = "Client " + id
});
```
Простые пути, такие как `/api/clients`, указывают на простые пути URI, поскольку использование синтаксиса параметров (даже с ограничениями) продолжает работать. Обратите внимание, что обратный вызов может принимать ID, маппированный из URI, как и контроллеры MVC. Одна вещь, на которую следует обратить внимание в лямбда-выражении, заключается в том, что типы параметров инференцируются (как и в большинстве случаев в C#). Это означает, что поскольку вы используете URL-параметр (например, `id`), вам нужно ввести первый параметр. Если вы его не ввели, то в лямбда-выражении будет сделана попытка угадать тип:
```
app.MapGet("/api/clients/{id:int}", (id) => new Client()
{
Id = id, // Doesn't Work
Name = "Client " + id
});
```
Это не работает, так как без подсказки типа первый параметр лямбда-выражения считается экземпляром `HttpContext`. Так происходит потому, что на самом низком уровне вы можете управлять собственным ответом на любой запрос с помощью объекта контекста. Но в большинстве случаев вы будете использовать параметры лямбда-выражения для помощи в маппинге объектов и параметров.
### Использование сервисов
До сих пор вызовы API, которые вы видели, не были похожи на реальность. В большинстве случаев для выполнения вызовов хочется воспользоваться обычными сервисами. Это подводит меня к вопросу о том, как использовать сервисы в Minimal API. Вы могли заметить, что ранее я оставил место для регистрации сервисов перед созданием `WebApplication`:
```
var bldr = WebApplication.CreateBuilder(args);
// Register services here
var app = bldr.Build();
```
Можно просто использовать объект builder для доступа к службам, например, так:
```
var bldr = WebApplication.CreateBuilder(args);
// Register services
bldr.Services.AddDbContext();
bldr.Services.AddTransient();
var app = bldr.Build();
```
Здесь видно, что вы можете использовать объект `Services` в builder приложения для добавления любых необходимых вам сервисов (в данном случае я добавляю объект контекста Entity Framework Core и хранилище, которое буду применять для выполнения запросов. Чтобы использовать эти сервисы, вы можете просто добавить их в параметры лямбда-выражения:
```
app.MapGet("/clients", async (IJurisRepository repo) => {
return await repo.GetClientsAsync();
});
```
При добавлении требуемого типа он будет введен в лямбда-выражение во время его выполнения. Это отличается от API на основе контроллеров тем, что зависимости обычно определяются на уровне классов. Эти инжектированные сервисы не меняют того, как службы обрабатываются сервисным уровнем (т.е. Minimal API по-прежнему создает область действия для ограниченных служб). Когда вы используете параметры URI, то можно просто добавить необходимые сервисы к другим параметрам:
```
app.MapGet("/clients/{id:int}", async (int id, IJurisRepository repo) => {
return await repo.GetClientAsync(id);
});
```
Для этого потребуется отдельно продумать сервисы, необходимые для каждого вызова API. Но это также обеспечивает гибкость в использовании сервисов на уровне API.
### Глаголы
До сих пор я рассматривал только HTTP GET API. Существуют методы для различных типов глаголов. К ним относятся:
* MapPost
* MapPut
* MapDelete
Эти методы работают идентично `MapGet`. Например, возьмем этот вызов для POST нового клиента:
```
app.MapPost("/clients", async (Client model, IJurisRepository repo) =>
{
// ...
});
```
Обратите внимание, что в данном случае модели не нужно использовать атрибуты для указания **FromBody**. Она определяет тип, если форма соответствует запрашиваемому типу. Вы можете смешивать и сочетать все, что вам может понадобиться (как показано в `MapPut`):
```
app.MapPut("/clients/{id}", async (int id, ClientModel model,
IJurisRepository repo) =>
{
// ...
});
```
Для других глаголов вам нужно выполнять их маппинг с помощью MapMethods:
```
app.MapMethods("/clients", new [] { "PATCH" },
async (IJurisRepository repo) => {return await repo.GetClientsAsync();
});
```
Обратите внимание на то, что метод `MapMethods` использует не только путь, но и список глаголов, которые нужно принять. В данном случае я выполняю это лямбда-выражение при получении глагола PATCH. Хотя вы создаете API отдельно, большая часть того же кода, с которым вы знакомы, продолжит работать. Единственное реальное изменение заключается в том, как плюмбинг находит ваш код.
### Использование кодов состояния HTTP
До сих пор в этих примерах вы не видели, как обрабатывать различные результаты действий API. В большинстве API, которые я пишу, невозможно предположить, что действие будет успешным, а выбрасывать исключения — не тот способ, который подходит. Для этого необходимо контролировать возвращаемые коды состояния. Этим занимается статический класс `Results`. Вы просто оборачиваете свой результат вызовом `Results` и кодом состояния:
```
app.MapGet("/clients", async (IJurisRepository repo) => {
return Results.Ok(await repo.GetClientsAsync());
});
```
Results поддерживает большинство кодов состояния, которые вам понадобятся, например:
* **Results.Ok:** 200
* **Results.Created:** 201
* **Results.BadRequest:** 400
* **Results.Unauthorized:** 401
* **Results.Forbid:** 403
* **Results.NotFound**: 404
И т.д.
В типовом сценарии вы можете использовать несколько из них:
```
app.MapGet("/clients/{id:int}", async (int id, IJurisRepository repo) => {
try {
var client = await repo.GetClientAsync(id);
if (client == null)
{
return Results.NotFound();
}
return Results.Ok(client);
}
catch (Exception ex)
{
return Results.BadRequest("Failed");
}
});
```
Если вы собираетесь передать делегат классам `MapXXX`, можно просто заставить их возвращать `IResult` для запроса кода состояния:
```
app.MapGet("/clients/{id:int}", HandleGet);
async Task HandleGet(int id, IJurisRepository repo)
{
try
{
var client = await repo.GetClientAsync(id);
if (client == null) return Results.NotFound();
return Results.Ok(client);
}
catch (Exception)
{
return Results.BadRequest("Failed");
}
}
```
Заметьте, что поскольку в этом примере применяется `async`, вам нужно обернуть `IResult` объектом `Task`. В результате возвращается экземпляр `IResult`. Хотя Minimal API предназначены для того, чтобы быть маленькими и простыми, вы быстро поймете, что с прагматической точки зрения API меньше зависит от того, как они инстанцируются, и больше от логики внутри них. И Minimal API, и API на основе контроллеров работают по сути одинаково. Меняется только плюмбинг.
Обеспечение безопасности Minimal API
------------------------------------
Хотя Minimal API работают с промежуточным ПО аутентификации и авторизации, вам все равно может понадобится способ указать на уровне API, как должна работать безопасность. Если вы работаете с API на основе контроллеров, можно использовать атрибут Authorize для указания способов защиты API, но если нет контроллеров, вам остается указать их на уровне API. Вы делаете это, вызывая методы на сгенерированных вызовах API. Для примера, чтобы потребовать авторизацию:
```
app.MapPost("/clients", async (ClientModel model, IJurisRepository repo) =>
{
// ...
}).RequireAuthorization();
```
Этот вызов `RequireAuthorization` равносилен использованию фильтра `Authorize` в контроллерах (например, вы можете указать, какова схема аутентификации или другие необходимые вам свойства). Допустим, вы собираетесь требовать аутентификацию для всех вызовов:
```
bldr.Services.AddAuthorization(cfg => {
cfg.FallbackPolicy = new AuthorizationPolicyBuilder()
.RequireAuthenticatedUser()
.Build();
});
```
Тогда вам не нужно добавлять `RequireAuthentication` для каждого API, но вы можете переопределить это значение по умолчанию, разрешив анонимность для других вызовов:
```
app.MapGet("/clients", async (IJurisRepository repo) =>
{
return Results.Ok(await repo.GetClientsAsync());
}).AllowAnonymous();
```
Таким образом, вы можете смешивать и сочетать аутентификацию и авторизацию по своему усмотрению.
### Использование Minimal API без функций верхнего уровня
Это новое изменение в .NET 6 может шокировать многих из вас. Возможно, вы не захотите менять свой `Program.cs`, чтобы использовать функции верхнего уровня для всех своих проектов. Но можно ли использовать Minimal API без перехода на них? Если вы помните, ранее в статье я упоминал, что большая часть магии Minimal API исходит от интерфейса `IEndpointRouteBuilder`. Его поддерживает не только класс `WebApplication`, он также используется в традиционном классе Startup, который вы, возможно, уже используете. Когда вы вызываете `UseEndpoints`, делегат, указанный там, передает `IEndpointRouteBuilder`, что означает — можно просто вызвать `MapGet`:
```
public void Configure(IApplicationBuilder app,
IWebHostEnvironment env)
{
if (env.IsDevelopment())
{
app.UseDeveloperExceptionPage();
}
app.UseRouting();
app.UseAuthorization();
app.UseEndpoints(endpoints =>
{
endpoints.MapGet("/clients", async (IJurisRepository repo) =>
{
return Results.Ok(await repo.GetClientsAsync());
}).AllowAnonymous();
});
}
```
Хотя я считаю, что Minimal API наиболее полезны для принципиально новых проектов или проектов прототипов, вы можете использовать их в своих существующих проектах (при условии, что выполнили апгрейд до .NET 6).
**Где мы находимся?**
Надеюсь, вы убедились в том, что Minimal API — это новый способ создания API без большого количества плюмбинга и церемоний, связанных с API на базе контроллеров. В то же время, я надеюсь, вы поняли, что по мере роста сложности API на базе контроллеров также имеют свои преимущества. Я рассматриваю Minimal API как отправную точку для создания API, а по мере развития проекта можно переходить к API на базе контроллеров. Хотя это еще очень новое направление, я считаю Minimal API отличным способом создания API. Ответы на закономерности и лучшие практики о том, как их использовать, появятся только со временем. Надеюсь, вы сможете внести свой вклад в это обсуждение!
---
Приглашаем всех желающих на открытое занятие сегодня в 20:00 по теме **«Работа с базой данных с помощью Entity Framework Core».** На этом занятии настроим работу с реляционной базой данных через Entity Framework Core. А также объясним, что представляет из себя паттерн Репозиторий и паттерн Unit Of Work. [**Регистрация здесь.**](https://otus.pw/y9Pz/) | https://habr.com/ru/post/666676/ | null | ru | null |
# Расширенные шаблоны многоэтапной сборки
Функция многоэтапной сборки в файлах Dockerfile позволяет создавать небольшие образы контейнеров с более высоким уровнем кэширования и меньшим объемом защиты. В этой статье я покажу несколько расширенных шаблонов — нечто большее, чем копирование файлов между этапами сборки и выполнения. Они позволяют добиться максимальной эффективности функции. Однако, если Вы — новичок в сфере многоэтапной сборки, то сперва, наверное, не лишним будет прочесть [руководство по использованию](https://docs.docker.com/develop/develop-images/multistage-build/).
### Совместимость версий
Поддержка многоэтапной сборки была добавлена в Docker в версии v17.05. Все шаблоны работают с любой последующей версией, но некоторые — значительно эффективнее, благодаря использующим серверную часть [BuildKit](https://github.com/moby/buildkit) компоновщикам. Скажем, BuildKit эффективно пропускает неиспользуемые этапы и, по возможности, создает этапы одновременно (эти примеры я выделил отдельно). В настоящее время BuildKit [добавляется в Moby](https://github.com/moby/moby/pull/37151) в качестве экспериментальной серверной части сборки и должен быть доступен в версии Docker CE v18.06. Также его можно применять [автономно](https://github.com/moby/buildkit#quick-start) или в рамках проекта [img](https://github.com/genuinetools/img).
---
#### Наследование от этапа
Многоэтапная сборка добавляет несколько новых концепций синтаксиса. Прежде всего, можно присвоить этапу, начинающемуся с команды `FROM`, имя `AS stagename` и использоваться опцию `--from=stagename` в команде `COPY` для копирования файлов из этого этапа. На самом деле команда `FROM` и метка `--from` имеют гораздо больше общего, не зря же у них одинаковое название. Обе принимают одинаковый аргумент, распознают его и либо запускают новый этап с этой точки, либо используют ее в качестве источника для копирования файла. То есть чтобы использовать предыдущий этап в исходного качестве образа для этапа текущего, брать можно не только `--from=stagename`, но и имя этапа `FROM stagename`. Полезно, если пользуетесь одинаковыми общими частями в нескольких командах в Dockerfile: уменьшает общий код и упрощает его обслуживание, сохраняя дочерние этапы раздельно. Таким образом, перестройка одного этапа не влияет на кэш сборки для других. Соответственно, каждый этап можно собрать индивидуально с помощью метки `--target` при вызове `docker build`.
```
FROM ubuntu AS base
RUN apt-get update && apt-get install git
FROM base AS src1
RUN git clone …
FROM base as src2
RUN git clone …
```
В этом примере второй и третий этап в BuildKit строятся одновременно.
### Непосредственное использование образов
Вместо того, чтобы использовать имена этапов сборки в командах `FROM`, которые ранее поддерживали только ссылки на образы, можно напрямую использовать образы — с помощью метки `--from`. Получается копировать файлы непосредственно из этих образов. Например, `linuxkit/ca-certificatesimage` в следующем коде напрямую копирует корни TLS CA в текущий этап.
```
FROM alpine
COPY --from=linuxkit/ca-certificates / /
```
### Псевдоним общего образа
Этап сборки необязательно включает какие-либо команды; он может состоять из единственной строки `FROM`. Если используется образ в нескольких местах, это упростит чтение и сделает так, что, если надо обновить общий образ, потребуется изменить только одну строку.
```
FROM alpine:3.6 AS alpine
FROM alpine
RUN …
FROM alpine
RUN …
```
В данном примере каждое место, использующее образ alpine, фактически фиксируется на `alpine:3.6`, а не `alpine:latest`. Когда придет время обновиться до `alpine:3.7`, изменить потребуется единственную строку, и можно не сомневаться: теперь во всех элементах сборки используется обновленная версия.
Это тем более важно, когда в псевдониме используется аргумент сборки. Следующий пример аналогичен предыдущему, но позволяет пользователю переопределить все экземпляры сборки, в которых задействован образ alpine, путем настройки опции `--build-arg ALPINE_VERSION=value`. Помните: любые аргументы, используемые в командах `FROM`, нужно определить [до первого этапа сборки](https://docs.docker.com/engine/reference/builder/#understand-how-arg-and-from-interact).
```
ARG ALPINE_VERSION=3.6
FROM alpine:${ALPINE_VERSION} AS alpine
FROM alpine
RUN …
```
### Использование аргументов сборки в "— from"
Значение, указанное в метке `--from` команды `COPY`, не должно содержать аргументы сборки. Например, следующий пример недействителен.
```
// THIS EXAMPLE IS INTENTIONALLY INVALID
FROM alpine AS build-stage0
RUN …
FROM alpine
ARG src=stage0
COPY --from=build-${src} . .
```
Это связано с тем, что зависимости между этапами нужно определить еще до начала сборки. Тогда постоянная оценка всех команд не потребуется. Например, переменная среды, определенная в образе `alpine`, может влиять на оценку значения `--from`. Причина, по которой мы можем оценивать аргументы команды `FROM`, — в том, что эти аргументы определяются глобально до начала любого этапа. К счастью, как мы выяснили ранее, достаточно определить этап псевдонима с помощью одной команды `FROM` и ссылаться на него.
```
ARG src=stage0
FROM alpine AS build-stage0
RUN …
FROM build-${src} AS copy-src
FROM alpine
COPY --from=copy-src . .
```
Теперь, если переопределить аргумент сборки `src`, исходный этап для окончательного элемента `COPY` переключится. Обратите внимание: если какие-то этапы теперь не используются, то эффективно пропускать их смогут только компоновщики на основе BuildKit.
### Условия, использующие аргументы сборки
Нас просили добавить в Dockerfile поддержку условий стиля `IF/ELSE`. Мы пока еще не знаем, будем ли добавлять нечто подобное, но в будущем попробуем — с помощью поддержки клиентской части в BuildKit. Между тем, чтобы добиться аналогичного поведения, можно использовать текущие многоэтапные концепции (при некотором планировании).
```
// THIS EXAMPLE IS INTENTIONALLY INVALID
FROM alpine
RUN …
ARG BUILD_VERSION=1
IF $BUILD_VERSION==1
RUN touch version1
ELSE IF $BUILD_VERSION==2
RUN touch version2
DONE
RUN …
```
В предыдущем примере показан псевдокод для записи условий с помощью `IF/ELSE`. Чтобы добиться аналогичного поведения с помощью текущих многоэтапных сборок, может потребоваться определить различные условия ветвей в качестве отдельных этапов и использовать аргумент для выбора правильного пути зависимости.
```
ARG BUILD_VERSION=1
FROM alpine AS base
RUN …
FROM base AS branch-version-1
RUN touch version1
FROM base AS branch-version-2
RUN touch version2
FROM branch-version-${BUILD_VERSION} AS after-condition
FROM after-condition
RUN …
```
Последний этап в Dockerfile основан на этапе `after-condition`, который представляет собой псевдоним образа (распознается на основе аргумента сборки `BUILD_VERSION`). В зависимости от значения `BUILD_VERSION` выбирается тот или иной этап средней секции.
Обратите внимание: пропускать неиспользуемые ветви могут только компоновщики на базе BuildKit. В предыдущих вариантах компоновщиков строились бы все этапы, но перед созданием конечного образа их результаты были бы отброшены.
### Помощник по разработке/тестированию для минимального производственного этапа
В завершение давайте рассмотрим пример комбинирования предыдущих шаблонов для демонстрации того, как создать Dockerfile, создающий минимальный производственный образ и способный затем использовать его содержимое для тестирования и создания образа разработки. Начнем с базового примера Dockerfile:
```
FROM golang:alpine AS stage0
…
FROM golang:alpine AS stage1
…
FROM scratch
COPY --from=stage0 /binary0 /bin
COPY --from=stage1 /binary1 /bin
```
Когда создается минимальный производственный образ, это — довольно распространенный вариант. Но что, если надо также получить альтернативный образ разработчика или запустить тесты с этими двоичными файлами на конечном этапе? Первое, что приходит на ум, — это просто скопировать аналогичные двоичные файлы на этапах тестирования и разработки. Проблема же такова: нет гарантий того, что Вы будете тестировать все производственные двоичные файлы в той же комбинации. На конечном этапе что-то может измениться, а Вы забудете внести аналогичные изменения на других этапах или допустите ошибку в пути копирования двоичных файлов. В конце концов, мы не отдельный двоичный файл тестируем, а конечный образ.
Альтернативный вариант — определить этап разработки и тестирования после этапа производства и копировать все содержимое этапа производства. Затем использовать для этапа производства одну команду `FROM`, чтобы снова сделать этап производства по умолчанию последним шагом.
```
FROM golang:alpine AS stage0
…
FROM scratch AS release
COPY --from=stage0 /binary0 /bin
COPY --from=stage1 /binary1 /bin
FROM golang:alpine AS dev-env
COPY --from=release / /
ENTRYPOINT ["ash"]
FROM golang:alpine AS test
COPY --from=release / /
RUN go test …
FROM release
```
По умолчанию этот Dockerfile продолжит построение минимального образа по умолчанию, в то время как, например, сборка с опцией `--target=dev-env` будет создавать образ с оболочкой, содержащей все двоичные файлы окончательной версии.
---
Надеюсь, это было полезно и подсказало, как создать более эффективные многоэтапные файлы Dockerfile. Если участвуете в [DockerCon2018](https://2018.dockercon.com) и хотите узнать больше о многоэтапных сборках, Dockerfiles, BuildKit или о каких-то смежных темах, подписывайтесь на компоновщик [Hallway track](https://hallwaytrack.dockercon.com) или отслеживайте внутренние совещания платформы Docker на треках [Contribute and Collaborate](https://dockercon18.smarteventscloud.com/connect/sessionDetail.ww?SESSION_ID=187206) или [Black Belt](https://dockercon18.smarteventscloud.com/connect/sessionDetail.ww?SESSION_ID=193373). | https://habr.com/ru/post/433790/ | null | ru | null |
# Обзор релиз-кандидата React v0.14
Мы рады представить вам наш первый релиз-кандидат версии React 0.14! Мы опубликовали в июле [анонс](http://facebook.github.io/react/blog/2015/07/03/react-v0.14-beta-1.html) предстоящих изменениях, но сейчас мы еще больше стабилизировали релиз и нам бы хотелось, чтобы вы попробовали его до того, как мы выпустим финальную версию.
Сообщите нам, если у вас возникли любые проблемы, создав задачу в нашем [GitHub репозитории](https://github.com/facebook/react)
Инсталляция
-----------
Мы рекомендуем использовать React через **npm** и использовать утилиты, типа browserify или webpack для сборки вашего кода в один пакет:
```
npm install --save react@0.14.0-rc1
npm install --save react-dom@0.14.0-rc1
```
Помните, что по умолчанию, в режиме разработки React запускает дополнительные проверки и предоставляет полезные предупреждения. Поэтому, при развертывания вашего приложения установите переменную окружения **NODE\_ENV** в **production** для использования production-режима, при котором React не включает служебные предупреждения и работает значительно быстрее.
Если вы не можете использовать **npm**, мы также предоставляем скомпилированные сборки для браузеров для вашего удобства:
* **React**
Dev-сборка с предупреждениями: <https://fb.me/react-0.14.0-rc1.js>
Минифицированная production-сборка: <https://fb.me/react-0.14.0-rc1.min.js>
* **React с Add-Ons**
Dev-сборка с предупреждениями: <https://fb.me/react-with-addons-0.14.0-rc1.js>
Dev-сборка с предупреждениями: <https://fb.me/react-with-addons-0.14.0-rc1.min.js>
* **React DOM** (подключайте React на странице до React DOM)
Dev-сборка с предупреждениями: <https://fb.me/react-dom-0.14.0-rc1.js>
Dev-сборка с предупреждениями: <https://fb.me/react-dom-0.14.0-rc1.min.js>
Эти сборки также доступны в качестве bower-пакетов: **react** и **react-dom**
Основные изменения
------------------
### Два пакета: React и React DOM
Когда мы смотрим на такие модули, как [react-native](https://github.com/facebook/react-native), [react-art](https://github.com/reactjs/react-art), [react-canvas](https://github.com/Flipboard/react-canvas) и [react-three](https://github.com/Izzimach/react-three), становится понятно, что красота и сущность React не имеет ничего общего с браузерами или DOM.
Чтобы сделать это более прозрачным и проще для использования в большем количестве окружений, где React может рендерить, мы разделили главный пакет **react** на два: **react** и **react-dom**.
**Это открывает путь для написания компонентов, которые могут совместно использоваться в веб-версиях React и React Native.** Мы не предполагаем, что весь код в приложении должен быть расшарен, но мы хотим иметь возможность совместного использования компонентов, которые ведут себя одинаково на разных платформах.
Пакет **react** содержит **React.createElement**, **.createClass**, **.Component**, **.PropTypes**, **.Children** и другие хелперы ориентированные на элементы и компонентные классы. Мы думаем о них, как о [*изоморфных*](http://nerds.airbnb.com/isomorphic-javascript-future-web-apps/) или [*универсальных*](https://medium.com/@mjackson/universal-javascript-4761051b7ae9) хелперах, которые необходимы вам для построения компонентов.
Пакет **react-dom** содержит **ReactDOM.render**, **.unmountComponentAtNode** и **.findDOMNode**. В **react-dom/server** у нас есть поддержка рендера на сервере при помощи **ReactDOMServer.renderToString** и **.renderToStaticMarkup**.
```
var React = require('react');
var ReactDOM = require('react-dom');
var MyComponent = React.createClass({
render: function() {
return Hello World;
}
});
ReactDOM.render(, node);
```
Мы опубликовали [автоматизированный codemod скрипт](https://github.com/facebook/react/blob/master/packages/react-codemod/README.md), который мы используем в Facebook для этого перехода
Дополнения (Add-ons) были перемещены в отдельные пакеты: **react-addons-clone-with-props**, **react-addons-create-fragment**, **react-addons-css-transition-group**, **react-addons-linked-state-mixin**, **react-addons-perf**, **react-addons-pure-render-mixin**, **react-addons-shallow-compare**, **react-addons-test-utils**, **react-addons-transition-group** и **react-addons-update**, а также **ReactDOM.unstable\_batchedUpdates** в **react-dom**
На данный момент, используйте пожалуйста определенные версии **react** и **react-dom** в ваших приложениях, для предотвращения проблем с версионностью.
### Ссылки на DOM узлы
Другим важным изменением, которое мы сделали в этом релизе является то, что ссылки (refs) на компоненты DOM, теперь ссылаются на сам DOM узел.
Что это значит: мы посмотрели на то, что вы делаете с **ссылкой (ref)** на React DOM компоненты и поняли, что единственная полезная вещь, которую вы можете сделать с ним — это вызов **this.refs.giraffe.getDOMNode()** для получения DOM узла. В этом релизе, **this.refs.giraffe** *это* текущая DOM нода.
**Обратите внимание, что ссылки на кастомные (заданные пользователем) компоненты, работают также, как и раньше; только нативные DOM компоненты подпадают под это изменение.**
```
var Zoo = React.createClass({
render: function() {
return Giraffe name: ;
},
showName: function() {
// Previously: var input = this.refs.giraffe.getDOMNode();
var input = this.refs.giraffe;
alert(input.value);
}
});
```
Это изменение также относится и к возвращаемому результату **ReactDOM.render** когда мы передаем DOM узел, как корневой компонент. Как и в случаи с refs, эти изменения не распространяются на кастомные компоненты. C этими изменениями, мы объявляем метод **.getDOMNode()** неподдерживаемым и заменяем его методом **ReactDOM.findDOMNode** (см. далее).
### «Глупые» компоненты
В характерном для React коде, большинство компонентов, которые вы пишете, не должны иметь собственного состояния, т.н. stateless. Мы представляем новый, более простой синтаксис для таких компонентов, в котором вы можете передать props, как аргумент и вернуть элемент, который вы хотите отрисовать:
```
// Используя ES2015 (ES6) стрелочную функцию:
var Aquarium = (props) => {
var fish = getFish(props.species);
return {fish};
};
// Или с деструкцией и неявным возвращением:
var Aquarium = ({species}) => (
{getFish(species)}
);
// Далее используем:
```
Этот паттерн создан для поощрения создания этих простых компонентов, которые должны составить большую часть ваших приложений. В будущем, мы также сможем оптимизировать производительность, конкретно для этих компонентов, избегая ненужных проверок и распределения памяти.
### React-tools больше не поддерживается
Пакет **react-tools** и браузерный вариант **JSXTransformer.js** [— нежелательны к применению](/react/blog/2015/06/12/deprecating-jstransform-and-react-tools.html). Вы можете продолжить их использование в версии **0.13.3**, но мы больше их не поддерживаем и рекомендуем перейти на использование [Babel](http://babeljs.io/), который имеет встроенную поддержку React и JSX.
### Оптимизация компилятора
React теперь поддерживает две оптимизации компилятора, которые могут быть включены в Babel 5.8.23 и выше. Обе эти трансформации **должны быть включены только в продакшене** (например, до минификации) потому что хотя они и улучшают производительность выполнения, но делают служебные предупреждения более скрытыми и пропускают важные проверки, которые происходят в режиме разработки, в том числе propTypes.
**Встраивание React элементов:** **optimisation.react.inlineElements** конвертирует JSX элементы в объекты, типа **{type: 'div', props: ...}** вместо вызова **React.createElement**.
**Постоянное «всплытие» React элементов:** **optimisation.react.constantElements** «поднимает» создание элементов на верхний уровень поддеревьев, который полностью статичен, что уменьшает вызовы **React.createElement** и перемещения. Важнее то, что это информирует React, что поддерево не изменилось, поэтому React может полностью пропустить его при согласовании.
### Критические изменения
Как обычно, у нас есть несколько критических изменений в этом релизе. Всякий раз, когда мы вносим большие изменения, мы предупреждаем, как минимум за один релиз, т.ч. у вас есть время обновить ваш код. Кодовая база Facebook составляет более 15,000 React компонентов, поэтому в команде React, мы всегда стараемся свести к минимуму последствия от критических изменений.
Эти три критические изменения выводили предупреждения в версии 0.13, поэтому вам нет необходимости что-то делать, если в вашем коде нет предупреждений:
* Объект **props** теперь фиксирован, поэтому изменение props после создания компонента больше не поддерживается. В большинстве случае, взамен необходимо использовать [**React.cloneElement**](/react/docs/top-level-api.html#react.cloneelement). Эти изменения делают ваши компоненты более легкими для понимания и включают оптимизацию компиляции, описанную выше.
* Простые объекты больше не поддерживаются в качестве потомков React, вместо этого вы должны использовать массивы. Вы можете использовать хелпер [**createFragment**](/react/docs/create-fragment.html) для миграции, который сейчас возвращает массив.
* Add-Ons: **classSet** был удален. Вместо этого используйте [classnames](https://github.com/JedWatson/classnames)
А эти два изменения не диагностировались в 0.13, но их легко будет найти и исправить:
* **React.initializeTouchEvents** больше не нужно и может быть полностью удалено. Тач-эвенты теперь работают автоматически.
* Add-Ons: В связи с тем, что ссылки на DOM ноды изменились, как упоминалось выше, **TestUtils.findAllInRenderedTree** и связанные с ним хелперы больше недоступны для получения DOM компонентов, а только для кастомных компонентов.
### Новые исключения, выводимые в предупреждениях
* В связи с тем, что ссылки на DOM ноды изменились, как упоминалось выше, **this.getDOMNode()** теперь исключен и взамен вы можете использовать **ReactDOM.findDOMNode(this)**. Заметьте, что в большинстве случаев, вызов **findDOMNode** теперь не нужен – смотрите пример указанный выше в секции “Ссылки на DOM узлы".
Если у вас большая кодовая база, вы можете использовать наш [automated codemod script](https://github.com/facebook/react/blob/master/packages/react-codemod/README.md) для автоматического исправления вашего кода.
* **setProps** и **replaceProps** теперь запрещены. Вместо этого снова вызовите ReactDOM.render на верхнем уровне с новыми props.
* Классы компонентов ES6 теперь должны расширить **React.Component** надлежащим образом для поддержки «глупых» компонентов. [Шаблон ES3 модуля](/react/blog/2015/01/27/react-v0.13.0-beta-1.html#other-languages) продолжает работать.
* Переиспользование и изменение **style** объекта между рендерами теперь запрещена. Это отражает суть нашего изменения, заморозить **props** объекта.
* Add-Ons: **cloneWithProps** теперь запрещено. Взамен используйте [**React.cloneElement**](/react/docs/top-level-api.html#react.cloneelement) (в отличии от **cloneWithProps**, **cloneElement** не объединяет **className** или **style** автоматически, вы можете объединять их вручную, если надо).
* Add-Ons: Для повышения надежности, **CSSTransitionGroup** больше не будет слушать transition события. Вместо этого, вы должны вручную устанавливать продолжительность transition используя свойства, такие как **transitionEnterTimeout={500}**.
### Значимые улучшения
* Добавлен **React.Children.toArray** который берет объект вложенных потомков и возвращает плоский массив с ключами, назначаемые каждому ребенку. Этот хелпер упрощает управление коллекциями детей в ваших **render** методах, особенно, если вы хотите перераспределить или извлечь **this.props.children** перед передачей их далее. В дополнение, **React.Children.map** также теперь возвращает простой массив.
* Для предупреждений React теперь использует **console.error** вместо **console.warn**, т.ч. браузеры показывают полный стек в консоли. (Наши предупреждения появляются при использовании шаблонов, которые будут изменены в будущих версиях и для кода, который, скорее всего, ведет себя неожиданно, поэтому мы считаем, что наши предупреждения должны быть «must-fix» ошибками.)
* Ранее, использование ненадежных объектов, в качестве React потомков [могло привести к XSS-уязвимости](http://danlec.com/blog/xss-via-a-spoofed-react-element). Эта проблема должна быть должным образом исключена, путем валидирования входа на уровне приложений и не использования ненадежных объектов по всему коду приложения. В качестве дополнительного уровня защиты, [React теперь помечает элементы](https://github.com/facebook/react/pull/4832) определенным [ES2015 (ES6) типом **Symbol**](http://www.2ality.com/2014/12/es6-symbols.html), в браузерах, которые его поддерживают, для того, чтобы гарантировать, что React никогда не посчитает ненадежный JSON валидным элементом. Если это дополнительная защита безопасности является важной для вас, вы должны добавить **Symbol** полифил для старых браузеров, например [Babel’s polyfill](http://babeljs.io/docs/usage/polyfill/).
* Когда это возможно, React DOM теперь генерирует XHTML-совместимую разметку.
* React DOM теперь поддерживает такие стандартные HTML атрибуты: **capture**, **challenge**, **inputMode**, **is**, **keyParams**, **keyType**, **minLength**, **summary**, **wrap**. Он также теперь поддерживает и эти нестандартные атрибуты: **autoSave**, **results**, **security**.
* React DOM теперь поддерживает следующие SVG атрибуты, которые могут рендерится в namespaced атрибуты: **xlinkActuate**, **xlinkArcrole**, **xlinkHref**, **xlinkRole**, **xlinkShow**, **xlinkTitle**, **xlinkType**, **xmlBase**, **xmlLang**, **xmlSpace**.
* SVG тэг **image** теперь поддерживается в React DOM.
* В React DOM, произвольные атрибуты поддерживаются на пользовательских элеменах (тех, с дефисом в имени тега или атрибутом **is="..."**).
* React DOM теперь поддерживает следующие медиа-события на **audio** и **video** тэгах: **onAbort**, **onCanPlay**, **onCanPlayThrough**, **onDurationChange**, **onEmptied**, **onEncrypted**, **onEnded**, **onError**, **onLoadedData**, **onLoadedMetadata**, **onLoadStart**, **onPause**, **onPlay**, **onPlaying**, **onProgress**, **onRateChange**, **onSeeked**, **onSeeking**, **onStalled**, **onSuspend**, **onTimeUpdate**, **onVolumeChange**, **onWaiting**.
* Было сделано множество небольших улучшений производительности.
* Многие предупреждения показывают больше информации, чем раньше.
* Add-Ons: Дополнение [**shallowCompare**](https://github.com/facebook/react/pull/3355) было добавлено в качестве пути миграции для **PureRenderMixin** для ES6 классов.
* Add-Ons: **CSSTransitionGroup** может теперь использовать [произвольные имена классов](https://github.com/facebook/react/blob/48942b85/docs/docs/10.1-animation.md#custom-classes) вместо добавления **-enter-active** или схожего с именем transition.
### Новые полезные предупреждения
* React DOM теперь предупреждает вас, когда вложенные HTML элементы невалидны, что помогает вам избежать удивительных ошибок во время обновления.
* Подключение **document.body** напрямую в качестве контейнера для **ReactDOM.render** теперь выдает предупреждение, т.к. это может вызывать проблемы с расширениями браузера, которые изменяют DOM.
* Совместное использование нескольких инстансов React не поддерживается, поэтому мы теперь выводим предупреждение, когда обнаруживаем этот случай, чтобы помочь вам избежать проблем.
### Значимые исправления
* Click-события обрабатываются React DOM более надежно в мобильных браузерах, в частности в Mobile Safari.
* SVG элементы создаются с правильными неймспейсами в большинстве случаев.
* React DOM теперь правильно рендерит элементы с несколькими текстовыми детьми и рендерит элементы на сервере, с правильно выбранной опцией.
* Когда два отдельных экземпляра React добавляют узлы в один и тот же документ (в том числе, когда расширение для браузера использует React), React DOM упорно пытается не бросать исключения во время обработки событий.
* Использование HTML тэгов не в нижнем регистре в React DOM (например, **React.createElement('DIV')**) теперь не вызывает проблем, однако мы продолжаем рекомендовать использование нижнего регистра для соответствия с конвенцией наименования JSX тэгов (нижний регистр для встроенных компонентов, заглавное наименование для кастомных компонентов).
* React DOM понимает, что эти свойства CSS являются безразмерными и не добавляет «px» для их значений: **animationIterationCount**, **boxOrdinalGroup**, **flexOrder**, **tabSize**, **stopOpacity**.
* Add-Ons: При использовании тестовых утилит, **Simulate.mouseEnter** и **Simulate.mouseLeave** теперь работает
* Add-Ons: ReactTransitionGroup теперь корректно обрабатывает множественные узлы, удаляя одновременно.
Автор: [Ben Alpert](http://benalpert.com/) | https://habr.com/ru/post/266683/ | null | ru | null |
# Достаём потерянные статьи из сетевых хранилищ
Решение рассматривается (пока) только для одного сайта — того, на котором мы находимся. Идея появилась в результате того, что один пользователь сделал юзерскрипт, который переадресует страницу на кеш Гугла, если вместо статьи видим «Доступ к публикации закрыт». Понятно, что это решение будет работать лишь частично, но полного решения пока не существует. Можно повысить вероятность нахождения копии выбором результата из нескольких сервисов. Этим стал заниматься скрипт [HabrAjax](https://greasyfork.org/en/scripts/1970-habrajax) (наряду с 3 десятками других функций). Теперь (с версии 0.859), если пользователь увидел полупустую страницу, с которой можно перейти лишь на главную, в личную страницу автора (если повезёт) и назад, юзерскрипт предоставляет несколько альтернативных ссылок, в которых можно попытаться найти потерю. И тут начинается самое интересное, потому что ни один сервис не заточен на качественное архивирование одного сайта.
Кстати, статья и исследования порождены интересным опросом [А вас раздражает постоянное «Доступ к публикации закрыт»?](http://habrahabr.ru/post/146070/) и скриптом пользователя [dotneter](http://habrahabr.ru/users/dotneter/) — комментарий [habrahabr.ru/post/146070/#comment\_4914947](http://habrahabr.ru/post/146070/#comment_4914947).
Требуется, конечно, более качественный сервис, поэтому, кроме описания нынешней скромной функциональности (вероятность найти в Гугл-кеше и на нескольких сайтах-копировщиках), поднимем в статье краудсорсинговые вопросы — чтобы «всем миром» задачу порешать и прийти к качественному решению, тем более, что решение видится близким для тех, кто имеет сервис копирования контента. Но давайте обо всём по порядку, рассмотрим все предложенные на данный момент решения.
### Кеш Гугла
В отличие от кеша Яндекса, к нему имеется прямой доступ по ссылке, не надо просить пользователя «затем нажать кнопку „копия“». Однако, все кеширователи, как и известный archive.org, имеют ряд ненужных особенностей.
1) они просто не успевают мгновенно и многократно копировать появившиеся ссылки. Хотя надо отдать должное, что к популярным сайтам обращение у них частое, и за 2 и более часов они кешируют новые страницы. Каждый в своё время.
2) далее, возникает такая смешная особенность, что они могут чуть позже закешировать пустую страницу, говорящую о том, что «доступ закрыт».
3) поэтому результат кеширования — как повезёт. Можно обойти все такие кеширующие ссылки, если очень надо, но и оттуда информацию стоит скопировать себе, потому что вскоре может пропасть или замениться «более актуальной» бессмысленной копией пустой страницы.
### Кеш archive.org
Он работает на весь интернет с мощностями, меньшими, чем у поисковиков, поэтому обходит страницы какого-то далёкого русскоязычного сайта редко. Частоту можно увидеть здесь: [wayback.archive.org/web/20120801000000\*/http://habrahabr.ru](http://wayback.archive.org/web/20120801000000*/http://habrahabr.ru)
Да и цель сайта — запечатлеть фрагменты истории веба, а не все события на каждом сайте. Поэтому мы редко будем попадать на полезную информацию.
### Кеш Яндекса
Нет прямой ссылки, поэтому нужно просить (самое простое) пользователя нажать на ссылку «копия» на странице поиска, на которой будет одна эта статья (если её Яндекс вообще успел увидеть).
Как показывает опыт, статья, повисевшая пару часов и закрытая автором, довольно успешно сохраняется в кешах поисковиков. Впоследствии, скорее всего, довольно быстро заменится на пустую. Всё это, конечно, не устроит пользователей веба, который по определению должен хранить попавшую в него информацию.
### Yahoo Pipes
[pipes.yahoo.com/pipes/search?q=habrahabr+full&x=0&y=0](http://pipes.yahoo.com/pipes/search?q=habrahabr+full&x=0&y=0) и прочие.
Довольно интересное решение. Те, кто умеет их настраивать, возможно, полноценно решат задачу архивирования RSS. Из имеющегося, я не нашёл пайпов с поиском статьи по её номеру, поэтому пока нет прямой ссылки на такие сохранённые полные статьи. (Кто умеет с ним работать — прошу изготовить такую ссылку для скрипта.)
### Многочисленные клонировщики
Все из них болеют тем, что не дают ссылки на статью по её номеру, не приводят полный текст статьи, а некоторые вообще ограничиваются «захабренным» или «настолько ленивы», что копируют редко (к примеру, раз в день), что актуально не всегда. Однако, если хотя бы один автор копировщика подкрутит движок на сохранение полноценного и актуального контента, он окажет неоценимую услугу интернету, и его сервис займёт главное место в скрипте [HabrAjax](https://greasyfork.org/en/scripts/1970-habrajax).
Из живых я нашёл пока что 4, некоторые давно существовавшие (itgator) на данный момент не работали. В общем, пока что они почти бесполезны, потому что заставляют искать статью по названию или ключевым словам, а не по адресу, по которому пользователь пришёл на закрытую страницу (а по словам отлично ищет Яндекс и не только по одному их сайту). Приведены в скрипте для какой-нибудь полезной информации.
### Задача
Перед сообществом стоит задача, не утруждая организаторов сайта, довести продукт до качественного, не теряющего информацию ресурса. Для этого, как правильно заметили в комментариях к опросу, нужен **архиватор актуальных полноценных статей** (и комментариев к ним заодно).
В настоящее время неполное решение её, как описано выше, выглядит так:
Если искать в Яндексе, то подобранный адрес выведет единственную ссылку (или ничего):
Нажав ссылку «копия», увидим (если повезёт) сохранённую копию (страница выбрана исключительно для актуального на данный момент примера):
В Гугле несколько проще — сразу попадаем на копию, если тоже повезёт, и Гугл успел сохранить именно то, что нам надо, а не дубль отсутствующей страницы.
Забавно, что скрипт теперь предлагает «выбор альтернативных сервисов» и в этом случае («профилактические работы»):
Жду предложений по добавлению сервисов и копировщиков (или хотя бы проектов) (для неавторизованных — на почту spmbt0 на известном гуглоресурсе, далее выберем удобный формат).
**UPD** 23:00: опытным путём для **mail.ru** было выяснено строение прямой ссылки на кеш:
```
'http://hl.mailru.su/gcached?q=cache:'+ window.location
```
Знатоки или инсайдеры, расскажите, что это за ссылка, насколько она стабильна (не изменится ли, например, домен 3-го уровня), что значит приставка «g»-cached? Значит ли это кеш Гугла или это кеш движка Gogo? [Пример](http://hl.mailru.su/gcached?q=cache:http://habrahabr.ru/post/146154/).
Добавил ссылки мейла и ВК в [обновление скрипта (habrAjax)](https://greasyfork.org/en/scripts/1970-habrajax) (0.861), теперь там — на 2 строчки больше. | https://habr.com/ru/post/146200/ | null | ru | null |
# Youtube снова экспериментирует с дизайном
Привет, *%username%*! Уже по традиции, без лишнего шума, Google дала возможность посмотреть на новый экспериментальный интерфейс YouTube.
**Вот и он**:
На этот раз изменения затронули не только плеер. Ребята из Google постарались практически над всеми элементами UI.
**Меню пользователя** теперь выглядит вот так:
Добавили новый режим — **Dark Mode** (активируется в настройках):
И, собственно, делает интерфейс **темным**:
Из приятного, прямо здесь (в настройках) теперь можно изменять **язык** и **локацию**:
Также значительно поработали над дизайном **каналов**:
И, слегка, обновили страничку с **видео**:
Из **неприятного** — как-то нерационально они использовали место. Много ненужных отступов, и в целом — весь UI стал просторнее и начал занимать больше места.
И как же это дело испытать и\или использовать?
**Вариант 1**:
1. Открываем [YouTube](https://www.youtube.com/)
2. Открываем dev tools (нажимаем F12)
3. Открываем консоль (нажимаем Esc)
4. Вписываем в консоль `document.cookie="PREF=f6=4;path=/;domain=.youtube.com";`
5. Enter
**Вариант 2**:
1. Устанавливаем [расширение](https://chrome.google.com/webstore/detail/editthiscookie/fngmhnnpilhplaeedifhccceomclgfbg/related)
2. Открываем [YouTube](https://www.youtube.com/)
3. Открываем меню расширения
4. Кликаем на параметр `PREF`
5. Меняем значение на `al=en-GB≷=GB&hl=en-GB&f1=50000000&f5=30030&f6=4`
6. Пользуемся
**Вариант 3**:
Особо везучие пользователи могут активировать новый интерфейс используя «Try something new!» фичу. Для этого следует перейти в [TestTube](https://www.youtube.com/testtube) раздел и активировать новый пользовательский интерфейс.
Спасибо за внимание. Всем нового и хорошего дизайна! | https://habr.com/ru/post/401625/ | null | ru | null |
# Разработка нативных расширений для Node.js
В этом материале мы поговорим о важнейших концепциях разработки нативных расширений для Node.js. В частности, здесь будет рассмотрен практический пример создания такого расширения, который вполне может стать вашим первым проектом в этой области.
[](https://habrahabr.ru/company/ruvds/blog/353072/)
Основы разработки нативных расширений для Node.js
-------------------------------------------------
Если в двух словах рассказать о нативных расширениях для Node.js, можно отметить, что они представляют собой некую логику, реализованную на C++, которую можно вызывать из JavaScript-кода. Здесь стоит прояснить особенности работы Node.js и рассмотреть составные части этой платформы. Важно знать, что, в контексте Node.js, мы можем говорить о двух языках — JavaScript и C++. Всё это можно описать так:
* JavaScript — это язык программирования, на котором пишут проекты под Node.js.
* V8 — это движок, занятый выполнением JS-кода.
* Libuv — это библиотека, написанная на C, реализующая асинхронное выполнение кода.
Где же в этой схеме находятся нативные расширения? Рассмотрим это на примере операций для работы с диском. Доступ к дисковой подсистеме не входит в возможности JavaScript или V8. Libuv даёт возможности асинхронного выполнения кода. Однако, пользуясь Node.js, можно писать данные на диск и читать их. Именно здесь на помощь приходят нативные расширения. Модуль `fs` реализован средствами C++ (у него имеется доступ к диску), он даёт нам методы, вроде `writeFile` и `readFile`, которые можно вызывать из JavaScript.
*Взаимодействие с нативными расширениями из JS-кода*
Понимая этот механизм, мы можем сделать первые шаги в разработке нативных расширений. Но, прежде чем заняться программированием, поговорим об инструментах.
Базовые инструменты
-------------------
### ▍Файл binding.gyp
Этот файл позволяет настраивать параметры компиляции нативных расширений. Один из важнейших моментов, которые нам надо определить, заключается в том, какие файлы будут компилироваться, и в том, как мы будем вызывать готовую библиотеку. Структура этого файла напоминает JSON, он содержит настройки цели (target) и исходников (sources) для компиляции.
### ▍Инструмент node-gyp
Средство [node-gyp](https://github.com/nodejs/node-gyp) предназначено для компиляции нативных расширений. Оно реализовано на базе Node.js и доступно в npm, что позволяет скомпилировать расширение соответствующей командой. В ответ на эту команду система обнаружит файл `binging.gyp`, находящийся в корневой директории, и приступит к компиляции расширения.
Кроме того, `node-gyp` позволяет, по умолчанию, формировать релизные сборки или сборки для отладки. В результате, в зависимости от настроек, после компиляции, в папке `release` или `debug`, будет создан бинарный файл с расширением `.node`.
### ▍Инструмент node-bindings
Пакет [node-bindings](https://github.com/TooTallNate/node-bindings) позволяет экспортировать нативные расширения. Он отвечает за поиск соответствующих файлов в папке `build` или `release`.
### ▍API n-api
[N-api](https://nodejs.org/api/n-api.html) — это API, созданное средствами C, которое позволяет взаимодействовать с движком абстрактным способом, не зависящим от нижележащей среды исполнения. На наш взгляд, такой подход является результатом развития платформы, в ходе которого предпринимались усилия по портированию Node.js на различные архитектуры.
N-api даёт стабильность и совместимость при работе с различными версиями Node.js. Таким образом, если некое нативное расширение было скомпилировано для Node 8.1, не потребуется компилировать его снова для Node 8.6 или 9.3. Это упрощает жизнь тем, кто занимается поддержкой расширения или участвует в его разработке.
В данный момент n-api находится в [экспериментальном состоянии](https://nodejs.org/docs/latest/api/n-api.html#n_api_n_api).
### ▍Инструмент node-addon-api
Модуль [node-addon-api](https://github.com/nodejs/node-addon-api) даёт в распоряжение разработчика C++-реализацию n-api, которая позволят пользоваться возможностями этого языка.
Первые шаги в мире нативных расширений
--------------------------------------
Обратите внимание на то, что для этого примера использована платформа Node 9.3.
Для того, чтобы приступить к разработке нативных расширений, мы напишем классическое приложение «Hello World». Идея этого приложения позволяет реализовать его с помощью достаточно простого кода, не перегруженного дополнительной логикой, что даст нам возможность сосредоточиться на основных конструкциях, рассмотреть минимально необходимый код.
Начнём с инициализации npm, что позволит затем установить зависимости.
```
npm init
```
Теперь устанавливаем зависимости.
```
npm i node-addon-api bindings
```
На данном этапе нужно создать файл на C++, содержащий логику расширения.
```
#include
Napi::String SayHi(const Napi::CallbackInfo& info) {
Napi::Env env = info.Env();
return Napi::String::New(env, "Hi!");
}
Napi::Object init(Napi::Env env, Napi::Object exports) {
exports.Set(Napi::String::New(env, "sayHi"), Napi::Function::New(env, SayHi));
return exports;
};
NODE\_API\_MODULE(hello\_world, init);
```
В этом файле имеется три важных части, которые мы рассмотрим, начиная с той, которая находится в нижней части текста.
* `NODE_API_MODULE`. Первый аргумент представляет собой имя нативного расширения, второй — имя функции, которая инициализирует это расширение.
* `init`. Это — функция, которая ответственна за инициализацию расширения. Тут мы должны экспортировать функции, которые будут вызываться из JS-кода. Для того чтобы это сделать, нужно записать имя функции в объект `exports` и задать саму функцию, которая будет вызываться. Функция `init` должна возвращать объект `exports`.
* `sayHi`. Эта функция будет выполнена при вызове нашего нативного расширения из JavaScript.
Теперь создадим файл `binding.gyp`, который будет содержать конфигурацию нативного расширения.
```
{
"targets": [
{
"cflags!": [ "-fno-exceptions" ],
"cflags_cc!": [ "-fno-exceptions" ],
"include_dirs" : [
"
```
А вот как выглядит JavaScript-код, в котором подключается расширение и осуществляется работа с ним.
```
const hello_world = require('bindings')('hello_world')
console.log(hello_world.sayHi());
```
Теперь осталось лишь скомпилировать расширение и запустить JS-файл. Вот как это выглядит.
*Компиляция и использование нативного расширения*
История нативных расширений для Node.js и полезные материалы
------------------------------------------------------------
Полагаем, полезно рассказать об истории нативных расширений, так как изучение этого вопроса позволяет исследовать большой объём полезной документации и обнаружить множество примеров. N-api пришло на смену nan. Эта аббревиатура расшифровывается как [Native Abstraction for Node.js](https://github.com/nodejs/nan). Nan — это C++-библиотека, которая не отличается той же гибкостью, что и n-api. Она позволяет, в абстрактном виде, работать с V8, но привязана к релизу V8. В результате, в новых релизах Node.js могут присутствовать изменения V8, которые способны нарушить работу нативных расширений. Решение этой проблемы — одна из причин появления n-api.
Знание о существовании nan позволяет нам исследовать соответствующие примеры и документацию. Всё это может стать полезным источником знаний для тех, кто изучает разработку нативных расширений для Node.js.
Вот список полезных материалов, посвящённых разработке нативных расширений для Node:
* [Примеры](https://github.com/nodejs/node/tree/master/test/addons-napi) использования n-api.
* [Примеры](https://github.com/nodejs/abi-stable-node-addon-examples) работы с node-addon-api.
* [Примеры](https://github.com/nodejs/nan/tree/master/test) использования nan.
* [Тесты](https://github.com/nodejs/node-addon-api/tree/master/test), ценный источник знаний.
* [Ресурс](https://nodeaddons.com/), посвящённый нативным расширениям для Node.js.
Итоги
-----
Автор этого материала говорит, что изучение разработки нативных расширений для Node.js помогло ему лучше понять устройство этой платформы и особенности её функционирования. Существует множество сценариев, в которых подобные расширения могут оказаться полезными. Среди них — создание высокопроизводительных приложений, интеграция Node.js-проектов с C/C++ библиотеками, или использование в таких проектах устаревшего кода. Кроме того, разработка нативных расширений — это отличный способ изучения внутренних механизмов Node.js.
**Уважаемые читатели!** Пользуетесь ли вы нативными расширениями для Node.js в своих проектах?
[](https://ruvds.com/ru-rub/#order) | https://habr.com/ru/post/353072/ | null | ru | null |
# Одежда умная, но мы умнее: как мы делали футболку с контролем осанки
Всем привет! Во втором семестре все первокурсники программы «[Прикладная математика и информатика](https://spb.hse.ru/ba/appmath/)» в Питерской Вышке делают [командные проекты по С++](https://habr.com/ru/company/hsespb/blog/508394/). Мы занимались разработкой умной футболки.
О том, что это такое и что мы успели сделать за время работы над проектом, читайте в этой статье.
Мы — Денис Тарасов и Денис Филиппов — студенты уже второго курса бакалавриата «Прикладная математика и информатика» в Питерской Вышке. Мы работали над проектом вместе с Яном Фрейдкиным и Иваном Чунаревым. С ними мы учились в одной школе: Санкт-Петербургском ГФМЛ № 30.
В 11-м классе у Яна и Ивана был проект по робототехнике ー «Умная футболка» (она на первой фотографии). Идея такова: берётся футболка, на неё крепятся различные датчики (акселерометр, гироскоп и другие). По считываемым данным можно определить некоторые показатели, например, корректность осанки. Ребята успели принять участие в нескольких конференциях и собирались после окончания школы продолжить работу над проектом, но поняли, что им нужны программисты. ~~Собственно вот мы и здесь.~~
Футболка Яна и Ивана могла считывать ЭКГ и отслеживать корректность осанки. Для этого использовалась Arduino UNO — платформа разработки с устаревшими микроконтроллерами AVR. Достаточно скоро им стало не хватать памяти для кода. На новой стадии работы над проектом мы поняли, что нужно предъявлять более строгие требования к микроконтроллеру:
* чтобы можно было подключить больше датчиков, необходим был процессор с большей частотой, большее количество периферии и более скоростная периферия;
* больший объем flash памяти, оперативной памяти;
* меньшая стоимость;
* стабильность работы микроконтроллера.
Мы решили, что нужно менять микроконтроллер. У нас было два варианта: использовать более мощный микроконтроллер серии AVR (в нашем случае Arduino) или перейти на другую серию микроконтроллеров, а именно ARM (в нашем случае STM32). Несмотря на большое сообщество Arduino и простоту в использовании этого микроконтроллера, мы решили перейти на STM32, потому что его производительность лучше, а объем памяти — больше. Сейчас мы используем микроконтроллер серии STM32f4\*.
В прошедшем семестре мы поставили перед собой цель реализовать получение информации об осанке человека и её обработку. Схема проекта следующая: у нас есть футболка, на ней закреплены акселерометры и гироскопы, с помощью которых мы получаем углы закручивания. Полученные с датчиков данные поступают на микроконтроллер. Там они обрабатываются и, если нужно, подается напряжение на вибромотор, стимулирующий человека выпрямиться. С помощью приложения на Android включается и выключается обработка осанки, а также осуществляется связь футболки с пользователем. Но в целом футболка может работать и без доступа к смартфону: можно включить обработку осанки в приложении, оставить телефон дома и пойти в футболке гулять. При этом данные будут обрабатываться на микроконтроллере и вибромотор будет включаться, если положение неправильное.
Первые шаги. Зажгли светодиод
=============================
У нас не было опыта программирования микроконтроллеров, и мы прочитали, что инициализация и объявление датчиков и пинов на STM — это долго и сложно. Поэтому мы использовали высокий уровень абстракции с помощью библиотеки HAL и [STM32CubeMX](https://www.st.com/en/development-tools/stm32cubemx.html). [STM32CubeMX](https://www.st.com/en/development-tools/stm32cubemx.html) ー инструмент, который с помощью графического интерфейса настраивает порты микроконтроллера и генерирует соответствующий код, использующий библиотеку HAL. Сначала мы решили сделать самую базовую в программировании микроконтроллеров вещь (на уровне «Hello world») ー зажечь светодиод.
*Интерфейс STM32CubeMX*
После долгого поиска IDE, которая была бы кроссплатформенной, бесплатной и удобной для разработки, мы остановились на [STM32CubeIDE](https://www.st.com/en/development-tools/stm32cubeide.html).
Задача включения светодиода оказалась не самой простой, поскольку в интернете довольно мало информации по программированию STM32 (особенно по сравнению с Arduino). В дальнейшем этот фактор также усложнял работу над проектом.
Прошивка микроконтроллера
=========================
После того как мы научились зажигать светодиод и поняли, как вообще программировать микроконтроллер, мы занялись написанием основы прошивки микроконтроллера, на базе которой в дальнейшем можно было бы добавлять различный функционал. Для начала нужно было научиться инициализировать датчики и получать информацию с них. Из датчиков мы успели добраться лишь до IMU-сенсоров: гироскопа и акселерометра. У нас были сенсоры MPU-6050.
Общение с микроконтроллером осуществляется по шине I2C. Благодаря библиотеке HAL передача данных производится легко: необходимо вызвать функцию для чтения/записи. Пример чтения данных с акселерометра из кода:
```
HAL_I2C_Mem_Read(i2c_handle, addres, ACCEL_XOUT_H_REG, 1, buffer, 6, 1000)
```
Функция получает хэндлер нужной шины, адрес датчика на ней, регистр, из которого необходимо прочитать (регистры прописаны в документации к датчику), размер регистра, буфер для записи, размер буфера и таймаут (время, которое отводится на ожидание ответа) в миллисекундах. Функция записи обладает аналогичной сигнатурой. Пример установки диапазона измерений гироскопа:
```
HAL_I2C_Mem_Write(i2c_handle, addres, GYRO_CONFIG_RE G, 1, &Data, 1, 1000)
```
Также у нас был Bluetooth модуль (HC-05 и HC-06), но он не требовал каких-либо особых манипуляций для работы. После его подключения можно просто слать данные через универсальный асинхронный приемопередатчик (UART) — специальное устройство внутри микроконтроллера, которое позволяет общаться с другими устройствами. Для него в HAL предусмотрены функции, схожие с функциями для I2C. Мы лишь написали небольшую обертку над ними, чтобы было проще выводить сообщения во время отладки.
*HC-06*
Далее мы создали класс Controller, который осуществляет инициализацию датчиков, запускает основной цикл программы и обрабатывает запросы, приходящие из приложения. Запросы хранятся в очереди, поступают через Bluetooth и принимаются с помощью механизма прерываний. Прерывание — сигнал от программного или аппаратного обеспечения, сообщающий процессору о наступлении какого-либо события, которое требует немедленного внимания. Механизм прерывания нужен в том числе для быстрого реагирования системы на важные события.
Также Controller хранит список функций футболки с помощью базового класса BaseFunc. На данный момент у нас есть только обработка осанки, но в будущем при добавлении нового функционала достаточно будет просто создать класс-наследник и добавить его в список функций. Контроллер выглядит примерно так:
```
class Controller {
std::vector> IMUSensors; // список сенсоров
std::queue reqQueue; // очередь запросов
std::vector, bool>> mithrilFuncs; // список пар
//<функция футболки, включена ли она>
Controller();
void Run(); // основной цикл программы
};
```
Также для получения углов закручивания с IMU-сенсоров пришлось добавить специальный фильтр, который по данным с акселерометра и гироскопа выдает корректные углы отклонения. Мы решили использовать комплементарный фильтр, потому что он достаточно эффективен, и при этом его было легко реализовать. При реализации этого фильтра мы написали математику для кватернионов. Можно было обойтись и векторами, но кватернионы понадобились в другом фильтре, который мы тестировали, так что сейчас мы используем кватернионы.
Что там по прототипу
====================
После того, как мы разобрались с программированием микроконтроллера и написали основы его прошивки, понадобился прототип футболки, с помощью которого можно было бы начать заниматься обработкой осанки. И тут вмешался коронавирус...
Из-за пандемии мы больше не могли встречаться и работать над футболкой вчетвером, и у нас фактически не было возможности ездить к Яну и Ивану, чтобы в случае проблем с прототипами оперативно их решать. Ян и Иван разработали прототип футболки, на котором можно было расставлять датчики, протягивая провода так, чтобы они не влияли на показания своим весом и натяжением. Ребята послали нам с Денисом по экземпляру футболки, а также изоленты, провода и др., чтобы мы сами могли устранять возможные поломки.
Приложение для Android
======================
Мы поставили перед собой цель создать Android-приложение с возможностью общаться через Bluetooth с микроконтроллером. Как и в случае с программированием микроконтроллеров, опытом написания приложений под Android мы не обладали, однако найти информацию про Android оказалось намного легче, чем про STM32. Основы мы изучали при помощи [курса на Stepik.org](https://stepik.org/course/4792) (курс действительно неплохой), где сначала разбирают основы языка Kotlin, а затем рассказывают о программировании под Android.
Первая версия приложения позволяла подключаться к микроконтроллеру через Bluetooth и передавать ему сообщения. Последняя версия не сильно отличается от первой (написание приложение для нас не было в приоритете): в ней появились виджеты для запуска калибровки и включения/выключения функции слежения за корректностью осанки.
На то, чтобы написать первую рабочую версию приложения, ушло около 6 часов — мы потратили больше времени на изучение теории. Код такого простенького приложения занял примерно 400 строк, что приятно удивило. При этом наверняка его можно написать компактнее.
*Меню навигации*
*Вкладка для подключения через Bluetooth*
*Вкладка для обмена данными*
Обработка осанки
================
Мы пришли к двум разным способам обработки осанки: с помощью методов анализа данных и без них.
Обработка осанки с помощью методов анализа данных
-------------------------------------------------
В предыдущей версии на футболке был только один датчик, по данным с которого принималось решение о правильности осанки человека: оно зависело от угла закручивания датчика. Очевидно, что такой подход не может дать высокой точности, ведь у нас нет никаких данных о положении большей части спины. В нашей версии появилось 4 датчика. Было достаточно сложно придумать, как интерпретировать их показания, поэтому мы решили прибегнуть к методам анализа данных. Из-за проблем с прототипами многое не успели сделать к дедлайну.
Сначала мы сняли с себя данные: углы закручивания и показания акселерометра с каждого из датчиков. Получили примерно 2000 замеров: около 1000 положительных и 1000 отрицательных. Конфигурация датчиков была следующая (два датчика расположены на лопатках и два на позвоночнике):
К сожалению, на обоих прототипах возникли проблемы с одним из четырех датчиков, поэтому датчик под номером 3 не использовался. Мы расположили их интуитивно: хотели отслеживать положение лопаток и отдела позвоночника вблизи шеи.
*Проекции данных в двумерное пространство.*
Здесь зеленым цветом выделены области правильной осанки, красным — неправильной. В проекции на трехмерное пространство видно, что правильные положения и неправильные легко отделить друг от друга.
Далее необходимо было выбрать модели для предсказания. Мы решили попробовать линейную регрессию, а точнее ее модификацию Ridge, метод опорных векторов (SVM) с линейным ядром и дерево принятия решений. Выбор обусловлен простотой переноса моделей на микроконтроллер: первые две описываются некоторым количеством коэффициентов, а последняя представляет из себя набор условий if-else. Модели были взяты из библиотеки scikit-learn. Пример переноса линейной регрессии:
```
bool isPostureCorrect =
(a11 * deviceAngles1[0] + a12 * deviceAngles1[1] + a13 * deviceAngles1[2] +
g11 * deviceGravity1[0] + g12 * deviceGravity1[1] + g13 * deviceGravity1[2] +
a21 * deviceAngles2[0] + a22 * deviceAngles2[1] + a23 * deviceAngles2[2] +
g21 * deviceGravity2[0] + g22 * deviceGravity2[1] + g23 * deviceGravity2[2] +
a41 * deviceAngles3[0] + a42 * deviceAngles3[1] + a43 * deviceAngles3[2] +
g41 * deviceGravity3[0] + g42 * deviceGravity3[1] + g43 * deviceGravity3[2]) > bias;
```
значения a??, g??, bias берутся из обученной модели.
Точность моделей с разной конфигурацией на тестовой выборке можно увидеть в таблице:
Размер тестовой выборки составлял 33% от всех данных. Такие высокие показатели скорее всего обусловлены малым количеством данных, ибо предсказания уж слишком хороши.
В реальных условиях модели, которые мы успели протестировать (деревья решений и некоторые конфигурации линейной регрессии), не работали настолько хорошо, поэтому их пришлось немного корректировать, чтобы они вели себя адекватнее. Лучше всех себя показал Ridge, обученный на углах закручивания.
*Пример дерева принятия решений.*
В условиях пандемии и наличия только двух прототипов мы не смогли собрать большого количества данных с разных людей, что плохо сказывается на работе моделей. Также в текущем решении используется лишь один замер для определения корректности осанки, чего, разумеется, недостаточно. Человек может просто наклониться за предметом, а футболка начнет подавать вибросигнал. Для решения подобных проблем следует попробовать модели, которые делают предсказания по последовательности входных данных, однако такие модели будет тяжелее перенести на микроконтроллер тем способом, что был в текущем решении.
Обратка осанки без методов анализа данных
-----------------------------------------
Для того, чтобы обрабатывать осанку без ML, пришлось сначала изучить множество медицинских статей об осанке. Очень хотелось найти информацию о количественных характеристиках, которые можно было бы измерить и сравнить с нормой: то есть знать «нормальный» диапазон значений.
Мы изучили множество статей, но в большинстве из них либо не было количественных характеристик, либо характеристики невозможно было бы измерить имеющимися у нас средствами. Только одна [статья](https://www.researchgate.net/publication/49823922_Posture_and_body_image_in_individuals_with_major_depressive_disorder_A_controlled_study) оказалась полезной для нас (кстати, на неё ссылаются многие другие исследования, связанные с осанкой человека). В ней были описаны различные углы, по значениям которых можно определять корректность осанки.
*Показатели осанки у людей с большим депрессивным расстройством до (A) и после (B) лечения из* [*статьи J.Canales et al (2010)*](https://www.researchgate.net/publication/49823922_Posture_and_body_image_in_individuals_with_major_depressive_disorder_A_controlled_study)
Осталось только измерить эти углы. Для измерения можно приближенно изобразить нормальное положение позвоночника с помощью какой-нибудь функции, а затем брать нужные точки на графике и по ним искать значения различных углов.
*Конфигурация датчиков*
Датчики расположены вдоль позвоночника. В точках, где они находятся, можно получить углы наклона касательных, а следовательно, найти значение производной (которая равна тангенсу угла наклона касательных). Поскольку позвоночник изгибается, координаты точек всё время меняются. Из-за этого применить, например, интерполяцию по Эрмиту невозможно. При этом известны расстояния между точками вдоль кривой: их можно физически измерить. Изначально по этим данным мы хотели попробовать найти гладкую функцию, например, какой-нибудь многочлен. Но, во-первых, для этого нужно побольше точек, в которых известны производные, а во-вторых, задача довольно не проста с математической и вычислительной точек зрения. Поэтому на данном этапе разработки было принято решение приближать позвоночник с помощью кусочно-линейной функции.
В результате из двух углов, которые мы пытались измерить (углы 3 и 4 на изображении из статьи), один измерялся корректно, а другой — нет. Значения угла 3 совпадали с нормальными, указанными в статье. Угол 4 измерялся плохо из-за особенностей конструкции. Скорее всего, проблема заключается в том, что футболка в некоторых местах не плотно прилегает к телу, из-за чего угол наклона касательных вычисляется неверно.
Демо-видео
==========
Вот демо-видео работы футболки и приложения:
Сначала включается обработка осанки, затем запускается калибровка, а после этого начинают приходить сообщения о корректности осанки.
Заключение
==========
В результате у нас получилось обработать осанку двумя способами, разобраться с программированием под Android, написать приложение для Android и заодно немного разобраться с программированием микроконтроллера STM32.
Конечно, нельзя считать, что наша футболка закончена — но пока мы работали над ней в течение одного семестра первого курса. Еще многое остается доделать, и в следующем году мы планируем продолжить!
Теперь немного о наших планах на будущее. Мы хотим:
* Усовершенствовать приближения позвоночника с помощью функции, чтобы точнее измерять углы, связанные с позвоночником.
* Собрать побольше данных для обработки осанки. На текущий момент данные сняты только с нас двоих и наши прототипы немного отличаются.
* Расширить функционал. Например, добавить снятие электрокардиограммы, чтобы по ней можно было выявлять различные болезни, отклонения и т. д.
* Усовершенствовать приложение: расширить его функционал. Например, подсчитывать статистику, анализировать её, рисовать графики.
* Создать прототип футболки, который будет иметь более товарный вид. На текущем этапе прототипы предназначены исключительно для тестирования функционала. Хочется собрать футболку, готовую для полноценного использования.
Ссылки на гитхаб проекта:
[github.com/DT6A/Mithril](https://github.com/DT6A/Mithril) ー прошивка микроконтроллера,
[github.com/DT6A/MithrilApp](https://github.com/DT6A/MithrilApp) ー приложение для android,
[github.com/DT6A/MithrilData](https://github.com/DT6A/MithrilData) ー работа с данными. | https://habr.com/ru/post/513794/ | null | ru | null |
# О новом простом методе снижения высокой размерности данных
[](https://habr.com/ru/company/skillfactory/blog/683498/)
О новом методе решения проблемы оценки ковариационной матрицы в данных высокой размерности [научная работа опубликована в 2012 году] рассказываем к старту нашего [флагманского курса по Data Science](https://skillfactory.ru/data-scientist-pro?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=data-science_dspr_190822&utm_term=lead). Подробности — под катом:
* [Оптимальная оценка ковариационной матрицы в больших размерностях](https://habr.com/ru/company/skillfactory/blog/683498/#intro)
* [Основы](https://habr.com/ru/company/skillfactory/blog/683498/#basics)
* [Проблема](https://habr.com/ru/company/skillfactory/blog/683498/#problem)
* [Решение](https://habr.com/ru/company/skillfactory/blog/683498/#solution)
* [Пример кода](https://habr.com/ru/company/skillfactory/blog/683498/#example)
* [Заключение](https://habr.com/ru/company/skillfactory/blog/683498/#conclusion)
* [Литература](https://habr.com/ru/company/skillfactory/blog/683498/#ref)
---
Оптимальная оценка ковариационной матрицы в больших размерностях
----------------------------------------------------------------
Приложения в области статистики, машинного обучения и даже в таких областях, как финансы и биология, часто нуждаются в точной оценке ковариационной матрицы. Однако в настоящее время многие из этих приложений используют данные высокой размерности, и поэтому обычная (выборочная) ковариационная оценка просто не подходит. Таким образом, множество работ за последние два десятилетия пытались решить именно эту проблему. Чрезвычайно мощный метод, появившийся в результате этих исследований, — «нелинейное снижение размерности» [1]. Я сосредоточусь на новейшей версии этого подхода, квадратичном обратном линейном снижении размерности (QIS) от [2]. Этот подход делает нелинейное снижение размерности простым в реализации и быстрым для вычисления.
---
> 
>
> А на наших курсах вы научитесь применять математику в решении конкретных проблем бизнеса:
>
>
>
> * [Профессия Data Scientist (24 месяца)](https://skillfactory.ru/data-scientist-pro?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=data-science_dspr_190822&utm_term=conc)
> * [Профессия Data Analyst (18 месяцев)](https://skillfactory.ru/data-analyst-pro?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=analytics_dapr_190822&utm_term=conc)
>
Давайте начнём с основ (если вы уже имели дело с ковариационными матрицами, то можете смело пропустить этот раздел).
Основы
------
Ковариационная матрица содержит дисперсии и ковариации двух или более случайных величин. То есть, если мы посмотрим на случайные величины ,  и , то ковариационная матрица будет иметь вид:
Поскольку ковариация между  и  и  и  одинакова, матрица обязательно будет симметричной. Более того, из линейной алгебры мы знаем, что эта матрица имеет так называемое разложение на собственные значения, т. е.
Важной частью здесь является лямбда-матрица, которая представляет собой диагональную матрицу, содержащую собственные значения ковариационной матрицы
Таким образом, мы можем диагонализовать ковариационную матрицу, а её диагональные элементы будут содержать важную информацию. Например, они сразу сообщают нам ранг ковариационной матрицы: то есть, просто количество ненулевых собственных значений. Если матрица имеет полный ранг, т.е. все её собственные значения больше нуля, это означает, что случайные величины полностью разбросаны в -мерном пространстве. Это также очень полезно, потому что
В частности, мы видим, что ковариационная матрица обратима тогда и только тогда, когда все её собственные значения отличны от нуля или если ранг матрицы равен .
Каждая симметричная матрица может быть разложена на произведение ортогональных матриц и (вещественной) диагональной матрицы. Значения диагональной матрицы раскрывают важные свойства и могут использоваться для лёгкого вычисления обратной матрицы, если она существует.
Проблема
--------
Предположим, что теперь у нас есть выборка из  независимых одинаково распределённых случайных векторов в -измерениях с ожидаемым значением, равным нулю (для простоты). Ковариационная матрица  может оцениваться с помощью обычной выборочной ковариационной матрицы (далее — ВКМ):
Это оказывается как раз оценкой максимального правдоподобия, если распределение ваших данных соответствует распределению Гаусса. Такая оценка обладает всевозможными благоприятными свойствами и, в частности, известно, что она сходится к истине, когда  стремится к бесконечности, а  остаётся постоянным (или медленно растёт относительно  так, что  стремится к нулю).
Однако обратите внимание, что в приведённой выше матрице у нас есть элементы  для оценки. Здесь  — это количество способов выбрать два элемента из , которое мы делим на 2, потому что матрица симметрична. В выборке  это становится проблемой, если  не намного больше, чем ! Это легче всего увидеть, когда  оказывается больше . В этом случае можно показать, что ВКМ матрица  имеет ранг не более чем . В частности, даже если истинная ковариационная матрица обратима (имеет все собственные значения больше нуля), ВКМ будет иметь  нулевых собственных значений и, таким образом, никогда не будет обратимой. Поэтому, если вам нужна оценка обратной ковариационной матрицы, как в линейном дискриминантном анализе или при вычислении значения гауссовой плотности, это может оказаться проблемой.
Это может показаться крайностью, но даже если у вас есть, скажем, , ошибка оценки ВКМ может быть существенной. Давайте теперь посмотрим на удачный способ решения этой проблемы.
Решение
-------
Тут я буду радикален. Конечно, у этой проблемы есть множество решений, и в зависимости от ситуации некоторые из них работают лучше других. Даже простое изменение того, как вы измеряете успех, может изменить порядок методов.
Возможно, простая идея, которая привела к множеству исследований и появлению новых приложений, состоит в том, чтобы просто взять линейную комбинацию ВКМ и единичной матрицы:
Интенсивность снижения размерности  может быть выбрана различными способами, но чаще всего она автоматически выбирается по данным из теоретических соображений. Если рассматривать разложение на собственные значения тождества и ВКМ, то мы уже видим нечто своеобразное:
Получается, у нас просто есть новые собственные значения, которые являются выпуклой комбинацией ВКМ и . Таким образом, если -тое собственное значение было равно 2, то регуляризованное значение теперь равно . В частности, поскольку наименьшее собственное значение ВКМ равно 0, наименьшее регуляризованное собственное значение теперь равно . Итак, пока , регуляризованная матрица всегда будет обратимой! Формула также может быть знакома по L2-регуляризованной регрессии:
Принцип, согласно которому собственные векторы остаются неизменными, а собственные значения адаптируются, является важным в этих методах уменьшения размерности. Это имеет смысл, потому что, как правило, бесполезно правильно оценивать все параметры, когда  близко или превышает . Но собственные значения  — это совсем другая история, и они могут быть достижимы. Это основная идея нелинейного уменьшения размерности, из-за этой идеи оно на шаг впереди.
Оценка собственных векторов в большой размерности бесполезна. Таким образом, важным принципом является адаптация собственных значений и просто сохранение собственных векторов неизменными.
В приведённом выше линейном уменьшении размерности, если выбрать  «правильно», то можно фактически достичь оптимальной производительности в асимптотическом пределе, когда и , и  идут вместе до бесконечности. Это было установлено в статье 2004 г. [3] и показывает оптимальную оценку собственного значения, если класс оценок является линейным, как в примере выше. То есть класс линейных оценок снижения размерности — это просто все оценки вида (1) при изменении .
Нелинейное уменьшение размерности даёт асимптотическую оценку в гораздо более крупном классе, который не обязательно должен быть просто линейной функцией ВКМ. В частности, решает проблему
где  — некоторая функция потерь. Мы ищем выбор (уменьшенных) собственных значений, который максимально приближает результирующую матрицу к истинной ковариационной матрице, если нам разрешено использовать только собственные векторы ВКМ! Как мы видели ранее, линейное уменьшение размерности является частным случаем этого, потому что мы также меняем только собственные значения. Однако теперь способ, которым мы определяем лямбду, не ограничивается линейностью, что обеспечивает гораздо большую гибкость!
Интересно, что (недостижимое) оптимальное решение вышеизложенного вполне интуитивно понятно:
где  — это просто примеры собственных векторов из предыдущего:
То есть лучшим решением для собственных значений в этом контексте являются не истинные значения, а то значение, которое мы получаем, когда применяем собственные векторы ВКМ к истинной ковариационной матрице.
Лучшее, что мы можем сделать для диапазона функций потерь, — это оценить значения, которые получаются, когда выборки собственных векторов применяются к истинной ковариационной матрице.
Оказывается, метод нелинейного снижения размерности способен последовательно оценивать эти оптимальные элементы, когда  и  вместе стремятся к бесконечности! Давайте теперь посмотрим на пример.
Пример кода
-----------
Итак, нелинейное снижение размерности красиво выглядит в теории, но применимо ли оно на практике? Вот тут-то и появляются две совсем недавние статьи, благодаря которым нелинейное снижение размерности превратилось из причудливой идеи, требующей больших вычислений, в реально используемый инструмент. В частности, метод QIS (квадратичное обратное линейное снижение размерности, [2]) можно рассчитать в несколько строк кода! Но вам даже этого делать не нужно, так как весь необходимый код [Python, R, MatLab] доступен [здесь](https://www.econ.uzh.ch/en/people/faculty/wolf/publications.html#Programming_Code).
Давайте рассмотрим приложение в R, использующее функцию [qis](https://github.com/MikeWolf007/covShrinkage/blob/main/qis.R). В этом примере мы берём сложную истинную ковариационную матрицу, которая имеет
Так, в частности, дисперсия равна 1, и чем дальше друг от друга индексы  и , тем меньше ковариация между ними. Таким образом, элементы ковариационной матрицы экспоненциально приближаются к нулю по мере нашего движения вправо, но многие из них всё равно будут больше нуля. Давайте используем  и  в этом примере, так что :
```
library(mvtnorm)
source("qis.R")
set.seed(1)
n<-800
p<-1000
rho<-0.7
# Generate the covariance matrix
Sig<-sapply(1:p, function(i) {sapply(1:p, function(j) rho^{abs(i-j)} ) } )
# Take the eigendecomposition of the true covariance matrix
spectral<-eigen(Sig)
# Simulate data
X<-rmvnorm(n = n, sigma = Sig)
# Take the eigendecomposition of the scm
samplespectral<-eigen(cov(X))
# Use QIS and take the eigendecomposition
Cov_qis <- qis(X)
qisspectral<-eigen(Cov_qis)
# Rename
qisspectral$U<-qisspectral$vectors
qisspectral$Lambda<-qisspectral$values
# Want u_j'*Sig*u_j for all j=1,...,p
whatwewant<-diag( t(qisspectral$U)%*%Sig%*%qisspectral$U )
#check on first value whether its really calculated correctly
(whatwewant[1]-t(qisspectral$U[,1,drop=F])%*%Sig%*%qisspectral$U[,1,drop=F])
```
Код моделирует данные из 1000-мерной нормали и вычисляет выборочную ковариационную матрицу с её собственными значениями. Обратите внимание, что это работает без проблем, несмотря на то, что . Это одна из опасностей ВКМ, она работает даже тогда, когда это может быть неуместно. Затем вычисляется матрица QIS вместе с собственными значениями и собственными векторами (которые совпадают с собственными векторами ВКМ). Наконец, мы вычисляем теоретическое оптимальное решение, рассмотренное выше.
Давайте построим график:
```
plot(sort(samplespectral$values, decreasing=T), type="l", cex=0.8, lwd=1.5, lty=1)
lines(sort(spectral$values, decreasing=T), type="l", col="darkblue", cex=0.8, lwd=1.5, lty=2)
lines(sort(whatwewant, decreasing=T), type="l", col="darkred", cex=0.8, lwd=1.5,, lty=3)
lines(sort(qisspectral$Lambda, decreasing=T), type="l", col="darkgreen", cex=0.8, lwd=1.5, lty=4)
legend(500, 20, legend=c("Sample Eigenvalues", "True Eigenvalues", "Attainable Truth", "QIS"),
col=c("black", "darkblue", "darkred", "darkgreen"), lty=1:4, cex=0.8)
```
Что даёт
Чем интересен этот график? Во-первых, мы видим, что выборочные собственные значения сильно отличаются — они оказываются выше самых больших собственных значений и ниже самых маленьких. В частности, последние 1000 – 800 = 200 собственных значений равны нулю. Эта «сверхдисперсия» хорошо известна в больших размерностях: малые собственные значения оцениваются как слишком маленькие, а большие — как слишком большие. С другой стороны, мы видим, что нелинейно уменьшенные собственные значения (выделены зелёным) довольно близки к истинным значениям, показанным синим. Что ещё более важно, они очень близки к красной линии, которая является достижимой истиной выше, то есть !
Действительно, тогда оценка общей матрицы лучше более чем на 30%:
```
((norm(cov(X)-Sig,type="F")-norm(Cov_qis-Sig, type="F"))/norm(Cov_qis-Sig, type="F"))
[1] 0.3088145
```
Эта разница может быть намного больше в зависимости от формы истинной базовой ковариационной матрицы. Важно отметить, что QIS работает примерно так же, как и обычная оценка ковариационной матрицы, когда  очень мало по сравнению с , и становится (намного) лучше, как только  растёт относительно . Таким образом, если  достаточно велико, то есть , может быть даже выгодно всегда использовать QIS напрямую!
Заключение
----------
В этой статье даётся представление о методе нелинейного снижения размерности выборочной ковариационной матрицы. После более концептуального/математического введения, небольшой пример кода иллюстрирует метод в R. Код для метода также доступен в Matlab и Python.
Есть много реальных приложений, где широко используется этот метод, в частности, в области финансов. Знаете ли вы другие приложения, где это может быть полезно, из вашего собственного рабочего опыта? Я всегда рад услышать об интересных вариантах использования и наборах данных.
Литература
----------
[1] Ledoit, O. and Wolf, M. (2012). Nonlinear Shrinkage Estimation of Large-Dimensional Covariance Matrices. The Annals of Statistics, 40(2):1024–1060.
[2] Ledoit, O. and Wolf, M. (2022). Quadratic Shrinkage for Large Covariance Matrices. Bernoulli, 28(3):1519–1547.
[3] Ledoit, O and Wolf, M (2004). A Well-Conditioned Estimator for Large-Dimensional Covariance Matrices. Journal of Multivariate Analysis, 88(2):365–411.
---
> 
>
> А мы поможем прокачать ваши навыки или с самого начала освоить профессию, востребованную в любое время:
>
>
>
> * [Профессия Data Scientist (24 месяца)](https://skillfactory.ru/data-scientist-pro?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=data-science_dspr_190822&utm_term=conc)
> * [Профессия Data Analyst (18 месяцев)](https://skillfactory.ru/data-analyst-pro?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=analytics_dapr_190822&utm_term=conc)
> * [Профессия Fullstack-разработчик на Python (15 месяцев)](https://skillfactory.ru/python-fullstack-web-developer?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_fpw_190822&utm_term=conc)
> | https://habr.com/ru/post/683498/ | null | ru | null |
# Плагины Jira: несколько примеров успешного изобретения велосипеда
Мы в Mail.ru Group вкладываем много сил в развитие продуктов компании Atlassian и, в частности, Jira. Благодаря нашим усилиям свет увидели плагины MyGroovy, JsIncluder, My Calendar, My ToDo и [другие](https://marketplace.atlassian.com/vendors/37127/my-com). Все эти плагины мы развиваем и активно используем внутри компании.
Мы получаем массу запросов от смежных подразделений по внедрению новых фич. Иногда это выливается в новые плагины, но чаще мы решаем поставленные задачи используя уже существующие плагины, так как большинство повседневных задач ими легко покрываются.
Для проведения экскурсий в офисе нужно было предусмотреть создание запросов с проверкой пересекающихся экскурсий. Для тестировщиков — сделать механизм отслеживания этапов тестирования с ответственным за выполнение. Техподдержка хотела получить автоматический доступ к базе знаний.
Сегодня я расскажу, как путем комбинирования плагинов удалось решить эти задачи.
Запрос от «экскурсоводов»
=========================
Инструменты:
* My Calendar
* JS Includer
Проблема
--------
В офисе Mail.ru Group много «экскурсоводов», которые договариваются с гостями и затем ставят задачи на АХО. Иногда случается так, что несколько экскурсий могут образоваться в одно и тоже время — тогда по офису одновременно ходят несколько групп, либо одному экскурсоводу отказывают, и он идет передоговариваться с гостями.
Решение
-------
1. Появление в задаче «слотов» (даты и времени из набора свободных вариантов) для выбора при создании заявки на экскурсию На день — 3 слота. Например:
* 9:00-10:00
* 17:30-18:30
* 20:00-21:00
Если слот был выбран в другой задаче, нельзя предлагать его для выбора в новой. Также нужна возможность убрать слоты из выбора руками (в случае, например, когда экскурсии в офисе невозможны в принципе).
2. Появление календаря, формируемого из свободных и занятых слотов, который можно расшарить на экскурсоводов.
Реализация
----------
**Шаг 1**: добавляем необходимые поля на экран создания запроса.
Для этого создадим поле «Дата» типа Date и поле «Время экскурсии» типа Radiobutton для выбора одного значения из 3 вариантов (9:00-10:00; 17:30-18:30; 20:00-21:00).
**Шаг 2**: создаем календарь.
Делаем новый календарь. Нацеливаем через JQL его на наш проект с экскурсиями,
указываем Event start созданное ранее поле «Дата», а так же добавляем в отображение созданное ранее поле «Время экскурсии».
Сохраняем календарь. Теперь наши экскурсии можно просматривать в календаре.
**Шаг 3**: ограничиваем создание экскурсий и добавляем баннер с ссылкой на календарь.
Чтобы этого добиться, потребуется JS, который будет отслеживать изменение в поле «Дата». Когда выбрана дата, мы должны подставить ее в jql-функцию и получить все запросы на эту дату, затем узнаем какое время занято и прячем эти варианты на экране, чтобы лишить возможности выбрать занятое время.
*Когда нет запросов*
*Когда есть 2 запроса на 9 утра и на 20 вечера*
```
(function($){
/*
Пояснение:
Дата — customfield_19620
Время экскурсии — customfield_52500
Опции поля «Время экскурсии»:
9:00-10:00 — 47611
17:30-18:30 — 47612
20:00-21:00 — 47613
*/
/*
Сначала добавляем проверку значения в поле дата.
Весь дальнейший код будет внутри этого блока.
*/
$("input[name=customfield_19620]").on("click change", function(e) {
var idOptions = [];
var url = "/rest/api/latest/search";
/*
Если «Дата» не выбрана, то скрываем выбор времени.
*/
if (!$("#customfield_19620").val()) {
$('input:radio[name=customfield_52500]').closest('.group').hide();
}
/*
Иначе берем значение из поля даты и переводим в удобный для подстановки в jql вид, так же выводим на экран все значения времени.
*/
else {
var temp = $("#customfield_19620").val();
var arrDate = temp.split('.');
var result = "" + arrDate[2].trim() + "-" + arrDate[1].trim() + "-" + arrDate[0].trim();
$('input:radio[name=customfield_52500][value="-1"]').parent().remove();
$('input:radio[name=customfield_52500]').closest('.group').show();
$('input:radio[name=customfield_52500][value="47611"]').parent().show();
$('input:radio[name=customfield_52500][value="47612"]').parent().show();
$('input:radio[name=customfield_52500][value="47613"]').parent().show();
/*
Затем подставляем в jql.
*/
var params = {
jql: "issuetype = Events and cf[52500] is not EMPTY and cf[19620] = 20" + result,
fields: "customfield_52500"
};
/*
Далее в полученном JSON находим все запросы и скрываем использованное в них время с экрана.
*/
$.getJSON(url, params, function (data) {
var issues = data.issues
for (var i = 0; i < issues.length; i++) {
idOptions.push(issues[i].fields.customfield_52500.id)
}
for (var k = 0; k < idOptions.length; k++) {
$('input:radio[name=customfield_52500][value=' + idOptions[k] + ']').parent().hide();
}
});
}
});
/*
Добавляем баннер с ссылкой на календарь.
*/
$('div.field-group:has(#customfield_19620)').last().before(`
Как работать с календарем
Выберите дату планируемой экскурсии
Затем выберите время экскурсии из доступных вариантов
По ссылке ниже вы можете посмотреть запланированные экскурсии в календаре
[Календарь экскурсий](https://jira.ru/secure/MailRuCalendar.jspa#calendars=492)
`);
})(AJS.$);
```
Запрос от тестировщиков
=======================
Инструмент:
* My Groovy
Проблема
--------
В запросе нужно настроить отображение этапов тестирования с указанием ответственного за задачу сотрудника. Должно быть видно, что этап еще не завершен, либо этап завершен (и кто его проводил).
Решение
-------
Настроить поле типа scripted field на отображение этапов тестирования и связать с workflow, записывать в ответственных за этап автора перехода.
Реализация
----------
1. Создаем поле «Ход выполнения» типа scripted field.
2. Создаем поля типа UserPicker, соответствующие этапам тестирования.
Для примера определим следующие этапы и создадим поля UserPicker с теми же названиями:
* Базовая информация собрана
* Локализовано
* Логи собраны
* Воспроизведено
* Ответственный найден
3. Настраиваем workflow так, чтобы на переходах заполнялись ответственные.
Например переход «Локализовано» записывает currentUser в поле UserPicker «Локализовано».
4. Настраиваем отображение при помощи scripted field.
Заполняем блок groovy:
```
import com.atlassian.jira.component.ComponentAccessor
import com.atlassian.jira.config.properties.APKeys
baseUrl = ComponentAccessor.getApplicationProperties().getString(APKeys.JIRA_BASEURL)
colorApprove = "#D2F0C2"
colorNotApprove = "#FDACAC"
return getHTMLApproval()
def getHTMLApproval(){
def approval = getApproval()
def html = "
"
approval.each{k,v->
html += """| ${k} | ${v?displayUser(v):""} |
"""
}
html += "
"
return html
}
def displayUser(user){
"[${user.displayName}](${baseUrl}/secure/ViewProfile.jspa?name=${user.name})"
}
def getApproval(){
def approval = [:] as LinkedHashMap
if (issue.getIssueTypeId() == '10001'){ //Тип запроса - Тестирование
approval.put("Базовая информация собрана", getCfValue(54407))
approval.put("Логи собраны", getCfValue(54409))
approval.put("Воспроизведено", getCfValue(54410))
approval.put("Ответственный найден", getCfValue(54411))
approval.put("Локализовано", getCfValue(54408))
}
return approval
}
def getCfValue(id){
ComponentAccessor.customFieldManager.getCustomFieldObject(id).getValue(issue)
}
```
В блоке velocity выводим $value. Получаем такой результат:
Запрос от техподдержки
======================
Инструменты:
* JS Includer
* My Groovy
Проблема
--------
У техподдержки есть своя база знаний на Confluence. Нужна возможность отображать связанные с проблемой статьи из базы знаний в запросе Jira. Так же нужен механизм поддержки базы в актуальном состоянии — если статья не была полезной, нужно поставить запрос техническому писателю в Jira на написание актуальной статьи. При закрытии запроса должны остаться только статьи относящиеся к запросу. Ссылки могут быть видны только техподдержке.
Решение
-------
При выборе определенного типа обращения в Jira (поле каскадного типа) в запросе должны отображаться статьи с Confluence, которые ему соответствуют в отдельном поле с wiki разметкой.
Статья при успешном использовании выбирается как актуальная с помощью отметки чекбокса.
При решении задачи, если оно не описано в прикрепленной статье, должна создаваться задача в Jira с типом «Документация», связанная с текущим запросом.
Реализация
----------
**Шаг 1**: подготовка
1. Создаем поле Text Field (multi-line) с wiki разметкой — Links.
2. Создаем поле типа Select List (cascading) — «Тип обращения».
Для примера используем следующие значения:
* ACCOUNT
* HARDWARE
3. Заготовим лейблы для статей, которыми будем связывать статьи на Confluence с запросами в Jira:
* Изменение членства в группах AD — officeit\_jira\_изменение\_членства\_в\_группах\_ad
* Подписка/отписка от рассылки — officeit\_jira\_подписка\_отписка\_от\_рассылки
* Предоставление доступа к папке — officeit\_jira\_предоставление\_доступа\_к\_папке
* Сброс пароля от доменной УЗ — officeit\_jira\_сброс\_пароля\_от\_доменной\_уз
* Сброс пароля от почты — officeit\_jira\_сброс\_пароля\_от\_почты
* Выдача временного оборудования — officeit\_jira\_выдача\_временного\_оборудования
* Выдача новой техники — officeit\_jira\_выдача\_новой\_техники
* Замена жесткого диска и установка системы с нуля — officeit\_jira\_замена\_жесткого\_диска\_и\_установка\_системы\_с\_нуля
* Замена жесткого диска с переносом информации — officeit\_jira\_замена\_жесткого\_диска\_с\_переносом\_информации
* Замена неисправного/устаревшего оборудования — officeit\_jira\_замена\_неисправного\_устаревшего\_оборудования
Далее необходимо создать статьи на Confluence, проставить им лейблы.
4. Подготавливаем workflow.
Тип обращения будем заполнять при создании.
Links добавляем на отдельный экран и помещаем на переход в закрыть (в примере переход называется «Check actual Links»), запоминаем id перехода (необходимо в дальнейшем для настройки js).
**Шаг 2**: MyGroovy post-function (добавляем статьи в запрос)
```
/*
Пояснение:
Тип обращения — customfield_40001
Links — customfield_50001
*/
/*
Указываем куда, под кем и как будем подключаться.
*/
def usr = "bot"
def pas = "qwerty"
def url = "https://confluence.ru"
def browse = "/pages/viewpage.action?pageId="
/*
Добавляем методы
*/
def updateCustomFieldValue(issue, Long customFieldId, newValue) {
def customField = ComponentAccessor.customFieldManager.getCustomFieldObject(customFieldId)
customField.updateValue(null, issue, new ModifiedValue(customField.getValue(issue), newValue), new DefaultIssueChangeHolder())
return issue
}
def getCustomFieldObject(Long fieldId) {
ComponentAccessor.customFieldManager.getCustomFieldObject(fieldId)
}
def parseText(text) {
def jsonSlurper = new JsonSlurper()
return jsonSlurper.parseText(text)
}
def getCustomFieldValue(issue, Long fieldId) {
issue.getCustomFieldValue(ComponentAccessor.customFieldManager.getCustomFieldObject(fieldId))
}
/*
Указываем скрипту, как соотносить типы обращения с лейблами.
*/
def getLabelFromMap(String main, String sub){
def mapLabels = [
"ACCOUNT": [
"Изменение членства в группах AD" :["officeit_jira_изменение_членства_в_группах_ad"],
"Подписка/отписка от рассылки" :["officeit_jira_подписка_отписка_от_рассылки"],
"Предоставление доступа к папке" :["officeit_jira_предоставление_доступа_к_папке"],
"Сброс пароля от доменной УЗ" :["officeit_jira_сброс_пароля_от_доменной_уз"],
"Сброс пароля от почты" :["officeit_jira_сброс_пароля_от_почты"]
],
"HARDWARE": [
"Выдача временного оборудования" :["officeit_jira_выдача_временного_оборудования"],
"Выдача новой техники" :["officeit_jira_выдача_новой_техники"],
"Замена жесткого диска и установка системы с нуля":["officeit_jira_замена_жесткого_диска_и_установка_системы_с_нуля"],
"Замена жесткого диска с переносом информации":["officeit_jira_замена_жесткого_диска_с_переносом_информации"],
"Замена неисправного/устаревшего оборудования":["officeit_jira_замена_неисправного_устаревшего_оборудования"]
]
]
def labels = mapLabels[main][sub]
def result = ""
if(!labels){
return ""
}
for (def i=0;i
```
**Шаг 3**: JS-скрипт
```
/*
Пояснение:
Переход — Check actual Links
id перехода — 10
Links — customfield_50001
*/
(function($){
/*
Вначале объявляем переменные, с которыми будем работать, прячем ненужное от посторонних глаз и делаем проверку что код будет выполняться для нужного нам перехода.
*/
var buttonNewArticle = 'Необходима новая статья';
var buttonDeleteUnchecked = 'Сохранить отмеченные';
var buttonNewArticleTitle = 'Автоматически будет создан таск на новую статью';
var buttonDeleteUncheckedTitle = 'Все неотмеченные статьи будут удалены.';
var avalibleTransitions = [10];
var currentTransition = parseInt(AJS.$('.hidden input[name^="action"]').val());
if(avalibleTransitions.indexOf(currentTransition)==-1){
console.log('Error: transition ' + currentTransition + ' is not avalible');
return;
}
var customFieldId = 50001;
var labelTxt = 'Выберите актуальные статьи';
var idname = 'cblist';
var checkboxCounter = 'cbsq';
var text = '' + labelTxt +''
AJS.$('.field-group label[for^="customfield_'+customFieldId+'"]').parent().hide();
AJS.$('.field-group label[for^="comment"]').parent().hide();
$('.jira-dialog-content div.form-body').prepend(text);
/*
Далее пишем следующие функции:
*/
/*
renameButtonNeedNewArticle и renameButtonDeleteUnchecked — меняем кнопку « Закрыть» в зависимости от того выбраны ли статьи или нужно создать новую
addCheckbox — рисуем чекбокс напротив каждой статьи.
*/
function arrayToString(arrays) {
return arrays.join('\n');
}
function renameButtonNeedNewArticle() {
$('#issue-workflow-transition-submit').val(buttonNewArticle);
$('#issue-workflow-transition-submit').attr("title",buttonNewArticleTitle);
}
function renameButtonDeleteUnchecked() {
$('#issue-workflow-transition-submit').val(buttonDeleteUnchecked);
$('#issue-workflow-transition-submit').attr("title",buttonDeleteUncheckedTitle);
}
function addCheckbox(array) {
var value = array.join('|');
var name = array[0].replace('[','');
var link = array[1].replace(']','');
var container = $('#'+idname);
var inputs = container.find('input');
var id = inputs.length+1;
$('', { type: 'checkbox', id: checkboxCounter+id, value: value }).appendTo(container);
$('', { for: checkboxCounter+id, text: ' ' }).appendTo(container);
$('', { href: link, text: name,target: "_blank" }).appendTo(container);
$('
').appendTo(container);
}
/*
Меняем отображение при загрузке экрана на то, что нам нужно:
*/
renameButtonNeedNewArticle();
$(document).ready(function() {
var val = AJS.$('#customfield_'+customFieldId+'').val();
AJS.$('#customfield_'+customFieldId+'').val('');
if(val==""){return;}
var i = val.split('\n');
i.forEach(function( index ) {
if(index == ""){return;}
var link = index.split('|');
addCheckbox(link);
});
});
/*
Отслеживаем выбранные чекбоксы и формируем итоговое значение для поля Links.
*/
$('#'+idname+' input[type="checkbox"]').change(function() {
var prevalue = [];
AJS.$('#'+idname+' input:checkbox:checked').each(function(){
prevalue.push(this.value);
});
AJS.$('#customfield_'+customFieldId+'').val(arrayToString(prevalue));
if(prevalue.length<1){
renameButtonNeedNewArticle();
}else{
renameButtonDeleteUnchecked();
}
});
})(AJS.$);
``` | https://habr.com/ru/post/476446/ | null | ru | null |
# Multi-page SPA на Питоне
**Мост между Python и React**
Сова – это нано-фреймворк, который можно встроить в другие фреймворки.
Картинка с sova.online, на котором запущено 3 http сервера:
<http://sova.online/> — просто Falcon
<http://sova.online:8000/> — просто Django
<http://sova.online:8001/> — просто Python (логин: 1, пароль: 1)
Там же исходные коды и инструкция по установке. Там же нет рекламы.
Идея делать сайты на Питоне с прорисовкой на React не нова. Есть замечательный фреймворк <https://plot.ly/products/dash/>, зачем еще что-то делать?
Объясняю: Сова не рассчитана на разработку сайтов. Это инструмент для замены толстых клиентов на приложения, работающие через браузер (десктопные приложения).
— Что-ли веб-клиент?
— Нет. Это не веб-клиент. Это приложение, работающее в браузере.
— Не понимаю.
— К сожалению, и многие разработчики не понимают.
Я как генеральный активно работал с несколькими интернет приложениями.
**Онлайн клиент банка Югра (банк закрыт).**
Хорошее было приложение, но это был Java applet, т.е. толстый клиент, запускаемый из браузера. И банк Югра, и апплеты в прошлом.
**Онлайн клиент банка ВТБ-24 (банк закрыт).**
Я гуманист, но поработав с этим чудом, стали появляться жестокие мысли типа: «Заставить разработчика зарегистрировать в нем 1000 платежек».
При этом как веб-клиент он прекрасен. Анимация, открывается на мобильнике. Вау! Круто!
Спросил знакомого бухгалтера: как ты с ним работаешь?
Она говорит: прекрасно! загружаю данные в 1с, в 1с работаю, результаты выгружаю обратно.
**Онлайн клиент сбербанка**
Удовлетворительный клиент, работать можно. Когда меня попросили его оценить, я поставил ему 3 бала из 5 и дал список замечаний. Это при моих 10 платежках в месяц. Те, кто делает 100 платежек в день, скорее всего, выгружают информацию.
Заполнение платежки.
Зеленая область, занимающая 20% экрана – это меню. Оно не просто мешает (position: fixed), оно говорит о том, что разработчик не профессионал. Если я начал создавать платеж, на экране д.б. 3 кнопки: «Создать», «Сохранить как шаблон», «Отмена». Эти кнопки есть (почему-то внизу). Здесь не multi-page SPA: перейдешь по пункту меню, — данные в форме пропадут.
Тот, кто это делал, даже не поймет, в чем наезд: «Нормально сделано, все так делают, такая библиотека, люди ведь работают …». И он прав. Спрашивать надо с руководителя проекта, а для руководителя главное – это БД и слои в концептуальной модели. А формы – наймем мальчиков, они нарисуют. И ведь гордятся, наверное, этой халтурой.
**Торговые площадки (5 штук, 44 ФЗ)**
Это действительно приложения (не веб-клиенты). Но контроллеры полей мне не нравятся.
Примеры:
Выровнено странно, ширина поля явно недостаточна, autoheight в поле ввода отсутствует.
Еще пример. В поле «Дата публикации» нет шаблона дд.мм.гггг, календарь с ошибкой, пиктограмма календаря пугает:
Список на rts-tender: есть выделенная цветом текущая запись, стрелками можно двигаться по списку, но нет автоскроллинга (можно убежать за границу экрана), ни Enter, ни пробел не открывают ссылку, табулятор не привязан к текущей записи. Хотя открыть ссылку можно только мышкой, я оцениваю контрол со знаком плюс. Такого функционала (запомнить и подсветить текущий документ) мне не хватает в mail.ru
Вроде как мелочи. Но профессиональное приложение отличается от полупрофессионального именно мелочами. Конечному пользователю наплевать, какая у вас БД и сколько слоев в концептуальной модели. Он работает с экранными формами и у него 3 требования: функционально, удобно, быстро.
К сожалению, выбор системы определяют айтишники и начальники, которые сами с системой не работали и работать не будут. Скорость они оценят, функциональность оценят так, как они это понимают, а на удобство им наплевать, главное, чтобы было красиво.
Павел Валерьевич Дуров не изобретал ни соцсеть, ни мессенджер. Он сделал то, что нужно пользователям, удобно и красиво. И люди это оценили, в том числе и материально.
Сова – это инструмент для построения профессионального интерфейса.
Что это значит, на примере СЭД.
Есть СЭД, в ней 3 группы пользователей:
Начальство
Специалисты, готовящие документы
Делопроизводители.
Начальники, они как дети. Им нужно, чтобы просто и красиво. В идеале 1 кнопка и 1 поле. И чтобы понтов побольше. Веб-клиент и, конечно, мобильный клиент, чтобы понты демонстрировать.
Специалисты. Веб-клиент, помесь соцсеть/почтовик. Не забывайте, что специалистов много и их надо обучать. Чем привычней будет для них среда, тем лучше. Мобильный клиент тоже пригодится, если служба безопасности разрешит.
Делопроизводители. Вот здесь пригодится Сова. Делопроизводители – это системообразующая группа пользователей. Все остальные могут заболеть/уйти в отпуск/перестать пользоваться, — СЭД будет работать. Если остановится регистрация, встанет все.
Делопроизводство – это конвейер, и здесь важно все, любая мелочь: шрифты, полутона, автоматическое заполнение, проверка значений, удобство ввода и т.д.
СЭД «Дело». Кабинеты исполнителей сделаны на веб-клиенте, канцелярия – толстый клиент. Все прекрасно, но это будет работать, пока правительство не запретит Windows в госструктурах. Я люблю Win 7, но если бы правителем был я, it-рынок взбодрился новыми заказами, а MS остался в светлой памяти. Кстати, 6 декабря Антон Силуанов подписал [директиву](https://www.vedomosti.ru/technology/articles/2018/12/16/789399-siluanov-trebuet-ot-goskompanii) о переходе на отечественное ПО.
**Sova.online**
Как Сова открывает форму.
Без multi-page.
Центральным элементом Совы является компонент Document. Нажав ctrl-U на стартовой странице, вы увидите все, что нужно для создания объекта класса Document:
— данные полей БД;
— url формы для отображения;
— dbAlias, unid — для работы с БД;
— что-то там еще.
В некоторой степени Document – это аналог Redux-form.
Форма загружается в виде JSON строки, затем бывший словарь становится объектом, имеющим style, className и массив (список) элементов. Массив будет вставлен в элемент с id=root в виде
```
…массив…
```
Элемента массива — это объекты, описывающие теги
```
, , ![](),
```
, или массив, или компоненты.
За парсинг массива отвечает функция boxing. Если встретится элемент, содержащий массив, она рекурсивно вызовет себя.
Пуп земли, конечно, div.
В простейшем случае это строка: dict(div='Привет', className='h2')
Но может быть и массив (массив массивов):
```
def style(**par):
return {'style': {**par}}
dict( # словарь описывает стартовую страницу sova.online
style(position='relative'),
readOnly = 1,
div = [
dict( style(width=1000, margin='auto', paddingTop=20),
div=[
{ 'div': subFormTop.panel() },
{ 'div': [subFormLeft.panel(), subFormRight.panel()], 'className': 'row' },
# { 'div': [subFormDown.panel()] },
]),
]
)
```
Здесь 3 панели (каждая в отдельном файле: subFormTop.py и т.д.).
subFormTop.panel() возвращает массив для построения верхней панели.
subFormLeft.panel() и subFormRight.panel() объединены в строку ('className': 'row') и описывают левую и правую панели.
subFormDown.panel() закомментирована (не пригодилась).
Возможно, покажется сложным. Но это Питон: все можно упростить.
Пример формы, из журнала «Отчеты». Функция labField(метка, имя\_поля\_БД) возвращает массив из двух словарей (строку таблицы): 1-й словарь – это {'div': метка}, второй {'field': [имя\_поля\_БД, 'tx']}.
```
div = [
docTitle('Отчет'),
dict ( wl='40mm', className='cellbg-green', div=_table(
labField('Отчет', 'nodafd'),
labField('Запуск отчета', '_STARTINGTIME'),
labField('Окончание', '_ENDTIME'),
labField('Пользователь', 'CREATOR'),
labField('Категория', 'REPORTCAT'),
labField('Название', 'REPORTNAME'),
labField('Заголовок', 'REPORTTITLE'),
labField('Начало периода', 'dt1'),
labField('Конец периода', 'dt2'),
labField('Начало периода 2', 'dt3'),
labField('Конец периода 2', 'dt4'),
labField('Журналы', 'LBYEARS'),
labField('Префиксы', 'GRGROUP'),
labField('Формула отбора', 'QUERYMAIN'),
labField('Комментарий', 'NOTES'),
)),
sent(),
]
```
 | https://habr.com/ru/post/424779/ | null | ru | null |
# Демка MONOSPACE, победитель Assembly ONLINE 2020, умещается в 1021 байт
Первое место в соревновании разработчиков [Assembly ONLINE 2020](https://archive.assembly.org/2020) в категории «Online 1k intro» заняла демка MONOSPACE. Программа размером в 1021 байт после сжатия [написана](https://www.pouet.net/prod.php?which=87082) на JavaScript. Автор демки — креативный кодер и демосценер-оптимизатор [Mathieu 'p01' Henri](http://www.p01.org/).
Создатель демки предупредил, что она работает в последних стабильных версиях браузеров на основе Chromium или Webkit. В Firefox будет просто слайдшоу из-за того, что его разработчики так и не исправили ошибку [1190398](https://bugzilla.mozilla.org/show_bug.cgi?id=1190398), связанную с ShadowBlur. [Ссылка](http://www.p01.org/MONOSPACE/monospace.htm) на демку для Chrome\Edge, [версия](http://www.p01.org/MONOSPACE/monospace-compatible.htm) для всех совместимых браузеров. [Скачать](http://www.p01.org/MONOSPACE/monospace.zip) демку можно с сайта автора.
Код MONOSPACE сжат с использованием техники [PNG bootstrapping](http://www.p01.org/VOLTRA/).
Mathieu 'p01' Henri пояснил, что в демке использовал 2D Canvas, избыточно использовав ShadowBlur для рендеринга изображения с разной глубиной резкости. Для воспроизведения аудио он задействовал scriptProcessingNode, злоупотребляя событием onAudioProcess для рендеринга звуковых и визуальных эффектов. Также в демке используется синтезатор речи, после его активации происходит новая отрисовка в ходе выполнения программы. Демка MONOSPACE названа в честь семейства моноширинных шрифтов.
Для создания растрового изображения при помощи JavaScript (canvas) и контекста рендеринга демки требуется 59 байт кода:
```
b=c.getContext`2d`
```
Минифицированный код MONOSPACE имеет длину 1438 байт:
```
d=[2280,1280,1520,c.width=1920,document.body.style.font="0px MONOSPACE"],g=new AudioContext,o=g.createScriptProcessor(4096,document.body.style.margin=t=n=0,1),o.connect(g.destination),o.onaudioprocess=o=>{o=o.outputBuffer.getChannelData(e=Math.sin(t/16%1,m=Math.sin(Math.min(1,y=t/128)*Math.PI)**.5+.1,c.height=1080,b.shadowOffsetY=32420,c.style.background="radial-gradient(#"+[222,222,222,222,155,155,102,102][t/16&7]+",black",b.font="920 32px MONOSPACE",f=[(x,y,t)=>x/y*2-t,(x,y,t)=>(x**2+y**2)**.5-t,(x,y,t)=>x/4^y/4-t,(x,y,t)=>y%x-t][t/16&3],u=""+[[,f,f," CAN YOU HEAR ME",f,f,,"MONOSPACE","THE END"][t/16|0]],t>n&&speechSynthesis.speak(new SpeechSynthesisUtterance(u,n+=16))));for(i=0;4096>4*i;i++)g[i]=r=(f(x=16-i%32,a=16-(i/32|0),t)/2&1)+(g[i]||0)/2,x+=o[0]/4+4*(1-m**.3)*Math.sin(i+t+8),a+=o[64]/4+4*(1-m**.3)*Math.sin(i+t),h=x*Math.sin(y*2+8)+a*Math.sin(y*2),p=4096/(m*32+4*h*Math.sin(e)+t%16),b.beginPath(f[i]=r/p),b.arc(h*Math.sin(e+8)*p+1280,x*Math.sin(y*2)*p-a*Math.sin(y*2+8)*p-31920,p>0&&p/(2+32-r*16),0,8),b.shadowBlur=o[0]**2*32+32-m*32+4+h*h/2,b.shadowColor="hsl("+[f(x,y,t)&2?t-a*8:180,(t&64)*m+"%",(t&64)*m+"%"],b.fill();b.shadowBlur=o[0]**2*32,b.shadowColor="#fee";for(i=0;4096>i;i++)o[i]=o[i]/2+((Math.sin(t*d[t/[4,4,4,4,1/4,1/4,16,4][t/16&7]&3]*Math.PI)*8+(t*d[t/8&3]/2&6)+t*d[t/16&3]/4%6)/64+f[i/4|0])*m,64>i&t%16*6>i&&b.fillText([u[i+(o[i]*2&1)]],i%9*32+o[0]*16+180,(i/9|0)*64+o[64]*16-t-31920),t+=1/g.sampleRate}
```
В начале октября 2020 года программист-энтузиаст HellMood из группы DESiRE [выпустил](https://habr.com/ru/news/t/522104/) демку для MS-DOS/FreeDos под названием Gespensterwald. Программа размером в 62 байта написана на ассемблере. Автор демо постарался показать в нескольких строчках кода в 3D анимации угрюмый и жуткий лес, около которого он живет. HellMood добавил в демо необычное гудение, которое иногда возникает в этом реальном лесу.
> См. также:
>
>
>
> * «[Космическая демосцена: Вселенная умещается в 64 килобайта](https://habr.com/ru/company/mailru/blog/406969/)»
> * «[Как сделано интро на 64k»](https://habr.com/ru/post/330090/)»
> | https://habr.com/ru/post/524116/ | null | ru | null |
# Gem ice_cube для повторяющихся событий
В некоторых проектах требуется дать возможность пользователю настроить правила для повторяющихся событий. Иногда правила событий могут быть достаточно сложными, к примеру, “каждый предпоследний день месяца” или “каждую вторую пятницу месяца до определенной даты“. Для решения подобных задач можно успешно применять [gem ice\_cube](http://seejohnrun.github.com/ice_cube/).
Gem ice\_cube позволяет задавать правила для повторяющихся событий используя API на подобие iCalendar и сериализовать/десериализовать расписания в форматах YAML и Ruby Hash. Ice\_cube позволяет хранить только одно расписание, а не генерировать сразу сотни событий на перед. Мы выбрали ice\_cube из-за удобного и гибкого API, постоянных обновлений и исправлений ошибок, популярности среди других разработчиков.
Инсталяция gem:
```
gem install ice_cube
```
Для создания расписания необходимо воспользоваться классом IceCube::Schedule:
```
require 'rubygems'
require 'ice_cube'
include IceCube
# Параметры:
# - дата/время начала расписания
# {
# :duration => 3600 - продолжительность в секундах
# :end_time => Time.now + 3600 - время окончания
# }
schedule = Schedule.new(Date.today)
# Добавить повторение
schedule.add_recurrence_time(Date.today)
# Добавить исключение
schedule.add_exception_time(Date.today + 1)
```
Для создания правил повторения служит класс IceCube::Rule. Ice\_сube поддерживает правила для ежедневных, еженедельных, ежемесячных, ежегодных, ежечасных, ежеминутных и ежесекундных повторений. Несколько примеров использования (более полный список примеров можно найти на странице проекта):
```
# Каждый 4-ый день
schedule.add_recurrence_rule Rule.daily(4)
# Каждую вторую неделю, в понедельник и пятницу
schedule.add_recurrence_rule Rule.weekly(2).day(:monday, :friday)
# Ежемесячно 10, 20 числа, и в последний день месяца
schedule.add_recurrence_rule Rule.monthly.day_of_month(10, 20, -1)
# Каждый месяц, в первый понедельник и последний вторник
schedule.add_recurrence_rule Rule.monthly.day_of_week(
:monday => [1],
:tuesday => [-1]
)
# Каждый год, на 50 день и на 100 день с конца
schedule.add_recurrence_rule Rule.yearly.day_of_year(50, -100)
```
Несколько правил можно комбинировать в одном расписании, в том числе и исключающие правила:
```
# Каждый 4-ый день / исключая понедельники и пятницы
schedule.add_recurrence_rule Rule.daily(4)
schedule.add_exception_rule Rule.weekly.day(1, 5)
```
Для правил можно устанавливать ограничения по количеству повторов и до определенной даты:
```
# Каждый 2-ой день, десять раз
schedule.add_recurrence_rule Rule.daily(2).count(10)
# Каждый 2-ой день, до конца месяца
schedule.add_recurrence_rule Rule.daily(2).until(Date.today.next_month - Date.today.day)
```
Теперь, наверное, самое интересное — запросы к расписанию:
```
# Все случаи повторений
schedule.all_occurrences
# Все случаи повторений до определенного времени
schedule.occurrences((Date.today + 5).to_time)
# Произойдет в определенное время
schedule.occurs_at?(Time.now)
# Произойдет в определенный день
schedule.occurs_on?(Date.today)
# Произойдет в промежутке времени
schedule.occurs_between?(Time.now, (Date.today + 5).to_time)
# Первые случаи повторения
schedule.first
schedule.first(3)
# Следующий случий повторения
schedule.next_occurrence
# Следующие 3 случая повторения
schedule.next_occurrences(3)
# Оставшиеся случаи повторения
schedule.remaining_occurrences
```
Сериализация данных в форматы YAML/HASH/iCal:
```
# YAML
yaml = schedule.to_yaml
Schedule.from_yaml(yaml)
# Hash
hash = schedule.to_hash
Schedule.from_hash(hash)
# iCalendar
schedule.to_ical
```
Мы используем gem ice\_cube для реализации календаря повторяющихся событий вместе с FullCalendar и DelayedJob, пример использования можно посмотреть на [этой странице](http://demo.inexfinance.com/main/events/calendar).
Некоторые примеры для этой статьи взяты из официальной документации. Если у Вас есть вопросы или замечания, буду рад на них ответить.
Ссылки:
[github.com/seejohnrun/ice\_cube](http://github.com/seejohnrun/ice_cube) — страница проекта на GitHub.
[seejohnrun.github.com/ice\_cube/static/ice\_cube\_ruby\_nyc.pdf](http://seejohnrun.github.com/ice_cube/static/ice_cube_ruby_nyc.pdf) — презентация ice\_cube.
[seejohnrun.github.com/ice\_cube/static/lsrc\_ice\_cube.pdf](http://seejohnrun.github.com/ice_cube/static/lsrc_ice_cube.pdf) — еще одна презентация.
[www.inexfinance.com/en/blog/2012/12/2/gem\_ice\_cube](https://www.inexfinance.com/en/blog/2012/12/2/gem_ice_cube) — английский вариант этой статьи.
[github.com/inex-finance/blog-examples](https://github.com/inex-finance/blog-examples) — примеры из данной статьи. | https://habr.com/ru/post/161123/ | null | ru | null |
# Абсолютный поворотный энкодер с однодорожечным кодом Грея
В этом материале речь пойдёт о физической реализации абсолютного поворотного энкодера. Разрешение этого энкодера составляет 6 градусов, то есть — 60 шагов. Этого достаточно для того чтобы сделать на его основе часы. Здесь используется [одношаговый код Грея](https://www.ncbi.nlm.nih.gov/pmc/articles/PMC6111776/).
[](https://habr.com/ru/company/ruvds/blog/592201/)
Материалы
---------
Для реализации проекта понадобится печатная плата с оптическим датчиком, Arduino (я применил тут Arduino Uno), а так же — диск энкодера.
*Плата с оптическим датчиком*
*Схема Arduino Uno*
*Диск энкодера*
Шаг 1. Принципы работы энкодера
-------------------------------
*Работа энкодера*
*Преобразование однодорожечного кода Грея в двоичный код*
*Таблица преобразования кода Грея в двоичный код*
Когда диск энкодера вращается, оптический датчик реагирует на прохождение мимо него светлых и тёмных мест дорожки с кодом, а программа, работающая на Arduino, выполняет нахождение точной позиции диска.
Вот файлы с программным кодом:
* [madewithmath3.ino](https://content.instructables.com/ORIG/FJ1/C7C1/KVP8ZGZ3/FJ1C7C1KVP8ZGZ3.ino)
* [PCF8574.cpp](https://content.instructables.com/ORIG/FOB/F13S/KVP8ZGZ4/FOBF13SKVP8ZGZ4.cpp)
* [PCF8574.h](https://content.instructables.com/ORIG/F15/YLKQ/KVP8ZGZ5/F15YLKQKVP8ZGZ5.h)
Шаг 2. Принципиальная схема устройства
--------------------------------------
*Принципиальная схема устройства*
Микроконтроллер Arduino подключён к плате с оптическим датчиком 4 проводами. Речь идёт о контактах `GND`, `+5V`, `SDA`, `SCL`.
Шаг 3. Диск энкодера
--------------------
*Диск энкодера*
Реальный диск энкодера, используемый в этом проекте, выглядит именно так.
Шаг 4. Подробнее о диске энкодера
---------------------------------
На следующих рисунках выделена зона диска энкодера, которую анализирует оптический датчик.
*Область диска энкодера, которую анализирует датчик*
*Область диска энкодера, которую анализирует датчик*
Шаг 5. Создание диска энкодера
------------------------------
*В основе диска энкодера лежит обычный CD-диск*
*Подготовка изображения для нанесения на диск*
*Разметка изображения*
*Чёрные и белые области разметки, на которые реагирует оптический датчик*
*Размеченный диск*
Приведённые здесь изображения можно распечатать на принтере и приклеить к диску. Того же эффекта можно достичь, вручную нанеся разметку на диск.
Я пользовался 38-миллиметровой клейкой лентой разных цветов. Сначала я наклеил два разноцветных куска ленты на диск, постаравшись, чтобы края лент сошлись бы точно в центре диска. Потом, следуя разметочным линиям, вырезал участки лент. Можно, вырезав участки ленты одного цвета, приклеить их поверх соответствующих участков ленты другого цвета.
Шаг 6. Проверка параметров элементов, формирующих одношаговый код Грея, и оптического датчика
---------------------------------------------------------------------------------------------
*Размеры элементов и диска*
*Элементы оптического датчика*
Шаг 7. Сопоставление кода Грея и элементов оптического датчика
--------------------------------------------------------------
*Код, который нужно прочитать датчику*
Код Грея, нанесённый на диск, считывается элементами датчика, угловое расстояние между которыми составляет 30 градусов. Разрешение энкодера составляет 6 градусов, то есть — 60 шагов (360/60 = 6 градусов). В ходе работы устройства получается последовательность [13, 3, 6, 2, 6, 13, 3, 6, 2, 6]. Шаг 13 соответствует 78 градусам.
Шаг 8. Варианты применения абсолютного энкодера
-----------------------------------------------
Я использовал абсолютный энкодер для изготовления часов.
*Часы*
*Большие часы*
Вот — несколько снимков, демонстрирующих процесс изготовления часов.
Планируете ли вы сделать какой-нибудь проект на основе абсолютного поворотного энкодера?
[](https://ruvds.com/ru-rub/news/read/151?utm_source=habr&utm_medium=article&utm_campaign=perevod&utm_content=absolyutnyj_povorotnyj_enkoder_s_odnodorozhechnym_kodom_greya) | https://habr.com/ru/post/592201/ | null | ru | null |
# PeerVPN – пиринговый VPN с открытым кодом
*Перевод анонса и небольшой документации проекта [PeerVPN](http://www.peervpn.net/), который показался мне интересным.*
#### PeerVPN
Это программа, создающая виртуальную локалку из нескольких удалённых компьютеров. Такие сети могут быть полезны для непосредственного общения приложений, например совместного использования файлов или игр. Часто обычными способами наладить такое взаимодействие невозможно из-за фаерволов или NAT.
Традиционные VPN работают по схеме клиент-сервер, когда много узлов соединяются с одним сервером. У такой звёздной топологии есть недостатки. Центральный сервер должен обладать большой пропускной способностью, чтобы обрабатывать весь трафик сети. Если сервер падает, сеть падает следом.
PeerVPN работает по распределённой технологии, когда все узлы общаются друг с другом без необходимости в центральном сервере. Если один узел отключается, на сеть это не влияет.
Настроить сеть просто. Нужно задать имя сети, пароль и контактную информацию (IP и порт) другого узла. Добавление новых узлов не требует перенастройки сети, их адреса раздаются по сети автоматически.
#### Свойства
— поддержка Ethernet через TAP
— поддержка IPv6
— распределённая технология
— автоматическое поднятие туннелей через фаервол и NAT без дополнительных настроек
— поддержка совместно используемых ключей и авторизации
#### Платформы
Linux и FreeBSD. Требуется наличие OpenSSL
#### Лицензия
PeerVPN распространяется по лицензии GPLv3.
#### Скачать
Версия 0.042 (2015-01-21)
source code: [peervpn-0-042.tar.gz](http://www.peervpn.net/files/peervpn-0-042.tar.gz)
statically linked x86 binary for Linux: [peervpn-0-042-linux-x86.tar.gz](http://www.peervpn.net/files/peervpn-0-042-linux-x86.tar.gz)
#### Веб-страница
[www.peervpn.net](http://www.peervpn.net)
#### Пример настройки
Допустим, вы установили PeerVPN на два Linux-компьютера, которые мы будем называть «Узел А» и «Узел Б».
##### Настройка узла А
Создайте файл peervpn.conf следующего содержания:
```
port 7000
networkname ExampleNet
psk mysecretpassword
enabletunneling yes
interface peervpn0
ifconfig4 10.8.0.1/24
```
Будет открыт UDP-порт 7000 и создан виртуальный Ethernet-интерфейс под именем peervpn0 и с адресом 10.8.0.1.
Узел А должен быть доступен напрямую с узла Б. Если узел А находится за NAT, нужно прокинуть 7000 порт.
##### Настройка узла Б
Создайте файл peervpn.conf следующего содержания:
```
port 7000
networkname ExampleNet
psk mysecretpassword
enabletunneling yes
interface peervpn0
ifconfig4 10.8.0.2/24
initpeers node-a.example.com 7000
```
Вместо node-a.example.com нужно подставить адрес узла А.
##### Тестирование
Запустите PeerVPN на обоих нодах. На каждой должен появиться интерфейс peervpn0. Установка туннеля VPN может занять некоторое время. Попробуйте пингануть 10.8.0.2 с узла А или 10.8.0.1 с узла Б. Если ответ получен, то VPN работает!
##### Добавление узлов в сеть
Скопируйте peervpn.conf с узла Б на новый узел и поменяйте IP в команде ifconfig на 10.8.0.3, 10.8.0.4, и т.д. При запуске узла сначала будет построен туннель к узлу А, а через некоторое время – к узлу Б и другим узлам сети. | https://habr.com/ru/post/250277/ | null | ru | null |
# Использование библиотеки OpenCV для распознавания эллиптических дуг на 2D сечениях 3D облаков точек
В связи с все более широким распространением доступных лазерных сканеров (лидаров), способных получать 3D облака точек (*3dОТ*) и все более широким применением этой технологии в различных областях (от машиностроения до безопасности, от нефтяной промышленности до архитектуры), оживился интерес к алгоритмам обработки облаков точек.
Одно из востребованных применений *3dОТ* в промышленности — это создание конструкторской документации на только возводимое, старое или переделанное оборудование, которое обычно представляет из себя трубопроводы и другие конструкции цилиндрической геометрии.
Для детектирования геометрических примитивов в *3dОТ* обычно применяются специализированные 3D библиотеки, например *Microsoft PCL*. У подхода с использованием готовых библиотек наряду с достоинствами есть и недостатки. Например, трудно включить их в уже существующие кадовские схемы обработки, которые обычно имеют 2D размерность.
Рассмотрим, как можно было бы обрабатывать *3dОТ*, например насосной станции, начав с 2D сечений и используя весь арсенал 2D обработки, который есть в надежных и оптимизированных библиотеках обработки изображений, например *OpenCV*.
*Рисунок 1. 3D ОТ модель насосной станции*
Основным элементом сечений, полученных при сканировании различных трубных конструкций являются *эллиптические дуги*.
*Рисунок 2. Горизонтальное сечение 3D модели насосной станции на среднем уровне*
Для данной статьи, ограничим нашу задачу рассмотрением одного ключевого алгоритма, позволяющего детектировать произвольные эллиптические дуги — это итеративный алгоритм *роста дуговых сегментов и связывания краев* (*region growth and edge linking*).
Ростовые алгоритмы являются наиболее наглядными и легко верифицируемыми, хотя и трудоемкими по сравнению со статистическими алгоритмами, которые лучше подходят для случая, когда сцена содержит слабо связанные, отдаленные объекты, которые принадлежат одному эллипсу. Эти алгоритмы будут рассмотрены в следующих статьях.
#### Нахождение метрики контуров
Пока, для простоты, опустим процедуру получения сечения из исходного файла *3dОТ*, препроцессинг сечения, его кластеризацию для изолирования геометрических примитивов, а так же последующую привязку, ректификацию и другие фотограмметрические операции, нужные для получения параметров модели. Не станем так же обсуждать параметризацию эвристических поисковых алгоритмов. Опишем все *основные операции*, из которых строится алгоритм.
Будем считать, что нам необходимо детектировать (распознать, классифицировать) эллиптическую дугу(то есть вычислить параметры эллипса, а так же начальный и конечный угол эллиптической дуги) на данном снимке, вырезанном из горизонтального сечения облака точек.
*Рисунок 3. Одна из эллиптических дуг сечения 3D модели (после сглаживания)*
Для того чтобы минимизировать работу с растром вслепую, все операции с растром будем проводить через *оконтуривание*.
*OpenCV* процедура *findContours* находит на растре *mat*, все внешние (без внутренних фигур) контура *contours* в виде вектора векторов целочисленных точек (в координатах растра):
```
Mat mat(size);
vector> contours;
findContours(mat, contours, RETR\_EXTERNAL, CHAIN\_APPROX\_SIMPLE);
```
Это наша ключевая операция, которая в некоторых простых случаях полностью решает поставленную задачу. Но так как не всегда встречаются вырожденные случаи, рассмотрим подробнее технологию обработки через оконтуривание.
Обратная операция, генерация растра по имеющемуся внешнему контуру с помощью *OpenCV* функции, так же выглядит просто:
```
drawContours(mat, contours, -1, Scalar(255), -1);
```
Она тоже очень часто используется для маскирования контура, рисования или для вычисления площади.
Таким образом, на начальном этапе мы имеем *набор патчей* (кусочков некоторой кривой), который нужно связать в эллиптическую дугу, отбраковав попавшие в сечение части других компонентов конструкции (например, крепежных элементов) или оптический шум, возникающий из-за затенения при сканировании и других причин.
Создадим *дискриминантную функцию*, которая будет возвращать тип контура (эллипс, линейный отрезок, штриховка или что то еще), а так же концевые точки контура и его повернутый габаритный прямоугольник:
```
contourTypeSearch(
const vector &contour, Vec4i &def, RotatedRect &rc);
```
Соотношения длины и ширины прямоугольника помогает быстро дискриминировать контура, близкие *линейным отрезкам*, а так же небольшие *шумовые контура*.
Повернутый прямоугольник в *OpenCV* имеет непростую систему координат. Если требуется не сам угол, а его *тригонометрические функции*, все более менее очевидно из контекста. Если же используется *абсолютное значение угла*, надо учесть, что угол отсчитывается от горизонтали до первого ребра прямоугольника против часовой и имеет отрицательное значение.
*Концевые точки* эллиптических контуров находятся с помощью нашей процедуры, которая получает на вход растр *mat* с дискриминируемым контуром, выделенным из исходного изображения маскированием и возвращает *максимальный дефект*:
```
contourConvFeature(mat, &def, … );
```
Основным кодом этой функции является вызов двух процедур *OpenCV*:
```
vector \*hull = new vector();
convexHull(contour, \*hull);
vector \*defs = new vector();
convexityDefects(contour, \*hull, \*defs);
```
Первая процедура находит *выпуклый многоугольник* для исследуемого контура, вторая – вычисляет все *дефекты выпуклости*.
Мы берем только *самый большой* по значению выпуклости дефект, считая что он и определяет концевые точки контура. Это может быть не так, если внешняя или внутренняя границы контура имеют *особенности*. Для того чтобы их *сгладить*, мы применяем дополнительное сглаживание к исследуемому контуру (а не ко всему изображению, чтобы не «замылить» перешейки между контурами, и не нарушить исходную топологию).
*Рисунок 4. Вычисление дефекта выпуклости*
*Вариант(а)* ошибочно определяет красную концевую точку. *Вариант(б)* правильно определяет концевые точки. *Вариант(в)* переопределяет концевые точки на исходной фигуре.
Так как в принятой нами технологии контур каждый раз *регенерируется*, приходится заново искать точки соответствия (вернее их индексы) процедурой *полного перебора*:
```
nearestContourPtIdx(const vector &contour, const Point& pt);
```
Для случаев, когда от особенностей не удается полностью избавиться, был так же реализован дополнительный режим разделения дуг(работа отдельно с внутренней/внешней дугой). Это важно например в тех случаях, когда внешняя дуга контура *соприкасается* с другими объектами или *зашумлена*. В таком случае, можно перейти на работу с внутренней дугой. В рассматриваемом случае обрабатывать отдельно внешнюю и внутреннюю дуги не нужно.
Так же, по известной формуле о соотношении *выпуклости дуги* приблизительно оценивается *радиус* окружности и слишком большие эллипсы отбраковываются:
```
R = bulge / 2 + SQR(hypot) / (8 * bulge);
```
Таким образом, для всех контуров найдена их *метрика дефекта выпуклости* (или они классифицированы как линейные или малые и выведены из процедуры). На последнем этапе, к исходной метрике добавляются дополнительные параметры, такие как параметр повернутого габарита и др. и полный набор исследуемых метрик *упорядочивается размеру*.
```
typedef tuple //тип контура
RectDefMetric;
```
#### Алгоритм связывания сегментов дуг по конечным точкам
Ростовой алгоритм является наглядным и очевидным: берем самый большой контур в качестве *затравки* и пытаемся ее растить, то есть найти и присоединить к ее концевым точкам ближайшие патчи, удовлетворяющие условиям роста. В выращенную фигуру вписываем *искомую эллиптическую дугу*. Маскируем и *вычитаем* фигуру из исходного набора. Повторяем ростовую процедуру пока исходное множество не иссякнет.
Основная процедура ростового алгоритма выглядит так:
```
vector \*patch =
growingContours(contour, def, tmp, hull);
```
где *contour* — исследуемый контур, *def* — его дефект выпуклости, *hull* — выпуклый многоугольник всего региона, *tmp* — вспомогательная буферная матрица. На выходе получаем векторный выращенный контур.
Процедура состоит из цикла попыток роста затравки, заканчивающихся либо исчерпанием доступных патчей для роста, либо ограничена *параметром максимального числа итераций*.
*Рисунок 5. Множество патчей для роста без затравки*
Главная сложность — выбрать *ближайшие патчи* к концевым точкам контура, такие чтобы фигура росла только *вперед*. За *тангенциальное направление* примем усредненную прямую, принадлежащую дуге, в окрестности концевой точки. На *Рисунке 6* показаны кандидаты для присоединения к затравке на некоторой итерации.
*Рисунок 6. Затравка, окруженная множеством ростовых патчей-кандидатов*
Для каждого патча-кандидата вычисляется следующая метрика:
```
typedef tuple<
double, //расстояние от одной из 2х точек роста до одного из 2х концов патча
bool, bool, //флаги, определяющие 4 перестановочные комбинации
int, //индекс патча
Vec4i> //его дефект выпуклости
DistMetric;
```
Учитываются только патчи, попавшие в *тангенциальный конус*. Затем выбирается патч с наименьшим расстоянием и, путем впечатывания в растр соединительного отрезка, *соединяется* с соответствующим концом затравки. Для другого конца затравки производится поиск подходящего по параметрам патча, и если найден, тоже соединяется с затравкой. Затем затравка *маскируется и вычитается* из множества патчей. Процедура повторяется с самого начала.
По окончании ростовой процедуры, мы получили *эллиптическую дугу*, которую предстоит верифицировать.
Для начала, используя стандартну *OpenCV* процедуру, которая получает наш патч (в виде контура, мы помним, что контур и растр у нас взаимозаменяемы) и возвращает *повернутый габарит*, то есть полный эллипс.
```
RotatedRect box = fitEllipse(patch);
```
Затем, забракуем слишком большие и слишком маленькие эллипсы, а потом применим нашу оригинальную процедуру *сравнения площадей* полученной эллиптической дуги и исходного ростового патча в *растровом виде*. Эта процедура включает в себя некоторые трюки с маскировкой, поэтому ее описание пока опустим.
И наконец, найдем оставшиеся параметры детектированного эллипса — *начальный и конечный угол* (полуоси мы уже знаем из *fitEllipse*).
Для определения начального и конечного угла поступим следующим образом: преобразуем наш полный эллипс, *обратно в полигон* и прямым перебором найдем его ближайшие к нашим концам точки. Их *угловые координаты*(фактически, индексы) и будут начальным и конечным углами эллиптической дуги. В коде это выглядит так (немного упростив):
```
pair
ellipseAngles(const RotatedRect &box,
vector ℓ, const Point &ps,
const Point &pe, const Point ±)
{
vector ell0;
ellipse2Poly(Point(box.center.x, box.center.y),
Size(box.size.width / 2, box.size.height / 2),
box.angle, 0, 355, 5, ell0);
int i0 = nearestContourPtIdx(ell0, ps);
int i1 = nearestContourPtIdx(ell0, pe);
cutSides(ell0, i0, i1, i2, ell, nullptr);
return pair(i0, i1);
}
```
Наша процедура *cutSides* учитывает *топологию* обхода эллиптической дуги. Всего надо рассмотреть восемь возможных случаев обхода индексов *i0, i1, i2*. Идем ли мы по внешнему контуру или по внутреннему и какой из индексов больше, начальный или конечный?
Легче посмотреть код:
```
void cutSides(
const vector &ell0, int i0, int i1, int i2,
vector \*ell\_in, vector \*ell\_out)
{
if (i0 < i1) {
if (i2 > i0 && i2 < i1) {
if (ell\_in) {...}
if (ell\_out) {...}
} else {
if (ell\_in) {...}
if (ell\_out) {...}
}}
else {
if (i2 > i1 && i2 < i0) {
if (ell\_in) {...}
if (ell\_out) {...}
} else {
if (ell\_in) {...}
if (ell\_out) {...}
}}}
```
Некоторые результаты детектирования эллипсов в сложных случаях, показаны на *Рисунке 7*.
В следующих статьях рассмотрим статистические методы детектирования. | https://habr.com/ru/post/490400/ | null | ru | null |
# Когда в gcc 16-битные адреса, а памяти внезапно 256к
### … или как выстрелить себе в ногу на Arduino
В летней компьютерной школе мы используем для обучения разработке игр [собственноручно сделанный старый компьютер](https://habr.com/post/336632/).
Сейчас в нём установлена плата Arduino Mega с процессором ATmega2560, в котором целых 256 килобайт флеш-памяти. Предполагалось, что этого хватит очень надолго, ведь игры получаются простые (экран-то всего лишь 64x64 пикселя). В реальности мы столкнулись с некоторыми проблемами уже по достижении прошивкой размера примерно 128 килобайт.
В памяти программ, несмотря на её название, кроме исполняемого кода игр хранятся всякие неизменные данные типа спрайтов и таблиц уровней. Этих данных не так уж и много.
Но когда мы [подключили к нашему компьютеру звуковой чип YM2149F](https://habr.com/post/335508/), и загрузили пару десятков мелодий в ту же программную память, начались проблемы.
Приставка зависала при попытке проиграть мелодию, либо рисовала какой-то мусор в меню игры. Непонятно было как это вообще отлаживать, ведь процессор не только занимается логикой игры, но и выводит изображение и звук. В итоге оказалось, что компилятор gcc-avr использует для хранения указателей переменные размером в два байта. Но адресовать 256 килобайт всего двумя байтами невозможно! Как же он выкручивается?
### Указатели на код
Во-первых, инструкции вызова функций и переходы могут использовать трёхбайтовые адреса. Поэтому линкеру достаточно подставить полный адрес в такую инструкцию и всё заработает. Если же адрес функции передаётся через указатель, то такой номер не пройдёт — ведь указатель-то у нас двухбайтовый.
В такой ситуации gcc вставляет в нижних 64кб «трамплин» — инструкцию jmp, которая переходит на нужную функцию. Тогда в качестве адреса функции, который надо хранить в переменной, будет выступать адрес этого трамплина — ведь он же помещается в два байта. А при вызове будет происходить переход куда надо.
### Указатели на данные
Но мы-то храним в памяти программ не только исполняемый код. А значит трамплины здесь не помогут — мы разыменовываем указатели, а не переходим на них.
В библиотеке AVR даже есть функции/макросы типа pgm\_read\_byte\_far(addr), чтобы разыменовать полный указатель (им передаются четырёхбайтовые значения). Но gcc не умеет добывать эти указатели средствами языка Си.
К счастью, есть макрос pgm\_get\_far\_address(var) для получения полного адреса переменной. Это делается с помощью встроенного ассемблера (тот случай, когда ассемблер умнее компилятора).
Осталось переписать весь код, который использует данные в ПЗУ. То есть музыкальный проигрыватель, отрисовку спрайтов, вывод текста,… Не очень приятное занятие. Да ещё и код станет более тормозным, а для вывода графики это очень критично. Поэтому,
### Распределяем данные по ПЗУ
Линкер очень старается разместить данные для программной памяти в нижних 64к. Это не срабатывает, если данных слишком много. Но ведь самые большие данные у нас — это музыкальные файлы. А значит если убрать только их, то всё остальное влезет в нижнюю память и основную часть кода переделывать не придётся.
Для этого будем эксплуатировать особенности линкерного скрипта. Одна из последних секций, которые линкер размещает в ПЗУ, называется .fini7. Сохраним все массивы с музыкой в этой секции:
```
#define MUSICMEM __attribute__((section(".fini7")))
const uint8_t tetris2[] MUSICMEM = { ... };
```
Теперь avr-nm говорит нам, что всё в порядке — данные со спрайтами и уровнями оказались в нижней части ПЗУ, а музыка в верхней.
```
00002f9c t _ZL10level_menu
00002e0f t _ZL10rope_lines
000006de t _ZL10ShipSprite
00023a09 t tetris2
00024714 T the_last_v8
```
Остаётся переделать проигрыватель на использование четырёхбайтовых указателей и вместо указателя на массив с кодом мелодии использовать функцию для получения её адреса. Функции нужны, потому что у нас есть приложение-проигрыватель, где можно слушать все мелодии по выбору. В нём теперь хранятся указатели на функции подобного вида:
```
00006992 <_Z12tetris2_addrv>:
6992: 61 ef ldi r22, 0xF1 ; 241
6994: 7a e3 ldi r23, 0x3A ; 58
6996: 82 e0 ldi r24, 0x02 ; 2
6998: 99 27 eor r25, r25
699a: 08 95 ret
```
Конец света откладывается до момента, когда спрайты забьют нижние 64к. Это маловероятно, потому что кода всё-таки больше, чем спрайтов, а значит скорее закончится память вообще.
Бонус
-----
Этим летом мы написали игру в стиле Сокобана. Некоторые уровни получились довольно сложными. Попробуйте, к примеру, пройти вот этот:
Ссылки
------
1. [Страница проекта на github](https://github.com/CSchool/Gamebox)
2. [Arduino и светодиодный дисплей](https://habr.com/post/403231/)
3. [Arduino и ~~философский~~ музыкальный камень](https://habr.com/post/335508/)
4. [Немного прошлогодних игр](https://habr.com/post/336632/) | https://habr.com/ru/post/421601/ | null | ru | null |
# Сказ о том, как я настраивал Azure AD B2C на React и React Native Часть 4 (Туториал)
### Предисловие
Продолжение цикла по работе с Azure B2C. В данной статье я расскажу о том, как подключить аутентификацию на React Native.
**Ссылки на связанные посты**
* [Часть 1: Создание и настройка приложений на Azure AD B2C](https://habr.com/ru/post/503890/)
* [Часть 2: Работа с Identity Framework Experience](https://habr.com/ru/post/504030/)
* [Часть 3: Подключение приложения React](https://habr.com/ru/post/504690/)
* Часть 4: Подключение приложения React Native
* [Часть 5: Подключение и настройка бэкэнда на .NET Core 3](https://habr.com/ru/post/505978/)
ШАГ 1
-----
Необходимо установить [react-native-app-auth](https://www.npmjs.com/package/react-native-app-auth) **(npm i react-native-app-auth)**.
ШАГ 2
-----
Открыть в Azure AD B2C ваше приложение. Во вкладке **«Проверка подлинности»** — нажать **«Добавить платформу»**.
Необходимо выбрать **Android** и **iOS**.
[](https://habrastorage.org/webt/pv/uy/zf/pvuyzf7p-aagmalxcsgzrcpmmz8.png)
После того, как вы создатие обе платформы вы полчите примерно такие данные:
[](https://habrastorage.org/webt/gv/bm/vm/gvbmvmu6b_gbjzktbg0ykaq-1_4.png)
ШАГ 3
-----
Создать файл **auth-provider.js** в папке **./src**
```
import { authorize, revoke, refresh } from 'react-native-app-auth';
const config = (page) => ({
// Найти issuer можно во вкладке "Обзор". Для этого нажмите кнопку "Конечные точки".
// Также необходимо добавить "tfp" как показано в примере ниже.
// В качестве параметра передаем нужную политику.
issuer: `https://myapp.b2clogin.com/tfp/mycompany.onmicrosoft.com/${pages[page]}`,
// ClientID вашего приложения Azure AD B2C
clientId: '777aaa77a-7a77-7777-bb77-8888888aabc',
scopes: ['openid'], // Обязательно укажите openid
// Нужно для того, чтобы при повторной авторизации, пользователь мог
// снова выбрать способ авторизации (Google, Facebook и т.д.)
additionalParameters: { prompt: 'login' },
// URI перенаправления (Android)
redirectUrl: 'msauth://com.myapp/asdasd%o293o4iro21342/',
});
const logOutConfig = {
clientId: '777aaa77a-7a77-7777-bb77-8888888aabc',
serviceConfiguration: {
revocationEndpoint:
'https://mycompany.b2clogin.com/mycompany.onmicrosoft.com/B2C_1A_SignIn/oauth2/v2.0/logout',
},
};
// Используем отдельную политику для каждого действия
const pages = {
signIn: 'B2C_1A_SignIn',
signUp: 'B2C_1A_SignUp',
resetPassword: 'B2C_1A_PasswordReset',
};
// Функция для получения данных с Azure.
const getAzureData = async (page) => {
try {
const data = await authorize(config(page));
return data;
} catch (e) {
requestErrorHandler(e, 'azure authorize error');
}
};
export const signIn = () => async (dispatch) => {
const authMethod = 'signIn';
try {
const data = await getAzureData(authMethod);
dispatch(userRegistration(data, authMethod));
} catch (e) {
requestErrorHandler(e, 'sign in error');
}
};
export const azureLogOut = () => async (dispatch, getState) => {
const { refreshToken } = getState().Authentication;
try {
await revoke(logOutConfig, {
tokenToRevoke: refreshToken,
sendClientId: true,
});
dispatch(authActions.logOut());
} catch (e) {
console.warn(e);
}
};
```
**Где брать названия политик вы можете увидеть на скриншоте**
[](https://habrastorage.org/webt/-d/bv/nb/-dbvnbzig1vatibisepcb9ekdxq.png)
ШАГ 4
-----
Теперь нужно внести небольшие изменения в следующие файлы:
**/android/app/build.gradle**
```
defaultConfig {
manifestPlaceholders = [
appAuthRedirectScheme: 'msauth'
]
...
}
```
**/ios/yourApp/Info.plist**
```
CFBundleURLTypes
...
CFBundleURLName
com.yourApp
CFBundleURLSchemes
msauth.com.yourApp
```
ШАГ 5
-----
Теперь нам необходимо сохранить токен, что бы не просить пользователя авторизоваться каждый раз когда он открывает ваше приложение. Для этого необходимо скачать **[redux-persist-sensitive-storage](https://www.npmjs.com/package/redux-persist-sensitive-storage)**.
(npm i redux-persist-sensitive-storage).
>
> ```
> import { compose, applyMiddleware, createStore } from "redux";
> import { persistStore, persistCombineReducers } from "redux-persist";
> import createSensitiveStorage from "redux-persist-sensitive-storage";
> import reducers from "./reducers"; // where reducers is an object of reducers
>
> const storage = createSensitiveStorage({
> keychainService: "myKeychain",
> sharedPreferencesName: "mySharedPrefs"
> });
>
> const config = {
> key: "root",
> storage,
> };
>
> const reducer = persistCombineReducers(config, reducers);
>
> function configureStore () {
> // ...
> let store = createStore(reducer);
> let persistor = persistStore(store);
>
> return { persistor, store };
> }
>
> ```
>
>
>
ШАГ 6
-----
Добавляем функции для обновления токена
```
export const autoSignIn = (params) => async (dispatch) => {
try {
const userData = await getRefreshedAzureUserData(params);
await dispatch(openApplication(userData, params.authMethod));
} catch (e) {
requestErrorHandler(e, 'auto sign in error');
}
};
export const getRefreshedAzureUserData = async ({ refreshToken, authMethod }) => {
try {
const result = await refresh(config(authMethod), { refreshToken });
return result;
} catch (e) {
requestErrorHandler(e, 'get refresh token error');
}
};
```
### Заключение
Вуаля. все готово! Теперь ваши пользователи смогут авторизовываться в вашем мобильном приложении.
Спасибо за внимание! | https://habr.com/ru/post/505408/ | null | ru | null |
# Пишем бот для рыбалки в игре Albion Online на языке Python
Всем привет, я являюсь счастливым пользователем операционной системы GNU/Linux.И как многим известно, игрушек идущих на линукс без дополнительных танцев с бубном намного меньше чем в «Винде».
И еще меньше игр в жанре MMORPG.
Однако, где-то пол года или год назад я узнал что под линукс портировали игру Albion Online.
Игра очень занимательная, однако занимает достаточно большое количество времени. И дабы не тратить свои драгоценные часы жизни по напрасну, я решил написать бота. Который будет фармить мне ресурсы, пока я буду заниматься своими делами.
В игре есть много видов ремесла, можно рубить лес, камни копать, даже выращивать огороды, однако мой выбор был сделан в пользу рыбалки.
Итак, суть рыбалки в альбион онлайн проста, берете удочку, подходите к водоему, зажимаете кнопку, дабы закинуть наживку, ждете в течении определённого времени поклевки.
Когда клюет, вы должны опять нажать на кнопки и сыграть в мини-игру.
Тут потребуется попеременно то тянуть, то не тянуть удочку, в зависимости от движений поплавка. Поплавок движется всегда случайно, с разными последовательностями и скоростями. И если вы все сделаете верно и поплавок не выйдет за пределы допустимой зоны, то вы выловите рыбу.
Итак, все это дело мы будем автоматизировать. По средствам компьютерного языка python. Начать я решил с самого сложного, а именно с момента, где начинается игра с поплавком. Тут снова мне на выручку пришла моя любимая библиотека с компьютерным зрением [OpenCV](https://opencv.org/). Запустив ее мы можем обнаруживать объекты к примеру на картинках. Однако сама библиотека не знает что именно нам нужно обнаружить. Конечно существуют множество шаблонов где представлены различные предметы для их определения. Однако, там точно нет поплавков для Albion Online.
Зато в данной библиотеке есть замечательная функция поиска по заданному шаблону. И в качестве шаблона я просто взял скриншот нашего поплавка.
И как мы видим все прекрасно нашлось на картинке.
А разница между картинкой и потоковым видео не велика, ведь по сути это просто поток картинок с очень быстрой скоростью, и несколько строчек кода. И вот мы уже можем находить поплавок на потоковом видео.
**Код**
```
import numpy as np
import cv2
from mss.linux import MSS as mss
from PIL import Image
import time
import pyautogui as pg
import cv2
import mss
import numpy
template = cv2.imread("2019-07-02_06-55_1.png", cv2.IMREAD_GRAYSCALE)
w, h = template.shape[::-1]
with mss.mss() as sct:
monitor = {"top": 40, "left": 0, "width": 800, "height": 640}
while "Screen capturing":
last_time = time.time()
img = numpy.array(sct.grab(monitor))
cv2.imshow("OpenCV/Numpy normal", img)
print("fps: {}".format(1 / (time.time() - last_time)))
gray_frame = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
res = cv2.matchTemplate(gray_frame, template, cv2.TM_CCOEFF_NORMED)
loc = np.where(res >= 0.7)
for pt in zip(*loc[::-1]):
cv2.rectangle(img, pt, (pt[0] + w, pt[1] + h), (0, 255, 0), 3)
cv2.imshow("Frame", img)
key = cv2.waitKey(1)
if cv2.waitKey(25) & 0xFF == ord("q"):
cv2.destroyAllWindows()
break
```
Идем далее. Сам поплавок двигается туда-сюда и мы также должны его двигать, нажимая кнопку на мышке.
А посему, нам нужны его координаты. И для этого нас выручают вот эти строчки.
```
for p in img:
pts = (pt[0],pt[1])
x = (pt[0])
y = (pt[1])
print (x)
cv2.circle(template,pts,5,(200,0,0),2)
cv2.putText(img, "%d-%d" % (x,y), (x+10,y-10),
cv2.FONT_HERSHEY_SIMPLEX, 1, color_yellow, 2)
```
Затем мы просто воспользуемся библиотекой [PyAutoGUI](https://pypi.org/project/PyAutoGUI/), которая будет зажимать кнопку мыши и отжимать ее с определенной периодичностью.
```
if 100 < x < 500:
pyautogui.mouseDown(button='left')
time.sleep(1)
pyautogui.mouseUp(button='left')
x = 0
```
И сама мини игра успешно выигрывается.
Засунем все это дело в функцию и пока оставим.
Затем вернемся к изначальной части, где мы должны следить за поплавком.
Тут все несколько иначе, допустим мы можем определить, куда закинется поплавок, и попробовать анализировать ту часть экрана на наличие поплавка. Однако поплавок закинутый в воду предстает под разными углами и постоянно колышется.
В таком случае мы возьмём тот несколько иной метод. Суть его в том, что мы анализируем, скажем так разницу в пикселях внутри отслеживаемого фрагмента. Которая, если поплавка нет приближается к нулю.
В итоге было найдено оптимальное значение при котором при исчезновении поплавка, мы можем производить действия.
**Код**
```
def screen_record():
sct = mss.mss()
last_time = time.time()
while(True):
img = sct.grab(mon)
print('loop took {} seconds'.format(time.time() - last_time))
last_time = time.time()
img = np.array(img)
processed_image = process_image(img)
mean = np.mean(processed_image)
print('mean = ', mean)
if mean <= float(0.11):
print('SSSSSSSS ')
pyautogui.click(button='left')
break
return
else:
time.sleep(0.01)
continue
return
if cv2.waitKey(25) & 0xFF == ord('q'):
cv2.destroyAllWindows()
break
```
И мы их производим, а именно нажимаем на кнопку мыши. Также засовываем это в функцию.
Ну и наконец в заключении мы просто записываем скрипт где в бесконечном цикле мы забрасываем удочку и выполняем попеременно первую и вторую функцию.
```
while "Черный":
time.sleep(1)
pyautogui.moveTo(431,175,duration=1)
pyautogui.mouseDown(button='left')
pyautogui.moveTo(450.200,duration=1)
pyautogui.mouseUp(button='left')
time.sleep(2)
screen_record()
time.sleep(0.01)
ss()
```
Вот полная видео инструкция и пример работы данного бота:
Есть правда некоторые нюансы в том что там надо шаманить с цифрами, так как эти цифры подобраны под мой монитор, локацию, персонажа и экипировку. Но я думаю для грамотного питониста это не составит проблем.
Весь скрипт:
**Код**
```
import numpy as np
import cv2
from mss.linux import MSS as mss
from PIL import Image
import time
import pyautogui as pg
import imutils
import mss
import numpy
import pyautogui
template = cv2.imread("2019-07-02_06-55_1.png", cv2.IMREAD_GRAYSCALE)
w, h = template.shape[::-1]
color_yellow = (0,255,255)
mon = {'top': 80, 'left': 350, 'width': 100, 'height': 100}
def process_image(original_image):
processed_image = cv2.cvtColor(original_image, cv2.COLOR_BGR2GRAY)
processed_image = cv2.Canny(processed_image, threshold1=200, threshold2=300)
return processed_image
def ss():
op = 1
with mss.mss() as sct:
monitor = {"top": 40, "left": 0, "width": 800, "height": 640}
while "Screen capturing":
last_time = time.time()
img = numpy.array(sct.grab(monitor))
gray_frame = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
res = cv2.matchTemplate(gray_frame, template, cv2.TM_CCOEFF_NORMED)
loc = np.where(res >= 0.7)
op += 1
print (op)
for pt in zip(*loc[::-1]):
cv2.rectangle(img, pt, (pt[0] + w, pt[1] + h), (0, 255, 0), 3)
for p in img:
pts = (pt[0],pt[1])
x = (pt[0])
y = (pt[1])
print (x)
if 100 < x < 490:
pyautogui.mouseDown(button='left')
time.sleep(2)
pyautogui.mouseUp(button='left')
x = 0
break
else:
continue
break
else:
continue
break
key = cv2.waitKey(1)
if cv2.waitKey(25) & 0xFF == ord("q"):
cv2.destroyAllWindows()
if op > 35:
return
def screen_record():
sct = mss.mss()
last_time = time.time()
while(True):
img = sct.grab(mon)
print('loop took {} seconds'.format(time.time() - last_time))
last_time = time.time()
img = np.array(img)
processed_image = process_image(img)
mean = np.mean(processed_image)
print('mean = ', mean)
if mean <= float(0.11):
print('SSSSSSSS ')
pyautogui.click(button='left')
break
return
else:
time.sleep(0.01)
continue
return
if cv2.waitKey(25) & 0xFF == ord('q'):
cv2.destroyAllWindows()
break
while "Черный":
time.sleep(1)
pyautogui.moveTo(431,175,duration=1)
pyautogui.mouseDown(button='left')
pyautogui.moveTo(450.200,duration=1)
pyautogui.mouseUp(button='left')
time.sleep(2)
screen_record()
time.sleep(0.01)
ss()
```
Те кто любит сказать, что это бесполезная трата времени, я замечу, что это лишь инструмент, эти библиотеки вы можете применить и в других проектах. Само компьютерное зрение применяется как при наведении баллистических ракет, так и в программах для помощи инвалидам. Куда вы решите их применить, только ваше желание.
Всем спасибо за внимание. | https://habr.com/ru/post/459110/ | null | ru | null |
# Трансляция h264 видео без перекодирования и задержки
Не секрет, что при управлении летательными аппаратами часто используется передача видео с самого аппарата на землю. Обычно такую возможность предоставляют производители самих БПЛА. Однако что же делать, если дрон собран своими руками?
Перед нами и нашими швейцарскими партнёрами из компании Helvetis встала задача транслировать видео в режиме реального времени с web-камеры с маломощного embedded-устройства на дроне по WiFi на Windows-планшет. В идеале бы нам хотелось:
* задержку < 0.3с;
* низкую загрузку CPU на embedded-системе (меньше 10% на одно ядро);
* разрешение хотя бы 480p (лучше 720p).
Казалось бы, что может пойти не так?
Итак, мы остановились на следующем списке оборудования:
* Minnowboard 2-core, Atom E3826 @ 1.4 GHz, ОС: Ubuntu 16.04
* Web-камера ELP USB100W04H, поддерживающая несколько форматов (YUV, MJPEG, H264)
* Windows-планшет ASUS VivoTab Note 8
Попытки обойтись стандартными решениями
=======================================
### Простое решение с Python+OpenCV
Сначала мы попробовали использовать [простой Python-скрипт](http://www.chioka.in/python-live-video-streaming-example/), который с помощью OpenCV получал кадры с камеры, сжимал их, используя JPEG, и отдавал по HTTP приложению-клиенту.
**Http mjpg стриминг на python**
```
from flask import Flask, render_template, Response
import cv2
class VideoCamera(object):
def __init__(self):
self.video = cv2.VideoCapture(0)
def __del__(self):
self.video.release()
def get_frame(self):
success, image = self.video.read()
ret, jpeg = cv2.imencode('.jpg', image)
return jpeg.tobytes()
app = Flask(__name__)
@app.route('/')
def index():
return render_template('index.html')
def gen(camera):
while True:
frame = camera.get_frame()
yield (b'--frame\r\n'
b'Content-Type: image/jpeg\r\n\r\n' + frame + b'\r\n\r\n')
@app.route('/video_feed')
def video_feed():
return Response(gen(VideoCamera()),
mimetype='multipart/x-mixed-replace; boundary=frame')
if __name__ == '__main__':
app.run(host='0.0.0.0', debug=True)
```
Этот подход оказался (почти) работающим. В качестве приложения для просмотра можно было использовать любой web-браузер. Однако мы сразу заметили, что частота кадров была ниже ожидаемой, а уровень загрузки CPU на Minnowboard был постоянно на уровне 100%. Embedded-устройство просто не справлялось с кодированием кадров в режиме реального времени. Из плюсов данного решения стоит отметить очень небольшую задержку при передаче 480p видео с частотой не более 10 кадров в секунду.
В ходе обыска была обнаружена web-камера, которая помимо несжатых YUV-кадров могла выдавать кадры в формате MJPEG. Было решено воспользоваться такой полезной функцией, чтобы уменьшить нагрузку на CPU и найти способ передать видео без перекодирования.
### FFmpeg / VLC
Первым делом мы попробовали всеми любимый open-source комбайн ffmpeg, позволяющий, среди прочего, считывать видео-поток с UVC-устройства, кодировать его и передавать. После небольшого погружения в мануал были найдены ключи командной строки, которые позволяли получить и передать сжатый MJPEG видеопоток без перекодирования.
```
ffmpeg -f v4l2 -s 640x480 -input_format mjpeg -i /dev/video0 -c:v copy -f mjpeg udp://ip:port
```
Уровень загрузки CPU был невысок. Обрадовавшись, мы с нетерпением открыли поток в плеере ffplay… К нашему разочарованию, уровень задержки видео был абсолютно неприемлемым (около 2 — 3 секунд). Попробовав все [отсюда](https://trac.ffmpeg.org/wiki/StreamingGuide) и прошерстив Интернет, мы так и не смогли добиться положительного результата и решили отказаться от ffmpeg.
После провала с ffmpeg пришла очередь медиаплеера VLC, а точнее консольной утилиты cvlc. VLC по умолчанию использует кучу всяких буферов, которые с одной стороны помогают добиться плавности изображения, но с другой дают серьезную задержку в несколько секунд. Изрядно помучавшись, мы подобрали параметры, с которыми стриминг выглядел достаточно сносно, т.е. задержка была не очень большой (около 0.5 с), не было перекодирования, и клиент показывал видео достаточно плавно (пришлось, правда, на клиенте оставить небольшой буфер в 150 мс).
Так выглядит итоговая строка для cvlc:
```
cvlc -v v4l2:///dev/video0:chroma="MJPG":width=640:height=480:fps=30 --sout="#rtp{sdp=rtsp://:port/live,caching=0}" --rtsp-timeout=-1 --sout-udp-caching=0 --network-caching=0 --live-caching=0
```
К сожалению, видео работало не вполне стабильно, да и задержка в 0.5 с была для нас неприемлема.
### Mjpg-streamer
Наткнувшись на [статью](http://petrkout.com/electronics/low-latency-0-4-s-video-streaming-from-raspberry-pi-mjpeg-streamer-opencv/) о практически нашей задаче, решили попробовать mjpg-streamer. Попробовали, понравилось! Абсолютно без изменений получилось использовать mjpg-streamer для наших нужд без существенной задержки видео на разрешении 480p.
На фоне предыдущих неудач мы довольно долго были счастливы, но потом мы захотели большего. А именно: чуть меньше забивать канал и повысить качество видео до 720p.
H264 стриминг
=============
Чтобы уменьшить загрузку канала, мы решили поменять используемый кодек на h264 (найдя в наших запасах подходящую web-камеру). Mjpg-streamer не имел поддержки h264, так что было решено его доработать. Во время разработки мы использовали две камеры со встроенным кодеком h264, производства Logitech и ELP. Как оказалось, содержимое потока h264 у этих камер существенно различалось.
### Камеры и структура потока
Поток h264 состоит из пакетов NAL (network abstraction layer) нескольких типов. Наши камеры генерировали 5 типов пакетов:
* Picture parameter set (PPS)
* Sequence parameter set (SPS)
* Coded slice layer without partitioning, IDR picture
* Coded slice layer without partitioning, non-IDR picture
* Coded slice data partition
IDR (Instantaneous decoding refresh) — пакет, содержащий кодированное изображение. При этом все необходимые данные для декодирования изображения находятся в этом пакете. Этот пакет необходим декодеру, чтобы начать формировать изображение. Обычно первый кадр любого видео сжатого h264 — IDR picture.
Non-IDR — пакет, содержащий кодированное изображение, содержащее ссылки на другие кадры. Декодер не в состоянии восстановить изображение по одному Non-IDR кадру без наличия других пакетов.
Помимо IDR-кадра, декодеру нужны пакеты PPS и SPS для декодирования изображения. Эти пакеты содержат метаданные об изображении и потоке кадров.
Основываясь на коде mjpg-streamer, мы воспользовались API V4L2 (video4linux2) для считывания данных от камер. Как выяснилось, один “кадр” видео содержал несколько NAL пакетов.
Именно в содержимом “кадров” обнаружилось существенное различие между камерами. Мы воспользовались библиотекой [h264bitstream](https://github.com/aizvorski/h264bitstream) для парсинга потока. Существуют [standalone-утилиты](https://github.com/shi-yan/H264Naked), позволяющие просмотреть содержимое потока.
Поток кадров камеры Logitech состоял в основном из non-IDR кадров, к тому же разделенных на несколько data partition. Раз в 30 секунд камера генерировала пакет, содержащий IDR picture, SPS и PPS. Так как декодеру нужен IDR пакет для того, чтобы начать декодировать видео, нас эта ситуация сразу не устроила. К нашему сожалению, оказалось, что нет адекватного способа установить период, с которым камера генерирует IDR пакеты. Поэтому нам пришлось отказаться от использования этой камеры.
Камера производства ELP оказалась существенно удобнее. Каждый получаемый нами кадр содержал в себе пакеты PPS и SPS. К тому же, камера генерировала IDR пакет раз в 30 кадров (период ~1с). Это нас вполне устраивало и мы остановили свой выбор на этой камере.
### Реализация сервера вещания на основе mjpg-streamer
За основу серверной части решено было взять вышеупомянутый mjpg-streamer. Его архитектура позволяла легко добавлять новые плагины ввода и вывода. Мы начали с добавления плагина для считывания потока h264 с устройства. В качестве плагина вывода выбрали уже имеющийся плагин http.
В V4L2 достаточно было указать что мы хотим получать кадры в формате V4L2\_PIX\_FMT\_H264, чтобы начать получать поток h264.Так как для декодирования потока необходим IDR-кадр, мы парсили поток и ожидали IDR-кадр. Приложению-клиенту поток отправлялся по HTTP начиная с этого кадра.
На клиентской части решили воспользоваться libavformat и libavcodec из проекта ffmpeg для чтения и декодирования потока h264. В первом тестовом прототипе получение потока по сети, разбиение его на кадры и декодирование было возложено на ffmpeg, конвертирование получаемого декодированного изображения из формата NV12 в RGB и отображение было реализовано на OpenCV.
Первые тесты показали, что данный способ транслирования видео работоспособен, но имеется существенная задержка (около 1 секунды). Наше подозрение пало на протокол http, поэтому было решено использовать для передачи пакетов UDP.
Так как у нас не было необходимости поддержки существующих протоколов вроде RTP, мы реализовали свой простейший ~~велосипед~~ протокол, в котором внутри UDP-датаграмм передавались NAL-пакеты потока h264. После небольшой доработки принимающей части мы были приятно удивлены малой задержкой видео на настольном ПК. Однако первые же тесты на мобильном устройстве показали, что программное декодирование h264 — не конёк мобильных процессоров. Планшет просто не успевал обрабатывать кадры в режиме реального времени.
Так как процессор Atom Z3740, используемый на нашем планшете, поддерживает технологию Quick Sync Video (QSV), мы попробовали использовать QSV h264 декодер из libavcodec. К нашему удивлению, он не только не улучшил ситуацию, но и увеличил задержку до 1.5 секунд даже на мощном настольном ПК! Однако этот подход действительно существенно снизил нагрузку на CPU.
Перепробовав различные варианты конфигурации декодера в ffmpeg, было решено отказаться от libavcodec и использовать [Intel Media SDK](https://software.intel.com/en-us/media-sdk) напрямую.
Первым сюрпризом для нас стал ужас, в который предлагается погрузиться человеку, решившему разрабатывать используя Media SDK. Официальный [пример](https://github.com/Intel-Media-SDK/samples), предлагаемый разработчикам, представляет из себя мощный комбайн, который умеет всё, но в котором трудно разобраться. К счастью, на [форумах Intel](https://software.intel.com/en-us/forums/intel-media-sdk) мы нашли единомышленников, также недовольных примером. Они нашли старые, но более легкоусвояемые [туториалы](https://software.intel.com/en-us/articles/media-sdk-tutorials-for-client-and-server). На основе пример simple\_2\_decode мы получили следующий код.
**Декодирование стрима при помощи Intel Media SDK**
```
mfxStatus sts = MFX_ERR_NONE;
// Буфер с содержимым потока h264
mfxBitstream mfx_bitstream;
memset(&mfx_bitstream, 0, sizeof(_mfxBS));
mfx_bitstream.MaxLength = 1 * 1024 * 1024; // 1MB
mfx_bitstream.Data = new mfxU8[mfx_bitstream.MaxLength];
// Реализация протокола на основе UDP
StreamReader *reader = new StreamReader(/*...*/);
MFXVideoDECODE *mfx_dec;
mfxVideoParam mfx_video_params;
MFXVideoSession session;
mfxFrameAllocator *mfx_allocator;
// Инициализация сессии MFX
mfxIMPL impl = MFX_IMPL_AUTO;
mfxVersion ver = { { 0, 1 } };
session.Init(sts, &ver);
if (sts < MFX_ERR_NONE)
return 0; // :(
// Создаем декодер, устанавливаем кодек AVC (h.264)
mfx_dec = new MFXVideoDECODE(session);
memset(&mfx_video_params, 0, sizeof(mfx_video_params));
mfx_video_params.mfx.CodecId = MFX_CODEC_AVC;
// Декодируем в системную память
mfx_video_params.IOPattern = MFX_IOPATTERN_OUT_SYSTEM_MEMORY;
// Устанавливаем глубину очереди в минимальное значение
mfx_video_params.AsyncDepth = 1;
// получаем метаинформацию о видео
reader->ReadToBitstream(&mfx_bitstream);
sts = mfx_dec->DecodeHeader(&mfx_bitstream, &mfx_video_params);
if (sts < MFX_ERR_NONE)
return 0; // :(
// Запросим информацию о размере кадров
mfxFrameAllocRequest request;
memset(&request, 0, sizeof(request));
sts = mfx_dec->QueryIOSurf(&mfx_video_params, &request);
if (sts < MFX_ERR_NONE)
return 0; // :(
mfxU16 numSurfaces = request.NumFrameSuggested;
// Для декодера необходимо чтобы ширина и высота были кратны 32
mfxU16 width = (mfxU16)MSDK_ALIGN32(request.Info.Width);
mfxU16 height = (mfxU16)MSDK_ALIGN32(request.Info.Height);
// NV12 - формат YUV 4:2:0, 12 бит на пиксель
mfxU8 bitsPerPixel = 12;
mfxU32 surfaceSize = width * height * bitsPerPixel / 8;
// Выделим память для поверхностей в которые будут декодироваться кадры
mfxU8* surfaceBuffers = new mfxU8[surfaceSize * numSurfaces];
// Метаинформация о поверхностях для декодера
mfxFrameSurface1** pmfxSurfaces =
new mfxFrameSurface1*[numSurfaces];
for(int i = 0; i < numSurfaces; i++)
{
pmfxSurfaces[i] = new mfxFrameSurface1;
memset(pmfxSurfaces[i], 0, sizeof(mfxFrameSurface1));
memcpy(&(pmfxSurfaces[i]->Info),
&(_mfxVideoParams.mfx.FrameInfo), sizeof(mfxFrameInfo));
pmfxSurfaces[i]->Data.Y = &surfaceBuffers[surfaceSize * i];
pmfxSurfaces[i]->Data.U =
pmfxSurfaces[i]->Data.Y + width * height;
pmfxSurfaces[i]->Data.V = pmfxSurfaces[i]->Data.U + 1;
pmfxSurfaces[i]->Data.Pitch = width;
}
sts = mfx_dec->Init(&mfx_video_params);
if (sts < MFX_ERR_NONE)
return 0; // :(
mfxSyncPoint syncp;
mfxFrameSurface1* pmfxOutSurface = NULL;
mfxU32 nFrame = 0;
// Начало декодирования потока
while (reader->IsActive() &&
(MFX_ERR_NONE <= sts
|| MFX_ERR_MORE_DATA == sts
|| MFX_ERR_MORE_SURFACE == sts))
{
// Ждем если устройство было занято
if (MFX_WRN_DEVICE_BUSY == sts)
Sleep(1);
if (MFX_ERR_MORE_DATA == sts)
reader->ReadToBitstream(mfx_bitstream);
if (MFX_ERR_MORE_SURFACE == sts || MFX_ERR_NONE == sts)
{
nIndex = GetFreeSurfaceIndex(pmfxSurfaces, numSurfaces);
if (nIndex == MFX_ERR_NOT_FOUND)
break;
}
// Декодирование кадра
// Декодер самостоятельно находит NAL-пакеты в потоке и забирает их
sts = mfx_dec->DecodeFrameAsync(mfx_bitstream,
pmfxSurfaces[nIndex], &pmfxOutSurface, &syncp);
// Игнорируем предупреждения
if (MFX_ERR_NONE < sts && syncp)
sts = MFX_ERR_NONE;
// Ожидаем окончания декодирования кадра
if (MFX_ERR_NONE == sts)
sts = session.SyncOperation(syncp, 60000);
if (MFX_ERR_NONE == sts)
{
// Кадр готов!
mfxFrameInfo* pInfo = &pmfxOutSurface->Info;
mfxFrameData* pData = &pmfxOutSurface->Data;
// Декодированный кадр имеет формат NV12
// плоскость Y: pData->Y, полное разрешение
// плоскость UV: pData-UV, разрешение в 2 раза ниже чем у Y
}
} // Конец цикла декодирования
```
После реализации декодирования видео при помощи Media SDK мы столкнулись с аналогичной ситуацией — задержка видео составила 1.5 секунды. Отчаявшись, мы обратились к форумам и нашли советы, которые должны были снизить задержку при декодировании видео.
Декодер h264 из состава Media SDK накапливает кадры прежде чем выдавать декодированное изображение. Было обнаружено, что если в структуре данных, передаваемых в декодер (mfxBitstream), установить флаг “конец потока”, то задержка снижается до ~0.5 секунд:
```
mfx_bitstream.DataFlag = MFX_BITSTREAM_EOS;
```
Далее экспериментальным путем было обнаружено, что декодер держит 5 кадров в очереди, даже если установлен флаг окончания потока. В итоге нам пришлось добавить код, который симулировал “окончательное окончание потока” и заставлял декодер выдавать кадры из этой очереди:
```
if( no_frames_in_queue )
sts = mfx_dec->DecodeFrameAsync(mfx_bitstream, pmfxSurfaces[nIndex],
&pmfxOutSurface, &syncp);
else
sts = mfx_dec->DecodeFrameAsync(0, pmfxSurfaces[nIndex], &pmfxOutSurface, &syncp);
if (sts == MFX_ERR_MORE_DATA)
{
no_frames_in_queue = true;
}
```
После этого уровень задержки опустился до приемлемого, т.е. незаметного взглядом.
Выводы
======
Приступая к задаче трансляции видео в режиме реального времени, мы очень рассчитывали использовать существующие решения и обойтись без своих велосипедов.
Нашей главной надеждой были такие гиганты работы с видео, как FFmpeg и VLC. Несмотря на то, что вроде бы они умеют делать то, что нам надо (передавать видео без перекодирования), нам не удалось убрать получающуюся при передаче видео задержку.
Практически случайно наткнувшись на проект mjpg-streamer, мы были очарованы его простотой и четкой работой в деле трансляции видео в формате MJPG. Если вам вдруг понадобится передавать именно этот формат, то мы категорически рекомендуем его использовать. Неслучайно, что именно на его основе мы и реализовали свое решение.
В результате разработки мы получили достаточно легковесное решение для передачи видео без задержки, не требовательное к ресурсам ни передающей, ни принимающей стороны. В задаче декодирования видео нам сильно помогла библиотека Intel Media SDK, пусть и пришлось применить немного силы, чтобы заставить отдавать ее кадры без буферизации. | https://habr.com/ru/post/343362/ | null | ru | null |
# Почему я ненавижу YouTube*
###### \*Желтый заголовок, не обращайте внимания. На самом деле название поста «Почему я не люблю смотреть длинные видео, когда можно сказать тоже самое в двух словах», но он бы был не таким привлекательным.
Я не против YouTube, как и не против всех других видео-хостингов(наверное, исключая vimeo, которое отвратительно воспроизводится на мобильных устройствах и старых браузерах.). Они позволили очень быстро и легко делиться видео(помните, эти ужасные ссылки на сайтах «скачать видео-ролик, avi, 5.4mb»?), что, несомненно, плюс.
Конечно, в НЕКОТОРЫХ случаях без видео не обойтись.
Но вот что мне категорически не нравится — видео-обзоры, и большинство видео-инструкций.
Сейчас я играюсь с планшетом Ramos W6HD, и в числе прочих, ставил [прошивку](http://www.librehat.co.cc/2012/03/keep-updating-ics-hatmod-for-ramos-w6hd.html), собранную одним из энтузиастов. Позволю себе привести пример с этой страницы.
Как прошить планшет, видео-инструкция.
2 минуты времени. Планшет, лежащий на столе, карточка, которую вставляют в планшет, потом его прислоняют к банке с салфетками, чтоб можно было поставить фотоаппарат напротив. Потом надо нажать две кнопки одной рукой — вторая занята фотоаппаратом, предварительно потыкав пальцем в кнопки. Надписи на них можно разглядеть, только открыв видео на весь экран — проигрыватель на сайте зело маленький. Кнопки надо держать, поэтому рука закрывает половину экрана. Теперь смотрим на процесс прошивки — как полоска бежит по экрану. Смотрим, смотрим, смотрим, смотрим… Ура, закончилось. Теперь смотрим на процесс загрузки. Все довершает музыка.
Как прошить планшет, текстовая инструкция.
`Depress the 7z file, put all extracted files into SDcard.
Then, press the M button and Power button to flash it.`
Распакуйте, скопируйте на карточку, выключите планшет, и нажмите одновременно M+Power.
Две строчки! Две строчки, которые я прочитаю за пару секунд, вместо двух минут моей жизни!
А теперь серьезно. Почему я предпочитаю текст видео?
1) Внимание. Чтоб смотреть видео, необходимо все внимание уделять ролику. Особенно если со звуком. Чуть повернешься в сторону — и все, «что это он сейчас сделал?!» и ищи то время, когда ты отвлекся, елозя мышкой по красной полоске.
**Отвлекаться во время вдумчивого чтения, конечно, неприятно, но не смертельно — максимум придется перечитать предыдущее предложение, что не займет много времени.**
2) Непрерывность. Для того, чтоб отвлечься от видео, надо сначала поставить его на паузу. А если что-то захотите уточнить — сначала найдите то место с точностью до нескольких секунд.
**Для текста этой проблемы не возникает — не проблема мгновенно отвлечься, и потом столь же быстро вернуться к чтению. Легко можно оставить открытой вкладку, и ответить на сообщение или письмо. Или уйти спать, и дочитать ее завтра. Или выключить компьютер, зная, что найти нужное место в тексте — пара движений глаз и колесика мыши. А не повторная загрузка ролика и его перелистывание.**
3) Неудобное движение и поиск
Найти в 20-минутном видео нужный фрагмент очень трудно. Либо пользоваться сервисами для ускорения роликов, либо листать с небольшим промежутком, надеясь на то, что вы наткнетесь на нужный момент.
**Поиск в тексте гораздо более легкая задача. Либо Ctrl+F, либо глазами(при прокачанной навыке «скорость чтения» это очень удобно) и вы мгновенно перемещаетесь к нужному моменту.**
4) Одномерность
В видео в один момент можно увидеть только один кадр. Вы ставите на паузу, и ограничиваете себя 1/30 секунды реального времени.
**Видя перед собой страницу текста, вы можете только движением глаз переместиться к предыдущему абзацу, а потом вернуться назад. Движения глаз несоизмеримо быстрее осмысления, движения рукой к мышке, и поиск нужного фрагмента в ролике. И не забывайте, надо еще вернуться точно в то же время назад.**
5) Большая требовательность к технике
Все-таки, как создание видео, так и его просмотр гораздо более сложнее и требовательнее к ресурсам.
Для монтажа ролика вам, как минимум нужна камера и простой видео-редактор, для просмотра — современный компьютер, быстрый интернет, или дорогой сматрфон.
**Для чтения текста вам нужен дешевый телефон, ридер, коммуникатор, электронная книга, планшет, или в конце-концов простая бумажная книга. Для написания — простой ноутбук или телефон с клавиатурой.**
Dixi. 73! | https://habr.com/ru/post/146645/ | null | ru | null |
# Нейросети для детей: объясняем максимально просто
***Всем привет. Ни для кого не секрет, что практически все статьи в нашем блоге публикуются к запуску того или иного курса. Следующую статью можно было бы приурочить к запуску курса «Нейронные сети на Python», но с учетом простоты материала, я не хочу связывать его с курсом, а просто выкладываю в качестве бонусного материала, как небольшой туториал для самых маленьких. Предвещая вопросы, хочу сразу сказать о том, что эта статья не имеет отношения к курсу и написана не преподавателем. Если же у вас есть желание подробнее узнать о курсе, то сделать это можно на [соответствующей странице](https://otus.pw/7HDy/).***
---
Всем привет! Сегодня я хочу рассказать о том, как устроены нейросети, но так просто, что понять могут даже начинающие, которые освоили только самые основы Python.
### Что такое нейронные сети и искусственный интеллект в целом?
В философии ИИ существует два вида искусственного интеллекта — сильный и слабый. Теория сильного искусственного интеллекта предполагает, что компьютеры смогут обрести способность мыслить и осознавать себя как отдельную личность (ну примерно как в Detroit Become Human произошло). Теория слабого искусственного интеллекта предполагает, что такой интеллект нельзя или очень сложно сконструировать, и пока наука способна создавать нейросети, которые только частично повторяют работу нейросетей живых существ. Но философия как раз и не относится к науке потому, что там ничего нельзя доказать, поэтому заострять внимание на этом не будем. Слабые же нейронные сети сейчас занимают доминирующее положение в Data Science и применяются широко: в распознавании визуальных образов, умной закупке товаров, даже системе ОБС автомобиля – поэтому начать учить ИИ сейчас более чем актуально.
### А что такой нейронные сети?
Нейронные сети представляют собой математические модели работы реальных нейронных сетей живых существ. Математическую модель достаточно просто перевести в программу (и из-за этого в программировании нейронных сетей так широко используется Python, столь удобный для программирования решений математических задач. На самом деле нейронные сети можно написать на практически любом языке программирования, в котором поддерживается какая-никакая математика. Даже на Scratch, который изначально был создан для обучения основам программирования младших школьников. Можно посмотреть [здесь](https://scratch.mit.edu/projects/26859854/) ).
### Основные понятия нейросетей
Существует множество алгоритмов работы нейросетей (и сейчас математическая сторона этого вопроса активно разрабатывается). Классическим решением для новичков является метод обратного распространения ошибок(backpropagation) — метод вычисления градиента, который используется для обновления весов многослойного перцептрона. В том виде, в котором его обычно изучают новички (с сигмооидной функцией активации) нейросеть получается достаточно медленная, но относительно точная.
Программа, которую мы собираемся написать называется нейронной сетью с огромной натяжкой.
Прежде чем перейти к ее описанию, давайте обсудим, чем вообще занимаются нейронные сети.
### Чем вообще занимаются нейросети, если все упростить
Если немного упростить концепцию нейронных сетей, то нейросеть, которая обучается по принципу обучения с учителем, после обучения по принципу «стимул — реакция», с указанием правильных ответов, может работать с *незнакомыми* данными. Иными словами, если вы предложили нейросети на вход некий набор слов (например, набор отзывов на кинопоиске, положительных и отрицательных, в любом формате, хоть txt, хоть json, здесь вопрос стоит только в программе обработки этих данных). Для успешного создания нейросети вам потребуются два набора данных: тестовый набор, с помощью которого можно будет оценить эффективность работы созданной нейросети и обучающий набор, в котором для нее данные размечены на положительные/отрицательные (и здесь возникает проблема классификации больших данных, потому что это долгое и муторное занятие). После обучения нейросети (которое может занять много времени времени и ресурсов компьютера, в зависимости от размерности данных, их обработки, и что чаще всего самое главное, применяемых алгоритмов), она сможет *пытаться* предугадывать с некоторой точностью положительный или отрицательный отзыв к ней пришел на вход. Но нейросети (как впрочем и реальный человек), имеют некоторый процент ошибки. Задача оптимизации — сделать его минимальным, но вопрос оценки качества нейросетей скорее всего никогда никуда не денется. К примеру, вам дают фотографию хот-дога и вы точно говорите, что это хот-дог. Но что, если фотография будет смазана? Черно-белая? Снята в плохой видимости? Здесь вы сможете уже утверждать только с некоторой долей вероятности, даже если приготовили или съели немало хот-догов в своей жизни.
### Начинаем программировать нашу игрушечную нейросеть
Окей, поехали. В нашей игрушечной нейросети не будет тестовых и тренировочных данных, наша игрушечная нейросеть будет пытаться найти *коэффициент соотношения* между любыми данными.
Стоп. А какой в этом смысл? Это же находится одним простым математическим выражением.
Вне сомнения. Однако сейчас я взял это выражение, чтобы показать процесс обучения нейросети. Допустим, перед нами стоит задача выяснить, какой коэффициент перевода между дюймами и сантиметрами. Сколько сантиметров занимает один дюйм? Для человека, который знает математику хотя бы пятого класса (а то и раньше), не составляет труда вспомнить, какой коэффициент перевода – 2.54.
Но сейчас мы на время забудем об этом, и представим, что нам нужно создать простой алгоритм, который будет универсально вычислять этот параметр. Однако загвоздка ещё и в том, что нейросети не являются некоторыми константами с готовыми значениями коэффициентов, иначе бы в них не было «живого» обучения.
Итого, мы в положении ребенка, который только сел перед набором кубиков и собирается взять их впервые в свои руки и соорудить первую в своей жизни башенку. Он только примерно знает, как работает физика предметов, он также как и мы знает, что какой-то определенный коэффициент соотношения существует (в его случае это гравитация). Так что сделает ребенок?
Он возьмет и наугад поставит какой-то кубик. Точно также мы можем только наугад предположить, какой у нас будет коэффициент (и реальные взрослые нейросети тоже так делают, только обычно руководствуясь генерацией чисел в нормальном распределении).
Просто наугад предположим, что коэффициент связи дюймов и сантиметров (давайте начнем его называть **вес**, как во взрослых нейросетях) будет равен, к примеру, 2.4. Тогда у нас получится сложнейшее математическое выражение:
```
1 * 2.4 = 2.4
```
Здорово, мы почти угадали, и у нас есть некоторый результат. Но он неверный, и что нормально для процесса обучения, у нас есть некоторая ошибка. Как в нервной системе с обратной связью нам нужно как-то среагировать на ошибку. Но сначала нужно понять ее размер. Как я уже говорил, в нейросетях обучения с учителем сначала данные прогоняют на размеченных данных и только потом уже отправляют в классификацию на похожих, но неразмеченных. Так же и мы знаем, какой у нас должен получится правильный результат, соответственно я смогу подсчитать ошибку:
```
t_target = 2.54
t_now = 2.40
e = t_target - t_now
//получаем значение е, равное сейчас 0.14
```
Теперь мы знаем насколько ошиблись. Но что делать? Естественно, наша игрушечная нейросеть должна считать данные как можно с наименьшим коэффициентом ошибки. И в этом проявляется ещё одна подводная особенность нейросетей — чаще всего они имеют некоторый коэффициент потери при обучении, минимизацией ошибки занимается часть Data Science, под названием [оптимизация](https://ru.wikipedia.org/wiki/%D0%9E%D0%BF%D1%82%D0%B8%D0%BC%D0%B8%D0%B7%D0%B0%D1%86%D0%B8%D1%8F_(%D0%BC%D0%B0%D1%82%D0%B5%D0%BC%D0%B0%D1%82%D0%B8%D0%BA%D0%B0)).
Но сейчас не об этом. Вне сомнения, нам нужно начать изменять коэффициент связи на какой-то шаг, но на какой? Очевидно, что надо не слишком большой, а то наш коэффициент связи получится неточным и не слишком маленький, иначе нам придется довольно долго обучать нейросеть. Здесь нет 100% правильного варианта нахождения этого шага, чаще всего эти параметры и в реальной нейросети подбираются скорее интуитивно, чем на основании какой-то формулы или алгоритма (хотя такое тоже возможно). Сейчас мы можем наугад выбрать значение нашего шага (на языке нейросетей наш шаг называется learning\_rate), к примеру, достаточно оптимально будет работать значение 0.05. Кроме этого, нужно договориться о том, сколько раз будет происходить отступ на **learning rate**. Количество этих отступов мы назовем эпохи, как во взрослых нейросетях. Теперь, вооружившись всеми этими знаниями, можно попробовать написать небольшую программу на Python, которая будет выполнять нашу программу «игрушечной» нейросети.
```
import random
# возьмем встроенную в Python библиотеку random, что мы могли задавать случайный вес нашей нейросети
inches = 40 # мы знаем что 40 дюймов равняется примерно 101, 6 сантиметрам
centimetre = 101.6
# создаем функцию, которая занимается подбором и принимает на вход эпохи, learning rate и точность
def kid_neuro(epoch, lr, accur):
W_coef = random.uniform(0, 2) # получаем наш случайный вес связи
print("Наш первоначальный случайный вес равен: ", W_coef)
for i in range(epoch): # воспользуемся циклом для прокрутки
Error = centimetre - (inches * W_coef)
print("Наша ошибка составляет", Error) # будем печатать ошибку для нашей визуализации
if Error > 0:
W_coef += lr # если ошибка слишком большая, мы начинаем прибавлять коэффициент
if Error < 0:
W_coef -= lr # если ошибка отрицательная, тогда начинаем уменьшать коэффициент
if Error < accur:
print("Наш итоговый результат", W_coef)
return # эффектно вычисляем, сколько же сантиметров в одном дюйме
epoch = int(input("epoch: ")) # эпохи это у нас количество "прогонов"
lr = float(input("enter learning rate: ")) # наш шаг обучения
accur = float(input("enter accurancy: ")) # нам нужно уточнить, на какую точность мы согласны, потому что идеальной у нас скорее всего не получится
kid_neuro(epoch, lr, accur) #вызываем нашу функцию в конце-концов
```
Я оставляю читателя самостоятельно попробовать позапускать эту детскую нейронную сеть с различными параметрами. Неплохо получается на epoch = 100-, learning rate = 0.01, accur = 0.1.
Несмотря на кажущуюся бесполезность этой программы, мы разобрали с вами работу и основные понятия нейронных сетей, которые используются и в построении реальных больших нейронных сетей, к примеру в алгоритме обратного распространения ошибки(backprogation).
Вкратце эти основные понятия:
* **W** — вес. Вес обычно показывает связь узла нейронной сети с каким-то понятием, если нейросеть настроена на классификацию. В нашей программе был только один вес — коэффициент взаимосвязи между дюймами и сантиметрами, но обновляли мы его примерно также, как в реальной неройсети
* **lr** — learning rate, или скорость обучения. Показывает с каким шагом мы будем *обновлять* наш вес при каждом прогоне
* **epoch** Эпохи, или сколько прогонов у нас будет для достижения максимально точного результата
В качестве практики вы можете самостоятельно попробовать написать свою детскую нейросеть, которая будет переводить, к примеру, километры в мили. И вооружившись полученными в данной статье знаниями, сможете без проблем прийти например [сюда](https://playground.tensorflow.org/), и уже попробовать позапускать нейросеть более осмысленно.
Несколько полезных ссылок, на которые вы можете перейти, если пожелаете продолжить обучение нейросетям:
* [Хорошая серия статей про нейросети на русском на Хабре](https://habr.com/ru/post/312450/)
* [Перцептроны в одиночку используются в современных нейросетях не очень широко. Но начать свой путь именно с них хорошая идея](https://www.allaboutcircuits.com/technical-articles/how-to-perform-classification-using-a-neural-network-a-simple-perceptron-example/)
* [Если вы собираетесь развиваться в нейросетях, написать что-то на Mnist – что-то навроде Hello World](https://medium.com/@mjbhobe/mnist-digits-classification-with-keras-ed6c2374bd0e) | https://habr.com/ru/post/498898/ | null | ru | null |
# История реверс-инжиниринга одного пушистого зверька
Тихим утром третьего января, когда Москва уже дремала после новогодних праздников, в нашей квартире раздался звонок в дверь. Почта наконец-то доставила посылку с новогодними подарками, заказанными на Амазоне. Среди прочего в ней находился и подарок для сына — электронный питомец [Furby](http://www.amazon.com/s/?field-keywords=furby). Покупка его была, в общем-то импульсной. Игрушка значилась в бестселлерах новогоднего сезона и стоила относительно недорого. В сортах Furby я не разбирался, но когда-то давно что-то позитивное об игрушке слышал.
Сынишку, в силу его годовалого возраста, подарок не сильно впечатлил, а позволять бросать сложное электронное устройство на пол и отрывать этому устройству уши мне было жалко, и все шло к тому, чтобы убрать подарок на полку до лучших времен, однако мой взгляд пал на одну надпись на красочной упаковке...
Надпись гласила, что для данной игрушки в AppStore можно скачать приложение, с помощью которого киберпитомца можно кормить, подавать ему всякие команды, а также переводить фразы, которые он произносил на своем языке — фурбише (Furbish), на английский. Приложение было скачано, питомец покормлен всякими съедобными и несъедобными объектами, которые он либо с аппетитом проглатывал, либо выплевывал, а переводчик с фурбиша на английский работал на удивление точно.
Неужели распознавание аудио работает в наше время так надежно и даже в довольно шумной обстановке? Что-то тут не так. И как приложение передает команды Furby? ИК отпадает (ранние версии Furby, как выяснилось, имели ИК-порт для общения между собой), Bluetooth тоже. Остается только аудио. Это интересно… Вот если бы удалось хакнуть протокол общения с этим созданием и уметь управлять им с компьютера… Найти какие-то «пасхальные яйца», скрытые или сервисные команды! Или…
В общем, как вы поняли, отец семейства сделал себе на Новый Год подарок.
\*\*\*
Для начала синхронизировал iPhone с компьютером и заглянул внутрь файла приложения (.ipa). Среди прочей требухи там нашлось несколько десятков коротких WAV-файлов, пронумерованных особым образом. Все это очень смахивало на готовые аудиокоманды. Первый файл начинался с номера 350. После воспроизведения этого файла в Audacity Furby чего-то деловито пожевал и выдал радостное «Mmm, yum!». «Ага!» — подумал Штирлиц, — «Теперь-то ты у меня наешься!».
Команды в приложении начинались с 350-й и заканчивались 900-й, с большими пробелами в нумерации. Значит потенциально Furby умеет воспринимать гораздо большее число команд, чем есть на руках этих готовых WAV-файлов. Надо искать дальше.
Внешний вид сигнала в Audacity наводил на мысль, что используется какая-то частотная модуляция, причем шел один сигнал, дальше небольшая пауза, затем визуально такой же сигнал снова. Общая продолжительность — полторы секунды. Раз модуляция частотная, то неплохо бы взглянуть на спектр. Посмотрел график — на нем отчетливо выделялось пять пиков на одинаковых расстояниях друг от друга в районе 16-19КГц:
Башня из Мордора — это, конечно, красиво, но как это расшифровать? Покопался в Audacity еще немного и отрыл режим отображения аудио в виде спектрограммы. Вот эта картинка уже была гораздо красивее первой:
Здесь отчетливо видны две посылки с паузой посередине, отличающиеся друг от друга порядком следования «нот» (базовых частот). Причем средняя частота является несущей, постоянно чередуясь с другими четырьмя «нотами».
Для удобства декодирования последовательности сделал в графическом редакторе маску, которую наложил поверх скриншота спектрограммы, присвоил каждой ноте последовательно числа от 0 до 3 и начал анализировать последовательно идущие команды (как мы помним, разработчики iOS-приложения услужливо пронумеровали нам все WAV-файлы). Поначалу оказалось, что в соседних командах числа иногда «прыгают», т.е. идут не так, как хотелось бы при последовательном инкрементировании чисел. После некоторого анализа стало понятно, что «ноты» надо нумеровать так, как на рисунке ниже:
Здесь посылка расшифровывается как `3233 3012 1032` (для удобства восприятия я разбил последовательности на блоки по четыре цифры; в четверичной системе каждый такой блок — это один байт).
Дальнейший анализ команд, перевод их бинарную форму и побитовое сравнение выявило следующую структуру посылки и команды в целом:
1. Первый байт (в примере это `3233`), будучи записанным в бинарном виде, имеет следующую структуру: `11 1 01111`, где старшие два бита всегда равны `11`, следующий бит равен `0` для первой посылки в команде и `1` для второй, а `01111` — это сами данные (часть идентификатора команды);
2. Второй байт (`3012`) — контрольная сумма, зависящая от 6 бит команды (где 1 бит — идентификатор посылки и 5 бит — сами данные);
3. Третий и заключительный байт посылки всегда равен `1032`.
Что это значит? Во-первых, команда разбивается на два пакета по 5 бит данных в каждом. В сумме мы получаем 10-битное число, т.е. потенциальное число команд, которые может посылать или принимать Furby — 1024. Однако метод вычисления контрольной суммы вычислить не удалось. Проанализировав номера команд получилось, что я могу на основе имеющихся WAV-файлов найти 7 из 32 контрольных сумм для первой посылки и 31 из 32 контрольных сумм для второй посылки. В сумме это давало 217 потенциальных команд вместо имеющихся 76 (в виде готовых WAV-файлов), что тоже неплохо.
Написал скрипт, который генерировал по нужному номеру команды WAV-файл, подобный готовому, и начал перебирать доступные мне диапазоны команд. Как оказалось, недокументированные команды действительно были — Furby реагировал на них разным образом, пел песенки, читал рэп, чихал, имитировал сон и делал прочие незамысловатые вещи.
Это подстегнуло исследовательский аппетит, однако алгоритм вычисления контрольной суммы реверс-инжинирингу упорно не поддавался, а значит большая часть команд оставалась для меня недоступной.
В очередной раз прочесывая Интернет на предмет каких-нибудь зацепок я вдруг обнаружил ссылку на официальное приложение Furby для Android (про которое на коробке с игрушкой не было ни слова). «Android → Java → байт-код → исходники → … → ПРОФИТ!». Никогда еще Штирлиц не был так близок к разгадке…
\*\*\*
Найдя наконец на какой-то помойке нужный мне .apk-файл, я залез внутрь и не увидел ни одного WAV-файла с командами, хотя в целом набор ресурсов был похож на тот, что в приложении для iOS. Раз WAV-файлов нет, то приложение как-то генерит команды на лету? Это то, что мне нужно! Декомпиляция и просмотр Java-кода дал несколько интересных зацепок, но как оказалось, вся интересная начинка, а именно генерация и анализ аудио, находится внутри нативной .so-библиотеки, в которой есть один метод, который мне был нужен, а именно `private static native byte[] GenerateComAirCommand(int paramInt);`.
Как же достучаться до нативного метода? Пораскинув мозгами, Штирлиц решил качать Android SDK. В итоге был собран маленький проект, в который включена сама нативная библиотека и минимальная обвязка, предоставляющая доступ к одной только нужной мне функции. Само же приложение при старте просто создавало WAV-файлы для минимально необходимого мне набора WAV-файлов, где в командах были те самые недостающие старшие и младшие 5 бит, для которых мне были нужны контрольные суммы. После некоторого курения Stack Overflow (опыта написания приложений под Android у меня на тот момент не было) приложение запустилось и сгенерировало мне на виртуальной SD-карте эмулятора набор нужных мне WAV-файлов, которые я перетащил через `adb pull` в нормальную файловую систему. Анализ этих файлов дал мне полное покрытие — все 64 контрольных суммы, по которым можно воссоздать любую из 1024 команд.
В ходе анализа реакций Furby на команды был найден еще один диапазон команд, на который Furby так или иначе реагировал. Однако каких-то атомарных команд типа «открой глаза», «закрой глаза», «пошевели ушами» обнаружено не было. Равно как и не была найдено команд самоуничтожения или зачитывания EULA на фурбише (это не значит, что каких-то специализированы команд нет, просто они могут активироваться, например, особой последовательностью или вообще другим набором кодов — но это как-то выяснить вряд ли возможно).
\*\*\*
Однако я решил пойти дальше и написать анализатор ответов Furby, так как некоторые команды, хотя и не дают видимого результата, могут вызывать реакцию Furby в виде ответных команд, что тоже интересно. В итоге был написан Perl-скрипт, анализирующий поток PCM-данных с микрофона, делающий на лету и расшифровывающий эти посылки. Писалось все это под Windows, где для Perl, к сожалению, нету нормальных способов записи данных с микрофона, поэтому пришлось сделать консольную программу на Delphi, которая читает с микрофона данные и выводит их непрерывно в STDOUT. Поток данных перенаправляется в скрипт, где уже происходит анализ. Такой вот Unix way для Windows.
**«Стоп, стоп, стоп,» — скажет утомленный читатель, — «А для чего все это нужно?»**
Мне было интересно посмотреть, «что у него внутри», не ломая игрушку физически (все-таки покупал не себе). Попутно получил знания о генерации и анализе звука в Perl, о FFT, оконных функциях, о работе с Android, что само по себе увлекательно.
Возможно кому-то данная статья пригодится при реализации собственного протокола, есть ведь всякие интересные [примочки для iPhone](https://squareup.com/), передающие данные как раз через аудиоразъем.
Ну и, наконец, возможность управлять Furby через компьютер потенциально открывает эмоциональный метод нотификации о каких-то событиях. Например, при приходе почты от определенного адресата можно попросить Furby что-то станцевать, по приходу коммита в Git от определенного человека — помурлыкать, а от другого — издать звук менее приличный (коих у Furby есть в запасе). Правда для этого все же нужно решить уже парочку задач хардверных. Во-первых, запретить Furby засыпать через 10 минут неактивности (а активностью считается физическое тормошение — для этого у него имеется датчик положения в пространстве) и питать его не от батареек, а от блока питания или USB. Может быть на Хабре есть знатоки железа, которые захотят окончательно укротить зверька?
Сам код после некоторого причесывания [выложен на GitHub](https://github.com/iafan/Hacksby). Пожелания и находки всячески приветствуются. Разумеется, вся изложенная информация и программный код предоставлен исключительно в образовательных целях.
Oo-tah-toh-toh. Kah way-loh. | https://habr.com/ru/post/166377/ | null | ru | null |
# Методы доступа. Наиболее популярные ситуации
Статья в первую очередь расчитана на начинающих разработчиков, либо для тех, кто только начинает переходить от процедурного стиля программирования к ООП, посему матерых гуру просьба не вгонять в минуса :)
Права доступа к свойствам и методам — это на первый взгляд всего лишь три слова: private, protected и public. Но что скрывается за ними? Какие преимущества это дает в разработке? И как их правильно использовать? Здесь, как и во всех других аспектах программирования, без практики не разобраться…
Одна из трех основных концепций ООП — наследование (другие две: инкапсуляция и полиморфизм). Вобщем-то именно для нее и были реализованы права доступов. Основанная идея наследования: Дочерний объект, при наследовании (extend) родителя перенимает себе все родительские методы и свойства, а так же может обзавестись своими собственными. Понимая эту базу, можно перейти в всему что находится ниже…
**Private** — объявляет метод или свойство доступным только в том классе в котором он присутствует. Тоесть к private методам и свойствам мы не можем обращаться ни из объектов, ни из дочерних классов.
**Protected** — объявляет метод или свойство защищенными. Тоесть такими, которые не могут быть доступны из объекта, реализующего класс, но вполне может быть использовано в дочерних классах.
**Public** — публичный. Классы и методы, объявленные public, могут быть доступны как внутри самого класса, так и в дочерних классах и в объектах, реализовавших класс.
Сразу хочу заметить, что при наследовании, методы доступа изменяться могут только к более лояльным. тоесть в следующей последовательности, но не обратно: private → protected → public
Так же методы могут быть *final* тоесть такими, которые невозможно переопределить в классах потомках.
Вобщем-то все методы доступа используются исключительно для самодокументации кода и не несут никакой логической составляющей, так что и без них жизнь только тяжела, но не невозможна, что доказывает РНР4, в котором все методы и свойства были публичными…
### Практика
Иногда случаются ситуации, когда этих методов доступа недостаточно. Тоесть, например, мы можем хотеть иметь доступ из объекта на чтение какого-то свойства, но при этом не иметь возможности в него писать. Самое простое решение: объявить свойство public и добавить комментарий */\* только для чтения \*/*, но про комментарий можно ненароком забыть и испортить логику поведения программы, вклинившись с нестандартным значением посреди выполнения. тогда приходит время использовать геттеры (getter\'s). Геттер — не что иное, как метод класса, реализующий исключительную возможность читать не публичные свойства из объекта. Вот пример:
> `class A {
>
> private $a = 7;//мы не можем читать и писать в это свойство из объекта, реализующего этот класс
>
>
>
> public function getA() { //публичный метод будет доступен объекту для обращения
>
> return $this->a; //внутри класса мы можем получать доступ к приватным свойствам
>
> }
>
> }
>
>
>
> $obj = new A();
>
> echo $obj->getA();//мы получили значение приватной переменной $a`
Похожим способом ведут себя и сеттеры (setter\'s), когда нам необходимо иметь возможность установить значение переменной, но не читать ее напрямую, так как она, к примеру, должна быть преобразована прежде чем быть использованной. Пример метода сеттера:
> `//...
>
> public funtion setA($value) { //метод будет доступен для объекта
>
> $this->a = $value; //приватное свойство $a может быть установленное внутри класса, но не доступно для прямого влияния из объекта
>
> }
>
> //...`
Еще одним вариантом реализации доступа к методам, когда метод должен быть *отовсюду* доступен только для чтения, является введение \«псевдо-свойства\»:
> `class A {
>
> public function getValue() {
>
> static $value;
>
>
>
> if (empty($value)) {
>
> $value = //... тут значение создается по каким-то известным параметрам и повлиять извне на него мы никак не сможем
>
> }
>
>
>
> return $value;
>
> }
>
> }`
в примере выше, класс А будет обладать псевдо-свойством $value. Псевдо — потому что оно реализуется исключительно через метод, а доступ к нему возможен только на чтение. Еще можете заметить что я использовал паттерн \«ленивой инициализации\», что бы отложить создание свойства до последнего момента и заодно как бы \«закешировать\» его. Где это можно применить, хорошо проиллюстрировано в соседнем топике об ООП в РНР.
Хорошей практикой является сокрытие всех свойств методом private и, в зависимости от нужд, создавать для них сеттеры или геттеры, но нужно быть внимательным, что если для свойства существует и сеттер и геттер, а дополнительной логики обработки данных нет, то не проще ли их убрать, а свойство сделать публичным? :) | https://habr.com/ru/post/21357/ | null | ru | null |
# Как устроен Grunt: смотрим исходники
[Grunt.js](http://gruntjs.com/) уже давно обрел популярность отличного инструмента для оптимизации и автоматизации рабочего процесса. [Признан](https://thenetawards.com/) лучшим проектом с открытым кодом в области веб-технологий за 2014 год. Он прост в применении, эффективен в работе, [используется](https://github.com/search?q=grunt+in%3Apath&type=Repositories&ref=searchresults) во множестве проектов. Не будем рассказывать о том, что с помощью него можно делать, подразумевается что в этом нет надобности. Лучше попробуем посмотреть что там внутри.
#### Getting Started
Исходники Grunt оформлены в виде [организации](https://github.com/gruntjs) на Github. В которой есть примерно следующие проекты:
* [grunt](https://github.com/gruntjs/grunt) — непостредственно сам grunt;
* [grunt-cli](https://github.com/gruntjs/grunt-cli) — интерфейс командной строки
* [grunt-init](https://github.com/gruntjs/grunt-init) — инструмент для создания новых проектов;
* [gruntjs.com](https://github.com/gruntjs/gruntjs.com) — [http://gruntjs.com/;](http://gruntjs.com/)
* [grunt-contrib-\*](https://github.com/gruntjs/grunt-contrib) — коллекция плагинов, которая поддерживается разработчиками grunt.
###### Gruntfile
Конфигурационный файл. Это может быть либо Gruntfile.js, Gruntfile.coffee, который нужен для загрузки и конфигурации плагинов, создания задач и т.п. Все наше общение с Grunt происходит через него. Он представляет из себя wrapper-функцию в которую передается объект grunt:
```
module.exports = function(grunt) {
// Do grunt-related things in here
};
```
*Разработчикам по всей видимости по душе CoffeeScript, по умолчанию его можно использовать для всего (конфигурирования `Gruntfile.coffee`, написания плагинов, ...)*
#### Command Line Interface
На официальном сайте нам рекомендуют установить интерфейс командной строки для Grunt.
```
npm install -g grunt-cli
```
**Структура grunt-cli:**
```
├── AUTHORS
├── Gruntfile.js # jshint
├── LICENSE-MIT
├── README.md
├── bin
│ └── grunt # заводила
├── completion # автодополнения
│ ├── bash
│ └── zsh
├── lib
│ ├── cli.js # опции cli
│ ├── completion.js # вывод дополнений
│ └── info.js # вывод в консоль по типу
└── package.json
3 directories, 11 files
```
Единственное [его](https://github.com/gruntjs/grunt-cli/blob/master/bin/grunt) предназначение — это найти в текущей директории [локально-установленный](https://github.com/substack/node-resolve) Grunt и запустить:
```
var resolve = require('resolve').sync;
try {
gruntpath = resolve('grunt', {basedir: basedir});
} catch (ex) {
gruntpath = findup('lib/grunt.js');
// No grunt install found!
if (!gruntpath) {
if (options.version) { process.exit(); }
if (options.help) { info.help(); }
info.fatal('Unable to find local grunt.', 99);
}
}
/**
* gruntpath -> {HOME_DIR}/node_modules/grunt/lib/grunt.js
* запускаем .cli() у найденного grunt
*/
require(gruntpath).cli();
```
#### Grunt Core
Основной проект, [grunt](https://github.com/gruntjs/grunt), тут задачи и запускаются. Оформлен как npm-модуль.
**Структура файлов:**
```
├── AUTHORS
├── CHANGELOG
├── CONTRIBUTING.md
├── Gruntfile.js # jshint, test, watch
├── LICENSE-MIT
├── README.md
├── appveyor.yml
├── docs
│ └── README.md
├── internal-tasks # внутренние задачи
│ ├── bump.js
│ └── subgrunt.js
├── lib
│ ├── grunt # внутренние библиотеки
│ │ ├── cli.js
│ │ ├── config.js
│ │ ├── event.js
│ │ ├── fail.js
│ │ ├── file.js
│ │ ├── help.js
│ │ ├── option.js
│ │ ├── task.js
│ │ └── template.js
│ ├── grunt.js # заводила
│ └── util
│ └── task.js # конструктор задач
├── package.json
└── test
└── **/*.js # тесты
22 directories, 71 files
```
###### Code Style
Понятный. Много комментариев и пояснений в коде, практически у каждого метода или блока, причем написаны они как-то «по-человечески», например `Yes, this is a total hack...` Призывают делать больше, но проще, нежели короче, но «хитрей».
**Примеры:**
```
// bad
var foo = 'bar'
, bizz = 'bazz';
// better
var foo = 'bar';
var bizz = 'bazz';
// bad
isOk && doGrunt();
// better
if (isOk) {
doGrunt();
}
// bad
isOk ? doGrunt() : doMake();
// better
if (isOk) {
doGrunt();
} else {
doMake();
}
```
Как и практически любой npm-модуль Grunt имеет свои [зависимости](https://github.com/gruntjs/grunt/blob/master/package.json), на них важно обращать внимание для лучшего понимания того, что происходит.
**dependencies:**
```
"async": "~0.1.22",
"coffee-script": "~1.3.3",
"colors": "~0.6.2",
"dateformat": "1.0.2-1.2.3",
"eventemitter2": "~0.4.13",
"findup-sync": "~0.1.2",
"glob": "~3.1.21",
"hooker": "~0.2.3",
"iconv-lite": "~0.2.11",
"minimatch": "~0.2.12",
"nopt": "~1.0.10",
"rimraf": "~2.2.8",
"lodash": "~0.9.2",
"underscore.string": "~2.2.1",
"which": "~1.0.5",
"js-yaml": "~2.0.5",
"exit": "~0.1.1",
"getobject": "~0.1.0",
"grunt-legacy-util": "~0.2.0",
"grunt-legacy-log": "~0.1.0"
```
###### Task Runner
Главный файл «заводила» находиться в `/lib/grunt.js`. В нем «строится» и [экспортируется](http://nodejs.org/api/modules.html#modules_module_exports) объект `grunt`, подключаются внутренние библиотеки проекта из `/lib/grunt/*.js`:
```
...
// Grunt -> export
var grunt = module.exports = {};
...
// Функция добавления внутренней библиотеки к объекту grunt
function gRequire(name) {
return grunt[name] = require('./grunt/' + name);
}
// Пример добавления
gRequire('template');
...
// Функция добавляния ссылки (alias) на конкретный метод к объекту grunt
function gExpose(obj, methodName, newMethodName) {
grunt[newMethodName || methodName] = obj[methodName].bind(obj);
}
// Пример добавления метода registerTask из task в объект grunt
gExpose(task, 'registerTask');
...
```
К объекту добавляется метод `tasks`, который в последствии и вызывается из CLI:
```
grunt.tasks = function(tasks, options, done) {
...
if (option('version')) {
// show version
return;
}
...
if(option('help')) {
// show help
return;
}
...
// если не передано ни одной задачи, берем 'default'
// здесь task -> /lib/grunt/task.js
var tasksSpecified = tasks && tasks.length > 0;
tasks = task.parseArgs([tasksSpecified ? tasks : 'default']);
...
// добавляем задачи в очередь по одной
// наблюдаем, что можем писать `grunt {TASK_1} {TASK_2}`
tasks.forEach(function(name) { task.run(name); });
// запуск
task.start({asyncDone:true});
};
```
###### CLI
Как мы уже заметили, из командной строки мы вызываем метод `grunt.cli()`, этот метод идет в наборе внутренних библиотек `/lib/grunt/*.js`, его задача [пропарсить](https://github.com/npm/nopt) переданные задачи и опции и запустить `grunt.tasks()`:
```
...
var nopt = require('nopt');
...
// экспортный cli()
var cli = module.exports = function(options, done) {
if (options) {
// добавляем опции
...
}
// запуск
grunt.tasks(cli.tasks, cli.options, done);
};
...
// описание стандартных опций
var optlist = cli.optlist = {
help: {
short: 'h',
info: 'Display this help text.',
type: Boolean
}
...
};
...
// парсим стандартные опции и переданные задачи
var parsed = nopt(known, aliases, process.argv, 2);
cli.tasks = parsed.argv.remain;
cli.options = parsed;
```
#### Tasks
Запуск и автоматизация задач — это основная функция `Grunt`. Задача для него — это просто функция, которую нужно вызвать в нужный момент.
**Пример registerTask:**
```
grunt.registerTask('foo', function(a, b) {
console.log(a, b);
});
// > grunt foo
// > undefined undefined
// > grunt foo:bar:baz
// > bar baz
// Парсер аргументов: /lib/util.task.js -> task.init() -> task._taskPlusArgs() -> task.splitArgs()
```
Для работы с задачами `Grunt` используется внутреннюю библиотеку [/lib/grunt/task.js](https://github.com/gruntjs/grunt/blob/master/lib/grunt/task.js) и библиотеку утилит [/lib/util/task.js](https://github.com/gruntjs/grunt/blob/master/lib/util/task.js), посмотрим на метод `registerTask`:
```
...
// "Наследуемся" от "task" util lib.
var parent = grunt.util.task.create();
// Говорим о том что этот объект пойдет на экспорт
var task = module.exports = Object.create(parent);
...
task.registerTask = function(name) {
...
// Запускаем .registerTask() родителя
// Он сфабрикует задачу в объект вида {name: name, info: info, fn: fn}
// И добавит его в массив task._tasks
parent.registerTask.apply(task, arguments);
// Теперь задачу можно от туда забирать
var thisTask = task._tasks[name];
// Ссылка на функцию задачи
var _fn = thisTask.fn;
thisTask.fn = function(arg) {
...
// Работа с опциями, лог происходящего
...
// Вызов функции задачи
return _fn.apply(this, arguments);
};
return task;
};
```
Так же `Grunt` позволяет нам объявлять задачи при помощи метода `registerMultiTask`. Единственное его отличие от `registerTask` состоит в том что, `Grunt` будет искать свойство с тем же именем, что и имя задачи в конфиге `grunt.initConfig({})`, в котором указываются различные конфигурации (цели) и данные для выполнения:
**Пример registerMultiTask:**
```
// Gruntfile.js
grunt.initConfig({
log: {
bar: [1, 2, 3],
baz: 'hello world'
}
});
grunt.registerMultiTask('foo', function() {
grunt.log.writeln(this.target + ': ' + this.data);
});
// > grunt foo
// > Running "foo:bar" (foo) task
// > bar: 1,2,3
// > Running "foo:baz" (foo) task
// > baz: hello world
// > grunt foo:bar
// > Running "foo:bar" (foo) task
// > bar: 1,2,3
```
```
task.registerMultiTask = function(name, info, fn) {
...
var thisTask;
task.registerTask(name, info, function(target) {
// Если не указана конфигурация (цель) запускаем все что нашли
if (!target || target === '*') {
return task.runAllTargets(name, this.args);
} else if (!isValidMultiTaskTarget(target)) {
throw new Error('Invalid target "' + target + '" specified.');
}
// Проверяем конфиг на наличие свойства с именем `name`
this.requiresConfig([name, target]);
// Сохраняем значение из конфига {name: target}
// Смотреть /lib/grunt/config.js -> .get() -> .getRow()
this.data = grunt.config([name, target]);
// Вызов
return fn.apply(this, this.args);
});
thisTask = task._tasks[name];
thisTask.multi = true;
};
```
#### Заключение
Нельзя сказать о том что `Grunt` единственный в своем роде и ему нет альтернатив. Но можно с уверенностью заявить о том что популярность и авторитет он завоевал. Он легко устанавливается, быстро настраивается, имеет привлекательный декларативный стиль конфигурирования задач, достаточно «модульная» структура проекта.
Так же хотел бы приложить ссылку на слайды одного из [авторов](https://twitter.com/cowboy) проекта [The State of Grunt](http://cowboy.github.io/state-of-grunt-fe-summit-2014-talk/#1), где рассказывается о том что сейчас есть `Grunt` и чем он планируется быть. Надеюсь статья оказалась хоть чуть-чуть интересной и помогла посмотреть глубже на инструмент, который мы так часто используем. | https://habr.com/ru/post/230753/ | null | ru | null |
# Делаем сами простые часы за выходные
Статья о том, как за выходные с нуля сделать простые электронные часы с использованием микроконтроллера. Показана только основа часов, количество программных и аппаратных фич ограничивается только вашей фантазией).
Данная статья является логическим продолжением статьи о микроконтроллерах, опубликованной на хабре 26 августа (http://habrahabr.ru/blogs/hardware/37764/). Основной задачей я ставлю не дать пошаговые инструкции, какой проводок к чему припаивать, а вызвать интерес читателей к теме, смотивировав к самостоятельному изучению.
Итак, для того что бы создать часы необходимо освоить 2 технологии — это пайка и создание печатных плат при помощи лазерно-утюжной технологии.
Статья о пайке: [licrym.org/index.php/%D0%9F%D0%B0%D0%B9%D0%BA%D0%B0](http://licrym.org/index.php/%D0%9F%D0%B0%D0%B9%D0%BA%D0%B0)
Статья о лазерно-утюжной технологии изготовления плат: [licrym.org/wiki/index.php?wakka=Texnologii/LazernoUtjuzhnajaTexnologijaIzgotovlenijaPlat](http://licrym.org/wiki/index.php?wakka=Texnologii/LazernoUtjuzhnajaTexnologijaIzgotovlenijaPlat)
Если нет желания / возможности изготовить печатную плату, то можно обойтись макетной платой, выглядит она так:
В ней просверлены отверстия с шагом 2,54 мм, от нее отрезается кусок подходящего размера, детали устанавливаются и припаиваются (вокруг каждого отверстия кружочек медной фольги) и затем необходимые соединения делаются отрезками провода. Выглядит неэстетично (паутина проводов), зато ненужно травить плату.
В совершенно крайнем случае можно заменить макетную плату плотной картонкой с проколотыми отверстиями, но тогда эту импровизированную плату нельзя ни мять ни гнуть.
Итак, нам понадобятся **инструменты**: паяльник, бокорезы, мультиметр (для отладки, хотя у меня всё заработало сразу).
**Детали**: микроконтроллер attiny2313, колодка под него, 2 кнопки, микросхема-стабилизатор 7805, четыре 7ми сегментных светодиодных индикатора, у меня это SA15–11GWA (высота цифр 38 мм). Размер индикатора любой, главное что бы ток сегмента не превышал 40 мА (смотреть в даташите на конкретный индикатор), 4 транзистора КТ817Б, кварц на 16 мгц, 2 конденсатора на 22 пф, конденсатор на 220 нф, ну и пара резисторов. Конкретные компоненты указывать не имеет смысла, т.к. возможно придется использовать аналоги + резисторы расчитываются.
Итак, начнем с деталей, на снимке:
Микроконтроллер обошелся в 41 руб, индикаторы по 52,8 руб за штуку. Всего получается 252,2 руб. Остальное было извлечено из запасов, но в любом случае бюджет бы не превысил бы 300 рублей.
Плата была нарисована вручную в программе Sprint Layout 4. Вот вытравленная плата:
Фото часов в сборе. На заднем плане мой блок питания, который я описывал тут: [Универсальный блок питания](http://licrym.org/wiki/index.php?wakka=SdelajjSam/Universal'nyjjBlokPitanija)
Вид часов в полумраке:
А теперь давайте разберемся с тем как это работает. Вот схема(широкая, потому ссылкой):
[licrym.org/habrahabr/small\_clock\_scheme.jpg](http://licrym.org/habrahabr/small_clock_scheme.jpg)
При включении питания запускается микроконтроллер. Микроконтроллер тактируется от кварца с частотой 16 МГц. В микроконтроллер залита управляющая программа.
У микроконтроллера есть внутри так называемый таймер, обычно их несколько (8ми и 16 битные). Таймер можно использовать по разному, для подсчета внешних импульсов, для генерирования заданной частоты, для генерирования ШИМ сигнала и т.д. В данном случае мы будем использовать его для отсчета времени. Мы включим таймер считать импульсы на системной шине (т.е. 16 мгц кварца), включим предделитель 256 и прерывание по совпадению с числом 625. Тоесть таймер будет у нас тикать с частотой 16Мгц/256=62500 Гц, и вызывать прерывание как только таймер досчитает до 625, тоесть прерывание у нас будет случаться каждые 1/100 сек. Каждое прерывание программа будет увеличивать счетчик сотых секунд на 1, сбрасывать таймер и возвращаться к отображению времени.
Если количество сотых секунд достигает 100, то мы увеличиваем на 1 значение секунд, а значением сотых секунд сбрасываем. И так далее вплоть до десятков часов, которые сбрасываются по достижении 24 без увеличения следующего разряда. Часы предельно простые, поэтому не считают ни дату, ни перевод на зимнее/летнее время и т.д. Данные функции можно реализовать программно, без изменения аппаратной части, поэтому остаются для реализации желающим.
Разобравшись с таймером и прерываниями мы получаем значение текущего времени в глобальных переменных. Теперь займемся выводом этих значений. Так как количество портов микроконтроллера ограничено, то будем эксплуатировать инерционность зрения. Катоды всех 4 индикаторов соединены параллельно, а аноды коммутируются отдельно, что позволяет нам в любой момент времени вывести любую цифру на любой индикатор. Быстро переключая порт B, к которому подключены катоды и быстро переключая аноды мы можем создать видимость, что у нас работают все 4 цифры, хотя единовременно работает только одна. Иными словами, если текущее время 12:51, то мы выводим цифру 1 на первый индикатор, спустя малый промежуток времени (у меня 1 мс) выводим цифру 2 на второй индикатор, спустя 1 мс выводим 5 на 3 индикатор, спустя 1 мс выводим 1 на 4 индикатор и так далее по кругу.
Кнопки опрашиваются после каждого цикла отображения (примерно 40 раз в сек), обработка нажатия снабжена антидребезгом и «защелкой» в виде флага, что позволяет считать именно нажатия не отвлекаясь на удержание.
Транзисторы установлены для комутации анодов. Дело в том что ток, который может пропустить через себя одна нога порта ограничено 40 мА, а у моего индикатора в случае включения всех 7 сегментов и точки (отдельный светодиод на схеме это как раз точка) составит 160 мА.
код, который управляет часами:
`/*****************************************************
This program was produced by the
CodeWizardAVR V1.25.7 beta 5 Professional
Automatic Program Generator
© Copyright 1998-2007 Pavel Haiduc, HP InfoTech s.r.l.
www.hpinfotech.com
Project : Simple AVR Clock
Version :
Date : 01.05.2008
Author : Spiritus Sancti
Company : licrym.org
Comments:
Chip type : ATtiny2313
Clock frequency : 16,000000 MHz
Memory model : Tiny
External SRAM size : 0
Data Stack size : 32
*****************************************************/
#include
#include
#define digit\_display\_time 1
unsigned char milliseconds, seconds, ten\_seconds, minutes, ten\_minutes, hours, ten\_hours;
bit button\_pressed1, button\_pressed2;
// Timer 1 output compare A interrupt service routine
interrupt [TIM1\_COMPA] void timer1\_compa\_isr(void) //Прерывание происходит 100 раз в сек, сохраняем в глобальные переменные текущее время
{ milliseconds++;
TCNT1H=0x00;
TCNT1L=0x00;
if (milliseconds >= 100 ) //Здесь моя ошибка. в переменной milliseconds хранятся СОТЫЕ доли секунд а не миллисекунды.
{
milliseconds = 0;
seconds++;
};
if (seconds >= 10)
{
seconds = 0;
ten\_seconds++;
};
if (ten\_seconds >= 6)
{
ten\_seconds = 0;
minutes++;
};
if (minutes >= 10)
{
minutes = 0;
ten\_minutes++;
};
if (ten\_minutes >= 6)
{
ten\_minutes = 0;
hours++;
};
if (hours >= 10)
{
hours = 0;
ten\_hours++;
};
if (ten\_hours >= 2 && hours == 4)
{
ten\_hours = 0;
hours=0;
};
}
void main(void)
{
unsigned char digits[10] = {18, 159, 56, 28, 149, 84, 80, 31, 16, 20}; //массив для генерации цифр. Какой элемент массива будет отправлен в порт, такая цифра и загорится.
// Crystal Oscillator division factor: 1
CLKPR=0x80;
CLKPR=0x00;
// Input/Output Ports initialization
// Port A initialization
// Func2=In Func1=In Func0=In
// State2=T State1=T State0=T
PORTA=0x00;
DDRA=0x00;
// Port B initialization
// Func7=Out Func6=Out Func5=Out Func4=Out Func3=Out Func2=Out Func1=Out Func0=Out
// State7=1 State6=1 State5=1 State4=1 State3=1 State2=1 State1=1 State0=1
PORTB=0xFF;
DDRB=0xFF;
// Port D initialization
// Func6=Out Func5=Out Func4=Out Func3=Out Func2=Out Func1=In Func0=In
// State6=0 State5=0 State4=0 State3=0 State2=0 State1=P State0=P
PORTD=0x03;
DDRD=0x7C;
// Timer/Counter 0 initialization
// Clock source: System Clock
// Clock value: Timer 0 Stopped
// Mode: Normal top=FFh
// OC0A output: Disconnected
// OC0B output: Disconnected
TCCR0A=0x00;
TCCR0B=0x00;
TCNT0=0x00;
OCR0A=0x00;
OCR0B=0x00;
// Timer/Counter 1 initialization
// Clock source: System Clock
// Clock value: 62,500 kHz
// Mode: Normal top=FFFFh
// OC1A output: Discon.
// OC1B output: Discon.
// Noise Canceler: Off
// Input Capture on Falling Edge
// Timer 1 Overflow Interrupt: Off
// Input Capture Interrupt: Off
// Compare A Match Interrupt: On
// Compare B Match Interrupt: Off
TCCR1A=0x00;
TCCR1B=0x04;
TCNT1H=0x00;
TCNT1L=0x00;
ICR1H=0x00;
ICR1L=0x00;
OCR1AH=0x02;
OCR1AL=0x71;
OCR1BH=0x00;
OCR1BL=0x00;
// External Interrupt(s) initialization
// INT0: Off
// INT1: Off
// Interrupt on any change on pins PCINT0-7: Off
GIMSK=0x00;
MCUCR=0x00;
// Timer(s)/Counter(s) Interrupt(s) initialization
TIMSK=0x40;
// Universal Serial Interface initialization
// Mode: Disabled
// Clock source: Register & Counter=no clk.
// USI Counter Overflow Interrupt: Off
USICR=0x00;
// Analog Comparator initialization
// Analog Comparator: Off
// Analog Comparator Input Capture by Timer/Counter 1: Off
ACSR=0x80;
// Global enable interrupts
#asm("sei")
while (1)
{
PORTD |=1<<5; //включаем первый индикатор
PORTB = digits[ten\_hours]; //выводим на него десятки часов
delay\_ms(digit\_display\_time); //ждем, время индикации одного разряда задается в заголовке программы
PORTD &=~(1<<5); //выключаем первый индикатор и переходим дальше и так в цикле для каждого из 4 разрядов
PORTD |=1<<4;
PORTB = digits[hours];
if (milliseconds >= 50) PORTB &=~(1<<4); else PORTB|=1<<4; //моргание точки
delay\_ms(digit\_display\_time);
PORTD &=~(1<<4);
PORTD |=1<<3;
PORTB = digits[ten\_minutes];
delay\_ms(digit\_display\_time);
PORTD &=~(1<<3);
PORTD |=1<<6;
PORTB = digits[minutes];
delay\_ms(digit\_display\_time);
PORTD &=~(1<<6);
//а вот теперь проверим кнопочки в стиле часов Электроника 13
if ((PIND & 1<<0) == 0 && button\_pressed1 == 0) //Если нажата кнопка 1
{
delay\_ms(1);
hours++;
button\_pressed1 = 1;
};
if ((PIND & 1<<0) == 1) button\_pressed1=0; //Если отпущена то сбрасываем флаг
if ((PIND & 1<<1) == 0 && button\_pressed2 == 0) //Если нажата кнопка 2
{
delay\_ms(1);
minutes++;
button\_pressed2 = 1;
};
if (PIND & 1<<1) button\_pressed2=0;
};
}`
Программа написана в CodeVisionAVR. Схема создана в программе PROTEUS. Кстати там же в протеусе можно нарисовать виртуальную схему устройства и тут же запустить ее на симуляцию, узнав работает или нет.
Само собой в статье невозможно ответить на все вопросы и рассказать про все тонкости. В частности тем, кто решит повторить конструкцию, необходимо будет сделать программатор (в самом простом случае 4 проводка на порт LPT, распаять колодку программирования на плате (подключить 10 контактную колодку к ногам MOSI, MISO, SCK, RESET и GND) и выставить FUSE биты микроконтроллера что бы тактовый генератор переключится от внутренней RC цепочки на внешний кварц. про всё это можно найти на сайтах вроде avr123.nm.ru)
На создание данных часов с нуля (от идеи до травления платы, распайки и написания кода) у меня ушло 1,25 дня.
Оригинальная статья: [licrym.org/index.php/%D0%9F%D1%80%D0%BE%D1%81%D1%82%D1%8B%D0%B5\_%D1%87%D0%B0%D1%81%D1%8B](http://licrym.org/index.php/%D0%9F%D1%80%D0%BE%D1%81%D1%82%D1%8B%D0%B5_%D1%87%D0%B0%D1%81%D1%8B)
Фичи которые можно добавить малой кровью:
1) прицепить на одну из свободных ног динамик и получить будильник
2) повесить на одну из свободных ног реле и получить таймер (например для автоматического включения гирлянды)
3) у микроконтроллера есть модуль USART так что подцепив микросхему — конвертер уровней (например MAX232 и пару конденсаторов) можно наладить двунаправленную связь с компьютером через COM порт.
P.S. Я создал блог DIY (http://habrahabr.ru/blogs/DIY/) и впредь все статьи из разряда «сделай сам» буду публиковать там.
P.P.S. Во избежание недоразумений поясняю. Часы эти делал лично я, и первоначально публиковал на своем портале licrym.org но решил перенести на самые лучшие и интересные статьи со своего портала на хабрахабр. | https://habr.com/ru/post/38443/ | null | ru | null |
# Эксплуатация Ceph: что такое Scrub и как им управлять
Scrub — это процесс фоновой проверки консистентности данных в Ceph. Он позволяет выявить и устранить несоответствия в копиях, а также найти рассыпающиеся диски, чтобы вовремя их заменить. При этом сам Scrub может создавать высокую нагрузку на кластер и мешать другим процессам. Сегодня расскажем о настройках, которые помогут оптимизировать его работу и сделать нагрузку практически незаметной.
Статья подготовлена на основе лекции Александра Руденко, ведущего инженера в группе разработки «Облака КРОК». Лекция доступна в рамках [курса по Ceph в «Слёрме»](https://slurm.io/ceph?utm_source=habr&utm_medium=post&utm_campaign=ceph&utm_content=post_12-01-2020&utm_term=fedoseenko).
Предыдущие материалы цикла по Ceph:
[Флаги для управления состояниями OSD](https://habr.com/ru/company/southbridge/blog/532250/),
[Флаги для управления восстановлением и перемещением данных](https://habr.com/ru/company/southbridge/blog/534912/).
### Как работает Scrub
Scrub или scrubbing — это специальный фоновый процесс, который проверяет консистентность данных в placement group. Например, есть пул с тройной репликацией, то есть одна placement group в нём имеет три копии. Данные в этих копиях должны быть полностью идентичны, что и проверяет Scrub.
Если Scrub обнаруживает расхождения (например, в какой-то placement group объект имеет контрольную сумму не такую, как на двух других, либо вообще отсутствует), то возникает ошибка, администратор о ней узнаёт и может исправить.
В Erasure coded pool нет копий, но принцип тот же: Scrub выявляет расхождения в данных, неконсистентность, возникшую по тем или иным причинам. Одна из основных причин — «тихие» повреждения магнитных дисков. Вчера вы записали данные, а сегодня некоторые секторы на диске посыпались и данные оказались повреждены.
Scrub бывает двух типов: обычный и глубокий.
В примере на скриншоте четыре placement groups находятся в состоянии scrubbing, и они же находятся в состоянии scrubbing+deep. «Deep» — это значит глубокий Scrub.
Сначала всегда выполняется обычный Scrub, и только если он завершился успешно, запускается глубокий.
**Обычный Scrub** проверяет атрибуты и размер объектов. Он проходит быстро и незаметно с точки зрения нагрузки.
**Глубокий Scrub** читает практически каждый байтик объектов и сверяет их на всех OSD в рамках проверки одной placement group. То есть все данные читаются, проверяются их контрольные суммы и контрольные суммы сверяются. Это достаточно затратный по ресурсам процесс. Он может затрагивать несколько placement group сразу. В примере выше параллельно проверяются данные четырёх placement groups.
Максимальная частота проверки одной placement group — раз в сутки, чаще Scrub не запускается. При этом у процесса есть дедлайн: одна placement group должна быть проверена в течение недели. То есть Scrub может проходить раз в сутки, но не реже раза в семь дней. Если placement group не проверялась больше семи дней, то возникает сообщение об ошибке.
Пример такого сообщения на скриншоте. Здесь показано, сколько placement group не успело пройти проверку в отведённые 7 дней.
Когда Scrub находит различие в данных в одной placement group, возникает такая ошибка:
Первая строчка показывает, что есть ошибки scrub error, и сколько их. Вторая строчка говорит, в скольки placement group обнаружена неконсистентность данных. Такие алерты может выдавать только Scrub. По-другому вы не узнаете, что placement group в неконсистентном состоянии.
Фактически алерт говорит: по какой-то причине данные некорректно записались на одну OSD и нужно запустить процесс repair — восстановление консистентности.
Мы считаем процесс Scrub очень важным ещё и потому, что он позволяет выявлять повреждения дисков.
> Во время проверки данные placement group читаются целиком. То есть в течение 7 дней 100% данных кластера оказываются прочитаны и сверены на разных OSD. В результате мы получаем проверку состояния дисков: способны ли они отдавать данные, работает ли чтение с них.
>
>
>
> Scrub читает данные, которые пользователь, возможно, не читал несколько месяцев и не будет читать ещё год. Если при чтении на диске возникает проблема (например, сектор магнитного диска отказал), то это провоцирует ошибку.
>
>
>
> В логе ядра Linux мы видим ошибку типа input/output error. Ceph сообщает, что возникла ошибка при проверке. В мониторинге появляется алерт, в котором фигурирует идентификатор диска. Мы понимаем, что на нём возникли input/output-ошибки, внимательно его смотрим и практически всегда меняем.
### Управление проверкой
Если Scrub заканчивается с ошибкой, нужно выяснить детали: какая именно placement group в неконсистентном состоянии и на каких OSD она сейчас находится. Сделать это можно следующей командой:
```
$ ceph health detail
```
Вывод будет примерно такой:
После этого можно пойти в логи ядра конкретной OSD и проверить. Скорее всего там обнаружится ошибка ввода/вывода и станет понятно, что диск нужно менять.
Чтобы узнать, какую именно ошибку выдал Scrub, используйте команду:
```
$ rados list-inconsistent-obj {PG} | jq
```
В длинном выводе будет примерно такая секция, как на скриншоте ниже. В ней показаны OSD и состояния проблемного объекта на них.
На скриншоте видно, что на двух OSD (875 и 925), в том числе и на primary, объект есть, у него есть есть контрольная сумма, а вот на третьей (463) его просто нет.
Когда есть primary-копия, и она корректная, можно запустить восстановление командой:
```
$ ceph pg repair {PG}
```
Процесс repair может идти несколько часов. После этого в логе Ceph можно будет найти эту placement group по id и увидеть результат восстановления. Там будет написано, сколько ошибок исправлено, а сколько нет. Но когда большинство данных в порядке и повреждена только одна копия, процесс repair без проблем восстанавливает объект, беря его из primary OSD.
### Оптимизация проверки
При всей полезности у скраббинга есть недостаток — он создаёт большую нагрузку. Когда идёт глубокий Scrub, данные из placement group читаются, чтение этих данных никак не отражается в системах мониторинга (это внутреннее io) и этот идущий Scrub может создавать нагрузку сам по себе. Раньше это была колоссальная нагрузка.
Кластеры на более ранних версиях сильно страдали от проверки. Scrub был невероятной проблемой. Можно было встретить много статей, как его лимитировать, чтобы он шёл медленнее и не создавал такую нагрузку.
Сейчас Scrub в Ceph стал более интеллектуальным, к нему прикрутили много параметров, которые позволяют его оптимизировать и практически в любом кластере сделать так, чтобы нагрузка от него не была сильно заметна.
Рассмотрим некоторые из этих параметров. Посмотрим на osd параметры, в которых есть слово “scrub”, так увидим все связанные с ним настройки.
```
ceph daemon osd.0 config show | grep osd | grep scrub
```
“osd\_max\_scrubs” — определяет, сколько placement group может параллельно «скрабить» одна OSD. По умолчанию стоит значение “1”, то есть Scrub максимально зажат.
Есть параметры, которые полезно настроить с самого начала:
“osd\_scrub\_begin\_hour” и “osd\_scrub\_end\_hour”. В нашем примере в первом параметре стоит значение “0”, во втором “24”, то есть процессу разрешено идти в любое время.
Поменяем значения: поставим время начала “02”, время окончания “08”:
```
ceph config set osd osd_scrub_begin_hour 02
ceph config set osd osd_scrub_end_hour 08
```
Таким образом мы задаём желательный интервал времени для проверки.
Но есть важный момент: это будет работать хорошо только поначалу. Как только какие-то placement group не смогут из-за этого интервала успевать «скрабиться» в течение недели, Scrub будет запускаться сразу по истечении недельного срока, независимо от ограничений по времени. Дедлайн для Scrub критичнее, чем эти интервалы.
Иными словами, этими параметрами вы задаёте время, когда вы хотели бы, чтобы Ceph делал Scrub, если он может это делать. Если у него настал дедлайн для какой-то placement group, то он проигнорирует интервалы, потому что дедлайн критичен.
“osd\_scrub\_sleep” — ещё один важный параметр. Для обычного скраба его значение “0.00000”. Можно задать “0.1”, хотя для обычного Scrub это не особо важно.
“osd\_debug\_deep\_scrub\_sleep” — задаёт sleep для Deep Scrub. По умолчанию его значение тоже “0”, но мы его у себя ставим “0.2”.
Меняется значение параметра аналогично:
```
ceph config set osd osd_debug_deep_scrub_sleep 0.2
```
Нужно понимать, что настройки Scrub в каждом кластере индивидуальны. Очень большие кластеры могут даже с дефолтными настройками не испытывать проблем. На кластерах меньшего размера он может быть заметен сильно. А если это кластер небольшого размера и у него ещё очень интенсивное io, то Scrub может быть проблемой.
“osd\_scrub\_chunk\_max” и “osd\_scrub\_chunk\_min” — это самые важные параметры, определяющие интенсивность проверки; то, что сильно зажимает или отпускает Scrub.
Если задать такое значение, то интенсивность идущего скраба упадёт в 5 раз — настолько медленнее будут читаться данные.
```
ceph config set osd osd_scrub_chunk_min 1
ceph config set osd osd_scrub_chunk_max 4
```
Хотя скорее всего, вы не заметите никакого эффекта, но получите алерты о том, что placement group не успевают пройти Scrub вовремя. Просто потому что слишком мало объектов берётся за одну итерацию, слишком медленное чтение.
Этими параметрами вы можете играть, задавая различные значения, чтобы достигнуть того баланса, когда Scrub успевает проходить за неделю и при этом не создаёт видимой нагрузки. Они меняются на лету, и вы можете ими в любой момент ускорять или зажимать Scrub.
“osd\_scrub\_auto\_repair” — ещё один интересный параметр. В начале статьи вы видели ошибку о том, что placement group в состоянии inconsistent. Если в значении этого параметра поставить “false”, то Ceph запустит repair на эту placement group, но только если количество ошибок до 5. Если ошибок больше, то он не запустит автоматический repair, будет висеть ошибка, и вам надо будет посмотреть, что же произошло. Ceph считает, что повреждённых объектов слишком много, чтобы их автоматически чинить. Нужно разобраться, в чём дело.
“osd\_scrub\_during\_recovery” — это относительно новый параметр. Если он активирован, то Scrub не будет запускаться, когда на OSD запущен backfilling, то есть идёт recovery io. Если у вас будет настроен когда-нибудь мониторинг текущего количества скрабов, то вы сможете увидеть, как во время запущенного rebalance график скрабов начинает стремительно снижаться.
Scrubbing io старается не конфликтовать с recovery io, и это ещё одна причина, по которой Scrub может откладываться. Если вы в течение недели делаете сильный rebalance — увеличиваете число placement group, добавляете сервер — Scrub откладывается, и через неделю вы получите множество сообщений о том, что Scrub не успел пройти за неделю, и вам нужно будет его либо ускорить, либо ждать, пока он «рассосётся».
Общая рекомендация: если вы видите проблему аномальной производительности в кластере и не понимаете, в чём дело, вы всегда можете отключить Scrub с помощью флагов:
Обычный:
```
ceph osd set noscrub
```
Глубокий:
```
ceph osd set nodeep-scrub
```
Кроме того, скраб можно отключать для конкретного пула. Если у вас несколько пулов, и вы хотите для конкретного пула отключить скраб, то это можно сделать командой:
```
ceph osd pool set {name} noscrub 1
ceph osd pool set {name} nodeep-scrub 1
```
Флаги отразятся в cluster health:
Эти флаги блокируют новый Scrub, но уже запущенные проверки не отклоняются и будут завершены. Когда текущие проверки закончатся, вы сможете оценить, изменилась ли ситуация с производительностью.
Если проблема исчезла, значит вам нужно немного зажать Scrub. Если сохранилась, то дело не в Scrub, его можно запускать снова и искать другую причину аномальной производительности. | https://habr.com/ru/post/536884/ | null | ru | null |
# Выгрузка сотрудников из 1C ЗУП в Битрикс24 или правдивая история о том как настроить интеграцию 1С-Битрикс24 c 1С ЗУП
В жизни так бывает, причём бывает чаще чем хотелось бы, хоть в целом и довольно редко – надо интегрировать Битрикс24 с ЗУП. Сими дружественными компаниями заявлена штатная интеграция (но только для коробки Б24), которая осуществляется по следующей принципиальной схеме:
1. Обмен инициирует всегда 1С. Это либо штатный, либо устанавливаемый самостоятельно и доступный модуль обмена, который посылает запросы.
2. На стороне Б24 имеем в качестве точки обмена скрипт, если быть точнее скрипты (но об этом будет ниже), в одном из которых вызов метода IncludeComponent, который подключает контроллер. Он и таит в себе логику обмена.
Штатный обмен, в принципе, если быть экспертом одного из продуктов можно освоить за небольшое количество минут или часов – информация представлена на одном из [официальных сайтов 1С-Битрикс](https://1c.1c-bitrix.ru/intranet/employees.php.).
### Пролог
Нам же это скучно, поэтому ввязываемся в авантюру по интеграции ЗУП с Б24 Enterprise, а чтобы было интереснее – берем закрытый объект, почти совсем не бизнес даже, а учреждение с многоуровневой и чудно ветвленой системой безопасности.
В общем, на руках бэкап Б24 с обезличенными данными и обезличенный же XML-файл обмена из ЗУП.
Итак, сама задача… Хотя, нет. До самой задачи ещё далеко – не помешало бы сначала наладить тестовый механизм для того, чтобы по заверениям работающий штатный алгоритм проверить.
Инструментарий:
* *Виртуальная машина VMBitrix – 1 шт.*
* *1С-Битрикс24 (копия для разработки) – 1 шт.*
* *Файл обмена, выгруженный предположительно штатным модулем обмена 1С – 1 шт.*
* *VS Code + SSH FS плагин на будущее – 1 комплект.*
* *Postman – 1 шт.*
### Виртуальная машина VMBitrix
По правде говоря, это никакая не виртуальная и даже не машина, а CentOS 7 (ну, или 6) со всеми вытекающими. Можно из чистой центоси сделать своеобразный и уже сконфигурированный LAMP+ для Битрикс несколькими командами.
`wget http://repos.1c-bitrix.ru/yum/bitrix-env.sh`
`# chmod +x bitrix-env.sh`
`# ./bitrix-env.sh`
Для дотошных читателей следует рассказать, что виртуальная машина в реальности всё же существует. На клиентском сайте вендора в разделе скачать. Образы уже сконфигурированных ОС под популярные виртуализации выложены и в корне сайта по умолчанию уже лежит скрипт установки демо и скрипт восстановления. Именно скрипт восстановления был использован для создания локальной копии портала.
Следует ещё отметить, что VMBitrix не единственное, но самое быстро-разворачиваемое универсальное окружение для Б24.
### 1С-Битрикс24 Enterprise
Не буду много распространяться про то, что отличает Энтерпрайз от других коробок. Наверное, в данном повествовании хватит акцента на цене и уровне ответственности. Тем более, модули связанные с масштабированием не используются. Впрочем, как и многосайтовость.
### Файл обмена из 1С ЗУП
Если вы хоть раз занимались интеграцией двух систем, будучи ответственным только на одном продукте, то вам знакомо как велик соблазн спихнуть на ту сторону любую мелочь, которую лень проверять на своей стороне. Этот недуг поражает даже самых ответственных людей, выступающих в любой роли и с любым уровнем погружения. Поддавался недугу и я.
Попытка повлиять на то чтобы пришли нужные данные сами чудесным образом, догадавшись, куда и в какой последовательности записываться, для очистки совести тоже осуществлена.
### VS Code + SSH FS плагин
Итак, вооружившись доступом к файловой системе проекта, мы начинаем свое путешествие в увлекательный мир не задокументированных интеграций.
Не зря в самом начале статьи была реплика про то, что «Обмен инициирует всегда 1С». Для понимания архитектуры это был первый шаг, в модуле обмена на стороне 1С прописан адрес скрипта, выступающего узлом обмена в Б24 – по умолчанию это /bitrix/admin/1c\_intranet.php.
В нем, согласно правилам системы ничего не хранится. Подключается один из служебных скриптов системного модуля Интранет(intranet) /bitrix/modules/intranet/tools/1c\_intranet.php.
Именно этот модуль нам дает программный интерфейс для организации работы с сотрудниками и структурой на портале. Модули в BitrixFramework занимают место модели в архитектуре MVC.
И именно для взаимодействия с ним написанный системный компонент intranet.users.import.1c вызывается из служебного скрипта при помощи метода IncludeComponent. Компоненты в BitrixFramework занимают место контроллера в архитектуре MVC. На вход компонента подается массив параметров, если не вдаваться в тонкости, то – настройки из модуля Интранет, которые задаются в административной части корпортала.
### Postman
При упоминании должности почтальона в наших широтах перед глазами встает образ скорее Печкина из Простоквашино, нежели герой Кевина Костнера из одноименного заокеанского фильма.
Но наш герой – программа, адрес тоже известен: postman.com [ссылка удалена модератором].
### Эпилог
Путем ~~нехитрых манипуляций~~ вычитки кода того самого системного компонента и экспериментов с программой-почтальоном за пару часов выработан полуавтоматических алгоритм, позволяющий подсунуть в Б24 файл выгрузки из 1С.
Что важно знать про обмен:
* Протокол обмена – GET
* Нужно несколько последовательных запросов с разными параметрами
Если файл выгрузки 1С ЗУП в архиве, то нужно использовать галочку «Использовать сжатие zip, если доступно» в настройках модуля Интранет в админке. И наоборот – если XML без архивной оболочки – галочку нужно снять.
Первый запрос, авторизация по логину и паролю:
`GET http://портал/bitrix/admin/1c_intranet.php?mode=checkauth`
Возвращает PHPSESSID. Его необходимо в последующем передавать с каждым запросом.
Второй запрос:
`GET http://портал/bitrix/admin/1c_intranet.php?mode=init`
Подготавливает/вычищает папку для загрузки файла. Возвращает что-то вроде `zip=no`
`file_limit=204800`, если всё отработало.
Третий запрос:
`GET http://портал /bitrix/admin/1c_intranet.php?mode=file&PHPSESSID=tmfi6bf67llse3akv7cv13m6h8&filename=import.xml`
В случае успешной передачи и записи файла на сервер возвращает success. Будьте бдительны – нужно передать в Body сам файл бинарно, и указать его название в GET-параметре filename.
Четвертый запрос:
`GET http://портал /bitrix/admin/1c_intranet.php?mode=import&PHPSESSID=tmfi6bf67llse3akv7cv13m6h8&filename=import.xml`
Надо отсылать несколько раз с теми же параметрами, пока не пройдут последовательно все шаги импорта. Все эти шаги также можно вычитать в коде вышеуказанного компонента, осуществляющего импорт. Возвращаемые значения:
`progress`
`Временные таблицы удалены.`
`progress`
`Временные таблицы созданы.`
`progress`
`Файл импорта прочитан.`
`progress`
`Временные таблицы проиндексированы.`
`progress`
`Проверка структуры успешно пройдена.`
`progress`
`Метаданные импортированы успешно.`
`progress`
`Обработано 2 из 2 пользователей.`
`progress`
`Загрузка пользователей завершена.`
`progress`
`Обработано 11 из 11 записей графика отсутствий.`
`progress`
`Загрузка графика отсутствий завершена.`
success
`Импорт успешно завершен.`
### Постскриптум
Наверняка, кто-то из комментаторов укажет на другие инструменты, или сможет поделиться похожим опытом. Возможно, кто-то проведет параллели с импортом каталога из УТ в БУС.
По правде говоря, сам тоже, хоть в статье и опустил, но руководствовался аналогичным опытом. Продолжение следует – в следующей статье расскажу как решалась сама задача породившая такую хитроумную организацию труда. | https://habr.com/ru/post/541694/ | null | ru | null |
# Билд-светофор: история еще одного внедрения
Обсуждая реализацию автотестирования в нашей компании, была предложена идея визуализации результатов с помощью светофора. Данный инструмент прост и понятен каждому, да и к тому же производит небольшой вау эффект. Под катом будет история внедрения светофора в нашу систему автотестов.
##### Поиск и покупка светофора
В интернете огромное количество предложений по покупке светофора. Мы не стали заморачиваться и собирать свой, а сразу купили готовый.
**Технические характеристики транспортного светодиодного светофора ГОСТ Р 52282-2004:**• Минимальное энергопотребление светофора: не более 6Вт (красная и желтая секция) и 8Вт (зеленая секция) на секцию;
• Рабочее напряжение питания: 220В переменного тока, в соответствии с ГОСТ 13109. По испытаниям, электрическая прочность изоляции выдерживает напряжение не менее 1500В с частотой 50Гц без пробоев в течении 1 мин;
• Гарантия от производителя 3 года. Срок службы светофоров не менее 12 лет. Используются долговечные энергосберегающие светодиодные излучатели (СИД).Средний срок службы светодиодов – 100 000 часов;
• Диапазон рабочих температур светодиодных светофоров: от – 60 С до +60 С;
• Светотехнические параметры светофоров, осевая сила света излучателей дорожных светофоров в соответствии с ГОСТ Р 52282-2004;
• Малый вес светофора не более 8 кг;
Светофор стоит недешево. Данная модель обошлась нам почти в 13000 р. Большим плюсом такого светофора является его компактность. Толщина светофора, включая козырьки, составляет 275 мм. Без козырьков 138 мм. Длина 840 мм. В комплекте идут кронштейны, с помощью которых мы повесили его на….шкаф.
##### Электроника
Для управления светофором решили использовать плату дискретных входов-выходов «Quartech – Jackpot – USB», разработанную нашими друзьями.
Плата управления размещена в корпусе светофора и управляет тремя твердотельными реле COSMO, обеспечивающими с большим запасом не только гальваническую развязку, но и необходимую нагрузочную способность (при желании через них можно управлять не одним десятком таких светофоров).
Был разработан и реализован расширяемый протокол управления, позволяющий при помощи этой платы управлять не только светофором, но и множеством других периферийных устройств (питание камер наблюдения, системы управления освещением, различные кнопки и датчики на демонстрационных макетах).
**Описание протокола управления**Весь обмен производится в режиме запрос-ответ со стороны ПК, либо в режиме потоковой выдачи данных в специальном режиме.
###### Физический уровень
Полнодуплексный обмен по USB через виртуальный COM-порт, открытый на скорости 9600кб/c.
###### Транспортный уровень
Обмен между любыми устройствами происходит в режиме прямого подключения. Все сообщения на транспортном уровне имеют стандартизированный формат:
| | | | | | | |
| --- | --- | --- | --- | --- | --- | --- |
| **Поле**
| **Стартовый байт**
| **Размер команды (номер + данные)**
| **Текущий статус**
| **Номер команды**
| **Данные команды**
| **Контрольная сумма**
|
| Размер
| 1
| 1
| 1
| 1
| 0-254
| 1
|
| Значение
| 0x7E
| 1 — 255
0 — ошибка
| Битовое поле, определяющее текущее состояние каждого типа устройств
| 1 — 255
0 — ошибка
| Определяется командой
| *Cумма всех предыдущих полей сообщения, включая стартовый байт*
|
Битовое поле текущего статуса имеет следующие поля:
бит 0: 0 — нормальная работа, 1 — ошибка
бит 1: 0 — режим ожидания запроса, 1 — режим потоковой выдачи данных
###### Командный уровень.
Каждая команда состоит из поля «Номер команды» и опционального поля «Данные команды». Четные номера команд — запросы, нечетные — ответы.
| | | |
| --- | --- | --- |
| **Номер команды**
| **Описание команды**
| **Данные**
|
| 0x01
| Запрос типа устройства
| нет
|
| 0x02
| Ответ типа устройства
| 1 байт:
0 — ошибка
1 — измерительная часть
2 — интерфейсная часть
3 — ПК
|
| 0x03
| Запрос серийного номера
| нет
|
| 0x04
| Ответ серийного номера
| 2 байта
|
| 0x05
| Запрос версии софта
| нет
|
| 0x06
| Ответ версии софта
| 2 байта
|
| 0x07
| Запрос версии железа
| нет
|
| 0x08
| Ответ версии железа
| 2 байта
|
| 0x0A
| Установка состояния порта
| 1 байт
|
| 0x0B
| Запрос состояния порта
| нет
|
| 0x0C
| Ответ состояния порта
| 1 байт
|
| 0x0D
| Включить пищалку, мс
| 1-2 байта
|
| 0x0E
| Запрос состояния джамперов
| нет
|
| 0x0F
| Ответ состояния джамперов
| 1 байт
|
| 0x10
| Запрос состояния входов (оптопар)
| нет
|
| 0x11
| Ответ состояния входов
| 1 байт
|
| 0х12
| Запрос количества фронтов входов
| 1 байт (номер входа)
|
| 0х13
| Ответ количества фронтов входов
| 5 байт:
1-й байт — номер входа
2-3 байты — количество передних фронтов
4-5 байты — количество задних фронтов
|
| 0х14
| Пакетный запрос состояния входов и счетчиков количества фронтов
| нет
|
| 0х15
| Ответ на пакетный запрос состояния входов и счетчиков количества фронтов
| 33 байта:
1-й байт — состояние входов
2-17 байты — количество передних фронтов по 2 байта на вход начиная с нулевого
18-33 байты — количество задних фронтов по 2 байта на вход начиная с нулевого
|
| 0х16
| Сброс счетчиков фронтов
| Нет (в ответ выдается команда 0х15 с нулевыми значениями счетчиков)
|
| 0х20
| Установка битов автоматического мигания выходов
| 1 байт
|
| 0х21
| Запрос установленных битов мигания выходов
| нет
|
| 0х22
| Ответ установленных битов мигания выходов
| 1 байт
|
| 0х23
| Установка периода мигания выхода
| 3 байта:
1-й байт — номер выхода
2-3 байты — период в мс
По умолчанию период равен 500мс. Если байты 2-3 равны 0, то устанавливается период по-умолчанию
|
| 0х24
| Ответ периода мигания выхода
| 3 байта (аналогично команде 0х23)
|
Если ответ на команду не получен в течение защитного интервала, то подключенное устройство считается потерянным.
###### Пример:
Управление выходными линиями платы.
В виртуальный COM-порт необходимо послать команду 0х0A с данными, соответствующими требуемому состоянию выходных линий. Если требуется подать сигнал только на нулевую линию, то в байте данных команд необходимо передать 0х01. Таким образом, вся команда будет иметь следующий вид:
0х7Е 0х02 0х00 0х0А 0х01 0x8B
в ответ на эту команду при возможности её выполнения плата ответит командой 0х0С с данными, соответствующими состоянию установленных выходных линий:
0х7Е 0х02 0х00 0х0С 0х01 0x8D
либо, при невозможности выполнения, сообщит об ошибке:
0х7Е 0х00 0х01 0x7F
##### Система тестирования
Система автоматического тестирования написана на языке python3. С периодичностью в одну минуту проверяется наличие новой ревизии в репозитории. Если такая присутствует, она выкачивается, и на нее «натравливаются» тесты. Тесты — это отдельные скрипты на все том же python3, между которыми есть зависимости. Благодаря зависимостям тесты выстраиваются в определенную последовательность: сначала запускается тест, осуществляющий сборку проекта; следом за ним — «быстрые» тесты; в последнюю очередь — все остальные. Результаты выполнения тестов помещаются в базу данных (sqlite).
Отдельный скрипт реализует web-сервер, который визуализирует результаты выполнения тестов.
Этот же web-сервер научили формировать сводку по совокупности тестов. Данная возможность используется для управления светофором.
**Под катом код скрипта для управления светофором:**
```
#! /usr/bin/env python3
import sys, os, termios, threading, time, http.client
if len(sys.argv)<=1:
sys.exit("Usage: {0} CONFIG-FILE".format(sys.argv[0]))
exec(open(sys.argv[1], "rt").read())
portfd=os.open(serialport, os.O_RDWR)
# Configure serial port - make it "raw", set 9600 baud rate and 8N1
iflag,oflag,cflag,lflag,ispeed,ospeed,cc=tuple(termios.tcgetattr(portfd))
iflag&=~(termios.IGNBRK|termios.BRKINT|termios.PARMRK|termios.ISTRIP|termios.INLCR|termios.IGNCR|termios.ICRNL|termios.IXON)
oflag&=~(termios.OPOST)
lflag&=~(termios.ECHO|termios.ECHONL|termios.ICANON|termios.ISIG|termios.IEXTEN)
cflag&=~(termios.CSIZE|termios.PARENB|termios.CSTOPB)
cflag|=termios.CS8
ispeed=termios.B9600
ospeed=termios.B9600
termios.tcsetattr(portfd, termios.TCSANOW, [iflag, oflag, cflag, lflag, ispeed, ospeed, cc])
# Current state of traffic light:
# 0 - fail (red light)
# 1 - success (green light)
# 2 - in progress (yellow light)
# 3 - no data (blinking yellow)
state=3
RED=0
YELLOW=1
GREEN=2
def trafficLightControl(light):
cmd=[0x7E, 0x02, 0xFF, 0x0A]
if light==RED:
cmd.append(1)
elif light==YELLOW:
cmd.append(2)
elif light==GREEN:
cmd.append(4)
else:
cmd.append(0)
cmd.append(sum(cmd)&0xFF)
os.write(portfd, bytes(cmd))
def controlThreadProc():
while True:
if state==0:
trafficLightControl(RED)
elif state==1:
trafficLightControl(GREEN)
elif state==2:
trafficLightControl(YELLOW)
else:
trafficLightControl(YELLOW)
time.sleep(1.5)
trafficLightControl(None)
time.sleep(1.5)
controlThread=threading.Thread(target=controlThreadProc)
controlThread.start()
def pollThreadProc():
global state
connection=None
while True:
try:
if connection is None:
connection=http.client.HTTPConnection(server)
connection.request("GET", "/{0}/status?test={1}".format(project, ",".join(tests)))
r=connection.getresponse().readall()
state=int(r.decode("ascii"))
except:
state=3
connection=None
time.sleep(5)
pollThread=threading.Thread(target=pollThreadProc)
pollThread.start()
```
В конфигурационном файле указывается адрес сервера и список тестов, за которыми будет следить светофор.
```
server="192.168.2.245"
project="tvz-win-trunk"
tests=['build', 'xmlcheck', 'qdebug', 'runss', 'runssc', 'tr_en', 'trcyr_en', 'warning1', 'warning10', 'warning100', 'xmldeps', 'issue16683a', 'issue17071', 'issue16796', 'runmain', 'issue17319', 'issue17318', 'issue17396a', 'smartstation_su', 'xmlrpcdoc_ss', 'src_encoding', 'issue17241', 'issue17228']
serialport="/dev/ttyUSB0"
```
Логика работы светофора в системе тестов очень проста:
* Красный – тест провален
* Желтый – идёт прогон тестов или перепроверка теста
* Зеленый – все тесты успешно завершились
* Мигание желтым – отсутствует соединение с сервером
##### Итоги
Светофор был размещен перед выходом из офиса. Это дает достаточно ощутимый психологический эффект: горит зеленый сигнал светофора – путь свободен (можно смело идти домой), красный – надо исправлять ошибку. | https://habr.com/ru/post/216743/ | null | ru | null |
# Как Netflix поддерживает надежность сервиса: ограничение нагрузки на основе приоритетов
> ***В преддверии старта курса*** [***"Highload Architect"***](https://otus.pw/4JNj/) ***приглашаем всех желающих посетить открытый вебинар на тему*** [***"Паттерны горизонтального масштабирования хранилищ"***](https://otus.pw/zB3m/)***.***
>
>
> А пока делимся с вами традиционным переводом материала.
>
>
---
#### Пользователи Netflix продолжают смотреть любимые сериалы, пока инфраструктура самостоятельно восстанавливается после системного сбоя
Авторы: [Мануэль Корреа (Manuel Correa)](https://twitter.com/mcorreadev), [Артур Гонингберг (Arthur Gonigberg)](https://twitter.com/agonigberg) и [Даниэль Уэст (Daniel West)](https://www.linkedin.com/in/danieljwest/)
Застрять в пробке — нет ничего хуже для любого водителя в мире. Движение замедляется до скорости черепахи, зачастую из-за какой-то ерунды или вообще без причины. Мы, инженеры из Netflix, постоянно ищем способы улучшения управления трафиком — в нашем случае сетевым, — но представим на минуту, что мы управляем уличным движением. Что если бы мы знали, насколько важно проехать тому или иному водителю, и могли бы выборочно обеспечивать движение отдельных машин, вместо того, чтобы заставлять ждать всех?
Сотрудники технических подразделений Netflix стремятся сделать так, чтобы сервис Netflix работал всегда, когда он вам нужен. И все же, еще совсем недавно (буквально в прошлом году) в наших системах регулярно возникали «пробки». У нас были [автоматические выключатели](https://netflixtechblog.com/introducing-hystrix-for-resilience-engineering-13531c1ab362), но не было прогрессивного способа ограничения нагрузки. Задавшись целью улучшить опыт наших подписчиков, мы внедрили прогрессивное ограничение нагрузки на основе приоритизации запросов.
В приведенной ниже анимации демонстрируется работа интерфейса Netflix, используемого зрителями, когда серверные системы регулируют трафик с учетом приоритета. Запросы с низким приоритетом отбрасываются, но воспроизведение идет без перебоев, поэтому зрители могут наслаждаться любимым сериалом. Давайте разберемся, как мы смогли этого добиться.
Существует масса причин, по которым может возникнуть сбой: неправильно работающие клиенты, вызывающие лавину повторных попыток; служба в серверной системе, у которой недостаточно ресурсов; неправильное развертывание; проблема в работе сети или неполадки у поставщика облачных услуг. Из-за всех подобных сбоев система может оказаться под непредвиденной нагрузкой, и раньше в определенные моменты любой из приведенных случаев вел к тому, что подписчики не могли воспроизводить контент. Понимая все это, мы поставили перед собой задачу сделать Netflix более устойчивым, задавшись следующими целями:
1. Согласованно определять приоритеты запросов для устройств разных типов (мобильные устройства, браузеры и телевизоры).
2. Прогрессивно регулировать выполнение запросов с учетом приоритета.
3. Оценивать предположения относительно приоритета запросов с применением [хаос-инжиниринга](https://netflixtechblog.com/chap-chaos-automation-platform-53e6d528371f) (намеренного внесения сбоя).
Далее приведена итоговая архитектура, которую мы разработали: с регулировкой по приоритету и применением хаос-инжиниринга.
Общая архитектура воспроизведения с регулировкой по приоритету и хаос-инжинирингом
Построение таксономии запросов
------------------------------
Мы решили выделить три измерения для разделения трафика запросов на категории: пропускная способность, функциональность и степень важности. По трем этим характеристикам трафик классифицировался следующим образом:
* **NON\_CRITICAL***.* Этот трафик никак не сказывается на воспроизведении видео или использовании сервиса подписчиками. В качестве примера трафика этого типа можно привести запросы журналов и фоновые запросы. Этим запросам обычно требуется значительная пропускная способность, что влечет за собой высокий процент нагрузки на систему.
* **DEGRADED\_EXPERIENCE**. Этот трафик сказывается на том, как подписчики могут использовать сервис, но не влияет на возможность воспроизводить видео. Трафик из этой категории используется для таких функций, как маркеры остановки и паузы, выбор языка в проигрывателе, история просмотра и др.
* **CRITICAL**. Этот трафик влияет на способность воспроизводить видео. Если запрос завершается неудачно, на экранах подписчиков отображается сообщение об ошибке.
По атрибутам запросов служба шлюза API ([Zuul](https://github.com/Netflix/zuul)) относит запросы к категориям NON\_*CRITICAL, DEGRADED\_*EXPERIENCE и CRITICAL и вычисляет значение приоритета в диапазоне от 1 до 100 для каждого запроса с учетом его индивидуальных характеристик. Это вычисление выполняется в первую очередь, чтобы его результат был доступен в течение остальной части жизненного цикла запроса.
Большую часть времени процесс обработки запросов выполняется как обычно, а приоритет запроса никак при этом не учитывается. Однако, как и в любом сервисе, у нас периодически возникают проблемы в различных серверных системах или в самой системе Zuul. В этом случае запросы с более высоким приоритетом обрабатываются в первую очередь. Запросы с более высоким приоритетом обслуживаются, а запросы, приоритет которых ниже, отбрасываются. Такая реализация аналогична очереди с динамическим порогом приоритета. В результате Zuul отбрасывает запросы, приоритет которых ниже текущего порога.
Определение лучшего места для регулировки трафика
-------------------------------------------------
Система Zuul может применять ограничение нагрузки в двух точках жизненного цикла запросов: когда она направляет запросы в конкретную серверную службу (регулировка служб) или во время первоначальной обработки запросов, что сказывается на всех серверных службах (глобальная регулировка).
### Регулировка служб
Система Zuul может определять, когда серверная служба испытывает проблемы, отслеживая частоту появления ошибок и количество одновременных запросов к этой службе. Эти два показателя являются косвенными индикаторами сбоев и задержки. Когда превышается пороговое процентное значение для одного из этих показателей, мы понижаем нагрузку на эту службу, регулируя трафик.
### Глобальная регулировка
Другой случай, когда проблемы испытывает уже сама система Zuul. В отличие от описанной выше ситуации, глобальная регулировка затрагивает *все* серверные службы, находящиеся позади Zuul, а не какую-то *одну* из них. Такое глобальное регулирование может стать причиной намного более значительных проблем для подписчиков. Ключевыми показателями, используемыми для запуска глобального регулирования, являются загрузка ЦП, количество одновременных запросов и количество подключений. При превышении любого порога для этих показателей система Zuul начинает агрессивно регулировать трафик, чтобы обеспечить свою работоспособность на время восстановления системы. Эта функция имеет важнейшее значение: если система Zuul выйдет из строя, трафик вообще не сможет проходить через наши серверные службы, что приведет к полной остановке работы сервиса.
Внедрение прогрессивного ограничения нагрузки на основе приоритетов
-------------------------------------------------------------------
Когда система определения приоритетов была готова, мы смогли объединить ее с нашим механизмом ограничения нагрузки и значительно повысить надежность стриминга. Когда мы оказываемся в сложной ситуации (например, при превышении любых из описанных выше пороговых значений), мы прогрессивно отбрасываем трафик, начиная с трафика с самым низким приоритетом. Для управления уровнем регулирования трафика используется кубическая функция. Когда все становится совсем плохо, уровень достигает острия кривой и под регулирование попадает весь трафик.
Приведенный выше график — это пример применения кубической функции. По мере роста процента перегрузки (то есть диапазона между порогом регулирования и максимальной емкостью) порог приоритета реагирует очень медленно: при 35 % он все еще составляет более 90 %. Если же работоспособность системы продолжает ухудшаться, то порог приоритета опускается до 50 при 80 %, а затем постепенно падает до 10 при 95 % и т. д.
С учетом того что относительно небольшое количество запросов оказывает влияние на доступность стриминга, регулирование трафика с низким приоритетом может сказаться на некоторых функциях продукта, но не помешает подписчикам нажать кнопку Play и посмотреть любимый сериал. За счет прогрессивного ограничения нагрузки с учетом приоритетов система Zuul может ограничивать *достаточный* объем трафика и стабилизировать работу сервиса так, что подписчики этого даже не замечают.
### Обработка лавины повторных попыток
Когда система Zuul принимает решение отбросить трафик, она отправляет устройствам сигнал, сообщающий, что им нужно сбавить обороты. Делает она это путем указания количества повторных попыток, которые они могут выполнить, а также промежутка времени, в течение которого они могут это делать. Например:
```
{ “maxRetries” : , “retryAfterSeconds”: }
```
С помощью такого контрольного механизма мы можем останавливать лавины повторных попыток намного быстрее, чем в прошлом. Мы автоматически регулируем эти два показателя с учетом приоритета запроса. Запросы с более высоким приоритетом могут повторяться агрессивнее, чем запросы с более низким приоритетом, что также повышает доступность стриминга.
Проверка правильности классификации запросов
--------------------------------------------
Чтобы проверить, правильно ли тот или иной запрос классифицирован в рамках нашей таксономии запросов (NON\_CRITICAL, DEGRADED или CRITICAL), нам нужен был способ оценить уровень комфорта пользователя в момент, когда этот запрос отбрасывается. Для этого мы использовали наш внутренний инструмент внедрения сбоев ([FIT](https://netflixtechblog.com/fit-failure-injection-testing-35d8e2a9bb2)) и создали точку внедрения сбоев в Zuul, с помощью которой мы могли отбросить любой запрос по указанному приоритету. Это дало нам возможность вручную имитировать ограничение нагрузки путем блокировки диапазонов приоритетов для определенного устройства или подписчика, чтобы получить представление о том, какие запросы можно спокойно отбрасывать, никак не затрагивая пользователя.
Постоянный пересмотр классификации запросов
-------------------------------------------
Одной из целей является снижение неудобства подписчиков путем отбрасывания запросов, которые, как ожидается, не повлияют на просмотр контента. Однако Netflix быстро изменяется, и запросы, которые одно время считались неважными, могут совершенно неожиданно стать важными. Кроме того, у Netflix широкий спектр клиентских устройств, версий клиентов и способов взаимодействия с системой. Чтобы гарантировать, что мы не причиняем неудобств подписчикам при регулировании запросов категории NONCRITICAL в любой из описанных ситуаций, мы использовали нашу платформу для экспериментов с инфраструктурой — [ChAP](https://netflixtechblog.com/chap-chaos-automation-platform-53e6d528371f).
Эта платформа позволяет нам проводить A-/B-тестирование, при котором небольшое количество действующих подписчиков на 45 минут добавляется в контрольную и экспериментальную группы, после чего для экспериментальной группы выполняется регулирование запросов с различными приоритетами в течение этого времени. Это позволяет нам отслеживать различные реальные ситуации и оценивать их влияние на то, как сервис воспроизводит видео для пользователей. Платформа ChAP анализирует показатели KPI для каждого устройства подписчиков и определяет, есть ли отклонения в показателях контрольной и экспериментальной групп.
При проведении первого эксперимента мы обнаружили состояние гонки на устройствах Android и iOS для запроса с низким приоритетом, который вызывал спорадические ошибки воспроизведения. После завершения первоначальных экспериментов и устранения ошибок мы запланировали периодическое выполнение таких экспериментов. Таким образом, мы можем выявлять регрессии на ранних стадиях и поддерживать работоспособность сервиса.
Эксперименты для обнаружения регрессии до и после исправления ошибки (показатель [SPS](https://netflixtechblog.com/sps-the-pulse-of-netflix-streaming-ae4db0e05f8a) указывает доступность стриминга)
Пожинаем плоды
--------------
В 2019 году до внедрения прогрессивного ограничения нагрузки в работах служб стриминга Netflix возникали перебои, из-за которых значительное число подписчиков не могло смотреть видео в течение некоторого времени. В 2020 году, спустя считаные дни после развертывания решения, инженерная группа начала отмечать преимущества его внедрения. В системах Netflix возникала похожая проблема, потенциальным следствием которой мог стать такой же перебой в работе сервиса, как и в 2019 году. Однако система прогрессивного ограничения нагрузки Zuul включилась и стала ограничивать трафик, пока работоспособность сервиса не была восстановлена в полном объеме. При этом способность подписчиков просматривать видео не пострадала вовсе.
На приведенном ниже графике показан стабильный показатель доступности стриминга: [число потоков в секунду (SPS)](https://netflixtechblog.com/sps-the-pulse-of-netflix-streaming-ae4db0e05f8a), когда система Zuul выполняет прогрессивное ограничение нагрузки с учетом приоритета во время инцидента. Разными цветами на графике отмечены запросы с разными приоритетами, выполнение которых регулируется.
Подписчики спокойно смотрели свои любимые сериалы на Netflix, пока инфраструктура самостоятельно восстанавливалась после системного сбоя.
Это еще не все
--------------
В будущем наша группа собирается применять приоритизацию запросов в других областях, среди которых улучшение политики обработки повторных запросов от устройств к серверным системам, динамическое изменение пороговых значений ограничения нагрузки, настройка приоритетов запросов на основе хаос-инжиниринга, а также в тех областях, которые позволят сделать Netflix еще более устойчивым.
Если вы заинтересованы помочь Netflix продолжать работать, несмотря на нестабильность систем и непредвиденные сбои, свяжитесь с нами.
---
> [**Узнать подробнее о курсе**](https://otus.pw/4JNj/) **"Highload Architect".**[**Записаться на открытый урок**](https://otus.pw/zB3m/) **"Паттерны горизонтального масштабирования хранилищ".**
>
> | https://habr.com/ru/post/531320/ | null | ru | null |
# ElasticSearch — агрегация данных
В статье мы рассмотрим, как правильно реализовывать агрегацию данных, зачем это может понадобиться, и сдобрим это кучей рабочих примеров.
Для всех, кому интересно как сделать свои запросы в ES интереснее и посмотреть на обычной поиск с другой стороны, прошу под кат.
*В предыдущей [статье](http://habrahabr.ru/company/smartprogress/blog/226749/) пользователи разделились поровну между статьёй по более простой теме и по более сложной, поэтому я выбрал не очень сложную тему, но довольно свежую, которая добавилась в ES относительно недавно(v1.0) и несёт довольно интересный функционал.*
#### Aggregation module
Этот модуль пришел в ES на смену Facets, причем в настойчивой форме, Facets теперь считаются устаревшими и будут удалены в ближайшие релизы. Хотя агрегаты и были добавлены в v1.0.0RC1, а сейчас уже >1.2, я все же не рекомендую использовать Facets.
Зачем же понадобилось изменять рабочий инструмент?
Наверное, главной фишкой агрегатов является их вложенность. Приведу общий синтаксис запроса:
```
"aggregations" : {
"" : {
"" : {
}
[,"aggregations" : { []+ } ]?
}
[,"" : { ... } ]\*
}
```
Как видно из структуры, агрегатов может быть сколь угодно много, и у каждого элемента может быть вложенный элемент без ограничений по глубине.
Используя вложенность, мы можем получить очень интересные статистические данные (пример в конце статьи).
##### Типы агрегатов
Типов агрегатов [очень много](http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/search-aggregations-metrics-min-aggregation.html), но все их можно объединить в 2 главных типа:
**— Bucketing (Обобщение)**
Для простоты понимания, это можно сравнить со всем знакомым инструментов «GROUP BY». Конечно, это довольно упрощенное сравнение, но принцип работы схож. Этот тип на основе фильтров обобщает документы, по какому-то определённому признаку, хороший пример это [terms aggregation](http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/search-aggregations-bucket-terms-aggregation.html).
**— Metric (Метрические)**
Это агрегаты, которые высчитывают какие либо значение по определенному набору документов. Например [sum aggregation](http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/search-aggregations-metrics-sum-aggregation.html)
Думаю, для начало теории хватит, всем, кого интересует более фундаментальная информация по этому модулю, могут ознакомится с ней [по этой ссылке](http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/search-aggregations.html).
#### Простой пример
Желающим попробовать всё собственноручно предлагаю использовать этот дамп
**Структура и данные для теста**Дамп наглым образом взят из этой прекрасной [статьи](http://blog.qbox.io/elasticsearch-aggregations)
```
curl -XPUT "http://localhost:9200/sports/" -d'
{
"mappings": {
"athlete": {
"properties": {
"birthdate": {
"type": "date",
"format": "dateOptionalTime"
},
"location": {
"type": "geo_point"
},
"name": {
"type": "string"
},
"rating": {
"type": "integer"
},
"sport": {
"type": "string"
}
}
}
}
}'
curl -XPOST "http://localhost:9200/sports/_bulk" -d'
{"index":{"_index":"sports","_type":"athlete"}}
{"name":"Michael", "birthdate":"1989-10-1", "sport":"Baseball", "rating": ["5", "4"], "location":"46.22,-68.45"}
{"index":{"_index":"sports","_type":"athlete"}}
{"name":"Bob", "birthdate":"1989-11-2", "sport":"Baseball", "rating": ["3", "4"], "location":"45.21,-68.35"}
{"index":{"_index":"sports","_type":"athlete"}}
{"name":"Jim", "birthdate":"1988-10-3", "sport":"Baseball", "rating": ["3", "2"], "location":"45.16,-63.58" }
{"index":{"_index":"sports","_type":"athlete"}}
{"name":"Joe", "birthdate":"1992-5-20", "sport":"Baseball", "rating": ["4", "3"], "location":"45.22,-68.53"}
{"index":{"_index":"sports","_type":"athlete"}}
{"name":"Tim", "birthdate":"1992-2-28", "sport":"Baseball", "rating": ["3", "3"], "location":"46.22,-68.85"}
{"index":{"_index":"sports","_type":"athlete"}}
{"name":"Alfred", "birthdate":"1990-9-9", "sport":"Baseball", "rating": ["2", "2"], "location":"45.12,-68.35"}
{"index":{"_index":"sports","_type":"athlete"}}
{"name":"Jeff", "birthdate":"1990-4-1", "sport":"Baseball", "rating": ["2", "3"], "location":"46.12,-68.55"}
{"index":{"_index":"sports","_type":"athlete"}}
{"name":"Will", "birthdate":"1988-3-1", "sport":"Baseball", "rating": ["4", "4"], "location":"46.25,-68.55" }
{"index":{"_index":"sports","_type":"athlete"}}
{"name":"Mick", "birthdate":"1989-10-1", "sport":"Baseball", "rating": ["3", "4"], "location":"46.22,-68.45"}
{"index":{"_index":"sports","_type":"athlete"}}
{"name":"Pong", "birthdate":"1989-11-2", "sport":"Baseball", "rating": ["1", "3"], "location":"45.21,-68.35"}
{"index":{"_index":"sports","_type":"athlete"}}
{"name":"Ray", "birthdate":"1988-10-3", "sport":"Baseball", "rating": ["2", "2"], "location":"45.16,-63.58" }
{"index":{"_index":"sports","_type":"athlete"}}
{"name":"Ping", "birthdate":"1992-5-20", "sport":"Baseball", "rating": ["4", "3"], "location":"45.22,-68.53"}
{"index":{"_index":"sports","_type":"athlete"}}
{"name":"Duke", "birthdate":"1992-2-28", "sport":"Baseball", "rating": ["5", "2"], "location":"46.22,-68.85"}
{"index":{"_index":"sports","_type":"athlete"}}
{"name":"Hal", "birthdate":"1990-9-9", "sport":"Baseball", "rating": ["4", "2"], "location":"45.12,-68.35"}
{"index":{"_index":"sports","_type":"athlete"}}
{"name":"Charge", "birthdate":"1990-4-1", "sport":"Baseball", "rating": ["3", "2"], "location":"46.12,-68.55"}
{"index":{"_index":"sports","_type":"athlete"}}
{"name":"Barry", "birthdate":"1988-3-1", "sport":"Baseball", "rating": ["5", "2"], "location":"46.25,-68.55" }
{"index":{"_index":"sports","_type":"athlete"}}
{"name":"Bank", "birthdate":"1988-3-1", "sport":"Golf", "rating": ["6", "4"], "location":"46.25,-68.55" }
{"index":{"_index":"sports","_type":"athlete"}}
{"name":"Bingo", "birthdate":"1988-3-1", "sport":"Golf", "rating": ["10", "7"], "location":"46.25,-68.55" }
{"index":{"_index":"sports","_type":"athlete"}}
{"name":"James", "birthdate":"1988-3-1", "sport":"Basketball", "rating": ["10", "8"], "location":"46.25,-68.55" }
{"index":{"_index":"sports","_type":"athlete"}}
{"name":"Wayne", "birthdate":"1988-3-1", "sport":"Hockey", "rating": ["10", "10"], "location":"46.25,-68.55" }
{"index":{"_index":"sports","_type":"athlete"}}
{"name":"Brady", "birthdate":"1988-3-1", "sport":"Football", "rating": ["10", "10"], "location":"46.25,-68.55" }
{"index":{"_index":"sports","_type":"athlete"}}
{"name":"Lewis", "birthdate":"1988-3-1", "sport":"Football", "rating": ["10", "10"], "location":"46.25,-68.55" }'
```
Давайте сгруппируем спортсменов по их виду спорта и узнаем сколько их в каждом спорте:
```
curl -XPOST "http://localhost:9200/sports/athlete/_search?pretty" -d'
{
"size": 0,
"aggregations": {
"the_name": {
"terms": {
"field": "sport"
}
}
}
}'
```
Тут мы используем агрегат «terms», который группирует документа по полю «sport».
`"size" : 0` (0 заменяется на Integer.MAX\_VALUE автоматически) говорит о том, что нам нужные все документы без исключения, в нашем случае не важна скорость, но надо учитывать, что более точный результат требует больше времени.
Ответ:
```
{
...
"aggregations" : {
"the_name" : {
"buckets" : [ {
"key" : "baseball",
"doc_count" : 16
}, {
"key" : "golf",
"doc_count" : 2
}, {
"key" : "basketball",
"doc_count" : 1
}, {
"key" : "football",
"doc_count" : 1
}, {
"key" : "hockey",
"doc_count" : 1
} ]
}
}
}
```
Отлично, бейсболистов больше всего.
Давайте отсортируем спортсменов по среднему значению их рейтинга, от большего к меньшему:
```
curl -XPOST "http://localhost:9200/sports/athlete/_search?pretty" -d'
{
"size": 0,
"aggregations": {
"the_name": {
"terms": {
"field": "name",
"order": {
"rating_avg": "desc"
}
},
"aggregations": {
"rating_avg": {
"avg": {
"field": "rating"
}
}
}
}
}
}'
```
Тут отлично видно, что такое вложенный агрегат и как он может помочь нам выбрать документы максимально гибко.
Сначала мы указываем, что нужно сгруппировать спортсменов по имени, потом отсортировать по «rating\_avg», который высчитывается в под агрегате «avg», по полю «rating». Заметьте, как элегантно ES работает с массивами (`"rating" : [10, 9]`) и с легкостью высчитывает среднее значение.
Ответ:
```
{
...
"aggregations" : {
"the_name" : {
"buckets" : [ {
"key" : "brady",
"doc_count" : 1,
"rating_avg" : {
"value" : 10.0
}
}, {
"key" : "wayne",
"doc_count" : 1,
"rating_avg" : {
"value" : 10.0
}
}, {
"key" : "james",
"doc_count" : 1,
"rating_avg" : {
"value" : 9.0
}
}, {
"key" : "bingo",
"doc_count" : 1,
"rating_avg" : {
"value" : 8.5
}
},
... {} ...
{
"key" : "duke",
"doc_count" : 1,
"rating_avg" : {
"value" : 3.5
}
}, {
"key" : "bob",
"doc_count" : 1,
"rating_avg" : {
"value" : 3.5
}
} ]
}
}
}
```
Еще одна прекрасная возможность агрегатов это использование `"script"`. Например:
```
curl -XPOST "http://localhost:9200/sports/athlete/_search?pretty" -d'
{
"size": 0,
"aggregations": {
"age_ranges": {
"range": {
"script": "DateTime.now().year - doc[\"birthdate\"].date.year",
"ranges": [
{
"from": 22,
"to": 25
}
]
}
}
}
}'
```
**Начиная с версии 1.2.0 выполнение скриптов по умолчанию отключено.** Вы можете [его включить](http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/modules-scripting.html), при условии что у пользователей нет прямого доступа к ES (Надеюсь, что это так, иначе советую вам немедленно закрыть этот доступ ради безопасности ваших данных).
#### Агрегация во всей красе или что-то посложнее
Давайте найдём всех спортсменов, которые находятся в радиусе 20 миль от точки `"46.12,-68.55"`
Сгруппируем их по виду спорта и выведем подробную статистику по рейтингу спортсменов в этом виде спорта.
Звучит неплохо, а вот и пример.
```
curl -XPOST "http://localhost:9200/sports/athlete/_search?pretty" -d'
{
"size": 0,
"aggregations": {
"baseball_player_ring": {
"geo_distance": {
"field": "location",
"origin": "46.12,-68.55",
"unit": "mi",
"ranges": [
{
"from": 0,
"to": 20
}
]
},
"aggregations": {
"sport": {
"terms": {
"field": "sport"
},
"aggregations": {
"rating_stats": {
"stats": {
"field": "rating"
}
}
}
}
}
}
}
}
}'
```
Ответ:
```
{
...
"aggregations" : {
"baseball_player_ring" : {
"buckets" : [ {
"key" : "*-20.0",
"from" : 0.0,
"to" : 20.0,
"doc_count" : 13,
"sport" : {
"buckets" : [ {
"key" : "baseball",
"doc_count" : 8,
"rating_stats" : {
"count" : 14,
"min" : 2.0,
"max" : 5.0,
"avg" : 3.357142857142857,
"sum" : 47.0
}
}, {
"key" : "golf",
"doc_count" : 2,
"rating_stats" : {
"count" : 4,
"min" : 4.0,
"max" : 10.0,
"avg" : 6.75,
"sum" : 27.0
}
}, {
"key" : "basketball",
"doc_count" : 1,
"rating_stats" : {
"count" : 2,
"min" : 8.0,
"max" : 10.0,
"avg" : 9.0,
"sum" : 18.0
}
}, {
"key" : "football",
"doc_count" : 1,
"rating_stats" : {
"count" : 1,
"min" : 10.0,
"max" : 10.0,
"avg" : 10.0,
"sum" : 10.0
}
}, {
"key" : "hockey",
"doc_count" : 1,
"rating_stats" : {
"count" : 1,
"min" : 10.0,
"max" : 10.0,
"avg" : 10.0,
"sum" : 10.0
}
} ]
}
} ]
}
}
}
```
#### Заключение
Надеюсь, я смог донести общие возможности этого прекрасного модуля. Всем, кого это тема заинтересовала, я советую ознакомиться со всем списком фильтров по [этой ссылке](http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/search-aggregations.html).
Рад любым полезным замечаниям и дополнениям по теме.
Так же можно прочитать мою предыдущую статью по ES — [ElasticSearch и поиск наоборот. Percolate API](http://habrahabr.ru/company/smartprogress/blog/226749/)
И принять участие в голосование внизу статьи.
[
— Достижение целей](https://smartprogress.do) | https://habr.com/ru/post/227131/ | null | ru | null |
# Метод Finite Volume — реализация на примере теплопроводности
В статье описывается реализация известного метода конечных объемов для численного решения уравнений в частных производных.Используется разбиение области на любые стандартные элементы(конечные объемы) — треугольники, четырехугольники и т.д.Метод визуализации результатов расчетов также самописный.
### **Метод Finite Volume (FVM)**
В основе метода лежит разбиение области на непересекающиеся контрольные объемы(элементы), узловые точки, в которых ищется решение.Узловые точки находятся в центрах контрольных объемов.Также, как и для метода конечных разностей, для каждого элемента составляется уравнение, получается система линейных уравнений.Решая ее — находим значения
искомых переменных в узловых точках.Для отдельного элемента уравнение получается путем интегрирования исходного дифф уравнения по элементу и аппроксимации интегралов.
Термин конечный объем в статье будет часто заменятся на Элемент, будем для удобства считать их эквивалентами (элемент в данной статье не имеет ничего общего с методом конечных элементов).
Есть 2 различных способа решения задачи по FVM:
1) грани контрольного объема совпадают с гранями элемента
2) грани контрольного объема проходят через центры граней элементов(на которые разбита область).Искомые переменные хранятся в вершинах этих элементов.Вокруг каждой вершины строится контрольный объем. Для непрямоугольной сетки этот способ имеет еще 2 подвида.
Мы будем использовать способ 1) с контрольными объемами совпадающими с элементами на которые разбита область.
Некоторые плюсы FVM:
* сохранение основных величин по всей области, таких как энергия системы, масса, тепловые потоки и тд.Причом это условие выполняется даже для грубой расчетной сетки
* высокая скорость расчета.Многие расчетные величины можно вычислить при разбиении области на элементы, и вычислять их на каждом шаге по времени нет необходимости.
* легкость использования для задач со сложной геометрией и криволинейными границами.Легкость использования разных геометрических типов элементов — треугольники, полигоны.
Метод FVM реализуем на примере уравнения теплопроводности:
Итак основные шаги при реализации FVM:
1. Перевод дифф уравнения в форму пригодную для FVM — интегрирование по контрольному объему
2. Составление дискретного аналога, выбор способа перевода производных и других подынтегральных выражений в дискретную форму
3. Получение уравнения для каждого из контрольных объемов, на которые разбита область.Составление системы линейных уравнений и ее решение.
### **Дискретизация по времени.**
Для производной по времени используем стандартный простейший метод Эйлера.Это будет явная схема по времени, где берутся искомые с предыдущего шага.А на первом шаге задаются как начальные условия.
### **Немного теории или первый шаг в реализации FVM**
Используя теорему о дивергенции интеграл по объему преобразуется в интеграл по площади.Смысл в том что интегрирование по всему внутреннему объему нашего элемента мы заменяем на интегрирование только по поверхности этого объема.Эта формулировка больше подходит для 3D случая.Для 2D у нас будет вместо объема V — площадь элемента, а вместо S — периметр элемента.Тоесть получается что интеграл по площади заменяется интегралом по периметру.Фактически у нас понижается степень производной.Если например была вторая производная то остается только первая, если была первая — то вместо производной будет искомая переменная.Надо только не забывать что имеем дело не с обычной производной а с дивергенцией.
Итак второй терм в нашем уравнении после интегрирования преобразуется так:
### **FVM на стандартной прямоугольной сетке**
На рисунке изображен Элемент С и его соседние элементы **справа(E), слева(W), сверху(N) и снизу(S)**.У элемента С есть 4 грани обозначенные буквами **e w n s**.Именно эти 4 грани и составляют периметр элемента и по ним производится интегрирование.Для каждого элемента в результате получаем дискретный аналог исходного дифф уравнения.
Составим дискретный аналог для элемента С.Для начала нужно разобраться с интегралом (3).Интеграл это ведь по факту сумма.Поэтому мы и заменяем интеграл по всей поверхности элемента, на сумму по 4-м составляющим этой поверхности, тоесть 4 граням элемента.
Индексы **e w n s** здесь обозначают что выражение или переменная вычисляется в центре соответствующей грани.
Теперь соберем вместе полученные упрощения частей исходного дифф уравнения — термы (2) и (4).Получим первую ступень аппроксимации:
Теперь нам осталось только до конца аппроксимировать (4), поскольку туда входит градиент, его то нам и надо перевести в численную форму.Фактически эта сумма представляет сумму потоков тепла через грани.Наш случай упрощается для прямоугольной сетки, т.к у нормали к грани остается только 1 компонент — либо вдоль оси х либо вдоль y.
Разберем подробно этот процесс на примере грани e.
Теперь подставим вместо суммы в уравнении (5) полученные дискретные аналоги для 4-х граней:
Уравнение (7) и есть конечное уравнение для элемента С, из него мы на каждом шаге по времени получаем новое значение температуры (Tnew) в элементе С.
### **Граничные условия на прямоугольной сетке**
На рисунке показан элемент С у которого грань e находится на границе и значения температуры на этой грани известны — либо как заданная температура либо как заданный поток тепла через грань.
Мы рассмотрим только 2 вида граничных условий.
1. Задана температура Tb на границе
2. Задан поток FluxB на границе, рассмотрим только случай когда FluxB=0, т.е. грань e будет теплоизолирована(Insulated)
Случай 2) самый простой, поскольку получается что грань e не потребуется при дискретизации(т.к. все коэффициенты Flux=0) и можно ее просто пропустить.
Теперь рассмотрим случай 1).Дискретизация грани e будет в целом похожа на ту что уже была описана.Будут только 2 изменения — вместо Te будет известное граничное значение Tb и вместо расстояния DXe будет DXe/2.В остальном можно рассматривать значение Te так, как будто это был бы обычный соседний узел E.Теперь подробнее распишем терм для граничного элемента С.
### **Пример численных расчетов на прямоугольной сетке**
В качестве примера рассмотрим область разбитую на 9 элементов, сетка 3\*3.На первых слайдах применены следующие граничные условия: по 3 сторонам температура T=0, снизу задана температура T=240.На второй строке слайдов по бокам заданы граничные условия с потоком Flux=0, сверху T=0, снизу T=240.По каждому случаю 2 картинки, одна с разбивкой области 3\*3 элемента, вторая 40\*40.
**Код расчетов для обоих случаев (в исходниках называется heat2dminimum )**
```
public void RunPhysic()
{
double Tc, Te, Tw, Tn, Ts;
double FluxC, FluxE, FluxW, FluxN, FluxS;
double dx = 0;
double Tb = 240;
double Tb0 = 0;
int i, j;
for (i = 0; i < imax; i++)
for (j = 0; j < jmax; j++)
{
Tc = T[i, j];
dx = dh;
if (i == imax - 1) { Te = Tb0; dx = dx / 2; }
else
Te = T[i + 1, j];
FluxE = (-k * FaceArea) / dx;
if (i == 0) { Tw = Tb0; dx = dx / 2; }
else
Tw = T[i - 1, j];
FluxW = (-k * FaceArea) / dx;
if (j == jmax - 1) { Tn = Tb0; dx = dx / 2; }
else
Tn = T[i, j + 1];
FluxN = (-k * FaceArea) / dx;
if (j == 0) { Ts = Tb; dx = dx / 2; }
else
Ts = T[i, j - 1];
FluxS = (-k * FaceArea) / dx;
FluxC = FluxE + FluxW + FluxN + FluxS;
T[i, j] = Tc + delt * (FluxC * Tc - (FluxE * Te + FluxW * Tw + FluxN * Tn + FluxS * Ts));
}
}
//Insulated
public void RunPhysic2()
{
double Tc, Te, Tw, Tn, Ts;
double FluxC, FluxE, FluxW, FluxN, FluxS;
double dx = 0;
double Tb = 240;
double Tb0 = 0;
int i, j;
for (i = 0; i < imax; i++)
for (j = 0; j < jmax; j++)
{
Tc = T[i, j];
dx = dh;
Te = 0; Tw = 0;
if (i == imax - 1)
FluxE = 0;
else
{
Te = T[i + 1, j];
FluxE = (-k * FaceArea) / dx;
}
if (i == 0)
FluxW = 0;
else
{
Tw = T[i - 1, j];
FluxW = (-k * FaceArea) / dx;
}
if (j == jmax - 1) { Tn = Tb0; dx = dx / 2; }
else
Tn = T[i, j + 1];
FluxN = (-k * FaceArea) / dx;
if (j == 0) { Ts = Tb; dx = dx / 2; }
else
Ts = T[i, j - 1];
FluxS = (-k * FaceArea) / dx;
FluxC = FluxE + FluxW + FluxN + FluxS;
T[i, j] = Tc + delt * (FluxC * Tc - (FluxE * Te + FluxW * Tw + FluxN * Tn + FluxS * Ts));
}
}
```
### **FVM в задачах со сложной геометрией**
Здесь как раз проявляется преимущество FVM, где также, как и в методе конечных элементов, можно представлять область с круглыми границами через разбиение на треугольники или любые другие полигоны.Но FVM имеет еще 1 плюс — при переходе от треугольников к полигонам с большим числом сторон не требуется абсолютно ничего менять, конечно если код был написан для произвольного треугольника а не равностороннего.Более того, можно без изменения кода использовать смесь разных элементов — треугольники, полигоны, квадраты и тд.
Рассмотрим общий случай, когда вектор соединяющий центры 2-х элементов не совпадает с вектором нормали к общей грани этих элементов.Вычисление потока flux через грань теперь будет состоять из 2-х частей.В первой будет расcчитываться ортогональная составляющая а во второй так называемая «кросс-диффузия».
На картинке изображены 2 элемента, С — текущий рассматриваемый элемент и F — соседний элемент.Опишем дискретизацию для грани, разделяющей эти 2 элемента.Вектор соединяющий центры элементов — DCF.Вектор e — это единичный вектор по направлению DCF.Вектор Sf — направлен по нормали к грани, его длинна равна длине грани.
Схема расчетов выглядит примерно так.
Второй терм здесь это кросс-диффузия, она будет тем больше, чем больше расхождение между векторами Ef и Sf, если они совпадают, то она равна 0.
Распишем сначала ортогональную часть(способ minimum correction).
В исходниках я не стал реализовывать терм с кроссдиффузией, т.к встал вопрос — как проверить корректность такой реализации.Визуально сравнение результатов Матлаб и моих ничем не отличалось в отсутствии кросс-диффузии.Видимо это связано с тем что Матлаб любит треугольники близкие к равносторонним, что в итоге делает кроссдиффузию=0.Возможно позже еще вернусь к этому вопросу.
Расчет граничных элементов ничем не отличается от расчетов не на границе, вместо центра соседнего элемента берется центр грани, ну и как обычно подставляется температура на границе.
В моей реализации в итоге получается так:
**Код расчетов для произвольного полигона (в исходниках называется heat2PolyTeach )**
```
public void Calc()
{
double bc, ac;
double sumflux;
double[] aa = new double[6];
double[] bb = new double[6];
int e;
for (e = 0; e < elementcount; e++)
{
Element elem = elements[e];
int nf;
bc = 0;
ac = 0;
sumflux = 0;
for (int nn = 0; nn <6; nn++)
{
aa[nn] = 0;
bb[nn] = 0;
}
for (nf = 0; nf < elem.vertex.Length; nf++)
{
Face face = elem.faces[nf];
Element nb = elem.nbs[nf];
if (face.isboundary)
{
if (face.boundaryType == BoundaryType.BND_CONST)
{
double flux1;
double flux;
flux1 = elem.k * (face.area / elem.nodedistances[nf]);
Vector2 Sf = face.sf.Clone();
Vector2 dCf = elem.cfdistance[nf].Clone();
if (Sf * dCf < 0)
Sf = -Sf;
//1) minimum correction
//Vector2 DCF = elem.cndistance[nf].Clone();
Vector2 e1 = dCf.GetNormalize();
Vector2 EF = (e1 * Sf) * e1;
flux = elem.k * (EF.Length() / dCf.Length());
ac += flux;
bc += flux * face.bndu;
bb[nf] = flux;
}
else if (face.boundaryType == BoundaryType.BND_INSULATED)
{
double flux;
flux = 0;
ac += flux;
bc += flux * face.bndu;
bb[nf] = flux;
}
}
else
{
double flux1;
double flux;
flux1 = -elem.k * (face.area / elem.nodedistances[nf]);
Vector2 Sf = face.sf.Clone();
Vector2 dCf = elem.cfdistance[nf].Clone();
if (Sf * dCf < 0)
Sf = -Sf;
Vector2 DCF = elem.cndistance[nf].Clone();
Vector2 e1 = DCF.GetNormalize();
//corrected flux
//1) minimum correction
Vector2 EF = (e1 * Sf) * e1;
flux = -elem.k * (EF.Length() / DCF.Length());
sumflux += flux * nb.u;
ac += -flux;
aa[nf] = -flux;
}
}
elem.u = elem.u + delt * (bc - sumflux - ac * elem.u);
}
}
```
### **Примеры и проверка результатов**
Проверка проводилась сравнением результатов в Матлаб и моей реализации. Mesh использовалась одинаковая, выгружалась из Матлаб и загружалась в прогу.На некоторые артефакты-треугольники не обращайте внимания, это просто непонятный глюк отрисовки.
### **Описание структуры исходников**
[Гитхаб с исходниками лежит тут](https://github.com/nexscifix/FiniteVolume)
Основная версия в папке heat2PolyV2.То что относится к вычислительной части лежит в heat2PolyV2\Src\FiniteVolume\.
Вначале файла Scene2.cs — параметры которые можно менять для отображения в разных цветовых схемах, масштаб, отображение mesh и т.д.Сами примеры хранятся в heat2PolyV2\bin\Debug\Demos\
Выгрузку из Матлаба сделать просто — нужно открыть pde toolbox, открыть m файл (либо создать самому с нуля), зайти в меню Mesh-Экспорт mesh, нажать ОК; перейти в основной Матлаб, в панельке появятся переменные — матрицы p e t, открыть файл savemymesh.m, выполнить его, появится файл p.out, перенести его в папку Demos.
В исходниках для выбора примера необходимо задать имя файла в строке param.file = «p»;(FormParam.cs).Далее необходимо применить граничные условия — для готовых примеров можно просто раскомментировать соответствующие блоки в MainSolver.cs:
```
//p.out
public void SetPeriodicBoundary()
```
Смысл тут простой — Матлаб разделяет границы по доменам, например внешние и внутренние.Также для каждого домена границы разбиты на части (группы), чтобы можно было задавать условия на участках границы по отдельности — например справа или снизу.
Возможно и вовсе не использовать Матлаб, а вручную прописать все элементы(треугольники) и их вершины + грани(только для граничных элементов)
**Описание структуры файла .out**Файл разбит на секции — ##Points (вершины),##Triangle(треугольники) и ##Boundary(грани — только те которые на границе)
##Points — координаты точек, первая строка — х, вторая -y.
##Triangle — треугольники, первая строка — индекс 1-ой вершины в массиве ##Points,2 и 3 строки — индексы 2 и 3 вершины треуольника.
##Boundary — грани, первая строка — индекс 1-ой вершины грани ,2-я — индекс второй вершины, пятая строка — группа, шестая — домен
**Описание папок с исходниками**Исходники написаны на Visual Studio 2010 c#.Использовался Матлаб R2012a.
[Гитхаб с исходниками](https://github.com/nexscifix/FiniteVolume)
* **heat2PolyV2** — финальная версия
* **other\heat2Utrianglestatic** — реализован пример из книги p346 versteeg\_h malalasekra\_w\_ An\_introduction\_to\_computational\_fluid…
* **other\water2dV2** — попытка решения уравнений Навье-Стокса частично используя FiniteVolume
* **matlab** — m файлы примеров pde toolbox + savemymesh.m который выгружает готовый .out файл для heat2PolyV2
**Список книг по теме*** **Versteeg HK Malalasek Introduction to computational fluid dynamics The finite volume method** — уже есть второе издание
* **F.Moukalled L.Mangani M.Darwish The finite volume method in computational fluid dynamics 2016г** — вышла недавно (чуть ли не вчера:)
* **Патанкар С.-Численные методы решения задач теплообмена и динамики жидкости-Энергоатомиздат (1984)**
* **Патанкар С.В.-Численное решение задач теплопроводности и конвективного теплообмена при течении в каналах-МЭИ (2003)**
* **Computational methods for fluid dynamics Ferziger JH Peric 2001** — хоть напрямую и не относится к FVM, но оч много полезного | https://habr.com/ru/post/276193/ | null | ru | null |
# Скрытые зависимости как «запах» проектирования
[Марк Симан](http://blog.ploeh.dk/about.html) написал [замечательный пост «Service Locator нарушает инкапсуляцию».](http://habrahabr.ru/post/270005/) Название поста говорит само за себя о том, что он посвящён паттерну (анти-паттерну) *Service Locator*. Когда программист произвольно в коде вызывает IoC-контейнер для разрешения зависимости того или иного объекта — он использует *Service Locator* анти\паттерн. Марк рассматривает следующий пример:
```
public class OrderProcessor : IOrderProcessor
{
public void Process(Order order)
{
var validator = Locator.Resolve();
if (validator.Validate(order))
{
var shipper = Locator.Resolve();
shipper.Ship(order);
}
}
}
```
Как мы видим инкапсуляция типа *OrderProcessor* поломана из-за двух скрытых зависимостей, которые по-тихому разрешаются в методе *Process*. Эти зависимости скрыты от вызывающего кода, что может привести к исключению в runtime в случае, если клиент не настроил должным образом IoC-контейнер, определив в нём необходимые зависимости. В качестве решения проблемы Марк предлагает перенести разрешение зависимостей в конструктор объекта.
```
public class OrderProcessor : IOrderProcessor
{
public OrderProcessor(IOrderValidator validator, IOrderShipper shipper)
public void Process(Order order)
}
```
Таким образом, вызывающий код будет в курсе того, что на самом деле требует объект *OrderProcessor*.
Однако, на мой взгляд, всё же есть сценарии, где сокрытие зависимостей можно применить. Рассмотрим WPF-приложение в котором практически любая *ViewModel* требует следующие зависимости: *IEventAggregator, IProgress, IPromptCreator*. Чтобы раскрыть смысл двух последних интерфейсов, добавлю, что реализация *IProgress* должна уметь принимать кусок долго выполняемого кода и показывать окно со шкалой прогресса, *IPromptCreator* позволяет открывать окна, запрашивающие подтверждение, согласие или отказ (модальные диалоги). Теперь представим, что есть *ViewModels*, которые требуют вдобавок две (а может и три) зависимости для создания модели. Вот каким образом *ViewModel* может начать выглядеть с таким количеством зависимостей:
```
public class PaymentViewModel: ICanPay
{
public PaymentViewModel(IPaymentSystem paymentSystem,
IRulesValidator rulesValidator,
IEventAggregator aggregator,
IProgress progress,
IPromptCreator promptCreator)
public void PayFor(Order order)
}
```
Какой бардак! Слишком много шума в декларации конструктора. Всего две зависимости действительно несут полезную информацию с точки зрения бизнес-логики.
Если мы, скажем, используем MEF для инъекции зависимостей, то мы можем сделать следующее:
```
[Export]
public class PaymentViewModel : ICanPay
{
[Import]
protected IEventAggregator aggregator;
[Import]
protected IProgress progress;
[Import]
protected IPromptCreator promptCreator;
public PaymentViewModel(IPaymentSystem paymentSystem,
IRulesValidator rulesValidator)
{
}
public void PayFor(Order order)
{
//use aggreagtor, progress, promptCreator
}
}
```
Мы перенесли зависимости из конструктора в декларации полей и пометили их атрибутом *Import*. Несмотря на то, что мы не вызываем IoC-контейнер напрямую (хотя, MEF это не IoC-контейнер в чистом виде), мы скрываем зависимости так же, как и в примере Марка. Ничего по сути не поменялось. Почему я считаю, что этот код не так уж плох? По нескольким основным причинам:
* *ViewModels* не являются бизнес-сущностями, они представляют собой просто куски кода для склеивания *Models* и *Views*. Никто особо не парится насчёт выше указанных зависимостей;
* *ViewModels* не являются публичным API и они не переиспользуются (в большинстве случаев);
* С учётом двух предыдущих пунктов, члены команды могут просто договориться о том, что все *ViewModels* имеют эти утилитарные зависимости, и всё тут;
* Эти утилитарные зависимости определены как protected, что позволяет в тестах создать класс *ViewModel*, наследующий *PaymentViewModel*, и заменить зависимости моками, поскольку мы будем иметь доступ к тем полям. Таким образом, мы не теряем возможность покрыть тестами *PaymentViewModel*. В примере Марка (где используется *Service Locator*) было необходимо настроить IoC-контейнер в проекте юнит-тестов для того, что замокать или застабить те зависимости, а такая практика может стать болезненной для процесса юнит-тестирования.
Заключение
----------
Как я уже говорил, в программировании нет единственно правильных ответов или утверждений на все случаи жизни. Вообще говоря, мы должны избегать использования *Service Locator*, поскольку это нарушает инкапсуляцию, как и говорит Марк в своей статье. Перед тем как использовать *Service Locator*, оцените потенциальный вред, который вы нанесёте системе. Если вы уверены, что скрытое разрешение зависимостей не влияет на клиентский код (который могут писать ваши товарищи по команде) и для системы нет потенциального вреда, то вперёд и с песней. | https://habr.com/ru/post/270547/ | null | ru | null |
# Uni Localization. Абсолютная кастомизация, работает на любом сайте (Vue, React, Angular, ...)
**Disclaimer:** Эта статья про веб компоненты и уже реализованное UI решение на них. Если вам нравится все новое и нестандартное, тогда, я уверен вам понравится и наша реализация.
Я всегда мечтал о функциональности, которую можно было бы использовать в любом web проекте. Еще я мечтал иметь максимально гибкое решение для абсолютной кастомизации под себя. Два года назад мы начали работать над воплощением этой смелой мечты в реальность. Первой такой функциональностью стала именно [Uni Локализация](http://uiwebkit.com/wgt/loc/2/?lang=ru).
К сожалению, нельзя было просто так взять и сделать. Большую часть времени из этих двух лет пришлось потратить на создание правильной инфраструктуры с нуля и ее документирование. Но теперь разработка самих виджетов у нас занимает считанные часы.
Раньше интеграция стороннего виджета и кастомизация его под себя занимала несколько дней (в лучшем случае). Сейчас возможно сэкономить эти дни и подключение займет секунды, а кастомизация - считанные минуты.
Как нам удалось этого добиться?
-------------------------------
**Во первых**, абсолютной портативности можно было добиться только лишь с **HTML**, так как он работает абсолютно в любом web проекте. Даже в JavaScriptфреймворках это решается несколькими строчками в конфигурации или вовсе ничего не нужно ничего делать. С JavaScript библиотекой у нас бы так не получилось!
**Во вторых**, абсолютной кастомизации можно было добиться только с открытыми HTML шаблонами. Изменение исходного кода в JavaScript - это практически всегда потеря обратной совместимости и последующих обновлений, а при изменении открытого HTML шаблона - нет. Поэтому мы сразу же сконцентрировались только лишь на Web стандарте: **Custom Elements & Web Components.**
**В третьих**, это - принцип матрешки. Как и сам виджет, так и его внутренние компоненты имеют сразу несколько уровней вложенности, которые можно легко вытащить на поверхность, в точности как в матрешке. Приведу пример: компонента **uni-icon-mat** содержится в **uni-icon**, а она, в свою очередь, содержится в **uni-button-icon**, а та - в **uni-button,** которая содержится в меню, карточках, … Эту цепочку мы можем продолжать еще множество раз и на каждом уровне у нас будет полный и легальный доступ ко внутреннему HTML шаблону.
### А что же с локализацией?
Сама **Uni Локализация** состоит из двух основных частей:
1. [**Uni Lang Menu**](http://uiwebkit.com/wgt/loc/2/menu/?lang=ru&type=element) - **next gen** виджет выбора языка;
2. [**Uni Translate**](http://uiwebkit.com/wgt/loc/2/translate/?lang=ru&type=element) - автоматическая компонента-переводчик;
**Next Gen** виджет и компонента-переводчик имеют по 3 режима:
1. Кастомный элемент (**Custom Element**) - это стандартный режим. Здесь отсутствует Shadow DOM, а значит его можно полностью стилизовать с помощью CSS. Характеристики: удобство и простота - максимальный уровень; гибкость и настраиваемость - средний и высокий уровень (со свойством “**only**”).
2. Веб компонент (**Web Component**) - это так называемый "черный ящик". Имеет собственный HTML шаблон и стили, которые изолированы по максимуму (**Shadow DOM**). Характеристики: надежность и безопасность - максимальный уровень; гибкость и настраиваемость - почти нулевой уровень.
3. Распакованный (**Unpacked**) - весь функционал (HTML шаблон) вывернут наружу. Является очень удобным для тонкой настройки и когда нужно иметь доступ к абсолютно всему внутреннему содержимому. Характеристики: удобство и простота - средний уровень; кастомизируемость - высочайший уровень.
А как же это выглядит?
----------------------
В упакованном виде (**custom element** / **web component**), виджет может выглядеть как выпадающее меню или как линейный список:
Может быть и без названия языка:
Может быть с круглыми флагами:
Может быть и без флагов:
Может отображаться различными кнопками:
Может быть с параметром в URL адресе, а может сохраняться только в памяти:
Может иметь свой, кастомный URL параметр:
Может сохраняться в объект **window** или **sessionStorage** или **localStorage.** Установите параметр **type=”local**” для того, чтобы открывать в новой вкладке с выбранным языком.
Может передавать переводы в **Shadow Dom** и **iFrame**
Даже может работать параллельно еще с несколькими виджетами локализации на одной странице и не конфликтовать с ними. Для этого необходимо указать другие пути в свойствах ***…-path*** *(см. API)*.
Для корректной работы виджета, необходим список языков в таком **JSON** формате:
```
[
{
"lang": "en",
"flag": "gb",
"name": "English",
"translation": "https://uni.github.io/loc/english.json"
}
]
```
Свойство *lang* необходимо для только роутинга.Если свойство *flag* не указано, тогда флаг не будет отображаться. Список доступных на данный момент флагов указан [*здесь*](https://uiwebkit.github.io/icons/assets/html/flag/).
В разобранном виде **(Unpacked)**, JSON формат может быть любой, как и сама реализация виджета. Вы вольны кастомизировать его как душе угодно.
Как же осуществляется сам перевод?
----------------------------------
**Uni Translate** получает объект с ключами и значениями для них и проверяет текст в дочерних HTML элементах на соответствие ключам. Замена ключа на значение происходит при соблюдении нескольких условий:
1. Ключевой текст находится в своем, отдельном **HTM**L теге;
2. Ключевой текст находится между **((** и **))** (биндинг);
Сами знаки биндинга можно переопределить и изначально они были **{{** и **}}**, но затем были изменены по умолчанию на **((** и **))** для более простой интеграции с большой тройкой JS фреймворков.
Ещё биндинги можно использовать прямо в файле локализации. Это удобно для переиспользования переводов и исключения дублирования.
Замена на новое значение производится даже в HTML атрибутах, тем самым можно произвести даже локализацию ссылок или плейсхолдеров. Мы сами этим пользуемся, очень полезная фича.
**Uni Локализация** является [**Open Source**](https://github.com/uiwebkit/localization) проектом с [**MIT**](https://github.com/uiwebkit/localization/blob/master/LICENSE) лицензией. A если, к примеру, вам необходимы дополнительные флаги стран, тогда вы можете добавить их самостоятельно в репозиторий [@uiwebkit/flags](https://github.com/uiwebkit/flags).
Интеграции:
-----------
[**WordPress plugin**](https://wordpress.org/plugins/uni-localize/) - есть стандартные настройки, переключая которые можно сразу же увидеть результат. Также есть **Next Gen** кастомизамизация, которая позволяет менять все что угодно самому прямо в настройках. Я уверен, что такого нет ни в одном другом WP виджете.
[**Vue.js 2**](https://github.com/uiwebkit/localize-vue-2x)- даже для **CLI** билда интеграция очень простая. В *index.html* подключите необходимые скрипты и в *main.js* добавьте строку:
```
Vue.config.ignoredElements = [/uni-\w*/];
```
[**Vue.js 3**](https://github.com/uiwebkit/localize-vue-3x) - для **CLI** билда интеграция чуть сложнее чем для второй версии. В *index.html* подключите необходимые скрипты и во *vue.config.js* добавьте:
```
module.exports = {
...,
chainWebpack: (config) => {
config.module
.rule("vue")
.use("vue-loader")
.tap((options) => ({
...options,
compilerOptions: {
...options.compilerOptions,
// treat any tag that starts with uni- as custom elements
isCustomElement: (tag) => tag.startsWith("uni-"),
},
}));
},
...
};
```
[**React**](https://github.com/uiwebkit/localize-react) - для *create-react-app* интеграция максимально простая. В *index.html* подключите необходимые скрипты. Всё!
[**Angular**](https://github.com/uiwebkit/localize-angular) - для **CLI** билда интеграция очень простая. В *index.html* подключите необходимые скрипты и в главный модуль добавьте:
```
@NgModule({
...,
schemas: [CUSTOM_ELEMENTS_SCHEMA],
...
})
```
Во всех интеграциях “большой тройки” не совсем корректно работает нативный HTML при **Next Gen** кастомизации и поэтому мы рекомендуем использовать .
Планы
-----
На подходе ещё несколько виджетов. Следующим будет виджет вкладок **(Uni Tabs**), а затем пойдут более крупные виджеты. Планируем выпускать новый **Next Gen** виджет каждый месяц или даже чаще. Ну а если если вы хотите иметь свой собственный виджет, который работает в любом web проекте и с любой технологией, тогда вы можете создать его самостоятельно с помощью [UiWebKit](https://uiwebkit.com/?lang=ru) пакетов, либо [заказать](mailto:support@uiwebkit.com) его у нас.
Буду рад конструктивным комментариям и вопросам, с удовольствием на них отвечу.
Всем спасибо! Ставьте звездочки на [**Github**](https://github.com/uiwebkit), мне будет очень приятно. Подписывайтесь на наш [**Twitter**](https://twitter.com/UiWebKit), [**Facebook**](https://www.facebook.com/uiwebkit) и [**Instagram**](https://www.instagram.com/uiwebkit/), чтобы быть в курсе всех новинок. Пользуйтесь в удовольствие, берегите себя, оставайтесь здоровым и продуктивным!
[Предыдущая статья](https://habr.com/ru/post/576088/) | https://habr.com/ru/post/598319/ | null | ru | null |
# Визуализация в IoT: или как самому развернуть систему сбора и отображения данных на MQTT+Telegraf+InfluxDB+Grafana
Введение
--------
В данной статье приведен скоуп информации о том, что взять за основу, чтобы развернуть свой домашний Linux-сервер и систему отображения данных для IoT-устройств, используя MQTT в качестве транспорта с оконечного оборудования.
Многие статьи или инструкции, которые есть в интернете, в части работы с InfluxDB и Telegraf – имеют отношения к довольно старым версиям рассматриваемого ПО, в виду чего у меня ушло какое-то время, чтобы со всем разобраться. Хотелось бы оставить небольшое обновление по инструкциям здесь, возможно, они помогут кому-то сэкономить время и нервы, так как информация агрегирована в виде summury моего погружения в реализацию данного решения.
Значит понадобилось, как оно водится, по работе, часто взаимодействовать с Linux: CentOS/RHEL, Debian/Ubuntu Server и даже с немного специфичным Clear Linux, специально собранный под процессоры Intel, что дает прирост в производительности во многих бенчмарках (например, [тык](https://openbenchmarking.org/result/2104228-IB-2104227IB95)).
Держать у себя постоянно включенную виртуальную машину стало накладно и решено было найти какой-нибудь интересный мини-пк на просторах популярной китайской площадки, дабы вынести все рабочие моменты на отдельное железо. Бонусом я также получил возможность дополнить данный мини-пк функционалом домашнего Linux-сервера, назначение которого варьируется сколь угодно широко, в зависимости от вашей фантазии.
В моем случае, учитывая контекст работы и дополнительное увлечение в виде преподавания в сфере IoT, я решил показать студентам, как самим собрать систему визуализации для дипломных устройств, где транспортом для передачи данных служит знакомый им MQTT.
Состав и описание решения
-------------------------
Рассмотрим состав решения:
Схема взаимодействия компонентов ПО1. **Оконечное оборудование**, собирающее телеметрию, доступом в интернет, разрабатываемое студентами индивидуально.
На оконечном оборудовании реализуется MQTT клиент, который публикует в определённый топик MQTT брокера некую информацию, например, температуру окружающей среды в градусах цельсия.
2. **Mosquitto MQTT broker.**
MQTT брокер служит неким посредником, который позволяет собирать (принимать) информацию от устройств в определенные топики и сразу же «отдавать» ее клиентам, которые эти топики слушают для сбора, обработки, анализа, визуализации получаемых данных.
3. **Telegraf.**
Чтобы получить информацию от MQTT брокера, также необходим клиент, который подписывается на топики брокера для получения данных, реализуя тем самым паттерн Издатель-подписчик (англ. publisher-subscriber или англ. pub/sub). Для этого и используется Telegraf. Он, как клиент-подписчик, прослушивает заданные MQTT топики и, получив сообщение, сразу же записывает информацию в InfluxDB. Вообще, Telegraf – это не только MQTT клиент. Telegraf – это серверный агент для сбора, обработки, агрегирования и записи метрик из различных стеков, датчиков и систем в InfluxDB.
4. **InfluxDB.**
InfluxDB – это система баз данных, оптимизированная для предоставления данных временных рядов и их хранения в привязке ко времени и значению (иными словами база данных временных рядов (time series database – TSDB)), разработанная компанией InfluxData.
И немного про временные ряды и их данные.
Временной ряд – это совокупность наблюдений за четко определенными элементами данных, полученных в результате повторяющихся измерений в течение определенного времени. Данные временного ряда индексируются во временном порядке, который представляет собой последовательность точек данных.
В InfluxDB есть встроенный конструктор дашбордов для визуализации – Chronograf, на котором можно было бы и остановиться, но он больше сделан для быстрого прототипирования дашбордов и проверки отображения тех или иных метрик в том или ином виде в самой InfluxDB. Гораздо удобнее использовать платформу Grafana, которая является плюс минус стандартном в вопросах визуализации (особенно в сфере IoT). Для этого будет настраиваться интеграция в Grafana на подключение к InfluxDB.
5. **Grafana**.
Grafana – программное обеспечение с открытым исходным кодом, позволяющее запрашивать, визуализировать и исследовать метрики (данные), где бы они ни хранились. По сути, предоставляет пользователю инструменты для преобразования информации из базы данных временных рядов (TSDB) в удобные графики и визуализации.
6. **Node-RED\*.**
Это инструмент визуального программирования для интернета вещей, позволяющий подключать друг к другу устройства, API и онлайн-сервисы. Выступает в роли многофункцильного бекэнда с поддержкой множества интерфейсов и протоколов.
Звездочка здесь стоит только потому, что данный компонент не обязателен, но всегда должна быть альтернатива, и Node-RED позволяет собирать и передавать данные альтернативным от Telegraf способом, имея мощный функционал промежуточной обработки.
7. **WireGuard.**
Современный VPN-протокол. Необходим, чтобы подключаться к нашему серверу из любой точки через домашнюю сеть. Приятное дополнение – это возможность шифровать трафик в любой публичной Wi-Fi сети без существенных ограничений по скорости и задержкам.
### На чем все запускать?
Сердце домашнего сервера и обитель всех рассматриваемых программных компонентов в моем случае – мини-пк Beelink U59 в конфигурации 16(8+8)RAM/512SSD на базе процессора Intel Celeron N5095. Таких характеристик хватит с запасом под разные задачи. Получается отличный вариант по качеству, производительности, сборке. Особенно в контексте цены – 250$, а если еще и распродажа, сами понимаете. На борту есть гигабитный Ethernet-порт и Wi-Fi 5 (ac). И все это в очень компактном корпусе.
Очень радует функция автоматического включения в случае пропадания и восстановления питания. Действительно получается такой мини-сервер, который всегда включен, если есть электричество. Дело остается за малым: чтобы и доступ в интернет не пропадал.
Изначально думал взять какой-нибудь микрокомпьютер, а-ля Raspberry Pi 4 или что-то похожее. Но против тех.спеки не попрешь: U59 на мой взгляд гораздо производительнее и удобнее под рассматриваемые задачи, а стоит аналогично Pi 4. (Если говорить о производительности, то тот же Geekbench на U59 показывает 710/2312 ([тык](https://browser.geekbench.com/v5/cpu/19188736)) против 337/877 на Pi 4 ([тык](https://browser.geekbench.com/v5/cpu/15807437))
Ознакомиться с подробными техническими характеристиками и отзывами можно по ссылке ([тык](https://aliexpress.ru/item/1005004009585758.html)), а выглядит он вот так:
Вы можете поступить аналогичным образом и раздобыть себе такой же или аналогичный мини-пк. Возможно, перепрофилировать какой-нибудь старый ноутбук или компьютер под эти задачи, или, в конце концов, развернуть виртуальную машину с характеристиками: 1GB RAM/ 1 CPU / 15GB (HDD/SSD). Есть решения, которые позволяют стартовать виртуальные машины при старте системы в фоновом режиме, без какого-либо интерфейса. А чтобы система при старте на помирала, можно настроить отложенный автозапуск. (Знаю, что у Hyper-V или VMware это есть).
В моем случае U59 стоит рядом с роутером, подключенный к нему по проводу. IP-адрес выдается DHCP-сервером. Итоговая общая схема получается следующая:
На этой схеме дополнительно появляются два блока, которые мы настроим в самом конце статьи.
Функция "Динамический DNS" (Dynamic DNS / DDNS) позволяет присвоить постоянное доменное имя (адрес для доступа из интернета) публичному IP-адресу, который роутер получает от интернет-провайдера. Публичный IP-адрес может поменяться, а доменное имя, которые вы зарегистрируете – нет. (есть сервисы, позволяющие сделать это бесплатно и вне ПО роутера, рассматриваемого в данной статье). Это будет необходимо для того, чтобы получать доступ к устанавливаемым сервисам через интернет с любого устройства по доменному имени. И порядком упростить конфигурацию, потому что не нужно прописывать конкретный IP адрес в различных конфигурациях ПО.
Далее, Port Forwarding (или Virtual Server) – настройка для WAN-интерфейса (который отвечает за подключение к интернету), позволяющая извне (через интернет) обращаться к конкретным клиентам локальной сети (например, к нашему мини-пк) по определенному порту приложения.
Таким образом, можно на любом устройстве открыть браузер, ввести зарегистрированное доменное имя и указать порт необходимого приложения, и вуаля, вы зашли на приложение своего сервера. Почти также, как вы попали на habr.com
Установка и настройка ОС
------------------------
Теперь, когда мы вкратце рассмотрели схемы решения и назначение каждого из компонентов, перейдем к установке и настройке программного обеспечения.
В качестве основной ОС будет использоваться Linux Debian 11.5.
Так как Debian поддерживает три модели выпуска своих ОС «стабильный», «тестируемый», «нестабильный», был выбран второй, так как хотелось иметь более свежие версии ядра и пакетов устанавливаемого ПО. (подробное описание есть на сайте: [тык](https://www.debian.org/releases/)).
Остается скачать netinst iso-образ для платформы amd64, потому что он содержит минимально необходимый набор базового устанавливаемого ПО. А все пакеты в процессе установки будут загружены из сети, что дает самую актуальную версию ОС и пакетов (ссылочка на образ, чтобы не искать: [тык](https://cdimage.debian.org/cdimage/daily-builds/daily/arch-latest/amd64/iso-cd/)).
Процесс установки описывать не буду, он достаточно простой даже для новичков (почти все этапы требуют простого нажатия enter). Пара моментов, которые хотел бы отметить: если устанавливаете через виртуальную машину - обязательно используйте режим bridge (режим моста или сетевого моста), чтобы машина была полноценным отдельным компьютером в вашей домашней сети; обязательная установка пароля для root-пользователя, так как все операции будут выполняться под ним; а также выбор устанавливаемых компонентов, который задается почти в самом конце установки, должен включать **только** SSH server:
Так выглядит конфигурация установки ОС без лишних компонентов, но с доступом по SSHПосле установки необходимо войти под пользователем root с паролем, который задавался при установке (и да, пароль при вводе никак не отображается, это нормально).
После ввода root пароля просто нажимаем enterИ внести последнее изменение с самого мини-пк: в конфигурации SSH необходимо разрешить подключение root пользователю, так как, повторюсь, все операции будем выполнять от него. Для этого вводим:
```
nano /etc/ssh/sshd_config
```
Ищем закомментированную строку `#PermitRootLogin prohibit-password` и правим в это: `PermitRootLogin yes`
Выглядит это так:
Записываем файл ctrl+o, enter и выходим из редактора ctrl+x.Перезапускаем сервер:
```
systemctl restart ssh || systemctl restart sshd
```
Узнаем ip адрес машины через команду:
```
ip a
```
Скорее всего нам нужен будет именно второй интерфейс, а так как IP-адрес получаем по DHCP от роутера, то он будет примерно следующего вида:
`192.168.XXX.YYY` (Например, 192.168.0.25 или 192.168.25.136).
(Во всей статье будет использоваться IP-адрес 192.168.50.56, поэтому держите в уме, что в вашем случае нужно будет заменить его на актуальный IP именно для вашего сервера. Вместо IP-адреса может быть указано также доменное имя)
Узнав адрес, можно отложить ПК в сторону и подключиться по SSH через терминал с основной машины, находящейся в одной локальной сети с сервером, следующей командой (работает в любой ОС):
```
ssh root@192.168.50.56
```
Остается только ввести пароль от пользователя root.
(если на вашей основной машине по каким-либо причинам не установлен ssh-клиент, можете воспользоваться Termius: [Win](https://termius.com/windows) / [MacOS](https://termius.com/mac-os) / [Linux](https://termius.com/linux) )
Как только получилось авторизоваться, немножко настроим и почистим систему. Уберем поддержку IPv6 и включим переадресацию для IPv4 между сетевыми интерфейсами командой (в терминал вставляется все, так как команды объединены связкой " `&& \`"):
```
echo "net.ipv6.conf.all.disable_ipv6 = 1" >> /etc/sysctl.conf && \
sysctl -w net.ipv4.ip_forward=1
```
Выключим ненужные сервисы:
```
systemctl stop cron && \
systemctl stop apparmor && \
systemctl stop console-setup && \
systemctl stop keyboard-setup && \
systemctl disable cron && \
systemctl disable apparmor && \
systemctl disable console-setup && \
systemctl disable keyboard-setup && \
systemctl mask --now systemd-journal-flush && \
systemctl mask --now systemd-journald && \
systemctl set-default multi-user.target
```
Удалим лишние пакеты и подчистим зависимости:
```
apt remove -y --purge vim-common vim-tiny ispell iamerican ibritish ienglish-common dictionaries-common emacsen-common wamerican cron cron-daemon-common apparmor console-setup console-setup-linux keyboard-configuration xkb-data kbd isc-dhcp-common shared-mime-info installation-report && \
apt autoclean -y && apt autoremove -y
```
Теперь установим базовый набор пакетов, необходимый для установки остального ПО:
```
apt install -y sudo curl wget gnupg2 htop lm-sensors
```
Отредактируем загрузчик, чтобы убрать 5 секундное ожидание при старте и отключить ограничения по уязвимостям Spectre, Meltdown и другим, открыв файл загрузчика для редактирования:
```
nano /etc/default/grub
```
Значения меняем на следующие:
```
GRUB_TIMEOUT=0
GRUB_CMDLINE_LINUX_DEFAULT="mitigations=off quiet nowatchdog processor.ignore_ppc=1 cpufreq.default_governor=performance"
```
Записываем файл `ctrl+o,` `enter` и выходим из редактора `ctrl+x`.
Обновляем загрузчик и перезагружаемся:
```
update-grub && \
reboot
```
Установка ПО: Mosquitto, Node-RED, WireGuard, Influx, Telegraf, Grafana
-----------------------------------------------------------------------
После перезагрузки снова коннектимся по SSH:
```
ssh root@192.168.50.56
```
***Установка Mosquitto***
Добавляем пакет и проверяем актуальную версию, должна быть 2.0.14:
```
wget -qO- http://repo.mosquitto.org/debian/mosquitto-repo.gpg.key | sudo tee /etc/apt/trusted.gpg.d/mosquitto-repo.asc && \
wget -O /etc/apt/sources.list.d/mosquitto-bullseye.list http://repo.mosquitto.org/debian/mosquitto-bullseye.list && \
wget http://ftp.ru.debian.org/debian/pool/main/o/openssl/libssl1.1_1.1.1n-0+deb11u3_amd64.deb && \
dpkg -i libssl1.1_1.1.1n-0+deb11u3_amd64.deb && \
rm libssl1.1_1.1.1n-0+deb11u3_amd64.deb && \
apt update && \
apt-cache show mosquitto | grep Version
```
Устанавливаем:
```
apt install -y mosquitto=2.0.14-0mosquitto1~bullseye1 mosquitto-clients=2.0.14-0mosquitto1~bullseye1
```
Создаем пароль для учетной записи IoT (после ввода команды нужно дважды ввести пароль):
```
sudo mosquitto_passwd -c /etc/mosquitto/passwd IoT
```
Создаем конфигурацию:
```
sudo nano /etc/mosquitto/conf.d/default.conf
```
И вставляем туда следующие содержимое:
```
allow_anonymous false
password_file /etc/mosquitto/passwd
listener 1883
```
Записываем файл `ctrl+o`, `enter` и выходим из редактора `ctrl+x`.
Сохраненная только что конфигурация запрещает анонимное подключение, без связки логин-пароль, указывает путь к файлу с заданным ранее паролем для пользователя IoT, а также задает порт, на котором будет работать MQTT брокер. Перезапускаем службу:
```
systemctl restart mosquitto
```
Проверим, что все работает, выполнив в двух отдельных терминальных окнах следующие команды (пароль необходимо изменить на свой или использовать student):
```
mosquitto_sub -h 192.168.50.56 -p 1883 -t Habr -u "IoT" -P "student"
mosquitto_pub -h 192.168.50.56 -p 1883 -t "Habr" -m "Hello, Habr!" -u "IoT" -P "student"
```
Верхняя команда будет прослушивать топик Habr, командой sub. Нижняя команда отправит на топик с названием Habr сообщение: «Hello, Habr!», командой pub. Что и получилось: В режиме прослушивания (подписки) терминалом была создана строка с полученным значением.
***Установка Node-RED + Node.js***
Установим сперва актуальную версию Node.js 18:
```
curl -fsSL https://deb.nodesource.com/setup_19.x | bash - && \
apt-get install -y nodejs
```
Далее, воспользуемся скриптом-установщиком, который установит Node-RED:
```
bash <(curl -sL https://raw.githubusercontent.com/node-red/linux-installers/master/deb/update-nodejs-and-nodered)
```
Установщик трижды спросит подтверждение, необходимо дважды ввести «y» и последний раз «n».
```
Are you really sure you want to install as root ? [y/N] ? y
Are you really sure you want to do this ? [y/N] ? y
Would you like to install the Pi-specific nodes ? [y/N] ? n
```
Далее, нам необходимо инициализировать параметры командой, если вы вдруг не нажали "y" в процессе установки на запрос конфигурации сейчас:
```
node-red admin init
```
Небольшая шпаргалка по ответам на вопросы скрипта:
```
Settings file -> enter
Do you want to setup user security? –> yes
Username -> admin
Password -> задаете_пароль_для_admin
User permissions -> full access
Add another user? -> yes
Username -> user
Password -> задаете_пароль_для_user
User permissions -> read-only access
Add another user? -> no
Do you want to enable the Projects feature? -> no
Enter a name for your flows file -> enter
Provide a passphrase to encrypt your credentials file -> задаете_пароль_для_credentials_file
Select a theme for the editor -> default
Select the text editor component to use in the Node-RED Editor -> monaco (default)
Allow Function nodes to load external modules? -> yes
```
Данная конфигурация включает форму авторизации на Node-RED и создает двух пользователей: admin и user, с полными правами и правами только на чтение соответственно. Затем необходимо включить и запустить сервисы Node-RED:
```
sudo systemctl enable nodered && \
sudo systemctl start nodered
```
Проверить, что все работает, можно зайдя по адресу: <http://192.168.50.56:1880/>
Если все действия выполнены успешно, вас встретит эта замечательная приветственная страница***Установка WireGuard***
WireGuard, как и Node-RED, тоже очень просто устанавливается скриптом-установщиком. Единственный нюанс, который возникает на Debian 11 в тестовой сборке, это отсутствие версии в базовых сведениях о системе, к которой привязывается скрипт. Исправим это, добавив строчку со значением:
```
sed -i 5i\ 'VERSION_ID=11' /etc/os-release
```
Загружаем скрипт, делаем его исполняемым:
```
curl -O https://raw.githubusercontent.com/angristan/wireguard-install/master/wireguard-install.sh && \
chmod +x wireguard-install.sh
```
И запускаем:
```
./wireguard-install.sh
```
Небольшая шпаргалка по ответам на вопросы скрипта:
```
IPv4 or IPv6 public address: -> my-home-server.noip.com (указываем доменное имя или публичный IP адрес с 2ip.ru, полученное в конце статьи)
Public interface: -> ens## (автоматом подтягивает имеющийся сетевой интерфейс, который мы видели командой ip a, если это он, можно не менять))
WireGuard interface name: -> wg0 (оставляем без изменений)
Server's WireGuard IPv4: -> 10.66.66.1 (оставляем предложенную адресацию без изменений)
Server's WireGuard IPv6: -> fd42:42:42::1(оставляем предложенную адресацию без изменений)
Server's WireGuard port [1-65535]: -> 1870 (указываем любой порт)
First DNS resolver to use for the clients: ->1.1.1.1
Second DNS resolver to use for the clients (optional): -> 1.0.0.1
```
После нажатия Enter’a, установки и конфигурирования серверной части скриптом, что был выше, скрипт переходит дальше, к настройке клиентской конфигурации, с помощью которой можно будет подключиться через клиентское приложение WireGuard к нашему серверу. Там указывается следующее:
```
Client name: -> Client_id_1 (или устанавливаем свое название файла)
Clinet's WireGuard IPv4: -> 10.66.66.2 (оставляем предложенную адресацию без изменений)
Clinet's WireGuard IPv6: -> fd42:42:42::2(оставляем предложенную адресацию без изменений)
```
Конфигурацию можно скачать по QR-коду или через FTP по пути /root/wg0-client-####.conf .
Результат выглядит вот так:В итоговой конфигурации удаляем все упоминания об IPv6 и ip6tables в строчках с PostUp и PostDown:
```
nano /etc/wireguard/wg0.conf
```
Результат должен быть примерно следующий:
```
[Interface]
Address = 10.66.66.1/24
ListenPort = 1870
PrivateKey = sLdyJJPFXSZCTuPbuaCKdvDvVDOCCdbwjmPj7QgQkEs
PostUp = iptables -A FORWARD -i enp2s0 -o wg0 -j ACCEPT; iptables -A FORWARD -i wg0 -j ACCEPT; iptables -t nat -A POSTROUTING -o enp2s0 -j MASQUERADE
PostDown = iptables -D FORWARD -i enp2s0 -o wg0 -j ACCEPT; iptables -D FORWARD -i wg0 -j ACCEPT; iptables -t nat -D POSTROUTING -o enp2s0 -j MASQUERADE
### Client
[Peer]
PublicKey = Rxo33+25X0oBni2v94+ftMXBSEveTpeXDDhmb7/x0mc=
PresharedKey = FNKcatwzm8KyAtP4lj8ZuXfSvQY0nh/SeV34TYMYaL0=
AllowedIPs = 10.66.66.2/32
```
Записываем файл `ctrl+o, enter` и выходим из редактора `ctrl+x`.
Перезапускаем службу:
```
systemctl restart wg-quick@wg0
```
Если захотите добавить еще одного пользователя (потому что каждая конфигурация поддерживает только одно активное подключение), то снова запустите скрипт (выбрав 1):
```
./wireguard-install.sh
```
Для проверки необходимо запустить клиентское приложение WireGuard, импортировать в него созданную ранее клиентскую конфигурацию (wg0-client-####.conf) и запустить подключение:
После установки WireGuard'a обязательно перезапустить систему:
```
reboot
```
После чего снова подключаемся по SSH:
```
ssh root@192.168.50.56
```
***Установка InfluxDB2 + Telegraf + Grafana***
Добавим репозитории для InfluxDB2 и Telegraf, скачаем заданную версию Grafana, установим и запустим службы (для Grafana проверяйте наличие обновленной версии перед установкой [здесь](https://grafana.com/grafana/download?edition=oss). Версию можно поправить прямо в скрипте, когда выйдет более актуальная)
```
wget -q https://repos.influxdata.com/influxdata-archive_compat.key && \
echo '393e8779c89ac8d958f81f942f9ad7fb82a25e133faddaf92e15b16e6ac9ce4c influxdata-archive_compat.key' | sha256sum -c && cat influxdata-archive_compat.key | gpg --dearmor | sudo tee /etc/apt/trusted.gpg.d/influxdata-archive_compat.gpg > /dev/null && \
echo 'deb [signed-by=/etc/apt/trusted.gpg.d/influxdata-archive_compat.gpg] https://repos.influxdata.com/debian stable main' | sudo tee /etc/apt/sources.list.d/influxdata.list && \
sudo apt-get install -y adduser libfontconfig1 && \
wget https://dl.grafana.com/oss/release/grafana_9.3.6_amd64.deb && \
sudo dpkg -i grafana_9.3.6_amd64.deb && \
sudo rm /root/grafana_9.3.6_amd64.deb && \
sudo systemctl enable grafana-server && \
sudo systemctl start grafana-server && \
sudo apt-get update && sudo apt-get install -y influxdb2 telegraf && \
sudo systemctl start influxd && \
sudo systemctl enable telegraf
```
Проверим, что InfluxDB и Grafana доступны, зайдя по адресам: <http://192.168.50.56:8086/> и <http://192.168.50.56:3000/>
Должно быть так:
Если все действия выполнены успешно, вас встретит эта замечательная приветственная страницаИ так:
Если все действия выполнены успешно, вас встретит эта замечательная приветственная страница**Настройка Influx, Telegraf, Grafana**
Заходим в InfluxDB по адресу http://192.168.50.56:8086 и нажимаем “GET STARTED” и первым делом создаем учетную запись, указываем название организации и корзины для данных (Organization Name и Bucket Name -> IoT). После заполнения нажать «CONTINUE», а в следующем окне «QUICK START»
Создаем учетную запись, указываем название организации и корзины для данныхВыбираем QUICK STARTДалее, нам необходимо создать файл конфигурации для Telegraf. Для этого необходимо создать токен доступа InfluxDB (так как просмотр созданных токенов стал запрещен).
В левом боковом меню нажимаем Load Data -> API Tokens -> GENERATE API TOKEN -> Custom API Token:
GENERATE API TOKEN -> All Access API TokenЗадаем любое название для создаваемого токена, выбираем все доступы Read и Write для категорий Buckets и Telegrafs и нажимаем GENERATE:
Задаем имя для токенаКопируем через “COPY TO CLIPBOARD” и сохраняем где-нибудь (еще раз обращу внимание на то, что токен показывается **только** **один** **раз** при его создании).
Копируем токен в буфер обмена (и обязательно сохраняем где-нибудь)Далее, создаем саму конфигурацию для Telegraf:
```
nano /etc/telegraf/telegraf.d/IoT.conf
```
И вставляем туда следующее содержимое, которое в части ip-адресов и токена вам нужно будет немного отредактировать:
```
# Configuration for telegraf agent
[agent]
interval = "5s"
round_interval = true
metric_batch_size = 1000
metric_buffer_limit = 10000
collection_jitter = "0s"
flush_interval = "5s"
flush_jitter = "0s"
precision = ""
hostname = ""
omit_hostname = false
[[outputs.influxdb_v2]]
urls = ["http://192.168.50.56:8086"]
token = "gj8siSCDDuWyPd31LvrA2JIzldDzso_e_R_NiRkjKGJei4VgdoBV4heKIYSb7jMXLvEufhKgZfEv2pjTCHYUXA=="
organization = "IoT"
bucket = "IoT"
[[inputs.mqtt_consumer]]
servers = ["tcp://192.168.50.56:1883"]
topics = ["#"]
username = "IoT"
password = "student"
data_format = "value"
data_type = "float"
```
Записываем файл `ctrl+o, enter` и выходим из редактора `ctrl+x`. Затем перезапускаем службу, чтобы применить конфиг:
```
systemctl restart telegraf
```
Теперь необходимо отправить данные на наш MQTT брокер:
```
mosquitto_pub -h 192.168.50.56 -p 1883 -t "Habr/Temp" -m "28.5" -u "IoT" -P "student"
```
А в InfluxDB проверить, что в Data Explorer -> IoT -> mqtt\_consumer есть топик Habr/Temp и данные. Для этого необходимо настроить пространство, как на скриншоте ниже ( нужно поменять тип график на Gauge, aggregate function указать last и нажать SUBMIT):
Все MQTT-сообщения от Telegraf будут собираться в mqtt\_consumerВуаля, наш температурный «спидометр» показывает ровно то значение, которое было отправлено в MQTT сообщении на топик Habr/Temp. Последний шаг, который осталось сделать: скопировать скрипт получения данных из БД. Делается это через SCRIPT EDITOR (рядом с SUBMIT со скриншота выше). Копируем запрос из 6 строк и сохраняем где-нибудь рядом с токеном.
Запрос может быть и больше, если шагом ранее вы выберете несколько метрикДалее, перейдем к настройкам Grafana. Первая авторизация происходит по логину/паролю admin/admin, после чего система попросит установить новый пароль.
Hello :)После чего попадаем на приветственное пространство Grafana. Далее, нам необходимо добавить интеграцию (подключение) с InfluxDB. Нажимаем значок настроек -> Data Sources -> Add Data Sourse -> InfluxDB -> Query Language (Flux) -> URL -> Basic Auth (off) -> Organozation(IoT) -> Default Bicket (IoT) -> Token (Берется в InfluxDB -> Load Data -> Api Tokens -> Admin`stoken) -> Save&Test (должен быть ok)
Много картинок здесь:Нажимаем значок настроек -> Data Sources ->-> Add Data Sourse ->-> InfluxDB ->-> Query Language (Flux) -> URL (http://192.168.50.56:8086)-> Basic Auth (off) -> Organozation(IoT) -> Default Bicket (IoT) -> Token (Берется в InfluxDB -> Load Data -> Api Tokens -> Admin`stoken) -> Save&Test (должен быть ok)После того, как Grafana успешно подключилась к InfluxDB и обнаружила все корзины с данными, можно добавить дашборд: Dashboards -> New Dashboard -> Add New Panel -> вставляем данные их SCRIPT EDITOR -> Apply -> Save -> Имя дашборда
И много картинок здесьDashboards -> New Dashboard ->-> Add New Panel ->вставляем данные из SCRIPT EDITOR в InfluxDB -> минимально настраиваем -> ApplyСоздаем еще одну панель с табличным отображениемСохраняем итоговый дашбордНа этом настройка первого дашборда по визуализации условной температуры завершена.
**ВАЖНО:** Службу Telegraf необходимо перезапускать после каждой перезагрузки системы. Почему-то она стартует в статусе «**failed**», а перезагружается со статусом «Active». Видимо баг в последних сборках. "Пофиксить" можно следующим образом:
```
sed -i 14i\ 'RestartSec=2s' /lib/systemd/system/telegraf.service
```
И применим изменения:
```
sudo systemctl daemon-reload
```
**Альтернатива с Node-RED**
Для этого нам необходимо зайти в приложение http://192.168.50.56:1880/ и авторизоваться под администратором, пароль которого задавался ранее. В базовом наборе есть множество узлов(нод), в том числе MQTT, поэтому остается добавить и настроить интеграцию с InfluxDB. Для этого необходимо загрузить дополнительную палитру node-red-contrib-influxdb, а еще нам понадобится random-generator\_node-red-contrib, для генерации случайных чисел.
Для этого в боковом меню выбирается "Управление палитрой", затем установить и в поле поиска вводится название палитры и нажимается кнопка "установить".
Выглядит это такБоковое меню -> Управление палитройУстанавливаем палитру node-red-contrib-influxd, аналогично действуем для random-generator\_node-red-contribПосле установки всего необходимого соберем поток:
Делаем так:1. Возьмем узел стартового генератор событий «inject» в разделе общее, который будет генерировать сообщение с текущей временной меткой
2. Возьмем узел «Number», в разделе Random Generator, где зададим диапазон случайно генерируемых чисел.
Настройка узла Number
3. Возьмем узел «mqtt out» в разделе сеть, чтобы отправить данные MQTTброкеру. И настроим его. Указав тему (топик), адрес сервера, и данные авторизации.
(Шаги с 1 по 3 нужны, чтобы с эмулировать данные от устройства, передающего данные по MQTT.)
Задается тема для публикации и настраивается серверЗадается адрес и порт сервераЗадаются параметры аутентификации
4. Возьмем узел «mqtt in» в разделе сеть, чтобы получать данные от MQTT брокера. И настроем его по аналогии с П.3
Указывается уже настроенный сервер и задается тема для подписки
5. Возьмем узел «influx out» в разделе хранилище, чтобы данные записывались в InfluxDB. И настроим его. Укажем организацию и корзину: IoT, задаим название переменной для измерений, укажем версию InfluxDB (2.0), адрес БД и знакомый по прошлым пунктам токен.
Указывается Org, Bucket и настраивается подключение к InfluxDBУказывается версия БД (2.0 обязательно), адрес и токен
6. Для удобства к узлам «Number» и «mqtt in» можно подключить узел debug, который покажет, что было сгенерировано такое-то значение, на узле “Number”, а оно же было получено на узле «mqtt in». (и, соответственно, записано в БД).
7. Нажимаем развернуть (чтобы применить любый изменения)
Проверим, что все настройки работают, нажав на запуск события узла «inject»:
Успех!Как мы видим, MQTT подключение к брокеру успешно установлено. А сгенерированные данные были отправлены и получены по MQTT. Проверим теперь запись измерения в InfluxDB. Заходим в уже знакомый раздел Data Explorer и видим там измерение с названием Habr\_temp, которые было задано в узле «influx out».
Данные в метрику Habr\_temp получены!Преимущество данного способа в том, что при получении информации по mqtt на шаге 4 выше, после него можно написать какую-нибудь функцию на javasсript по обработке полученных данных. И только потом записать их в InfluxDB.
Перенастройка Grafana на порт 80Для того, чтобы Grafana была доступна по порту 80, и не было необходимости вводить полный адрес с указанием порта, а только сам ip-адрес, можно использовать команду для настройки переадресации 80 порта на 3000 порт Grafana (после перезагрузки системы правила iptables очищаются, необходимо применять повторно):
```
sudo iptables -t nat -A PREROUTING -p tcp --dport 80 -j REDIRECT --to-port 3000 && \
sudo systemctl daemon-reload
```
Если необходимо сделать работу по 80 порту постоянной, то необходимо исправить конфигурацию графаны, указав необходимый порт, а также отредактировать службу, разрешив ей работать с портами <1024:
```
sed -i 's/;http_port = 3000/http_port = 80/' /etc/grafana/grafana.ini && \
sed -i 52i\ 'CapabilityBoundingSet=CAP_NET_BIND_SERVICE' /lib/systemd/system/grafana-server.service && \
sed -i 53i\ 'AmbientCapabilities=CAP_NET_BIND_SERVICE' /lib/systemd/system/grafana-server.service && \
sed -i 54i\ 'PrivateUsers=false' /lib/systemd/system/grafana-server.service && \
sudo systemctl daemon-reload && \
sudo systemctl restart grafana-server
```
После чего Grafana становится доступной по 80 порту.
**Немного про DDNS и PortFowarding на роутере ASUS и адресацию.**
Под конец настроим проброс портов установленных приложений. Для этого необходимо зайти на роутер (в моем случае адрес 192.168.50.1), авторизоваться и перейти в раздел бокового меню WAN. Там выбрать раздел Virtual Server / Port Forwarding и настроить значения следующим образом через “Add profile”. Необходимо ввести имя профиля, порт, который открываем, тип протокола и адрес нашего сервера:
В зависимости от производителя интерфейс может отличаться, но суть остается без изменений.На любом другом роутере интерфейс и названия могут отличаться, но функционал должен присутствовать почти на всех современных моделях. Теперь у нас есть доступ к нашим приложениям через интернет, при указании вашего публичного IP адреса и порта приложения.
Далее, перейдем к настройке нашего доменного имени. Необходимо перейти в соседнюю секцию, включить службу DDNS, установить метод запроса IP -> External. Указать свободное доменное имя и зарегистрировать его (в качестве примера используется: yours-linux-server-1.asuscomm.com). Когда процесс успешно завершится, применить всю конфигурацию. Через небольшой промежуток времени ваш публичный IP адрес привяжется к доменному имени, которое вы зарегистрировали и доступ к приложениям можно будет запрашивать по нему, вместо публичного IP адреса.
Кстати, если вы захотите в будущем заморочиться настройкой https соединения, то здесь же можно получить бесплатный сертификат Let`s Encrypt (кнопочка Export), который можно указать в качестве реквизитов при настройке https-соединения в настройках ПО выше.
Настройка службы DDNS на роутере Asus Немного про адресацию:
Доступ, например, в Node-Red, осуществляется по адресу http://localhost:1880 с компьютера, на котором он установлен, по адресу http://192.168.50.56:1880 если запрос идет из любого другого компьютера домашней локальной сети, и http://<ваш ip адрес на 2ip.ru / или доменное имя>:1880 если настроен проброс портов и запрашивается доступ через интернет. Итого это будет выглядеть следующим образом:
На самом сервере доступ к ПО осуществляется по ссылкам:
```
http://localhost:1880 –> Node-RED
http://localhost:1883 –> Mosquitto MQTT
http://localhost:1871 –> WireGuard VPN
http://localhost:3000 –> Grafana
http://localhost:8086 –> InfluxDBv2
```
На любом устройстве домашней локальной сети доступ к ПО осуществляется по ссылкам:
```
http://192.168.50.56:1880 –> Node-RED
http://192.168.50.56:1883 –> Mosquitto MQTT
http://192.168.50.56:1871 –> WireGuard VPN
http://192.168.50.56:3000 –> Grafana
http://192.168.50.56:8086 –> InfluxDBv2
```
На любом устройстве доступ к ПО через интернет осуществляется по ссылкам (на месте yours-linux-server-1.asuscomm.com может быть ваш публичный IP адрес на 2ip.ru):
```
http://yours-linux-server-1.asuscomm.com:1880 –> Node-RED
http://yours-linux-server-1.asuscomm.com:1883 –> Mosquitto MQTT
http://yours-linux-server-1.asuscomm.com:1871 –> WireGuard VPN
http://yours-linux-server-1.asuscomm.com:3000 –> Grafana
http://yours-linux-server-1.asuscomm.com:8086 –> InfluxDBv2
```
P.S.
----
Если любопытно посмотреть потребление ресурсов развернутой системы, то можно воспользоваться утилитой htop:
```
htop
```
P.S.S: Docker
-------------
Для тех, кто предпочитает контейнеры:Вставляем один большой скрипт (вот прям весь весь):
```
apt install -y iptables && \
wget https://download.docker.com/linux/debian/dists/bullseye/pool/stable/amd64/containerd.io_1.6.15-1_amd64.deb && \
wget https://download.docker.com/linux/debian/dists/bullseye/pool/stable/amd64/docker-ce-cli_20.10.23~3-0~debian-bullseye_amd64.deb && \
wget https://download.docker.com/linux/debian/dists/bullseye/pool/stable/amd64/docker-ce_20.10.23~3-0~debian-bullseye_amd64.deb && \
dpkg -i containerd.io_1.6.15-1_amd64.deb && \
dpkg -i docker-ce-cli_20.10.23~3-0~debian-bullseye_amd64.deb && \
dpkg -i docker-ce_20.10.23~3-0~debian-bullseye_amd64.deb && \
DOCKER_CONFIG=${DOCKER_CONFIG:-$HOME/.docker} && \
mkdir -p $DOCKER_CONFIG/cli-plugins && \
curl -SL https://github.com/docker/compose/releases/download/v2.15.1/docker-compose-linux-x86_64 -o $DOCKER_CONFIG/cli-plugins/docker-compose && \
chmod +x $DOCKER_CONFIG/cli-plugins/docker-compose && \
rm containerd.io_1.6.15-1_amd64.deb && \
rm docker-ce-cli_20.10.23~3-0~debian-bullseye_amd64.deb && \
rm docker-ce_20.10.23~3-0~debian-bullseye_amd64.deb && \
docker compose version && \
mkdir -m 777 -p ~/mosquitto/config && \
mkdir -m 777 -p ~/mosquitto/data && \
mkdir -m 777 -p ~/mosquitto/log && \
mkdir -m 777 -p ~/influxdb/data && \
mkdir -m 777 -p ~/influxdb/conf && \
mkdir -m 777 -p ~/telegraf/conf && \
mkdir -m 777 -p ~/grafana/data && \
mkdir -m 777 -p ~/grafana/conf && \
mkdir -m 777 -p ~/grafana/log && \
mkdir -m 777 -p ~/node-red/data && \
mkdir -m 777 -p ~/wireguard/config
```
Создадим конфигурацию для mosquitto:
```
cat > ~/mosquitto/config/mosquitto.conf <
```
Создадим конфигурацию для telegraf:
```
cat > ~/telegraf/conf/telegraf.conf <
```
Настроим Grafana на 80 порт:
```
cat > ~/grafana/conf/grafana.ini <
```
Создадим docker-compose.yml:
```
cat > docker-compose.yml <
```
Запустим создание контейнеров (процесс займет какое-то время):
```
docker compose up -d
```
Далее, необходимо, как в основной части статьи, настроить mosquitto. От вас требуется только придумать пароль:
```
docker exec -it mosquitto mosquitto_passwd -c /mosquitto/config/password.txt IoT
```
Включить авторизацию в конфигурации:
```
cat > ~/mosquitto/config/mosquitto.conf <
```
И применить конфигурацию:
```
docker restart mosquitto
```
Настроить авторизацию в Node-red, сгенерировав пароль сперва для admin, потом для user, и скопировав хеши куда-нибудь:
```
docker exec -it node-red node-red-admin hash-pw
```
И указать их здесь:
```
nano +76,5 ~/node-red/data/settings.js
```
Должно быть примерно так:
```
adminAuth: {
type: "credentials",
users: [
{
username: "admin",
password: "$2b$08$WhOtjRwX8Cd44vgryrOPue4rS8YkdOxS7DuuvUaUtotGRiSZ1bUny",
permissions: "*"
},
{
username: "user",
password: "$2b$08$sksoLeOB6EDecN3IZYLisO7mqNf/KSI519eioh7gtM0BpvAM3wA3q",
permissions: "read"
}
]
},
```
Затем применяем конфигурацию:
```
docker restart node-red
```
Получаем токен Influx по шагам в основной статье. И указываем его здесь:
```
nano +15,12 ~/telegraf/conf/telegraf.conf
```
И применяем конфигурацию для Telegraf:
```
docker restart telegraf
```
Все контейнеры должны быть в статусе UP
```
docker ps
```
Выглядит примерно вот такКонфиг для WireGuard можно получить командой:
```
docker exec -it wireguard /app/show-peer 1
```
Не забываем про настройку интеграции с Influx у Grafana и Node-RED (в части настроек все без изменений, как и в основной статье)
Вместо заключения
-----------------
На этом все! Домашний сервер с системой визуализации и подключением по MQTT настроен. Остается только отправлять данные в топики по MQTT и настраивать визуализацию, как душе угодно.
На самом деле в статье рассмотрен лишь частный случай с MQTT. Что Telegraf, что Node-RED – позволяют получать и передавать данные в InfluxDB (и другие БД) по множеству других интерфейсов и протоколов. Но это уже совсем другая история. | https://habr.com/ru/post/680902/ | null | ru | null |
# Ускорения параллельных вычислений
Главной целью создания и разработки многочисленных типов параллельных машин, о которых мы говорили в [прошлой](http://habrahabr.ru/blogs/hi/126930/) статье, это скорость. Суперкомпьютеры и многопроцессорные системы могут и должны делать все быстрее! Давайте постараемся расчитать, насколько быстрее.
Логично подумать, что если один процессор выполняет работу за n секунд, то четыре процессора потратят n/4 секунд. Понятие “фактор ускорения” (“speedup factor”) это отношение времени, которое тратит на выполнение работы один процессор к времени, которое тратит на эту же работу многопроцессорная система.
S(p) = Ts / Tp
Для расчета важно использовать самый оптимальный Ts, то есть лучший из возможных не-параллельных алгоритмов.
Теперь плохие новости: у этого ускорения есть лимит. Называется он Amdahl’s Law (Закон Амдала) и вот его суть: так выглядит какая-либо задача на обычной однопроцессорной системе:
Все время выполнения — знакомое уже нам Ts, состоит из той части, которую можно распределить на несколько процессоров (распараллелить) — (1-f)Ts, и той части, что распараллелить нельзя (серийная) — fTs.
Как будет выглядеть схема той же задачи для нескольких процессоров?
Теперь общее время выполнения Tp состоит из серийного времени и максимального из тех, что мы распределили на несколько процессоров (выполняются они все одновременно, но ждать нужно самого медленного). Для простоты допустим, что все они занимают одинаковое время.
Фактор ускорения расчитывается по формуле:
То есть все зависит от того, какой кусок программы мы сможем распараллелить (f в процентах означает количество серийного кода). Если f=0%, то есть абсолютно весь код распараллелен (чего практически не может быть), то чем больше процессоров мы задействуем, тем быстрее будет выполнена задача, и соотношение будет линейное: хотим в 10 раз быстрее — используем десять процессоров, хотим в миллион раз быстрее — закупаем миллион процессоров. Но вот стоит оставить 5% серийного кода, а 95% распараллелить, то фактор ускорения будет равен 20 и выше никак не прыгнуть. Даже если закупим к тому миллиону еще миллион процессоров, то программа все равно будет выполняться в 20 раз быстрее. Вот как этот грустный факт выглядит на графике с примерами разных процентов f:
Получается, что самое важное в вопросе эффективности параллельного кода — это хороший дизайн самого алгоритма. Каждая деталь может сильно повлиять на расширяемость: если сейчас алгоритм нормально использует ресурсы четырехядерного процессора, то возможно больше 8 ядер он нормально использовать не сможет, и тогда через год программу нужно будет писать заново — ведь вместо количества транзисторов теперь каждые полгода увеличивается количество ядер!
Чтобы написать хороший параллельный алгоритм, нужно вникнуть в суть проблемы и подумать, как его можно разделить на отдельные независимые (в идеале) части, чтобы все они выполнялись параллельно на разных процессорах. Посмотрим на примере довольно ёмкой задачи умножения матрицы А на вектор b. Результат будет записан в вектор y, который по размеру идентичен вектору b. Чтобы получить первое значение вектора y, нужно умножить первую строку матрицы на вектор b, чтобы получить второе значение y — вторую строку на b, и так далее. Получается, каждый элемент вектора y можно считать независимо от других, то есть параллельно.
Размер каждой такой задачи один и тот же — все строки A имеют одинаковый размер (пока не касаемся таких деталей, как плотность матрицы — возможно, в ней много нулей, но предположим, что это не сильно влияет на время выполнения). Нет никаких зависимостей между задачами, и все задачи используют один и тот же b.
Вот другой пример — запрос в базу данных:
**MODEL = “CIVIC” AND YEAR=2001 AND (COLOR=”GREEN” OR COLOR=”WHITE”);**
Запрос пытается получить все зеленые или белые Цивики 2001 года из такой базы:
Такую задачу можно разложить на три части: один процессор будет формировать таблицу все Цивиков 2001 года, другой процессор будет формировать таблицу всех белых и зеленых машин (эти два запроса могут идти параллельно), после чего результат join’а этих двух таблиц и будет ответом.
Можно изменить структуру запроса, что может повлиять на параллелизацию
Разделение задачи на части для последующего распределения этих частей на разные процессоры называется декомпозицией. Умножение матрицы на вектор это пример декомпозиции результата задачи: результат (вектор y) был разделен на несколько независимых частей и каждая расчитывалась отдельно от другой. То же самое можно сделать и с перемножением матриц:
#### Наша первая параллельная программа
Для написания нашей первой параллельной программы мы будем использовать Cilk. Это язык программирования, который по сути является С с удобными инструментами для параллелизации и синхронизации задач. Cilk был разработан в MIT в 1994 году, был бесплатным и свободным, но к 2006 году стал коммерциализироваться, стал поддерживать С++, а год назад был куплен с потрохами компанией Intel, которой, конечно же, выгодно иметь хороший язык программирования для многоядерных систем: они ведь саим такие системы и производят. Я не уверен, как можно получить компилятор бесплатно, в нашем университете есть академическая версия для студентов (разработчик Cilk хороший друг профессора), поэтому прошу меня извинить, если вы не сможете найти его. Но поискать, я считаю, стоит, потому что Cilk жутко прост и удобен! Не сравнить с Pthreads. Все, что нам нужно знать, чтобы начать программировать, это три ключевых слова: **cilk**, **spawn** и **sync**.
Лучше всего начать с примера, поэтому вот вам любимая всеми рекурсивная задача — числа Фибоначи — на Си:
```
int fib (int n){
if (n<2) return n;
else {
int x, y;
x = fib (n-1);
y = fib (n-2);
return (x+y);
}
}
```
А вот та же программа на Cilk:
```
cilk int fib (int n){
if (n<2) return n;
else {
int x, y;
x = spawn fib (n-1);
y = spawn fib (n-2);
sync;
return (x+y);
}
}
```
Заметили разницу? ,)
Ключевое слово **cilk** используется для указания функции. Самыми главными являются слова spawn и sync. **Spawn** ставится перед вызовом функции, которую мы хотим запустить на другом ядре, а **sync** ждет окончания выполнения всех вызванных ранее spawn’ами функций. То есть строчка
**x=spawn fib(n-1);**
запускается на другом ядре, и сразу выполняется строчка **y=spawn fib(n-2)**. Перед тем, как вернуть результат (**return (x+y)**) нужно дождаться окончания выполнения, иначе в переменных x и y не будет правильных значений. Это делает команда sync — как и понятно из названия.
Правда, легко?
Такая программа хоршенько загрузит множество ядер! Вот как выглядит схема работы этого алгоритма для n=4:
Цвета подсветки кода соответствуют цветам узлов графа. Каждый уровень графа выполняется одновременно, то есть первый вызов для n=4 вызывает две функции — для 3 и 2, они в свою очередь — для 2 и 1 и для 1 и 0 соответственно.
Вот [исходный код](http://dl.dropbox.com/u/72746/css/comp%204009/fib.cilk) этой программы:
В следующей статье мы поговорим о том, как расчитывается масштабируемость параллельных алгоритмов, какие виды шедулинга бывают и какой используется в cilk, а также коснемся сортировки и параллельного динамического программирования. | https://habr.com/ru/post/127007/ | null | ru | null |
# Трассировка и мониторинг в Istio: микросервисы и принцип неопределенности
Принцип неопределенности Гейзенберга гласит, что нельзя одновременно измерить положение объекта и его скорость. Если объект движется, то у него нет местоположения. А если местоположение есть – значит у него нет скорости.
Что касается микросервисов на платформе Red Hat OpenShift (и под управлением Kubernetes), то благодаря соответствующему софту с открытым кодом они могут одновременно рапортовать как о своей производительности, так и об исправности. Старика Гейзенберга это, конечно, не опровергает, но зато устраняет неопределенность при работе с облачными приложениями. Istio позволяет легко организовать отслеживание (трассировку) и мониторинг таких приложений, чтобы держать все под контролем.
### Определяемся с терминологией
Под **трассировкой** (Tracing) мы понимаем логирование системной активности. Звучит довольно общо, но на самом деле одно из основных правил здесь в том, чтобы сбрасывать данные трассировки в соответствующее хранилище, не заботясь об их форматировании. А вся работа по поиску и анализу данных возлагается на их потребителя. В Istio используется система трассировки Jaeger, реализующая модель данных OpenTracing.
**Трассами** (Traces, и слово «трассы» здесь используется в значении «следы», как например, в баллистической экспертизе) мы будем называть данные, которые полностью описывают прохождение запроса или единицу работы, как говорится, «от и до». Например, всё, что происходит с момента, когда пользователь жмет кнопку на веб-странице, и до момента возврата данных, включая все задействованные при этом микросервисы. Можно сказать, что одна трасса полностью описывает (или моделирует) прохождение запроса туда и обратно. В интерфейсе Jaeger трассы раскладывается на составляющие по оси времени, вроде того, как цепь можно разложить на отдельные звенья. Только вместо звеньев трасса состоит из так называемых span’ов.
**Span** – это интервал от начала выполнения единицы работы до ее завершения. Продолжая аналогию, можно сказать, что каждый span представляет собой отдельное звено цепи. Span может иметь (или не иметь) один или несколько дочерних span’ов. Как следствие, span самого верхнего уровня (root span) будет иметь ту же общую продолжительность, что и трасса, к которой он относится.
**Мониторинг** – это, собственно, само наблюдение за вашей системой – глазами, через UI или средствами автоматизации. В основе мониторинга лежат данные трассировки. В Istio мониторинг реализован средствами Prometheus и имеет соответствующий UI. Prometheus поддерживает автоматический мониторинг с использованием оповещений Alerts и Alert Managers.
### Оставляем зарубки
Чтобы трассировка стала возможной, приложение должно создать коллекцию span’ов. Потом их надо экспортировать в Jaeger, чтобы тот в свою очередь создал визуальное представление трассировки. Среди прочего эти span’ы маркируют имя операции, а также временны метки ее начала и завершения. Передача span’ов выполняется путем переадресации предназначенных для Jaeger заголовков HTTP-запросов от входящих запросов к исходящим запросам. В зависимости от используемого языка программирования для этого может потребоваться небольшая модификации исходного кода приложений. Ниже приводится пример кода на Java (при использовании фреймворка Spring Boot), который добавляет заголовки B3 (Zipkin-style) к вашему запросу в конфигурационном классе Spring:
При этом используются следующие настройки заголовков:
Если вы используете Java, то код можно не трогать, а просто добавить несколько строк в POM-файл Maven и задать переменные окружения. Вот какие строки надо добавить в файл POM.XML, чтобы внедрить Jaeger Tracer Resolver:
А соответствующие переменные среды задаются в Dockerfile:
Всё, теперь всё настроено, и наши микросервисы начнут генерировать данные трассировки.
### Смотрим в общих чертах
В состав Istio входит простенькая контрольная панель на основе Grafana. Когда все настроено и работает на платформе Red Hat OpenShift PaaS (в нашем примере Red Hat OpenShift и Kubernetes развернуты на minishift), эта панель запускается следующей командой:
```
open "$(minishift openshift service grafana -u)/d/1/istio-dashboard?refresh=5⩝Id=1"
```
Панель Grafana позволяет быстро оценить работу системы. Фрагмент этой панели показан на рисунке ниже:
Здесь видно, что микросервис customer вызывает микросервис preference v1, а тот в свою очередь вызывает микросервисы recommendation v1 и v2. На панели Grafana есть блок Dashboard Row для высокоуровневых метрик, таких как общее количество запросов (Global Request Volume), доля успешных запросов (success rates), ошибки 4xx. Кроме того, там есть представление Server Mesh с графиками для каждого сервиса и блок Services Row для просмотра подробных сведений по каждому контейнеру для каждого сервиса.
### Теперь копнем поглубже
При грамотно настроенной трассировке Istio, что называется, прямо из коробки позволяет углубиться в анализ производительности системы. В Jaeger’овском UI можно просматривать трассировки и видеть, как далеко и глубоко они уходят, а также визуально локализовать узкие места в производительности. При использовании Red Hat OpenShift на платформе minishift запуск Jaeger UI выполняете следующей командой:
```
minishift openshift service jaeger-query --in-browser
```
Что можно сказать про трассировку на этом скрине:
* Она разбивается на 7 span’ов.
* Общее время выполнения составляет 6.99 ms.
* На микросервис recommendation, который является последним в цепочке, тратится 0.69 ms.
Диаграммы такого типа позволяют быстро разобраться в ситуации, когда из-за какого-то одного неважно работающего сервиса страдает производительность всей системы.
А теперь усложним задачу и запустим два экземпляра микросервиса recommendation:v2 командой oc scale --replicas=2 deployment/recommendation-v2. Вот какие у нас после этого будут pod’ы:
Если теперь переключиться обратно в Jaeger и развернуть span для сервиса recommendation, мы увидим, на какой pod маршрутизируются запросы. Таким образом, мы может легко локализовать тормоза на уровне конкретного pod‘а. Смотреть при этом надо на поле node\_id:
### Куда и как всё ходит
Теперь переходим в интерфейс Prometheus и вполне ожидаемо видим там, что запросы между второй и первой версиями сервиса recommendation делятся в отношении 2:1, строго по количеству работающих pod’ов. Причем этот график будет динамически меняться при масштабировании pod’ов вверх-вниз, что будет особенно полезно при Canary Deployment (мы подробнее рассмотрим эту схему развертывания в следующий раз).
### Всё только начинается
На самом деле сегодня мы, что называется, лишь слегка затронули кладезь полезной информации о Jaeger, Grafana и Prometheus. В общем-то это и была наша цель – направить вас в нужном направлении и приоткрыть перспективы Istio.
И помните, все это уже встроено в Istio. При использовании определенных языков программирования (например, Java) и фреймворков (например, Spring Boot) всё это можно реализовать, совершенно не трогая сам код приложений. Да, код придется слегка модифицировать, если вы используете другие языки, в первую очередь имеются в виду Nodejs или C#. Но поскольку отслеживаемость (читай, «трассировка») является одним из обязательных условий при создании надежных облачных систем, вам в любом случае придется править код, есть у вас Istio или нет. Так почему бы не потратить усилия с большей пользой?
Хотя бы для того, чтобы всегда отвечать на вопросы «где?» и «как быстро?» со 100% определенностью.
### Хаос-инжиниринг в Istio: так и было задумано
### Умение ломать вещи помогает сделать так, чтобы они не ломались
Тестирование софта – вещь не только сложная, но и важная. В то же время тестирование на корректность (например, возвращает ли функция верный результат) – это одно, а тестирование в условиях ненадежной сети – это совсем другая задача (часто считается, что сеть всегда работает без сбоев, и это первейшее из восьми заблуждений относительно распределенных вычислений). Одна из сложностей при решении этой задачи заключается в том, как имитировать сбои в системе или вносить их намеренно, выполняя так называемый fault injection. Это можно делать путем модификации исходного кода самого приложения. Но тогда вы будете тестировать уже не свой изначальный код, а его версию, которая специально имитирует сбои. В результате вы рискуете угодить в смертельные объятия fault injection и столкнуть с гейзенбагами – сбоями, которые исчезают при попытке их обнаружить.
А теперь мы покажем, как Istio помогает справиться с этими сложностями на раз-два.
### Как всё выглядит, когда всё отлично
Рассмотрим следующий сценарий: у нас есть два pod’а для нашего микросервиса recommendation, который мы взяли из учебника по Istio. Один pod помечен как v1, а другой – как v2. Как видим, пока всё работает отлично:
(Кстати, число справа – это просто счетчик вызовов для каждого pod’а)
Но нам ведь нужно отнюдь не это, верно? Что ж, попробуем всё сломать, совершенно не трогая исходный код.
### Устраиваем перебои в работе микросервиса
Ниже приведен yaml-файл для правила маршрутизации Istio, которое в половине случаев будет выдавать сбой (ошибку сервера 503):
Обратите внимание, мы явно прописываем, что в половине случаев должна возвращаться ошибка 503.
А вот как будет выглядеть скриншот запущенной в цикле команды curl после того, как мы активируем это правило, чтобы имитировать сбои. Как видим, половина запросов возвращает ошибку 503, причем вне зависимости от того, на какой pod – v1 или v2 – они уходят:
Для восстановления нормальной работы достаточно удалить это правило, в нашем случае командой istioctl delete routerule recommendation-503 -n tutorial. Здесь Tutorial – это имя проекта Red Hat OpenShift, в котором работает наш учебник по Istio.
### Вносим искусственные задержки
Искусственные ошибки 503 помогают протестировать систему на устойчивость к сбоям, но способность прогнозировать и обрабатывать задержки должна впечатлить вас еще больше. Да и задержки в реальной жизни случаются чаще, чем сбои. Медленно работающий микросервис – это яд, от которого страдает вся система. Благодаря Istio можно протестировать код, относящийся к обработке задержек, никак его при этом не меняя. Для начала мы покажем, как это сделать в случае искусственно введенных задержек сети.
Обратите внимание, что после такого тестирования вам, возможно, понадобится (или захочется) доработать свой код. Хорошая новость здесь в том, в этом случае вы будете действовать проактивно, а не реактивно. Именно так и должен строиться цикл разработки: кодирование-тестирование-обратная связь-кодирование-тестирование…
Вот как выглядит правило, которое… Хотя знаете что? Istio так прост, а этот yaml-файл так понятен, что всё в этом примере говорит само за себя, просто взгляните:
В половине случаев у нас будет возникать 7-секундная задержка. И это вовсе не то же самое, как если бы мы вставили в исходный код команду sleep, поскольку Istio реально задерживает запрос на 7 секунд. Поскольку Istio поддерживает трассировку Jaeger, эта задержка отлична наблюдается в Jaeger’оском UI, как показано на скрине ниже. Обратите внимание на долгий запрос в правом верхнем углу диаграммы – его длительность составляет 7.02 секунды:
Этот сценарий позволяет протестировать код в условиях сетевых задержек. И понятно, что, убрав это правило, мы уберем искусственную задержку. Повторимся, но мы опять сделали всё это, никак не трогая исходный код.
### Не отступать и не сдаваться
Другая полезная для хаос-инжиниринга функция Istio – это повторные обращения к сервису заданное число раз. Смысл здесь в том, чтобы не прекращать попытки, когда первый запрос заканчивается ошибкой 503 – и тогда, возможно, в N-надцатый раз нам повезет. Может быть, сервис просто ненадолго прилег по той или иной причине. Да, эту причину надо бы раскопать и устранить. Но это потом, а пока что попробуем сделать так, чтобы система продолжала работать.
Итак, мы хотим, чтобы сервис время от времени выдавал ошибку 503, а Istio после этого повторял попытки с ним связаться. И тут явно нужен способ генерить ошибку 503, не трогая сам код…
Стоп, погодите! Мы же только что это делали.
Вот этот файл сделает так, что сервис recommendation-v2 будет в половине случаем выдавать ошибку 503:
Очевидно, что часть запросов будет заканчиваться неудачей:
А теперь задействуем Istio-функцию Retry:
Это правило маршрутизации делает три повтора с двухсекундным интервалом и должно сократить (а в идеале и вовсе убрать с радара) ошибки 503:
Резюмируем: мы сделали так, что Istio, во-первых, генерит ошибку 503 для половины запросов. А во-вторых, тот же Istio выполняет три попытки повторно связаться с сервисом при возникновении ошибки 503. В результате все работает просто отлично. Таким образом, используя функцию Retry, мы выполнили свое обещание не отступать и не сдаваться.
И да, мы опять сделали это, совершенно не трогая код. Всё, что нам понадобилось, – это два правила маршрутизации Istio:
### Как не подвести пользователя или семеро одного не ждут
А теперь вывернем ситуацию наизнанку и рассмотрим сценарий, когда не отступать и не сдаваться стоит только какое-то фиксированное время. А затем надо просто прекратить попытки обработать запрос, чтобы не заставлять всех ждать какого-то одного тормозящего сервиса. Иначе говоря, мы не будем защищать потерянную позицию, а отойдем на запасной рубеж, чтобы не подводить пользователя сайта и не вынуждать его томиться в неведении.
В Istio можно задать таймаут выполнения запроса. Если сервис превышает этот таймаут, возвращается ошибка 504 (Gateway Timeout) – опять же все это делается через конфигурацию Istio. Но нам придется добавить в исходный код сервиса команду sleep (а затем, конечно, выполнить rebuild и redeploy), чтобы имитировать медленную работу сервиса. Увы, иначе не получится.
Итак, мы вставили трехсекундный sleep в код сервиса recommendation v2, пересобрали соответствующий образ и сделали редеплой контейнера, а теперь добавим таймаут с помощью следующего правила маршрутизации Istio:
На скрине выше видно, что мы бросаем попытки связаться с сервисом recommendation, если не получаем ответа в течение одной секунды, то есть еще до того, как возникнет ошибка 504. После применения этого правила маршрутизации (и добавления трехсекундного sleep’а в код сервиса recommendation:v2), мы получим вот что:
Опять повторяемся, но таймаут можно задать, никак не трогая исходный код. А дополнительный бонус здесь в том, что теперь вы можете модифицировать свой код так, чтобы он реагировал на таймаут, и легко протестировать эти доработки с помощью Istio.
### А теперь всё вместе
Внести немного хаоса с помощью Istio – это отличный способ протестировать ваш код и надежность вашей системы в целом. Шаблоны fallback, bulkhead и circuit breaker, механизмы создания искусственных сбоев и задержек, а также повторные вызовы и таймауты будут очень полезны при создании отказоустойчивых облачных систем. В сочетании с Kubernetes и Red Hat OpenShift эти инструменты помогут уверенно встретить будущее. | https://habr.com/ru/post/485136/ | null | ru | null |
# Генерация Sitemaps «на лету» с помощью ASP.NET HttpHandler
Sitemaps — это XML-файл с информацией для поисковых систем (таких как Google, Yahoo, Ask.com, MSN, Яндекс) о страницах веб-сайта, которые подлежат индексации. Sitemaps может помочь поисковикам определить местонахождение страниц сайта, время их последнего обновления, частоту обновления и важность относительно других страниц сайта для того, чтобы поисковая машина смогла более разумно индексировать сайт.
Использование протокола Sitemaps не является гарантией того, что веб-страницы будут проиндексированы поисковыми системами, это всего лишь дополнительная подсказка для сканеров, которые смогут выполнить более тщательное сканирование Вашего сайта. В статье рассказывается как «на лету» получать Sitemaps, используя ASP.NET HttpHandler.
Пример карты сайта, которая содержит единственную страницу:
> `</fontxml version="1.0" encoding="UTF-8"?>
>
> <urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">
>
> <url>
>
> <loc>habrahabr.ruloc>
>
> <lastmod>2009-10-25lastmod>
>
> <changefreq>monthlychangefreq>
>
> <priority>0.8priority>
>
> url>
>
> urlset>
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Детальнее о протоколе можно почитать [здесь](http://www.sitemaps.org/protocol.php).
Внутри директории App\_Code создаем SiteMapHandler.cs:
Ниже код Asp.Net Sitemap Handler, который реализует интерфейс IHttpHandler:
> `public class SitemapHandler : IHttpHandler
>
> {
>
> protected enum ChangeFrequency
>
> {
>
> always,
>
> hourly,
>
> daily,
>
> weekly,
>
> monthly,
>
> yearly,
>
> never
>
> }
>
>
>
> #region IHttpHandler Members
>
>
>
> public bool IsReusable
>
> {
>
> get { return false; }
>
> }
>
>
>
> public void ProcessRequest(HttpContext context)
>
> {
>
> using (TextWriter textWriter = new StreamWriter(context.Response.OutputStream, System.Text.Encoding.UTF8))
>
> {
>
> XmlTextWriter writer = new XmlTextWriter(textWriter);
>
> writer.Formatting = Formatting.Indented;
>
> writer.WriteStartDocument();
>
> writer.WriteStartElement("urlset");
>
> writer.WriteAttributeString("xmlns", "http://www.sitemaps.org/schemas/sitemap/0.9");
>
>
>
> //Add home page
>
> writer.WriteStartElement("url");
>
> writer.WriteElementString("loc", "http://habrahabr.ru/");
>
> writer.WriteElementString("lastmod", DateTime.Now.ToString("yyy-MM-dd", System.Globalization.CultureInfo.InvariantCulture));
>
> writer.WriteElementString("changefreq", ChangeFrequency.always.ToString());
>
> writer.WriteElementString("priority", "0.8");
>
> writer.WriteEndElement(); // url
>
>
>
> // Your code here for page nodes
>
>
>
> writer.WriteEndElement(); // urlset
>
> }
>
> context.Response.ContentType = "text/xml";
>
> }
>
>
>
> #endregion
>
> }
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
В месте комментария «Your code here for page nodes» нужно вставить свою логику добавления страниц — либо с базы, либо с web.sitemap, либо с другого источника.
В web.config нужно добавить строки:
> `<httpHandlers>
>
> <add verb="\*" path="sitemap.axd"
>
> type="SitemapHandler" validate="false"/>
>
> httpHandlers>
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Для тестирования Sitemap откройте в строке браузера Sitemap.axd.
Далее необходимо создать файл robots.txt и внести туда строку:
*Sitemap: [youdomain/sitemap.axd](http://youdomain/sitemap.axd)*
В статье использовались материалы сайта [bloggingdeveloper](http://www.bloggingdeveloper.com/post/generate-sitemaps-for-google-msn-live-yahoo-ask-on-the-fly-using-an-aspnet-httphandler.aspx).
Спасибо за внимание! | https://habr.com/ru/post/73303/ | null | ru | null |
# CRUD API на Deno и PostgreSQL: работаем с динозавром
***Всем привет. В преддверии старта курса [«Fullstack разработчик JavaScript»](https://otus.pw/7TM5/), хотим поделиться интересным материалом, который прислал наш внештатный автор. Данная статья не имеет отношения к программе курса, но наверняка будет интересна, как небольшой обзор на Deno.***
---
> "-Райан, мы тут концепцию CLI команд для Deno продумываем. Сколько флагов для secure runtime добавить?"
>
> "-Да"
>
> "-Райан, нам надо придумать символ языка, чтобы все понимали, что мы делаем что-то прям новое. Какое животное выберем?"
>
> "-Динозавра"
Всем привет. Deno становится все известнее и популярнее, выходит огромное количество новых видео и текстовых гайдов на эту тему, но преимущественно на английском языке. На Хабре тоже выходило несколько статей на тему Deno, к примеру [здесь](https://habr.com/ru/company/ruvds/blog/504584/) и [здесь](https://habr.com/ru/post/449000/), но преимущественно статьи рассказывают о Deno в теоретическом плане. Сегодня мы попробуем создать небольшое CRUD Api, которое может обслужить, к примеру, todo-приложение на frontend, и я поделюсь с вам своими впечатлениями от этого динозавра в реальном кодинге.
Теоретическое вступление
=========================
Для тех кто в танке, я расскажу, что такое Deno, если вы не читали, например, какую-то из статей выше. Deno — это среда выполнения runtime, работающая на JavaScript и TypeScript (поддержка TypeScript осуществляется из коробки, версия компилятора TypeScript жестко зашита в версию Deno, сменить ее получится только если смените версию Deno), которая базируется на движке V8 и языке программирования Rust. Deno был создан Райаном Далом, создателем Node.js, и главные качества Deno — это производительность и безопасность. О появлении Deno на свет было объявлено в 2018, и о чем многие источники забывают упомянуть — испытал большое влияние Golang (да и вообще изначально был написан на Golang, однако впоследствии пришлось переписать на Rust).
Стандартная библиотека была создана по образцу стандартной библиотеки Go, да и множество инструментов или их реализации перешли из Golang в Deno, к примеру, отсутствие экосистемы вроде npm и подкачивание библиотек напрямую из веб-ресурсов на этапе первоначальной сборки (что вызывает некий ступор у Node.js разработчиков, которые вполне естественно не были знакомы с подобной системой у Go). Так для кого Deno сейчас? Если вам нравятся типизируемые языки, нравятся идеи и инструменты Golang, но хочется писать бэк на чем-то более простом — пора попробовать Deno в реальности. Однако, если вы хотите подождать, пока платформа «дозреет», появится большее количество библиотек и ответов на StackOverflow, возможно, вам стоит немного подождать.
Начинаем создавать
-------------------
Несмотря на молодость Deno, вокруг него успела сформироваться какая-никакая экосистема (которую конечно же пока нельзя сравнивать с экосистемой Node.js), которая позволяет вам покрыть базовые потребности в создании своего API. Давайте определимся, что создаем: я хочу создать простое CRUD Api, используя Deno и TypeScript на бекенде (раз есть поддержка TypeScript, то почему бы ей не воспользоваться), PostgreSQL в качестве базы данных (вообще я хотел использовать MySQL, но случайно сломал себе доступ по localhost и не смог починить. Любопытный факт, что по внешнему ip встроенный сервер PHP 7.4 смог соединиться с моей базой MySQL, а Deno показывал packets out of order), и запросы у нас будут выглядеть следующим образом:
| | | |
| --- | --- | --- |
| **Метод** | **Routes** | **Результат выполнения** |
| GET | /api/todos/get | Получение всех todo |
| POST | /api/todos/post | Создание нового дела |
| PATCH | /api/todos/:id | Обновление определенного дела |
| DELETE | /api/todos/:id | Удаление дела по id |
Отлично, со схемой запросов мы определились, сервер PostgreSQL запустили (если, что скачать его можно [отсюда](https://www.postgresql.org/download/), весьма приятный GUI-клиент [Postico](https://eggerapps.at/postico/)), базу данных crud\_api мы создали.
Что дальше? Руками с помощью sql-запросов или клиента таблицу создавать конечно можно, но хочется посмотреть, как там с миграциями у Deno. На этот случай нам пригодиться библиотека [nessia](https://github.com/halvardssm/deno-nessie), позволяющая создавать миграции похожие на миграции в Laravel. Но перед тем, как мы займемся миграциями, давайте поговорим об организации среды разработки.
Буквально на днях вышел официальный плагин для разработки на Deno от JetBrains. Найти его можно [здесь](https://plugins.jetbrains.com/plugin/14382-deno). На Visual Studio вам нужно установить плагин Deno, и в папке проекта создать папку настроек *.vscode*, где в settings.json вы включите поддержку deno (но у меня вроде поддержка работала и без этого):
```
"deno.enable":true
```
На этом с подготовительным этапом все, можем возвращаться к миграциям. Для начала нам нужно ввести команду инициализации, взяв ее из документации библиотеки:
```
deno run --allow-net --allow-read --allow-write https://deno.land/x/nessie/cli.ts init
```
Создаем конфигурирующий файл для нашей библиотеки, с помощью которой мы сможем определить, с какой СУБД и с какой базой данных вы собираетесь произвести коннект.
Изначально в файле создаются три шаблона — для PostgreSQL, MySQL и Sqlite(по умолчанию экспортятся настройки для PostgreSQL).
В итоге наш файл *nessie.config.ts* будет выглядеть следующим образом:
```
import { ClientPostgreSQL} from "https://deno.land/x/nessie/mod.ts";
const migrationFolder = "./migrations";
const configPg = {
client: new ClientPostgreSQL(migrationFolder, {
database: "deno_crud",
hostname: "localhost",
port: 5432,
user: "isakura313",
password: "",
}),
};
export default configPg;
```
Хорошо, теперь можно создать файл миграции, чтобы можно было его отредактировать, задав, какую таблицу и какие данные мы собираемся создавать. Для этого вводим следующую команду:
```
deno run --allow-net --allow-read --allow-write https://deno.land/x/nessie/cli.ts make create_todo
```
Возможно, у неискушенного читателя уже возникли вопросы, зачем такое количество флагов. Это и есть secure в Deno — для выполнения команды нужно указать, какой уровень доступа вы ему даете ( это же и есть гениальная система безопасности, которую мы ждали ). Эти флаги и вызывают довольно острое горение у многих — их надо печатать? Дописывать bash скрипты, в которых ты вызываешь их всегда с полными правами? Мне думается, в какой-то момент эта система поменяется, но пока как есть. Таким образом, у нас в папке `.migrations` должен появится файл миграции, который вы сможете его отредактировать, как заходите. Я отредактировал его следующим образом:
```
export const up = (): string => {
return "CREATE TABLE todo (id serial, text text, done boolean)";
};
export const down = (): string => {
return "DROP TABLE todo"
};
```
После этого мы можем выполнить миграции в базу данных с помощью следующей команды:
```
deno run --allow-net --allow-read https://deno.land/x/nessie/cli.ts migrate
```
В nessia есть более продвинутый вариант миграции, но я решил сделать все немного проще. Дальше мы можем переходить к созданию своей модели.
### Работаем с Моделью
Создаем папку `models`, в которой у нас будут находится сами запросы. Для начала нужно создать файл `config.ts`, в котором будут сложены настройки подключения к базе (да, они у нас уже были упомянуты в `nessie.config.ts`, но тот файл у нас использовался под миграции). Для коннекта в файле `config.ts` мы будем использовать библиотеку [deno-posgres](https://github.com/deno-postgres/deno-postgres). В итоге файл конфига будут выглядеть следующим образом:
```
import { Client } from "https://deno.land/x/postgres/mod.ts";
const client = new Client({
user: "isakura313",
database: "deno_crud",
hostname: "localhost",
port: 5432,
});
export default client;
```
Отлично! Теперь переходим непосредственно к модели. Для построения sql -запросов я собираюсь воспользоваться библиотекой [Dex](https://github.com/denjucks/dex), портом библиотеки Knex на Deno. Она позволит мне программно определять, какой sql — запрос я собираюсь выполнить. Начнем с определения, с каким диалектом Dex придется работать в этот раз, и определения интерфейса нашего todo:
```
const dex = Dex({ client: "postgres" });
interface Todo {
id?: number; //? - опциональный параметр в TypeScript
text: string;
done: boolean;
}
```
Отлично, теперь можем приступать к самой мякотке. Для начала определим get запрос, который будет получать все todo. Я буду использовать асинхронное выполнение функции, чтобы через await соединиться с базой данных и получить результат запроса:
```
async function getAllTodo() {
await client.connect();
const getQuery = dex.queryBuilder().select("*").from("todo").toString();
const result = await client.query(getQuery);
return result;
}
```
Если вы хоть немного знакомы в TypeScript и c async/await, здесь у вас вопросов не возникнет. Но дальше больше — нам нужно написать post-запрос, который будет добавлять дело в базу данных.
```
async function addTodo(todo: Todo) {
await client.connect();
const insertQuery = dex.queryBuilder().insert([todo]).into("todo").toString();
return client.query(insertQuery).then(async () => {
const getQuery = dex.queryBuilder().select("*").from("todo").where(
{ text: todo.text },
).toString();
const result = await client.query(getQuery);
const result_data = result.rows ? result.rows[0] : {};
return result_data;
});
}
```
Вышеприведённый код вполне можно сократить, однако я постарался сделать его максимально простым и выразительным, даже в ущерб количеству строк. В общем плане там происходит следующее — внутри функции у нас создается соединение с базой данных, выстраивается insert — запрос, происходит запрос, внутри которого создается новый запрос, который возвращает у нас только что созданное дело или пустой объект.
Остальные функции — редактирования и удаления я приведу вместе. В редактировании у нас происходит примерно то же самое, что и в добавлении дела, за исключением того, что в editTodo у нас происходит update. В delete у нас просто удаляется дело и ничего не возвращается:
```
async function editTodo(id: number, todo: Todo) {
await client.connect();
const editQuery = dex.queryBuilder().from("todo").update(todo).where({ id })
.toString();
return client.query(editQuery).then(async () => {
const getQuery = dex.queryBuilder().select("*").from("todo").where(
{ text: todo.text },
).toString();
const result = await client.query(getQuery);
const result_data = result.rows ? result.rows[0] : {};
return result_data;
});
}
async function deleteTodo(id: number) {
await client.connect();
const deleteQuery = dex.queryBuilder().from("todo").delete().where({ id })
.toString();
return client.query(deleteQuery);
}
```
Здорово. Осталось только экспортнуть наши функции, и можно приступать к настройке работы сервера и роутингу:
```
export {
addTodo,
getAllTodo,
editTodo,
deleteTodo,
};
```
### Работа роутинга и сервера
Создаем папку routes, в которой у нас будет routes.ts. Для работы нашего routes мы воспользуемся [denotrain](https://github.com/Caesar2011/denotrain/tree/master), библиотекой, которая была вдохновлена expressJS и позволяется работать с url — запросами, формировать роутинг и множество всего полезного. Мы импортируем наши функции и Router:
```
import { Router } from "https://deno.land/x/denotrain@v0.5.0/mod.ts";
import { addTodo, getAllTodo, editTodo, deleteTodo } from "../models/models.ts";
const api = new Router();
```
Добавим методы get и post:
```
api.get("/", (ctx) => {
return getAllTodo().then((result) => {
return result.rows;
//Возвращаем результат
});
});
api.post("/", (ctx) => {
const body = {
//формируем тело запроса
text: ctx.req.body.text,
done: ctx.req.body.done,
};
return addTodo(body).then((newTodo) => {
ctx.res.setStatus(201); // возвращаем код "Created"
return newTodo;
});
});
```
Ctx — это переменная, которая отвечает у нас за контекст ответа. Не знаю, что добавить к комментариями, по моему, все и так очевидно. Осталось только добавить только методы patch и delete и экспортировать наше api:
```
api.patch("/:id", (ctx) => {
const todo = {
text: ctx.req.body.text,
done: ctx.req.body.done,
};
return editTodo(ctx.req.params.id as number, todo).then((result) => {
return result;
});
});
api.delete("/:id", (ctx) => {
return deleteTodo(ctx.req.params.id as number).then(() => {
ctx.res.setStatus(204);
return true;
});
});
export default api;
```
Осталось только поднять наш сервак. В корневой папке создаем файл `server.ts`, в котором мы тоже импортируем Application из denotrain, чтобы поднять наш сервер:
```
import {Application} from "https://deno.land/x/denotrain@v0.5.0/mod.ts";
import api from "./routes/routes.ts";
const app = new Application({port: 1337}) // поднимаем наш сервер на порту 1337
app.use("/api/todos", api) // опредеяем адрес, по котором можно будет осуществлять запросы
app.run() // запускаем приложение
```
Вполне возможно, что у вас возникнут проблемы в работе приложения. Каждый раз перезапускать вручную компилирующийся сервер совсем не хочется, поэтому я использую аналог nodemon — [Denomon](https://github.com/muhibbudins/denomon), который вполне добросовестно будет перекомплировать ваш код и перезапускать сервер. В нашем случае подойдет следующая команда:
```
denomon --allow net,read server.ts
```
##### Мои впечатления
Мне очень понравилось писать на Deno. Несмотря на некий скептицизм в его сторону, с помощью TypeScript и грамотно выстроенной среды разработки можно достигнуть больших результатов в написании высоконадежного сервиса, который будет работать максимально предсказуемого. Еще есть куда расти (к примеру, в скорости перекомпиляции проекта) и пока рано пытаться применять Deno на серьезном продакшене, но я надеюсь динозавр сможет перенять самое лучшее от Node.js, немного изменить странности архитектуры, и продолжить свое развитие.
На этом в создании нашего API все. Весь проект целиком вы можете найти [здесь](https://github.com/isakura313/deno_crud). Можете открыть Postman и проверить, что все работает корректно. По традиции, несколько полезных ссылок:
[REST микрофреймворк для Deno без зависимостей](https://github.com/drashland/deno-drash)
[ejs-engine для Deno](https://github.com/syumai/dejs)
[Официальная документация к Deno](https://deno.land)
[сервер Deno в Discord](http://discord.gg/deno)
[Создание Chat App на Deno + React](https://aralroca.com/blog/learn-deno-chat-app)
[Прекрасное введение в Deno на русском](https://habr.com/ru/post/501480/)
---
[Узнать подробнее о курсе](https://otus.pw/7TM5/)
--- | https://habr.com/ru/post/505476/ | null | ru | null |
# Книга «Angular для профессионалов»
[](https://habrahabr.ru/company/piter/blog/340826/) Выжмите из Angular — ведущего фреймворка для динамических приложений JavaScript — всё. Адам Фримен начинает с описания MVC и его преимуществ, затем показывает, как эффективно использовать Angular, охватывая все этапы, начиная с основ и до самых передовых возможностей, которые кроются в глубинах этого фреймворка.
Каждая тема изложена четко и лаконично, снабжена большим количеством подробностей, которые позволят вам стать действительно эффективными. Наиболее важные фичи даны без излишних подробностей, но содержат всю необходимую информацию, чтобы вы смогли обойти все подводные камни.
### Об авторе
**Адам Фримен (Adam Freeman)** — опытный профессионал в области IT, занимавший руководящие должности во многих компаниях. До недавнего времени он занимал посты технического директора и главного инженера в одном из крупнейших банков. Сейчас Адам посвящает свое время в основном написанию книг и бегу на длинные дистанции.
### О научном редакторе
**Фабио Клаудио Феррачиати (Fabio Claudio Ferracchiati)** — старший консультант и ведущий аналитик/разработчик с опытом использования технологий Microsoft. Он работает на BluArancio (www.bluarancio.com). Фабио является сертифицированным разработчиком программных решений для .NET, сертифицированным разработчиком приложений для .NET, сертифицированным профессионалом Microsoft, плодовитым писателем и научным редактором. За последние 10 лет он написал ряд статей для итальянских и международных журналов и участвовал в написании более 10 книг по различным областям компьютерной тематики.
### Подготовка проекта Angular
Обновление корневого компонента
Начнем с корневого компонента — структурного блока Angular, который будет управлять элементом app в документе HTML. Приложение может содержать несколько компонентов, но среди них всегда присутствует корневой компонент, отвечающий за отображение контента верхнего уровня. Отредактируйте файл app.component.ts в папке SportsStore/src/app и включите в него код из листинга 7.5.
**Листинг 7.5.** Содержимое файла app.component.ts в папке SportsStore/src/app
```
import { Component } from "@angular/core";
@Component({
selector: "app",
template: `
This is SportsStore
`
})
export class AppComponent { }
```
Декоратор [Component](https://habrahabr.ru/users/component/) сообщает Angular, что класс AppComponent является компонентом, а его свойства описывают применение этого компонента. Полный набор свойств компонентов приведен в главе 17, но три свойства, приведенные в листинге, являются основными и часто применяемыми на практике. Свойство selector сообщает Angular, как следует применять компонент в документе HTML, а свойство template определяет контент, который будет отображаться компонентом. Компоненты могут определять встроенные шаблоны, как в данном случае, или использовать внешние файлы HTML, которые упрощают управление сложным контентом.
Класс AppComponent не содержит кода, потому что корневой компонент в проекте Angular существует только для управления контентом, отображаемым для пользователя. На начальной стадии мы будем управлять контентом, отображаемым корневым компонентом, вручную, но в главе 8 будет представлен механизм маршрутизации URL для автоматической адаптации контента в зависимости от действий пользователя.
### Обновление корневого модуля
Модули Angular делятся на две категории: функциональные модули и корневой модуль. Функциональные модули используются для группировки взаимосвязанной функциональности приложения, чтобы упростить управление приложением. Мы создадим функциональные модули для всех основных функциональных областей приложения, включая модель данных, пользовательский интерфейс магазина и интерфейс администрирования.
Корневой модуль передает описание приложения для Angular. В описании указано, какие функциональные модули необходимы для запуска приложения, какие нестандартные возможности следует загрузить и как называется корневой компонент. Традиционно файлу корневого компонента присваивается имя app.module.ts; создайте файл с таким именем в папке SportsStore/src/app и включите код из листинга 7.6.
**Листинг 7.6.** Содержимое файла app.module.ts в папке SportsStore/src/app
```
import { NgModule } from "@angular/core";
import { BrowserModule } from "@angular/platform-browser";
import { AppComponent } from "./app.component";
@NgModule({
imports: [BrowserModule],
declarations: [AppComponent],
bootstrap: [AppComponent]
})
export class AppModule { }
```
По аналогии с корневым компонентом класс корневого модуля не содержит код. Дело в том, что корневой модуль существует только для передачи информации через декоратор @NgModule. Свойство imports приказывает Angular загрузить функциональный модуль BrowserModule со всей основной функциональностью Angular, необходимой для веб-приложения.
Свойство declarations приказывает Angular загрузить корневой компонент, а свойство bootstrap сообщает, что корневым компонентом является класс AppModule. Информация будет добавлена в свойства этого декоратора при включении функциональности в приложение SportsStore, но для запуска приложения будет достаточно и базовой конфигурации.
### Анализ файла начальной загрузки
Следующий блок служебного кода — файл начальной загрузки, запускающий приложение. В книге основное внимание уделяется применению Angular для создания приложений, работающих в браузерах, но платформа Angular может портироваться в разные среды. Файл начальной загрузки использует браузерную платформу Angular для загрузки корневого модуля и запуска приложения. Создайте файл с именем main.ts, традиционно назначаемым файлу начальной загрузки, в папке SportsStore/src/app и добавьте в него код из листинга 7.7.
**Листинг 7.7.** Содержимое файла main.ts в папке SportsStore/src
```
import { enableProdMode } from '@angular/core';
import { platformBrowserDynamic } from '@angular/platform-browser-dynamic';
import { AppModule } from './app/app.module';
import { environment } from './environments/environment';
if (environment.production) {
enableProdMode();
}
platformBrowserDynamic().bootstrapModule(AppModule);
```
Инструменты разработки обнаруживают изменения в файле проекта, компилируют файлы с кодом и автоматически перезагружают браузер с выводом контента, изображенного на рис. 7.2.
Просматривая модель DOM в браузере, вы увидите, что временный контент из шаблона корневого компонента был вставлен между начальным и конечным тегами элемента app:
```
This is SportsStore
```
### Начало работы над моделью данных
Работу над любым новым проектом лучше всего начинать с модели данных. Я хочу поскорее продемонстрировать некоторые возможности Angular в действии, поэтому вместо определения модели данных от начала до конца мы начнем с реализации базовой функциональности на фиктивных данных. Затем эти данные будут использованы для создания интерфейсной части, а в главе 8 мы вернемся к модели данных и свяжем ее с REST-совместимой веб-службой.
### Создание классов модели
Каждой модели данных необходимы классы для описания типов данных, входящих в модель данных. В приложении SportsStore это классы с описанием товаров, продаваемых в интернет-магазине, и заказы, полученные от пользователей. Для начала работы приложения SportsStore достаточно возможности описания товаров; другие классы моделей будут создаваться для поддержки расширенной функциональности по мере их реализации. Создайте файл с именем product.model.ts в папке SportsStore/src/app/model и включите код из листинга 7.8.
**Листинг 7.8.** Содержимое файла product.model.ts из папки SportsStore/src/app/model
```
export class Product {
constructor(
public id?: number,
public name?: string,
public category?: string,
public description?: string,
public price?: number) { }
}
```
Класс Product определяет конструктор, который получает свойства id, name, category, description и price. Эти свойства соответствуют структуре данных, используемых для заполнения REST-совместимой веб-службы в листинге 7.2. Вопросительные знаки (?) за именами параметров указывают, что это необязательные параметры, которые могут быть опущены при создании новых объектов с использованием класса Product; это может быть удобно при разработке приложений, свойства объектов модели которых заполняются с использованием форм HTML.
### Создание фиктивного источника данных
Чтобы подготовить переход от фиктивных данных к реальным, мы будем передавать данные приложению из источника данных. Остальной код приложения не знает, откуда поступили данные, и переход на получение данных из запросов HTTP пройдет прозрачно.
Создайте файл static.datasource.ts в папке SportsStore/src/app/model и включите определение класса из листинга 7.9.
**Листинг 7.9.** Содержимое файла static.datasource.ts из папки SportsStore/src/app/model
```
import { Injectable } from "@angular/core";
import { Product } from "./product.model";
import { Observable } from "rxjs/Observable";
import "rxjs/add/observable/from";
@Injectable()
export class StaticDataSource {
private products: Product[] = [
new Product(1, "Product 1", "Category 1", "Product 1 (Category 1)", 100),
new Product(2, "Product 2", "Category 1", "Product 2 (Category 1)", 100),
new Product(3, "Product 3", "Category 1", "Product 3 (Category 1)", 100),
new Product(4, "Product 4", "Category 1", "Product 4 (Category 1)", 100),
new Product(5, "Product 5", "Category 1", "Product 5 (Category 1)", 100),
new Product(6, "Product 6", "Category 2", "Product 6 (Category 2)", 100),
new Product(7, "Product 7", "Category 2", "Product 7 (Category 2)", 100),
new Product(8, "Product 8", "Category 2", "Product 8 (Category 2)", 100),
new Product(9, "Product 9", "Category 2", "Product 9 (Category 2)", 100),
new Product(10, "Product 10", "Category 2", "Product 10 (Category 2)", 100),
new Product(11, "Product 11", "Category 3", "Product 11 (Category 3)", 100),
new Product(12, "Product 12", "Category 3", "Product 12 (Category 3)", 100),
new Product(13, "Product 13", "Category 3", "Product 13 (Category 3)", 100),
new Product(14, "Product 14", "Category 3", "Product 14 (Category 3)", 100),
new Product(15, "Product 15", "Category 3", "Product 15 (Category 3)", 100),
];
getProducts(): Observable {
return Observable.from([this.products]);
}
}
```
Класс StaticDataSource определяет метод с именем getProducts, который возвращает фиктивные данные. Вызов метода getProducts возвращает результат Observable — реализацию Observable для получения массивов объектов Product.
Класс Observable предоставляется пакетом Reactive Extensions, который используется Angular для обработки изменений состояния в приложениях. Класс Observable будет описан в главе 23, а в этой главе достаточно знать, что объект Observable похож на объект JavaScript Promise: он представляет асинхронную задачу, которая в будущем должна вернуть результат. Angular раскрывает использование объектов Observable для некоторых своих функций, включая работу с запросами HTTP; именно поэтому метод getProducts возвращает Observable вместо возвращения данных — простого синхронного или с использованием Promise.
Декоратор @Injectable применяется к классу StaticDataSource. Этот декоратор сообщает Angular, что этот класс будет использоваться как служба, что позволяет другим классам обращаться к его функциональности через механизм внедрения зависимостей, описанный в главах 19 и 20. Когда приложение начнет обретать форму, мы покажем, как работает служба.
### Создание репозитория модели
Источник данных должен предоставить приложению запрашиваемые данные, но обращение к данным обычно происходит через посредника (репозиторий), отвечающего за передачу этих данных отдельным структурным блокам приложения, чтобы подробности получения данных оставались скрытыми. Создайте файл product.repository.ts в папке SportsStore/src/app/model и определите класс из листинга 7.10.
**Листинг 7.10.** Содержимое файла product.repository.ts из папки SportsStore/app/model
```
import { Injectable } from "@angular/core";
import { Product } from "./product.model";
import { StaticDataSource } from "./static.datasource";
@Injectable()
export class ProductRepository {
private products: Product[] = [];
private categories: string[] = [];
constructor(private dataSource: StaticDataSource) {
dataSource.getProducts().subscribe(data => {
this.products = data;
this.categories = data.map(p => p.category)
.filter((c, index, array) => array.indexOf(c) == index).sort();
});
}
getProducts(category: string = null): Product[] {
return this.products
.filter(p => category == null || category == p.category);
}
getProduct(id: number): Product {
return this.products.find(p => p.id == id);
}
getCategories(): string[] {
return this.categories;
}
}
```
Когда Angular потребуется создать новый экземпляр репозитория, Angular анализирует класс и видит, что для вызова конструктора ProductRepository и создания нового объекта ему нужен объект StaticDataSource. Конструктор репозитория вызывает метод getProducts источника данных, после чего использует метод subscribe объекта Observable, возвращаемого для получения данных товаров. За подробностями о работе объектов Observable обращайтесь к главе 23.
» Более подробно с книгой можно ознакомиться на [сайте издательства](https://www.piter.com/collection/all/product/angular-dlya-professionalov)
» [Оглавление](https://static-eu.insales.ru/files/1/493/3883501/original/978544610451_X.pdf)
» [Отрывок](https://static-eu.insales.ru/files/1/494/3883502/original/978544610451_p.pdf)
Для Хаброжителей скидка 20% по купону — **Angular** | https://habr.com/ru/post/340826/ | null | ru | null |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.